openstack/rally-openstack
Code Issues Proposed changes

Port of Auth and Desicnate to new style

Browse Source 
Since current scenario implementation transforms method
to class at runtime, it is reasonable to have class-based
scenario implementation which will be much simpler to use
behind the scenes.

This class should be based on Scenario and do not break
compatibility. The only required method is run() which
is actually a body of scenario.

Change-Id: I2fb168c9762311975f1a9fad1412061944ee9a5d
This commit is contained in:
Anton Staroverov
2016-08-20 13:33:20 +03:00
committed by Staroverov Anton
parent 07cf071e3b
commit 1903fd05ab
4 changed files with 364 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
rally/plugins/openstack/scenarios/authenticate/authenticate.py
View File

@@ -18,24 +18,25 @@ from rally.task import atomic
from rally.task import validation
class Authenticate(scenario.OpenStackScenario):
"""Benchmark scenarios for the authentication mechanism.
"""Scenarios for Authentication mechanism."""
Benchmark scenarios for different types of OpenStack clients like Keystone,
Nova etc.
"""
@validation.required_openstack(users=True)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.keystone")
class Keystone(scenario.OpenStackScenario):
@atomic.action_timer("authenticate.keystone")
@scenario.configure()
def keystone(self):
def run(self):
"""Check Keystone Client."""
self.clients("keystone")
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_glance(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_glance")
class ValidateGlance(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Glance Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -46,15 +47,19 @@ class Authenticate(scenario.OpenStackScenario):
"""
glance_client = self.clients("glance")
image_name = "__intentionally_non_existent_image___"
with atomic.ActionTimer(self, "authenticate.validate_glance_%s_times" %
repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_glance_%s_times" % repetitions):
for i in range(repetitions):
list(glance_client.images.list(name=image_name))
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_nova(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_nova")
class ValidateNova(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Nova Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -63,15 +68,19 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
nova_client = self.clients("nova")
with atomic.ActionTimer(self, "authenticate.validate_nova_%s_times" %
repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_nova_%s_times" % repetitions):
for i in range(repetitions):
nova_client.flavors.list()
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_ceilometer(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_ceilometer")
class ValidateCeilometer(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Ceilometer Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -80,16 +89,19 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
ceilometer_client = self.clients("ceilometer")
with atomic.ActionTimer(self,
"authenticate.validate_ceilometer_%s_times"
% repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_ceilometer_%s_times" % repetitions):
for i in range(repetitions):
ceilometer_client.meters.list()
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_cinder(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_cinder")
class ValidateCinder(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Cinder Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -98,15 +110,19 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
cinder_client = self.clients("cinder")
with atomic.ActionTimer(self, "authenticate.validate_cinder_%s_times"
% repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_cinder_%s_times" % repetitions):
for i in range(repetitions):
cinder_client.volume_types.list()
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_neutron(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_neutron")
class ValidateNeutron(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Neutron Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -115,15 +131,19 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
neutron_client = self.clients("neutron")
with atomic.ActionTimer(self, "authenticate.validate_neutron_%s_times"
% repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_neutron_%s_times" % repetitions):
for i in range(repetitions):
neutron_client.list_networks()
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure()
def validate_heat(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@scenario.configure(name="Authenticate.validate_heat")
class ValidateHeat(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Heat Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -132,16 +152,20 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
heat_client = self.clients("heat")
with atomic.ActionTimer(self, "authenticate.validate_heat_%s_times"
% repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_heat_%s_times" % repetitions):
for i in range(repetitions):
list(heat_client.stacks.list(limit=0))
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@validation.required_services(consts.Service.MONASCA)
@scenario.configure()
def validate_monasca(self, repetitions):
@validation.number("repetitions", minval=1)
@validation.required_openstack(users=True)
@validation.required_services(consts.Service.MONASCA)
@scenario.configure(name="Authenticate.validate_monasca")
class ValidateMonasca(scenario.OpenStackScenario):
def run(self, repetitions):
"""Check Monasca Client to ensure validation of token.
Creation of the client does not ensure validation of the token.
@@ -150,7 +174,8 @@ class Authenticate(scenario.OpenStackScenario):
:param repetitions: number of times to validate
"""
monasca_client = self.clients("monasca")
with atomic.ActionTimer(self, "authenticate.validate_monasca_%s_times"
% repetitions):
with atomic.ActionTimer(
self,
"authenticate.validate_monasca_%s_times" % repetitions):
for i in range(repetitions):
list(monasca_client.metrics.list(limit=0))
list(monasca_client.metrics.list(limit=0))

202
rally/plugins/openstack/scenarios/designate/basic.py
View File

@@ -22,13 +22,16 @@ from rally.task import atomic
from rally.task import validation
class DesignateBasic(utils.DesignateScenario):
"""Basic benchmark scenarios for Designate."""
"""Basic scenarios for Designate."""
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_list_domains(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_list_domains")
class CreateAndListDomains(utils.DesignateScenario):
def run(self):
"""Create a domain and list all domains.
Measure the "designate domain-list" command performance.
@@ -42,10 +45,14 @@ class DesignateBasic(utils.DesignateScenario):
self._create_domain()
self._list_domains()
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def list_domains(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.list_domains")
class ListDomains(utils.DesignateScenario):
def run(self):
"""List Designate domains.
This simple scenario tests the designate domain-list command by listing
@@ -55,13 +62,16 @@ class DesignateBasic(utils.DesignateScenario):
uploaded for them we will be able to test the performance of
designate domain-list command in this case.
"""
self._list_domains()
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_delete_domain(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_delete_domain")
class CreateAndDeleteDomain(utils.DesignateScenario):
def run(self):
"""Create and then delete a domain.
Measure the performance of creating and deleting domains
@@ -70,10 +80,14 @@ class DesignateBasic(utils.DesignateScenario):
domain = self._create_domain()
self._delete_domain(domain["id"])
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_update_domain(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_update_domain")
class CreateAndUpdateDomain(utils.DesignateScenario):
def run(self):
"""Create and then update a domain.
Measure the performance of creating and updating domains
@@ -82,10 +96,14 @@ class DesignateBasic(utils.DesignateScenario):
domain = self._create_domain()
self._update_domain(domain)
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_delete_records(self, records_per_domain=5):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_delete_records")
class CreateAndDeleteRecords(utils.DesignateScenario):
def run(self, records_per_domain=5):
"""Create and then delete records.
Measure the performance of creating and deleting records
@@ -109,10 +127,14 @@ class DesignateBasic(utils.DesignateScenario):
self._delete_record(
domain["id"], record["id"], atomic_action=False)
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def list_records(self, domain_id):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.list_records")
class ListRecords(utils.DesignateScenario):
def run(self, domain_id):
"""List Designate records.
This simple scenario tests the designate record-list command by listing
@@ -127,10 +149,14 @@ class DesignateBasic(utils.DesignateScenario):
self._list_records(domain_id)
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_list_records(self, records_per_domain=5):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_list_records")
class CreateAndListRecords(utils.DesignateScenario):
def run(self, records_per_domain=5):
"""Create and then list records.
If you have only 1 user in your context, you will
@@ -150,10 +176,14 @@ class DesignateBasic(utils.DesignateScenario):
self._list_records(domain["id"])
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_list_servers(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_list_servers")
class CreateAndListServers(utils.DesignateScenario):
def run(self):
"""Create a Designate server and list all servers.
If you have only 1 user in your context, you will
@@ -165,10 +195,14 @@ class DesignateBasic(utils.DesignateScenario):
self._create_server()
self._list_servers()
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_delete_server(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_delete_server")
class CreateAndDeleteServer(utils.DesignateScenario):
def run(self):
"""Create and then delete a server.
Measure the performance of creating and deleting servers
@@ -177,10 +211,14 @@ class DesignateBasic(utils.DesignateScenario):
server = self._create_server()
self._delete_server(server["id"])
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]})
def list_servers(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(admin=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.list_servers")
class ListServers(utils.DesignateScenario):
def run(self):
"""List Designate servers.
This simple scenario tests the designate server-list command by listing
@@ -188,11 +226,15 @@ class DesignateBasic(utils.DesignateScenario):
"""
self._list_servers()
# NOTE: API V2
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_list_zones(self):
# NOTE: API V2
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_list_zones")
class CreateAndListZones(utils.DesignateScenario):
def run(self):
"""Create a zone and list all zones.
Measure the "openstack zone list" command performance.
@@ -206,10 +248,14 @@ class DesignateBasic(utils.DesignateScenario):
self._create_zone()
self._list_zones()
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def list_zones(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.list_zones")
class ListZones(utils.DesignateScenario):
def run(self):
"""List Designate zones.
This simple scenario tests the openstack zone list command by listing
@@ -218,10 +264,14 @@ class DesignateBasic(utils.DesignateScenario):
self._list_zones()
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_delete_zone(self):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_delete_zone")
class CreateAndDeleteZone(utils.DesignateScenario):
def run(self):
"""Create and then delete a zone.
Measure the performance of creating and deleting zones
@@ -230,10 +280,14 @@ class DesignateBasic(utils.DesignateScenario):
zone = self._create_zone()
self._delete_zone(zone["id"])
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]})
def list_recordsets(self, zone_id):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.list_recordsets")
class ListRecordsets(utils.DesignateScenario):
def run(self, zone_id):
"""List Designate recordsets.
This simple scenario tests the openstack recordset list command by
@@ -244,11 +298,15 @@ class DesignateBasic(utils.DesignateScenario):
self._list_recordsets(zone_id)
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@validation.required_contexts("zones")
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_delete_recordsets(self, recordsets_per_zone=5):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@validation.required_contexts("zones")
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_delete_recordsets")
class CreateAndDeleteRecordsets(utils.DesignateScenario):
def run(self, recordsets_per_zone=5):
"""Create and then delete recordsets.
Measure the performance of creating and deleting recordsets
@@ -272,11 +330,15 @@ class DesignateBasic(utils.DesignateScenario):
self._delete_recordset(
zone["id"], recordset["id"], atomic_action=False)
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@validation.required_contexts("zones")
@scenario.configure(context={"cleanup": ["designate"]})
def create_and_list_recordsets(self, recordsets_per_zone=5):
@validation.required_services(consts.Service.DESIGNATE)
@validation.required_openstack(users=True)
@validation.required_contexts("zones")
@scenario.configure(context={"cleanup": ["designate"]},
name="DesignateBasic.create_and_list_recordsets")
class CreateAndListRecordsets(utils.DesignateScenario):
def run(self, recordsets_per_zone=5):
"""Create and then list recordsets.
If you have only 1 user in your context, you will

36
tests/unit/plugins/openstack/scenarios/authenticate/test_authenticate.py
View File

@@ -19,22 +19,18 @@ from tests.unit import test
import mock
AUTHENTICATE_MODULE = (
"rally.plugins.openstack.scenarios.authenticate.authenticate")
class AuthenticateTestCase(test.ScenarioTestCase):
def test_keystone(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.keystone()
scenario_inst = authenticate.Keystone()
scenario_inst.run()
self.assertTrue(self.client_created("keystone"))
self._test_atomic_action_timer(scenario_inst.atomic_actions(),
"authenticate.keystone")
def test_validate_glance(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_glance(5)
scenario_inst = authenticate.ValidateGlance()
scenario_inst.run(5)
# NOTE(stpierre): We can't use assert_has_calls() here because
# that includes calls on the return values of the mock object
@@ -50,15 +46,15 @@ class AuthenticateTestCase(test.ScenarioTestCase):
"authenticate.validate_glance_5_times")
def test_validate_nova(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_nova(5)
scenario_inst = authenticate.ValidateNova()
scenario_inst.run(5)
self.clients("nova").flavors.list.assert_has_calls([mock.call()] * 5)
self._test_atomic_action_timer(scenario_inst.atomic_actions(),
"authenticate.validate_nova_5_times")
def test_validate_ceilometer(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_ceilometer(5)
scenario_inst = authenticate.ValidateCeilometer()
scenario_inst.run(5)
self.clients("ceilometer").meters.list.assert_has_calls(
[mock.call()] * 5)
self._test_atomic_action_timer(
@@ -66,24 +62,24 @@ class AuthenticateTestCase(test.ScenarioTestCase):
"authenticate.validate_ceilometer_5_times")
def test_validate_cinder(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_cinder(5)
scenario_inst = authenticate.ValidateCinder()
scenario_inst.run(5)
self.clients("cinder").volume_types.list.assert_has_calls(
[mock.call()] * 5)
self._test_atomic_action_timer(scenario_inst.atomic_actions(),
"authenticate.validate_cinder_5_times")
def test_validate_neutron(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_neutron(5)
scenario_inst = authenticate.ValidateNeutron()
scenario_inst.run(5)
self.clients("neutron").list_networks.assert_has_calls(
[mock.call()] * 5)
self._test_atomic_action_timer(scenario_inst.atomic_actions(),
"authenticate.validate_neutron_5_times")
def test_validate_heat(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_heat(5)
scenario_inst = authenticate.ValidateHeat()
scenario_inst.run(5)
self.assertItemsEqual(
self.clients("heat").stacks.list.call_args_list,
[mock.call(limit=0)] * 5)
@@ -91,8 +87,8 @@ class AuthenticateTestCase(test.ScenarioTestCase):
"authenticate.validate_heat_5_times")
def test_validate_monasca(self):
scenario_inst = authenticate.Authenticate()
scenario_inst.validate_monasca(5)
scenario_inst = authenticate.ValidateMonasca()
scenario_inst.run(5)
self.assertItemsEqual(
self.clients("monasca").metrics.list.call_args_list,
[mock.call(limit=0)] * 5)

320
tests/unit/plugins/openstack/scenarios/designate/test_basic.py
View File

@@ -19,206 +19,167 @@ import mock
from rally.plugins.openstack.scenarios.designate import basic
from tests.unit import test
DESIGNATE_BASIC = ("rally.plugins.openstack.scenarios.designate.basic"
".DesignateBasic")
BASE = "rally.plugins.openstack.scenarios.designate.basic"
class DesignateBasicTestCase(test.ScenarioTestCase):
@mock.patch(DESIGNATE_BASIC + "._list_domains")
@mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_list_domains(self, mock_designate_basic__create_domain,
mock_designate_basic__list_domains):
scenario = basic.DesignateBasic(self.context)
# Default options
scenario.create_and_list_domains()
mock_designate_basic__create_domain.assert_called_once_with()
mock_designate_basic__list_domains.assert_called_once_with()
@mock.patch("%s.CreateAndListDomains._list_domains" % BASE)
@mock.patch("%s.CreateAndListDomains._create_domain" % BASE)
def test_create_and_list_domains(self,
mock__create_domain,
mock__list_domains):
basic.CreateAndListDomains(self.context).run()
mock__create_domain.assert_called_once_with()
mock__list_domains.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._delete_domain")
@mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_delete_domain(
self, mock_designate_basic__create_domain,
mock_designate_basic__delete_domain):
@mock.patch("%s.CreateAndDeleteDomain._delete_domain" % BASE)
@mock.patch("%s.CreateAndDeleteDomain._create_domain" % BASE,
return_value={"id": "123"})
def test_create_and_delete_domain(self,
mock__create_domain,
mock__delete_domain):
scenario = basic.DesignateBasic(self.context)
basic.CreateAndDeleteDomain(self.context).run()
mock_designate_basic__create_domain.return_value = {"id": "123"}
mock__create_domain.assert_called_once_with()
mock__delete_domain.assert_called_once_with("123")
# Default options
scenario.create_and_delete_domain()
mock_designate_basic__create_domain.assert_called_once_with()
mock_designate_basic__delete_domain.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._update_domain")
@mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_update_domain(
self, mock_designate_basic__create_domain,
mock_designate_basic__update_domain):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.CreateAndUpdateDomain._update_domain" % BASE)
@mock.patch("%s.CreateAndUpdateDomain._create_domain" % BASE)
def test_create_and_update_domain(self,
mock__create_domain,
mock__update_domain):
domain = {
"name": "zone.name",
"email": "email@zone.name",
"id": "123"}
mock_designate_basic__create_domain.return_value = domain
scenario.create_and_update_domain()
mock_designate_basic__update_domain.assert_called_once_with(domain)
mock__create_domain.return_value = domain
basic.CreateAndUpdateDomain(self.context).run()
mock__update_domain.assert_called_once_with(domain)
@mock.patch(DESIGNATE_BASIC + "._list_domains")
def test_list_domains(self, mock_designate_basic__list_domains):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.ListDomains._list_domains" % BASE)
def test_list_domains(self, mock__list_domains):
basic.ListDomains(self.context).run()
mock__list_domains.assert_called_once_with()
# Default options
scenario.list_domains()
mock_designate_basic__list_domains.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._list_records")
@mock.patch(DESIGNATE_BASIC + "._create_record")
@mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_list_records(
self, mock_designate_basic__create_domain,
mock_designate_basic__create_record,
mock_designate_basic__list_records):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.CreateAndListRecords._list_records" % BASE)
@mock.patch("%s.CreateAndListRecords._create_record" % BASE)
@mock.patch("%s.CreateAndListRecords._create_domain" % BASE)
def test_create_and_list_records(self,
mock__create_domain,
mock__create_record,
mock__list_records):
domain = {
"name": "zone.name",
"email": "email@zone.name",
"id": "123"}
mock_designate_basic__create_domain.return_value = domain
mock__create_domain.return_value = domain
records_per_domain = 5
scenario.create_and_list_records(
basic.CreateAndListRecords(self.context).run(
records_per_domain=records_per_domain)
mock_designate_basic__create_domain.assert_called_once_with()
self.assertEqual(
mock_designate_basic__create_record.mock_calls,
[mock.call(domain, atomic_action=False)]
* records_per_domain)
mock_designate_basic__list_records.assert_called_once_with(
domain["id"])
mock__create_domain.assert_called_once_with()
self.assertEqual(mock__create_record.mock_calls,
[mock.call(domain, atomic_action=False)]
* records_per_domain)
mock__list_records.assert_called_once_with(domain["id"])
@mock.patch(DESIGNATE_BASIC + "._delete_record")
@mock.patch(DESIGNATE_BASIC + "._create_record")
@mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_delete_records(
self, mock_designate_basic__create_domain,
mock_designate_basic__create_record,
mock_designate_basic__delete_record):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.CreateAndDeleteRecords._delete_record" % BASE)
@mock.patch("%s.CreateAndDeleteRecords._create_record" % BASE)
@mock.patch("%s.CreateAndDeleteRecords._create_domain" % BASE)
def test_create_and_delete_records(self,
mock__create_domain,
mock__create_record,
mock__delete_record):
domain = {
"name": "zone.name",
"email": "email@zone.name",
"id": "123"}
mock_designate_basic__create_domain.return_value = domain
mock_designate_basic__create_record.return_value = {"id": "321"}
mock__create_domain.return_value = domain
mock__create_record.return_value = {"id": "321"}
records_per_domain = 5
scenario.create_and_delete_records(
basic.CreateAndDeleteRecords(self.context).run(
records_per_domain=records_per_domain)
mock_designate_basic__create_domain.assert_called_once_with()
self.assertEqual(
mock_designate_basic__create_record.mock_calls,
[mock.call(domain, atomic_action=False)]
* records_per_domain)
self.assertEqual(
mock_designate_basic__delete_record.mock_calls,
[mock.call(domain["id"], "321", atomic_action=False)]
* records_per_domain)
mock__create_domain.assert_called_once_with()
self.assertEqual(mock__create_record.mock_calls,
[mock.call(domain, atomic_action=False)]
* records_per_domain)
self.assertEqual(mock__delete_record.mock_calls,
[mock.call(domain["id"],
"321",
atomic_action=False)]
* records_per_domain)
@mock.patch(DESIGNATE_BASIC + "._list_records")
def test_list_records(self, mock_designate_basic__list_records):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.ListRecords._list_records" % BASE)
def test_list_records(self, mock__list_records):
basic.ListRecords(self.context).run("123")
mock__list_records.assert_called_once_with("123")
# Default options
scenario.list_records("123")
mock_designate_basic__list_records.assert_called_once_with("123")
@mock.patch("%s.CreateAndListServers._list_servers" % BASE)
@mock.patch("%s.CreateAndListServers._create_server" % BASE)
def test_create_and_list_servers(self,
mock__create_server,
mock__list_servers):
basic.CreateAndListServers(self.context).run()
@mock.patch(DESIGNATE_BASIC + "._list_servers")
@mock.patch(DESIGNATE_BASIC + "._create_server")
def test_create_and_list_servers(
self, mock_designate_basic__create_server,
mock_designate_basic__list_servers):
scenario = basic.DesignateBasic(self.context)
mock__create_server.assert_called_once_with()
mock__list_servers.assert_called_once_with()
# Default options
scenario.create_and_list_servers()
mock_designate_basic__create_server.assert_called_once_with()
mock_designate_basic__list_servers.assert_called_once_with()
@mock.patch("%s.CreateAndDeleteServer._delete_server" % BASE)
@mock.patch("%s.CreateAndDeleteServer._create_server" % BASE,
return_value={"id": "123"})
def test_create_and_delete_server(self,
mock__create_server,
mock__delete_server):
basic.CreateAndDeleteServer(self.context).run()
@mock.patch(DESIGNATE_BASIC + "._delete_server")
@mock.patch(DESIGNATE_BASIC + "._create_server")
def test_create_and_delete_server(
self, mock_designate_basic__create_server,
mock_designate_basic__delete_server):
scenario = basic.DesignateBasic(self.context)
mock__create_server.assert_called_once_with()
mock__delete_server.assert_called_once_with("123")
mock_designate_basic__create_server.return_value = {"id": "123"}
# Default options
scenario.create_and_delete_server()
mock_designate_basic__create_server.assert_called_once_with()
mock_designate_basic__delete_server.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._list_servers")
def test_list_servers(self, mock_designate_basic__list_servers):
scenario = basic.DesignateBasic(self.context)
# Default options
scenario.list_servers()
mock_designate_basic__list_servers.assert_called_once_with()
@mock.patch("%s.ListServers._list_servers" % BASE)
def test_list_servers(self, mock__list_servers):
basic.ListServers(self.context).run()
mock__list_servers.assert_called_once_with()
# NOTE: API V2
@mock.patch(DESIGNATE_BASIC + "._list_zones")
@mock.patch(DESIGNATE_BASIC + "._create_zone")
def test_create_and_list_zones(self, mock_designate_basic__create_zone,
mock_designate_basic__list_zones):
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.CreateAndListZones._list_zones" % BASE)
@mock.patch("%s.CreateAndListZones._create_zone" % BASE)
def test_create_and_list_zones(self,
mock__create_zone,
mock__list_zones):
basic.CreateAndListZones(self.context).run()
mock__create_zone.assert_called_once_with()
mock__list_zones.assert_called_once_with()
# Default options
scenario.create_and_list_zones()
mock_designate_basic__create_zone.assert_called_once_with()
mock_designate_basic__list_zones.assert_called_once_with()
@mock.patch("%s.CreateAndDeleteZone._delete_zone" % BASE)
@mock.patch("%s.CreateAndDeleteZone._create_zone" % BASE,
return_value={"id": "123"})
def test_create_and_delete_zone(self,
mock__create_zone,
mock__delete_zone):
basic.CreateAndDeleteZone(self.context).run()
@mock.patch(DESIGNATE_BASIC + "._delete_zone")
@mock.patch(DESIGNATE_BASIC + "._create_zone")
def test_create_and_delete_zone(
self, mock_designate_basic__create_zone,
mock_designate_basic__delete_zone):
mock__create_zone.assert_called_once_with()
mock__delete_zone.assert_called_once_with("123")
scenario = basic.DesignateBasic(self.context)
@mock.patch("%s.ListZones._list_zones" % BASE)
def test_list_zones(self, mock_list_zones__list_zones):
basic.ListZones(self.context).run()
mock_list_zones__list_zones.assert_called_once_with()
mock_designate_basic__create_zone.return_value = {"id": "123"}
@mock.patch("%s.ListRecordsets._list_recordsets" % BASE)
def test_list_recordsets(self, mock__list_recordsets):
basic.ListRecordsets(self.context).run("123")
mock__list_recordsets.assert_called_once_with("123")
# Default options
scenario.create_and_delete_zone()
mock_designate_basic__create_zone.assert_called_once_with()
mock_designate_basic__delete_zone.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._list_zones")
def test_list_zones(self, mock_designate_basic__list_zones):
scenario = basic.DesignateBasic(self.context)
# Default options
scenario.list_zones()
mock_designate_basic__list_zones.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._list_recordsets")
def test_list_recordsets(self, mock_designate_basic__list_recordsets):
scenario = basic.DesignateBasic(self.context)
# Default options
scenario.list_recordsets("123")
mock_designate_basic__list_recordsets.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._delete_recordset")
@mock.patch(DESIGNATE_BASIC + "._create_recordset")
def test_create_and_delete_recordsets(
self, mock_designate_basic__create_recordset,
mock_designate_basic__delete_recordset):
@mock.patch("%s.CreateAndDeleteRecordsets._delete_recordset" % BASE)
@mock.patch("%s.CreateAndDeleteRecordsets._create_recordset" % BASE,
return_value={"id": "321"})
def test_create_and_delete_recordsets(self,
mock__create_recordset,
mock__delete_recordset):
zone = {"id": "1234"}
self.context.update({
"tenant": {
@@ -226,40 +187,35 @@ class DesignateBasicTestCase(test.ScenarioTestCase):
}
})
scenario = basic.DesignateBasic(self.context)
mock_designate_basic__create_recordset.return_value = {"id": "321"}
recordsets_per_zone = 5
scenario.create_and_delete_recordsets(
basic.CreateAndDeleteRecordsets(self.context).run(
recordsets_per_zone=recordsets_per_zone)
self.assertEqual(
mock_designate_basic__create_recordset.mock_calls,
[mock.call(zone, atomic_action=False)]
* recordsets_per_zone)
self.assertEqual(
mock_designate_basic__delete_recordset.mock_calls,
[mock.call(zone["id"], "321", atomic_action=False)]
* recordsets_per_zone)
self.assertEqual(mock__create_recordset.mock_calls,
[mock.call(zone, atomic_action=False)]
* recordsets_per_zone)
self.assertEqual(mock__delete_recordset.mock_calls,
[mock.call(zone["id"],
"321",
atomic_action=False)]
* recordsets_per_zone)
@mock.patch(DESIGNATE_BASIC + "._list_recordsets")
@mock.patch(DESIGNATE_BASIC + "._create_recordset")
def test_create_and_list_recordsets(
self, mock_designate_basic__create_recordset,
mock_designate_basic__list_recordsets):
@mock.patch("%s.CreateAndListRecordsets._list_recordsets" % BASE)
@mock.patch("%s.CreateAndListRecordsets._create_recordset" % BASE)
def test_create_and_list_recordsets(self,
mock__create_recordset,
mock__list_recordsets):
zone = {"id": "1234"}
self.context.update({
"tenant": {
"zones": [zone]
}
})
scenario = basic.DesignateBasic(self.context)
recordsets_per_zone = 5
scenario.create_and_list_recordsets(
basic.CreateAndListRecordsets(self.context).run(
recordsets_per_zone=recordsets_per_zone)
self.assertEqual(
mock_designate_basic__create_recordset.mock_calls,
[mock.call(zone, atomic_action=False)]
* recordsets_per_zone)
mock_designate_basic__list_recordsets.assert_called_once_with(
zone["id"])
self.assertEqual(mock__create_recordset.mock_calls,
[mock.call(zone, atomic_action=False)]
* recordsets_per_zone)
mock__list_recordsets.assert_called_once_with(zone["id"])