openstack/openstacksdk
Code Issues Proposed changes

Merge OpenstackCloud and OperatorCloud files

Browse Source 
Change-Id: I4db00729eb9668baac25e722ee49263609c7dbb9
This commit is contained in:
Monty Taylor 2018-01-26 08:53:54 -06:00
parent bd3fad7d0e
commit a50a784375
No known key found for this signature in database
GPG Key ID: 7BAE94BC7141A594
27 changed files with 2844 additions and 2903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SHADE-MERGE-TODO.rst
View File

@ -40,7 +40,7 @@ Next steps
shade integration shade integration
----------------- -----------------
* Merge OpenStackCloud and OperatorCloud into Connection. This should result * Merge OpenStackCloud into Connection. This should result
in being able to use the connection interact with the cloud using all three in being able to use the connection interact with the cloud using all three
interfaces. For instance: interfaces. For instance:

3
doc/source/user/usage.rst
View File

@ -17,6 +17,3 @@ To use `openstack.cloud` in a project:
.. autoclass:: openstack.cloud.OpenStackCloud .. autoclass:: openstack.cloud.OpenStackCloud
:members: :members:
.. autoclass:: openstack.cloud.OperatorCloud
:members:

13
openstack/cloud/__init__.py
View File

@ -17,7 +17,6 @@ import keystoneauth1.exceptions
from openstack._log import enable_logging # noqa from openstack._log import enable_logging # noqa
from openstack.cloud.exc import * # noqa from openstack.cloud.exc import * # noqa
from openstack.cloud.openstackcloud import OpenStackCloud from openstack.cloud.openstackcloud import OpenStackCloud
from openstack.cloud.operatorcloud import OperatorCloud
def _get_openstack_config(app_name=None, app_version=None): def _get_openstack_config(app_name=None, app_version=None):
@ -65,15 +64,3 @@ def openstack_cloud(
raise OpenStackCloudException( raise OpenStackCloudException(
"Invalid cloud configuration: {exc}".format(exc=str(e))) "Invalid cloud configuration: {exc}".format(exc=str(e)))
return OpenStackCloud(cloud_config=cloud_region, strict=strict) return OpenStackCloud(cloud_config=cloud_region, strict=strict)
def operator_cloud(
config=None, strict=False, app_name=None, app_version=None, **kwargs):
if not config:
config = _get_openstack_config(app_name, app_version)
try:
cloud_region = config.get_one(**kwargs)
except keystoneauth1.exceptions.auth_plugins.NoMatchingPlugin as e:
raise OpenStackCloudException(
"Invalid cloud configuration: {exc}".format(exc=str(e)))
return OperatorCloud(cloud_config=cloud_region, strict=strict)

2570
openstack/cloud/openstackcloud.py
View File

File diff suppressed because it is too large Load Diff

2597
openstack/cloud/operatorcloud.py
View File

File diff suppressed because it is too large Load Diff

2
openstack/tests/functional/cloud/base.py
View File

@ -44,7 +44,7 @@ class BaseFunctionalTestCase(base.TestCase):
def _set_operator_cloud(self, **kwargs): def _set_operator_cloud(self, **kwargs):
operator_config = self.config.get_one( operator_config = self.config.get_one(
cloud=self._op_name, **kwargs) cloud=self._op_name, **kwargs)
self.operator_cloud = openstack.cloud.OperatorCloud( self.operator_cloud = openstack.cloud.OpenStackCloud(
cloud_config=operator_config) cloud_config=operator_config)
def pick_image(self): def pick_image(self):

4
openstack/tests/unit/base.py
View File

@ -124,8 +124,6 @@ class BaseTestCase(base.TestCase):
self.strict_cloud = openstack.cloud.OpenStackCloud( self.strict_cloud = openstack.cloud.OpenStackCloud(
cloud_config=self.cloud_config, cloud_config=self.cloud_config,
strict=True) strict=True)
self.op_cloud = openstack.cloud.OperatorCloud(
cloud_config=self.cloud_config)
# TODO(shade) Remove this and rename RequestsMockTestCase to TestCase. # TODO(shade) Remove this and rename RequestsMockTestCase to TestCase.
@ -464,8 +462,6 @@ class RequestsMockTestCase(BaseTestCase):
config=self.cloud_config) config=self.cloud_config)
self.cloud = openstack.cloud.OpenStackCloud( self.cloud = openstack.cloud.OpenStackCloud(
cloud_config=self.cloud_config) cloud_config=self.cloud_config)
self.op_cloud = openstack.cloud.OperatorCloud(
cloud_config=self.cloud_config)
def get_glance_discovery_mock_dict( def get_glance_discovery_mock_dict(
self, self,

16
openstack/tests/unit/cloud/test_aggregate.py
View File

@ -37,7 +37,7 @@ class TestAggregate(base.RequestsMockTestCase):
'availability_zone': None, 'availability_zone': None,
}})), }})),
]) ])
self.op_cloud.create_aggregate(name=self.aggregate_name) self.cloud.create_aggregate(name=self.aggregate_name)
self.assert_calls() self.assert_calls()
@ -62,7 +62,7 @@ class TestAggregate(base.RequestsMockTestCase):
}})), }})),
]) ])
self.op_cloud.create_aggregate( self.cloud.create_aggregate(
name=self.aggregate_name, availability_zone=availability_zone) name=self.aggregate_name, availability_zone=availability_zone)
self.assert_calls() self.assert_calls()
@ -78,7 +78,7 @@ class TestAggregate(base.RequestsMockTestCase):
'compute', 'public', append=['os-aggregates', '1'])), 'compute', 'public', append=['os-aggregates', '1'])),
]) ])
self.assertTrue(self.op_cloud.delete_aggregate('1')) self.assertTrue(self.cloud.delete_aggregate('1'))
self.assert_calls() self.assert_calls()
@ -99,7 +99,7 @@ class TestAggregate(base.RequestsMockTestCase):
}})), }})),
]) ])
self.op_cloud.update_aggregate(1, availability_zone='az') self.cloud.update_aggregate(1, availability_zone='az')
self.assert_calls() self.assert_calls()
@ -120,7 +120,7 @@ class TestAggregate(base.RequestsMockTestCase):
}})), }})),
]) ])
self.op_cloud.update_aggregate(1, availability_zone=None) self.cloud.update_aggregate(1, availability_zone=None)
self.assert_calls() self.assert_calls()
@ -139,7 +139,7 @@ class TestAggregate(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'set_metadata': {'metadata': metadata}})), json={'set_metadata': {'metadata': metadata}})),
]) ])
self.op_cloud.set_aggregate_metadata('1', metadata) self.cloud.set_aggregate_metadata('1', metadata)
self.assert_calls() self.assert_calls()
@ -158,7 +158,7 @@ class TestAggregate(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'add_host': {'host': hostname}})), json={'add_host': {'host': hostname}})),
]) ])
self.op_cloud.add_host_to_aggregate('1', hostname) self.cloud.add_host_to_aggregate('1', hostname)
self.assert_calls() self.assert_calls()
@ -177,6 +177,6 @@ class TestAggregate(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'remove_host': {'host': hostname}})), json={'remove_host': {'host': hostname}})),
]) ])
self.op_cloud.remove_host_from_aggregate('1', hostname) self.cloud.remove_host_from_aggregate('1', hostname)
self.assert_calls() self.assert_calls()

102
openstack/tests/unit/cloud/test_baremetal_node.py
View File

@ -50,7 +50,7 @@ class TestBaremetalNode(base.IronicTestCase):
fake_baremetal_two]}), fake_baremetal_two]}),
]) ])
machines = self.op_cloud.list_machines() machines = self.cloud.list_machines()
self.assertEqual(2, len(machines)) self.assertEqual(2, len(machines))
self.assertEqual(self.fake_baremetal_node, machines[0]) self.assertEqual(self.fake_baremetal_node, machines[0])
self.assert_calls() self.assert_calls()
@ -64,7 +64,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
machine = self.op_cloud.get_machine(self.fake_baremetal_node['uuid']) machine = self.cloud.get_machine(self.fake_baremetal_node['uuid'])
self.assertEqual(machine['uuid'], self.assertEqual(machine['uuid'],
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -87,7 +87,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
machine = self.op_cloud.get_machine_by_mac(mac_address) machine = self.cloud.get_machine_by_mac(mac_address)
self.assertEqual(machine['uuid'], self.assertEqual(machine['uuid'],
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -117,7 +117,7 @@ class TestBaremetalNode(base.IronicTestCase):
'validate']), 'validate']),
json=validate_return), json=validate_return),
]) ])
self.op_cloud.validate_node(self.fake_baremetal_node['uuid']) self.cloud.validate_node(self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -147,7 +147,7 @@ class TestBaremetalNode(base.IronicTestCase):
# ]) # ])
# self.assertRaises( # self.assertRaises(
# Exception, # Exception,
# self.op_cloud.validate_node, # self.cloud.validate_node,
# self.fake_baremetal_node['uuid']) # self.fake_baremetal_node['uuid'])
# #
# self.assert_calls() # self.assert_calls()
@ -165,8 +165,8 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node, json=self.fake_baremetal_node,
validate=dict(json=test_patch)), validate=dict(json=test_patch)),
]) ])
self.op_cloud.patch_machine(self.fake_baremetal_node['uuid'], self.cloud.patch_machine(
test_patch) self.fake_baremetal_node['uuid'], test_patch)
self.assert_calls() self.assert_calls()
@ -183,7 +183,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node, json=self.fake_baremetal_node,
validate=dict(json=test_patch)), validate=dict(json=test_patch)),
]) ])
self.op_cloud.set_node_instance_info( self.cloud.set_node_instance_info(
self.fake_baremetal_node['uuid'], test_patch) self.fake_baremetal_node['uuid'], test_patch)
self.assert_calls() self.assert_calls()
@ -201,7 +201,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node, json=self.fake_baremetal_node,
validate=dict(json=test_patch)), validate=dict(json=test_patch)),
]) ])
self.op_cloud.purge_node_instance_info( self.cloud.purge_node_instance_info(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -217,7 +217,7 @@ class TestBaremetalNode(base.IronicTestCase):
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.inspect_machine, self.cloud.inspect_machine,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
wait=True, wait=True,
timeout=1) timeout=1)
@ -251,7 +251,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=inspecting_node) json=inspecting_node)
]) ])
self.op_cloud.inspect_machine(self.fake_baremetal_node['uuid']) self.cloud.inspect_machine(self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -280,7 +280,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=inspecting_node), json=inspecting_node),
]) ])
self.op_cloud.inspect_machine(self.fake_baremetal_node['uuid']) self.cloud.inspect_machine(self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -337,7 +337,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=available_node), json=available_node),
]) ])
self.op_cloud.inspect_machine(self.fake_baremetal_node['uuid']) self.cloud.inspect_machine(self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -408,8 +408,8 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=available_node), json=available_node),
]) ])
self.op_cloud.inspect_machine(self.fake_baremetal_node['uuid'], self.cloud.inspect_machine(
wait=True, timeout=1) self.fake_baremetal_node['uuid'], wait=True, timeout=1)
self.assert_calls() self.assert_calls()
@ -450,8 +450,8 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
self.op_cloud.inspect_machine(self.fake_baremetal_node['uuid'], self.cloud.inspect_machine(
wait=True, timeout=1) self.fake_baremetal_node['uuid'], wait=True, timeout=1)
self.assert_calls() self.assert_calls()
@ -490,7 +490,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=inspect_fail_node), json=inspect_fail_node),
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.inspect_machine, self.cloud.inspect_machine,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
wait=True, timeout=1) wait=True, timeout=1)
@ -506,7 +506,7 @@ class TestBaremetalNode(base.IronicTestCase):
'maintenance']), 'maintenance']),
validate=dict(json={'reason': 'no reason'})), validate=dict(json={'reason': 'no reason'})),
]) ])
self.op_cloud.set_machine_maintenance_state( self.cloud.set_machine_maintenance_state(
self.fake_baremetal_node['uuid'], True, reason='no reason') self.fake_baremetal_node['uuid'], True, reason='no reason')
self.assert_calls() self.assert_calls()
@ -520,7 +520,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid'], append=[self.fake_baremetal_node['uuid'],
'maintenance'])), 'maintenance'])),
]) ])
self.op_cloud.set_machine_maintenance_state( self.cloud.set_machine_maintenance_state(
self.fake_baremetal_node['uuid'], False) self.fake_baremetal_node['uuid'], False)
self.assert_calls self.assert_calls
@ -534,7 +534,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid'], append=[self.fake_baremetal_node['uuid'],
'maintenance'])), 'maintenance'])),
]) ])
self.op_cloud.remove_machine_from_maintenance( self.cloud.remove_machine_from_maintenance(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -549,7 +549,7 @@ class TestBaremetalNode(base.IronicTestCase):
'states', 'power']), 'states', 'power']),
validate=dict(json={'target': 'power on'})), validate=dict(json={'target': 'power on'})),
]) ])
return_value = self.op_cloud.set_machine_power_on( return_value = self.cloud.set_machine_power_on(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value) self.assertIsNone(return_value)
@ -565,7 +565,7 @@ class TestBaremetalNode(base.IronicTestCase):
'states', 'power']), 'states', 'power']),
validate=dict(json={'target': 'power off'})), validate=dict(json={'target': 'power off'})),
]) ])
return_value = self.op_cloud.set_machine_power_off( return_value = self.cloud.set_machine_power_off(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value) self.assertIsNone(return_value)
@ -581,7 +581,7 @@ class TestBaremetalNode(base.IronicTestCase):
'states', 'power']), 'states', 'power']),
validate=dict(json={'target': 'rebooting'})), validate=dict(json={'target': 'rebooting'})),
]) ])
return_value = self.op_cloud.set_machine_power_reboot( return_value = self.cloud.set_machine_power_reboot(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value) self.assertIsNone(return_value)
@ -600,7 +600,7 @@ class TestBaremetalNode(base.IronicTestCase):
validate=dict(json={'target': 'rebooting'})), validate=dict(json={'target': 'rebooting'})),
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.set_machine_power_reboot, self.cloud.set_machine_power_reboot,
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -625,7 +625,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
self.op_cloud.node_set_provision_state( self.cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'active', 'active',
configdrive='http://host/file') configdrive='http://host/file')
@ -662,7 +662,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=active_node), json=active_node),
]) ])
return_value = self.op_cloud.node_set_provision_state( return_value = self.cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'active', 'active',
wait=True) wait=True)
@ -690,7 +690,7 @@ class TestBaremetalNode(base.IronicTestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.node_set_provision_state, self.cloud.node_set_provision_state,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'active', 'active',
wait=True, wait=True,
@ -715,7 +715,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
return_value = self.op_cloud.node_set_provision_state( return_value = self.cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'active', 'active',
wait=True) wait=True)
@ -742,7 +742,7 @@ class TestBaremetalNode(base.IronicTestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.node_set_provision_state, self.cloud.node_set_provision_state,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'active', 'active',
wait=True, wait=True,
@ -773,7 +773,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=available_node), json=available_node),
]) ])
return_value = self.op_cloud.node_set_provision_state( return_value = self.cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
'provide', 'provide',
wait=True) wait=True)
@ -798,7 +798,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=unlocked_node), json=unlocked_node),
]) ])
self.assertIsNone( self.assertIsNone(
self.op_cloud.wait_for_baremetal_node_lock( self.cloud.wait_for_baremetal_node_lock(
self.fake_baremetal_node, self.fake_baremetal_node,
timeout=1)) timeout=1))
@ -807,7 +807,7 @@ class TestBaremetalNode(base.IronicTestCase):
def test_wait_for_baremetal_node_lock_not_locked(self): def test_wait_for_baremetal_node_lock_not_locked(self):
self.fake_baremetal_node['reservation'] = None self.fake_baremetal_node['reservation'] = None
self.assertIsNone( self.assertIsNone(
self.op_cloud.wait_for_baremetal_node_lock( self.cloud.wait_for_baremetal_node_lock(
self.fake_baremetal_node, self.fake_baremetal_node,
timeout=1)) timeout=1))
@ -824,7 +824,7 @@ class TestBaremetalNode(base.IronicTestCase):
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.wait_for_baremetal_node_lock, self.cloud.wait_for_baremetal_node_lock,
self.fake_baremetal_node, self.fake_baremetal_node,
timeout=0.001) timeout=0.001)
@ -847,7 +847,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
return_value = self.op_cloud.activate_node( return_value = self.cloud.activate_node(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
configdrive='http://host/file', configdrive='http://host/file',
wait=True) wait=True)
@ -871,7 +871,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
return_value = self.op_cloud.deactivate_node( return_value = self.cloud.deactivate_node(
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
wait=True) wait=True)
@ -910,7 +910,7 @@ class TestBaremetalNode(base.IronicTestCase):
'node_uuid': node_uuid}), 'node_uuid': node_uuid}),
json=self.fake_baremetal_port), json=self.fake_baremetal_port),
]) ])
return_value = self.op_cloud.register_machine(nics, **node_to_post) return_value = self.cloud.register_machine(nics, **node_to_post)
self.assertDictEqual(self.fake_baremetal_node, return_value) self.assertDictEqual(self.fake_baremetal_node, return_value)
self.assert_calls() self.assert_calls()
@ -994,7 +994,7 @@ class TestBaremetalNode(base.IronicTestCase):
# point during code being refactored soon after the # point during code being refactored soon after the
# change landed. Presently, with the lock at 1.6, # change landed. Presently, with the lock at 1.6,
# this code is never used in the current code path. # this code is never used in the current code path.
return_value = self.op_cloud.register_machine(nics, **node_to_post) return_value = self.cloud.register_machine(nics, **node_to_post)
self.assertDictEqual(available_node, return_value) self.assertDictEqual(available_node, return_value)
self.assert_calls() self.assert_calls()
@ -1074,8 +1074,8 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']]), append=[self.fake_baremetal_node['uuid']]),
json=available_node), json=available_node),
]) ])
return_value = self.op_cloud.register_machine(nics, wait=True, return_value = self.cloud.register_machine(
**node_to_post) nics, wait=True, **node_to_post)
self.assertDictEqual(available_node, return_value) self.assertDictEqual(available_node, return_value)
self.assert_calls() self.assert_calls()
@ -1133,7 +1133,7 @@ class TestBaremetalNode(base.IronicTestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.register_machine, self.cloud.register_machine,
nics, nics,
**node_to_post) **node_to_post)
self.assert_calls() self.assert_calls()
@ -1193,7 +1193,7 @@ class TestBaremetalNode(base.IronicTestCase):
# want to block on until it has cleared. # want to block on until it has cleared.
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.register_machine, self.cloud.register_machine,
nics, nics,
timeout=0.001, timeout=0.001,
lock_timeout=0.001, lock_timeout=0.001,
@ -1248,7 +1248,7 @@ class TestBaremetalNode(base.IronicTestCase):
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.register_machine, self.cloud.register_machine,
nics, nics,
wait=True, wait=True,
timeout=0.001, timeout=0.001,
@ -1289,7 +1289,7 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']])), append=[self.fake_baremetal_node['uuid']])),
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.register_machine, self.cloud.register_machine,
nics, **node_to_post) nics, **node_to_post)
self.assert_calls() self.assert_calls()
@ -1329,8 +1329,8 @@ class TestBaremetalNode(base.IronicTestCase):
append=[self.fake_baremetal_node['uuid']])), append=[self.fake_baremetal_node['uuid']])),
]) ])
self.op_cloud.unregister_machine(nics, self.cloud.unregister_machine(
self.fake_baremetal_node['uuid']) nics, self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -1375,7 +1375,7 @@ class TestBaremetalNode(base.IronicTestCase):
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.unregister_machine, self.cloud.unregister_machine,
nics, nics,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
wait=True, wait=True,
@ -1404,7 +1404,7 @@ class TestBaremetalNode(base.IronicTestCase):
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.unregister_machine, self.cloud.unregister_machine,
nics, nics,
self.fake_baremetal_node['uuid'], self.fake_baremetal_node['uuid'],
timeout=0.001) timeout=0.001)
@ -1432,7 +1432,7 @@ class TestBaremetalNode(base.IronicTestCase):
for state in invalid_states: for state in invalid_states:
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.op_cloud.unregister_machine, self.cloud.unregister_machine,
nics, nics,
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
@ -1447,7 +1447,7 @@ class TestBaremetalNode(base.IronicTestCase):
json=self.fake_baremetal_node), json=self.fake_baremetal_node),
]) ])
# NOTE(TheJulia): This is just testing mechanics. # NOTE(TheJulia): This is just testing mechanics.
update_dict = self.op_cloud.update_machine( update_dict = self.cloud.update_machine(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assertIsNone(update_dict['changes']) self.assertIsNone(update_dict['changes'])
self.assertDictEqual(self.fake_baremetal_node, update_dict['node']) self.assertDictEqual(self.fake_baremetal_node, update_dict['node'])
@ -1501,7 +1501,7 @@ class TestUpdateMachinePatch(base.IronicTestCase):
self.register_uris(uris) self.register_uris(uris)
call_args = {self.field_name: value_to_send} call_args = {self.field_name: value_to_send}
update_dict = self.op_cloud.update_machine( update_dict = self.cloud.update_machine(
self.fake_baremetal_node['uuid'], **call_args) self.fake_baremetal_node['uuid'], **call_args)
if not self.changed: if not self.changed:

12
openstack/tests/unit/cloud/test_baremetal_ports.py
View File

@ -48,7 +48,7 @@ class TestBaremetalPort(base.IronicTestCase):
self.fake_baremetal_port2]}), self.fake_baremetal_port2]}),
]) ])
return_value = self.op_cloud.list_nics() return_value = self.cloud.list_nics()
self.assertEqual(2, len(return_value['ports'])) self.assertEqual(2, len(return_value['ports']))
self.assertEqual(self.fake_baremetal_port, return_value['ports'][0]) self.assertEqual(self.fake_baremetal_port, return_value['ports'][0])
self.assert_calls() self.assert_calls()
@ -60,7 +60,7 @@ class TestBaremetalPort(base.IronicTestCase):
status_code=400) status_code=400)
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.list_nics) self.cloud.list_nics)
self.assert_calls() self.assert_calls()
def test_list_nics_for_machine(self): def test_list_nics_for_machine(self):
@ -73,7 +73,7 @@ class TestBaremetalPort(base.IronicTestCase):
self.fake_baremetal_port2]}), self.fake_baremetal_port2]}),
]) ])
return_value = self.op_cloud.list_nics_for_machine( return_value = self.cloud.list_nics_for_machine(
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assertEqual(2, len(return_value['ports'])) self.assertEqual(2, len(return_value['ports']))
self.assertEqual(self.fake_baremetal_port, return_value['ports'][0]) self.assertEqual(self.fake_baremetal_port, return_value['ports'][0])
@ -89,7 +89,7 @@ class TestBaremetalPort(base.IronicTestCase):
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.list_nics_for_machine, self.cloud.list_nics_for_machine,
self.fake_baremetal_node['uuid']) self.fake_baremetal_node['uuid'])
self.assert_calls() self.assert_calls()
@ -102,7 +102,7 @@ class TestBaremetalPort(base.IronicTestCase):
json={'ports': [self.fake_baremetal_port]}), json={'ports': [self.fake_baremetal_port]}),
]) ])
return_value = self.op_cloud.get_nic_by_mac(mac) return_value = self.cloud.get_nic_by_mac(mac)
self.assertEqual(self.fake_baremetal_port, return_value) self.assertEqual(self.fake_baremetal_port, return_value)
self.assert_calls() self.assert_calls()
@ -116,6 +116,6 @@ class TestBaremetalPort(base.IronicTestCase):
json={'ports': []}), json={'ports': []}),
]) ])
self.assertIsNone(self.op_cloud.get_nic_by_mac(mac)) self.assertIsNone(self.cloud.get_nic_by_mac(mac))
self.assert_calls() self.assert_calls()

24
openstack/tests/unit/cloud/test_domains.py
View File

@ -36,7 +36,7 @@ class TestDomains(base.RequestsMockTestCase):
self.register_uris([ self.register_uris([
dict(method='GET', uri=self.get_mock_url(), status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json={'domains': [domain_data.json_response['domain']]})]) json={'domains': [domain_data.json_response['domain']]})])
domains = self.op_cloud.list_domains() domains = self.cloud.list_domains()
self.assertThat(len(domains), matchers.Equals(1)) self.assertThat(len(domains), matchers.Equals(1))
self.assertThat(domains[0].name, self.assertThat(domains[0].name,
matchers.Equals(domain_data.domain_name)) matchers.Equals(domain_data.domain_name))
@ -51,7 +51,7 @@ class TestDomains(base.RequestsMockTestCase):
uri=self.get_mock_url(append=[domain_data.domain_id]), uri=self.get_mock_url(append=[domain_data.domain_id]),
status_code=200, status_code=200,
json=domain_data.json_response)]) json=domain_data.json_response)])
domain = self.op_cloud.get_domain(domain_id=domain_data.domain_id) domain = self.cloud.get_domain(domain_id=domain_data.domain_id)
self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id))
self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name))
self.assert_calls() self.assert_calls()
@ -64,8 +64,8 @@ class TestDomains(base.RequestsMockTestCase):
json=response), json=response),
dict(method='GET', uri=self.get_mock_url(), status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json=response)]) json=response)])
domain = self.op_cloud.get_domain(name_or_id=domain_data.domain_id) domain = self.cloud.get_domain(name_or_id=domain_data.domain_id)
domain_by_name = self.op_cloud.get_domain( domain_by_name = self.cloud.get_domain(
name_or_id=domain_data.domain_name) name_or_id=domain_data.domain_name)
self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id))
self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name))
@ -82,7 +82,7 @@ class TestDomains(base.RequestsMockTestCase):
dict(method='POST', uri=self.get_mock_url(), status_code=200, dict(method='POST', uri=self.get_mock_url(), status_code=200,
json=domain_data.json_response, json=domain_data.json_response,
validate=dict(json=domain_data.json_request))]) validate=dict(json=domain_data.json_request))])
domain = self.op_cloud.create_domain( domain = self.cloud.create_domain(
domain_data.domain_name, domain_data.description) domain_data.domain_name, domain_data.description)
self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id))
self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name))
@ -101,7 +101,7 @@ class TestDomains(base.RequestsMockTestCase):
dict(method='POST', uri=self.get_mock_url(), status_code=400, dict(method='POST', uri=self.get_mock_url(), status_code=400,
json=domain_data.json_response, json=domain_data.json_response,
validate=dict(json=domain_data.json_request))]) validate=dict(json=domain_data.json_request))])
self.op_cloud.create_domain('domain_name') self.cloud.create_domain('domain_name')
self.assert_calls() self.assert_calls()
def test_delete_domain(self): def test_delete_domain(self):
@ -114,7 +114,7 @@ class TestDomains(base.RequestsMockTestCase):
json=new_resp, json=new_resp,
validate=dict(json={'domain': {'enabled': False}})), validate=dict(json={'domain': {'enabled': False}})),
dict(method='DELETE', uri=domain_resource_uri, status_code=204)]) dict(method='DELETE', uri=domain_resource_uri, status_code=204)])
self.op_cloud.delete_domain(domain_data.domain_id) self.cloud.delete_domain(domain_data.domain_id)
self.assert_calls() self.assert_calls()
def test_delete_domain_name_or_id(self): def test_delete_domain_name_or_id(self):
@ -130,7 +130,7 @@ class TestDomains(base.RequestsMockTestCase):
json=new_resp, json=new_resp,
validate=dict(json={'domain': {'enabled': False}})), validate=dict(json={'domain': {'enabled': False}})),
dict(method='DELETE', uri=domain_resource_uri, status_code=204)]) dict(method='DELETE', uri=domain_resource_uri, status_code=204)])
self.op_cloud.delete_domain(name_or_id=domain_data.domain_id) self.cloud.delete_domain(name_or_id=domain_data.domain_id)
self.assert_calls() self.assert_calls()
def test_delete_domain_exception(self): def test_delete_domain_exception(self):
@ -152,7 +152,7 @@ class TestDomains(base.RequestsMockTestCase):
openstack.cloud.OpenStackCloudURINotFound, openstack.cloud.OpenStackCloudURINotFound,
"Failed to delete domain %s" % domain_data.domain_id "Failed to delete domain %s" % domain_data.domain_id
): ):
self.op_cloud.delete_domain(domain_data.domain_id) self.cloud.delete_domain(domain_data.domain_id)
self.assert_calls() self.assert_calls()
def test_update_domain(self): def test_update_domain(self):
@ -163,7 +163,7 @@ class TestDomains(base.RequestsMockTestCase):
dict(method='PATCH', uri=domain_resource_uri, status_code=200, dict(method='PATCH', uri=domain_resource_uri, status_code=200,
json=domain_data.json_response, json=domain_data.json_response,
validate=dict(json=domain_data.json_request))]) validate=dict(json=domain_data.json_request))])
domain = self.op_cloud.update_domain( domain = self.cloud.update_domain(
domain_data.domain_id, domain_data.domain_id,
name=domain_data.domain_name, name=domain_data.domain_name,
description=domain_data.description) description=domain_data.description)
@ -183,7 +183,7 @@ class TestDomains(base.RequestsMockTestCase):
dict(method='PATCH', uri=domain_resource_uri, status_code=200, dict(method='PATCH', uri=domain_resource_uri, status_code=200,
json=domain_data.json_response, json=domain_data.json_response,
validate=dict(json=domain_data.json_request))]) validate=dict(json=domain_data.json_request))])
domain = self.op_cloud.update_domain( domain = self.cloud.update_domain(
name_or_id=domain_data.domain_id, name_or_id=domain_data.domain_id,
name=domain_data.domain_name, name=domain_data.domain_name,
description=domain_data.description) description=domain_data.description)
@ -206,5 +206,5 @@ class TestDomains(base.RequestsMockTestCase):
openstack.cloud.OpenStackCloudHTTPError, openstack.cloud.OpenStackCloudHTTPError,
"Error in updating domain %s" % domain_data.domain_id "Error in updating domain %s" % domain_data.domain_id
): ):
self.op_cloud.delete_domain(domain_data.domain_id) self.cloud.delete_domain(domain_data.domain_id)
self.assert_calls() self.assert_calls()

26
openstack/tests/unit/cloud/test_endpoints.py
View File

@ -82,7 +82,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
validate=dict(json=other_endpoint_data.json_request)) validate=dict(json=other_endpoint_data.json_request))
]) ])
endpoints = self.op_cloud.create_endpoint( endpoints = self.cloud.create_endpoint(
service_name_or_id=service_data.service_id, service_name_or_id=service_data.service_id,
region=endpoint_data.region, region=endpoint_data.region,
public_url=endpoint_data.public_url, public_url=endpoint_data.public_url,
@ -103,12 +103,12 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
# test v3 semantics on v2.0 endpoint # test v3 semantics on v2.0 endpoint
self.assertRaises(OpenStackCloudException, self.assertRaises(OpenStackCloudException,
self.op_cloud.create_endpoint, self.cloud.create_endpoint,
service_name_or_id='service1', service_name_or_id='service1',
interface='mock_admin_url', interface='mock_admin_url',
url='admin') url='admin')
endpoints_3on2 = self.op_cloud.create_endpoint( endpoints_3on2 = self.cloud.create_endpoint(
service_name_or_id=service_data.service_id, service_name_or_id=service_data.service_id,
region=endpoint_data.region, region=endpoint_data.region,
interface='public', interface='public',
@ -177,7 +177,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
validate=dict(json=admin_endpoint_data.json_request)), validate=dict(json=admin_endpoint_data.json_request)),
]) ])
endpoints = self.op_cloud.create_endpoint( endpoints = self.cloud.create_endpoint(
service_name_or_id=service_data.service_id, service_name_or_id=service_data.service_id,
region=public_endpoint_data_disabled.region, region=public_endpoint_data_disabled.region,
url=public_endpoint_data_disabled.url, url=public_endpoint_data_disabled.url,
@ -202,7 +202,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
self.assertThat(endpoints[0].enabled, self.assertThat(endpoints[0].enabled,
matchers.Equals(public_endpoint_data_disabled.enabled)) matchers.Equals(public_endpoint_data_disabled.enabled))
endpoints_2on3 = self.op_cloud.create_endpoint( endpoints_2on3 = self.cloud.create_endpoint(
service_name_or_id=service_data.service_id, service_name_or_id=service_data.service_id,
region=public_endpoint_data.region, region=public_endpoint_data.region,
public_url=public_endpoint_data.url, public_url=public_endpoint_data.url,
@ -230,7 +230,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
def test_update_endpoint_v2(self): def test_update_endpoint_v2(self):
self.use_keystone_v2() self.use_keystone_v2()
self.assertRaises(OpenStackCloudUnavailableFeature, self.assertRaises(OpenStackCloudUnavailableFeature,
self.op_cloud.update_endpoint, 'endpoint_id') self.cloud.update_endpoint, 'endpoint_id')
def test_update_endpoint_v3(self): def test_update_endpoint_v3(self):
service_data = self._get_service_data() service_data = self._get_service_data()
@ -247,7 +247,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
json=endpoint_data.json_response, json=endpoint_data.json_response,
validate=dict(json=reference_request)) validate=dict(json=reference_request))
]) ])
endpoint = self.op_cloud.update_endpoint( endpoint = self.cloud.update_endpoint(
endpoint_data.endpoint_id, endpoint_data.endpoint_id,
service_name_or_id=service_data.service_id, service_name_or_id=service_data.service_id,
region=endpoint_data.region, region=endpoint_data.region,
@ -278,7 +278,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
for e in endpoints_data]}) for e in endpoints_data]})
]) ])
endpoints = self.op_cloud.list_endpoints() endpoints = self.cloud.list_endpoints()
# test we are getting exactly len(self.mock_endpoints) elements # test we are getting exactly len(self.mock_endpoints) elements
self.assertThat(len(endpoints), matchers.Equals(len(endpoints_data))) self.assertThat(len(endpoints), matchers.Equals(len(endpoints_data)))
@ -324,7 +324,7 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
]) ])
# Search by id # Search by id
endpoints = self.op_cloud.search_endpoints( endpoints = self.cloud.search_endpoints(
id=endpoints_data[-1].endpoint_id) id=endpoints_data[-1].endpoint_id)
# # test we are getting exactly 1 element # # test we are getting exactly 1 element
self.assertEqual(1, len(endpoints)) self.assertEqual(1, len(endpoints))
@ -338,17 +338,17 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
matchers.Equals(endpoints_data[-1].interface)) matchers.Equals(endpoints_data[-1].interface))
# Not found # Not found
endpoints = self.op_cloud.search_endpoints(id='!invalid!') endpoints = self.cloud.search_endpoints(id='!invalid!')
self.assertEqual(0, len(endpoints)) self.assertEqual(0, len(endpoints))
# Multiple matches # Multiple matches
endpoints = self.op_cloud.search_endpoints( endpoints = self.cloud.search_endpoints(
filters={'region_id': 'region1'}) filters={'region_id': 'region1'})
# # test we are getting exactly 2 elements # # test we are getting exactly 2 elements
self.assertEqual(2, len(endpoints)) self.assertEqual(2, len(endpoints))
# test we are getting the correct response for region/region_id compat # test we are getting the correct response for region/region_id compat
endpoints = self.op_cloud.search_endpoints( endpoints = self.cloud.search_endpoints(
filters={'region': 'region1'}) filters={'region': 'region1'})
# # test we are getting exactly 2 elements, this is v3 # # test we are getting exactly 2 elements, this is v3
self.assertEqual(2, len(endpoints)) self.assertEqual(2, len(endpoints))
@ -369,5 +369,5 @@ class TestCloudEndpoints(base.RequestsMockTestCase):
]) ])
# Delete by id # Delete by id
self.op_cloud.delete_endpoint(id=endpoint_data.endpoint_id) self.cloud.delete_endpoint(id=endpoint_data.endpoint_id)
self.assert_calls() self.assert_calls()

18
openstack/tests/unit/cloud/test_flavors.py
View File

@ -38,7 +38,7 @@ class TestFlavors(base.RequestsMockTestCase):
"disk": 1600, "disk": 1600,
"id": None}}))]) "id": None}}))])
self.op_cloud.create_flavor( self.cloud.create_flavor(
'vanilla', ram=65536, disk=1600, vcpus=24, 'vanilla', ram=65536, disk=1600, vcpus=24,
) )
self.assert_calls() self.assert_calls()
@ -52,7 +52,7 @@ class TestFlavors(base.RequestsMockTestCase):
dict(method='DELETE', dict(method='DELETE',
uri='{endpoint}/flavors/{id}'.format( uri='{endpoint}/flavors/{id}'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=fakes.FLAVOR_ID))]) endpoint=fakes.COMPUTE_ENDPOINT, id=fakes.FLAVOR_ID))])
self.assertTrue(self.op_cloud.delete_flavor('vanilla')) self.assertTrue(self.cloud.delete_flavor('vanilla'))
self.assert_calls() self.assert_calls()
@ -63,7 +63,7 @@ class TestFlavors(base.RequestsMockTestCase):
endpoint=fakes.COMPUTE_ENDPOINT), endpoint=fakes.COMPUTE_ENDPOINT),
json={'flavors': fakes.FAKE_FLAVOR_LIST})]) json={'flavors': fakes.FAKE_FLAVOR_LIST})])
self.assertFalse(self.op_cloud.delete_flavor('invalid')) self.assertFalse(self.cloud.delete_flavor('invalid'))
self.assert_calls() self.assert_calls()
@ -79,7 +79,7 @@ class TestFlavors(base.RequestsMockTestCase):
status_code=503)]) status_code=503)])
self.assertRaises(openstack.cloud.OpenStackCloudException, self.assertRaises(openstack.cloud.OpenStackCloudException,
self.op_cloud.delete_flavor, 'vanilla') self.cloud.delete_flavor, 'vanilla')
def test_list_flavors(self): def test_list_flavors(self):
uris_to_mock = [ uris_to_mock = [
@ -185,7 +185,7 @@ class TestFlavors(base.RequestsMockTestCase):
endpoint=fakes.COMPUTE_ENDPOINT, id=1), endpoint=fakes.COMPUTE_ENDPOINT, id=1),
json=dict(extra_specs=extra_specs))]) json=dict(extra_specs=extra_specs))])
self.op_cloud.set_flavor_specs(1, extra_specs) self.cloud.set_flavor_specs(1, extra_specs)
self.assert_calls() self.assert_calls()
def test_unset_flavor_specs(self): def test_unset_flavor_specs(self):
@ -196,7 +196,7 @@ class TestFlavors(base.RequestsMockTestCase):
endpoint=fakes.COMPUTE_ENDPOINT, id=1, key=key)) endpoint=fakes.COMPUTE_ENDPOINT, id=1, key=key))
for key in keys]) for key in keys])
self.op_cloud.unset_flavor_specs(1, keys) self.cloud.unset_flavor_specs(1, keys)
self.assert_calls() self.assert_calls()
def test_add_flavor_access(self): def test_add_flavor_access(self):
@ -210,7 +210,7 @@ class TestFlavors(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'addTenantAccess': {'tenant': 'tenant_id'}}))]) json={'addTenantAccess': {'tenant': 'tenant_id'}}))])
self.op_cloud.add_flavor_access('flavor_id', 'tenant_id') self.cloud.add_flavor_access('flavor_id', 'tenant_id')
self.assert_calls() self.assert_calls()
def test_remove_flavor_access(self): def test_remove_flavor_access(self):
@ -222,7 +222,7 @@ class TestFlavors(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'removeTenantAccess': {'tenant': 'tenant_id'}}))]) json={'removeTenantAccess': {'tenant': 'tenant_id'}}))])
self.op_cloud.remove_flavor_access('flavor_id', 'tenant_id') self.cloud.remove_flavor_access('flavor_id', 'tenant_id')
self.assert_calls() self.assert_calls()
def test_list_flavor_access(self): def test_list_flavor_access(self):
@ -234,7 +234,7 @@ class TestFlavors(base.RequestsMockTestCase):
'flavor_access': [ 'flavor_access': [
{'flavor_id': 'vanilla', 'tenant_id': 'tenant_id'}]}) {'flavor_id': 'vanilla', 'tenant_id': 'tenant_id'}]})
]) ])
self.op_cloud.list_flavor_access('vanilla') self.cloud.list_flavor_access('vanilla')
self.assert_calls() self.assert_calls()
def test_get_flavor_by_id(self): def test_get_flavor_by_id(self):

12
openstack/tests/unit/cloud/test_groups.py
View File

@ -34,7 +34,7 @@ class TestGroups(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'groups': [group_data.json_response['group']]}) json={'groups': [group_data.json_response['group']]})
]) ])
self.op_cloud.list_groups() self.cloud.list_groups()
def test_get_group(self): def test_get_group(self):
group_data = self._get_group_data() group_data = self._get_group_data()
@ -44,7 +44,7 @@ class TestGroups(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'groups': [group_data.json_response['group']]}), json={'groups': [group_data.json_response['group']]}),
]) ])
self.op_cloud.get_group(group_data.group_id) self.cloud.get_group(group_data.group_id)
def test_delete_group(self): def test_delete_group(self):
group_data = self._get_group_data() group_data = self._get_group_data()
@ -57,7 +57,7 @@ class TestGroups(base.RequestsMockTestCase):
uri=self.get_mock_url(append=[group_data.group_id]), uri=self.get_mock_url(append=[group_data.group_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.delete_group(group_data.group_id)) self.assertTrue(self.cloud.delete_group(group_data.group_id))
def test_create_group(self): def test_create_group(self):
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
@ -74,7 +74,7 @@ class TestGroups(base.RequestsMockTestCase):
json=group_data.json_response, json=group_data.json_response,
validate=dict(json=group_data.json_request)) validate=dict(json=group_data.json_request))
]) ])
self.op_cloud.create_group( self.cloud.create_group(
name=group_data.group_name, description=group_data.description, name=group_data.group_name, description=group_data.description,
domain=group_data.domain_id) domain=group_data.domain_id)
@ -93,5 +93,5 @@ class TestGroups(base.RequestsMockTestCase):
json=group_data.json_response, json=group_data.json_response,
validate=dict(json=group_data.json_request)) validate=dict(json=group_data.json_request))
]) ])
self.op_cloud.update_group(group_data.group_id, group_data.group_name, self.cloud.update_group(
group_data.description) group_data.group_id, group_data.group_name, group_data.description)

30
openstack/tests/unit/cloud/test_identity_roles.py
View File

@ -51,7 +51,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [role_data.json_response['role']]}) json={'roles': [role_data.json_response['role']]})
]) ])
self.op_cloud.list_roles() self.cloud.list_roles()
self.assert_calls() self.assert_calls()
def test_get_role_by_name(self): def test_get_role_by_name(self):
@ -62,7 +62,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [role_data.json_response['role']]}) json={'roles': [role_data.json_response['role']]})
]) ])
role = self.op_cloud.get_role(role_data.role_name) role = self.cloud.get_role(role_data.role_name)
self.assertIsNotNone(role) self.assertIsNotNone(role)
self.assertThat(role.id, matchers.Equals(role_data.role_id)) self.assertThat(role.id, matchers.Equals(role_data.role_id))
@ -77,7 +77,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [role_data.json_response['role']]}) json={'roles': [role_data.json_response['role']]})
]) ])
role = self.op_cloud.get_role(role_data.role_id) role = self.cloud.get_role(role_data.role_id)
self.assertIsNotNone(role) self.assertIsNotNone(role)
self.assertThat(role.id, matchers.Equals(role_data.role_id)) self.assertThat(role.id, matchers.Equals(role_data.role_id))
@ -94,7 +94,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
validate=dict(json=role_data.json_request)) validate=dict(json=role_data.json_request))
]) ])
role = self.op_cloud.create_role(role_data.role_name) role = self.cloud.create_role(role_data.role_name)
self.assertIsNotNone(role) self.assertIsNotNone(role)
self.assertThat(role.name, matchers.Equals(role_data.role_name)) self.assertThat(role.name, matchers.Equals(role_data.role_name))
@ -117,8 +117,8 @@ class TestIdentityRoles(base.RequestsMockTestCase):
validate=dict(json=req)) validate=dict(json=req))
]) ])
role = self.op_cloud.update_role(role_data.role_id, role = self.cloud.update_role(
role_data.role_name) role_data.role_id, role_data.role_name)
self.assertIsNotNone(role) self.assertIsNotNone(role)
self.assertThat(role.name, matchers.Equals(role_data.role_name)) self.assertThat(role.name, matchers.Equals(role_data.role_name))
@ -136,7 +136,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
uri=self.get_mock_url(append=[role_data.role_id]), uri=self.get_mock_url(append=[role_data.role_id]),
status_code=204) status_code=204)
]) ])
role = self.op_cloud.delete_role(role_data.role_id) role = self.cloud.delete_role(role_data.role_id)
self.assertThat(role, matchers.Equals(True)) self.assertThat(role, matchers.Equals(True))
self.assert_calls() self.assert_calls()
@ -151,7 +151,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
uri=self.get_mock_url(append=[role_data.role_id]), uri=self.get_mock_url(append=[role_data.role_id]),
status_code=204) status_code=204)
]) ])
role = self.op_cloud.delete_role(role_data.role_name) role = self.cloud.delete_role(role_data.role_name)
self.assertThat(role, matchers.Equals(True)) self.assertThat(role, matchers.Equals(True))
self.assert_calls() self.assert_calls()
@ -179,7 +179,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
json={'role_assignments': response}, json={'role_assignments': response},
complete_qs=True) complete_qs=True)
]) ])
ret = self.op_cloud.list_role_assignments() ret = self.cloud.list_role_assignments()
self.assertThat(len(ret), matchers.Equals(2)) self.assertThat(len(ret), matchers.Equals(2))
self.assertThat(ret[0].user, matchers.Equals(user_data.user_id)) self.assertThat(ret[0].user, matchers.Equals(user_data.user_id))
self.assertThat(ret[0].id, matchers.Equals(role_data.role_id)) self.assertThat(ret[0].id, matchers.Equals(role_data.role_id))
@ -213,7 +213,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
]) ])
params = dict(user=user_data.user_id, domain=domain_data.domain_id, params = dict(user=user_data.user_id, domain=domain_data.domain_id,
effective=True) effective=True)
ret = self.op_cloud.list_role_assignments(filters=params) ret = self.cloud.list_role_assignments(filters=params)
self.assertThat(len(ret), matchers.Equals(1)) self.assertThat(len(ret), matchers.Equals(1))
self.assertThat(ret[0].user, matchers.Equals(user_data.user_id)) self.assertThat(ret[0].user, matchers.Equals(user_data.user_id))
self.assertThat(ret[0].id, matchers.Equals(role_data.role_id)) self.assertThat(ret[0].id, matchers.Equals(role_data.role_id))
@ -229,7 +229,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
openstack.cloud.exc.OpenStackCloudHTTPError, openstack.cloud.exc.OpenStackCloudHTTPError,
"Failed to list role assignments" "Failed to list role assignments"
): ):
self.op_cloud.list_role_assignments() self.cloud.list_role_assignments()
self.assert_calls() self.assert_calls()
def test_list_role_assignments_keystone_v2(self): def test_list_role_assignments_keystone_v2(self):
@ -249,7 +249,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [role_data.json_response['role']]}) json={'roles': [role_data.json_response['role']]})
]) ])
ret = self.op_cloud.list_role_assignments( ret = self.cloud.list_role_assignments(
filters={ filters={
'user': user_data.user_id, 'user': user_data.user_id,
'project': project_data.project_id}) 'project': project_data.project_id})
@ -277,7 +277,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [r.json_response['role'] for r in roles_data]}) json={'roles': [r.json_response['role'] for r in roles_data]})
]) ])
ret = self.op_cloud.list_role_assignments( ret = self.cloud.list_role_assignments(
filters={ filters={
'role': roles_data[0].role_id, 'role': roles_data[0].role_id,
'user': user_data.user_id, 'user': user_data.user_id,
@ -295,7 +295,7 @@ class TestIdentityRoles(base.RequestsMockTestCase):
openstack.cloud.OpenStackCloudException, openstack.cloud.OpenStackCloudException,
"Must provide project and user for keystone v2" "Must provide project and user for keystone v2"
): ):
self.op_cloud.list_role_assignments() self.cloud.list_role_assignments()
self.assert_calls() self.assert_calls()
def test_list_role_assignments_exception_v2_no_project(self): def test_list_role_assignments_exception_v2_no_project(self):
@ -304,5 +304,5 @@ class TestIdentityRoles(base.RequestsMockTestCase):
openstack.cloud.OpenStackCloudException, openstack.cloud.OpenStackCloudException,
"Must provide project and user for keystone v2" "Must provide project and user for keystone v2"
): ):
self.op_cloud.list_role_assignments(filters={'user': '12345'}) self.cloud.list_role_assignments(filters={'user': '12345'})
self.assert_calls() self.assert_calls()

4
openstack/tests/unit/cloud/test_image.py
View File

@ -181,11 +181,11 @@ class TestImage(BaseTestImage):
def test_get_image_name_operator(self): def test_get_image_name_operator(self):
# This should work the same as non-operator, just verifying it does. # This should work the same as non-operator, just verifying it does.
self.test_get_image_name(cloud=self.op_cloud) self.test_get_image_name(cloud=self.cloud)
def test_get_image_id_operator(self): def test_get_image_id_operator(self):
# This should work the same as the other test, just verifying it does. # This should work the same as the other test, just verifying it does.
self.test_get_image_id(cloud=self.op_cloud) self.test_get_image_id(cloud=self.cloud)
def test_empty_list_images(self): def test_empty_list_images(self):
self.register_uris([ self.register_uris([

2
openstack/tests/unit/cloud/test_limits.py
View File

@ -90,6 +90,6 @@ class TestLimits(base.RequestsMockTestCase):
}), }),
]) ])
self.op_cloud.get_compute_limits(project.project_id) self.cloud.get_compute_limits(project.project_id)
self.assert_calls() self.assert_calls()

2
openstack/tests/unit/cloud/test_magnum_services.py
View File

@ -33,7 +33,7 @@ class TestMagnumServices(base.RequestsMockTestCase):
method='GET', method='GET',
uri='https://container-infra.example.com/v1/mservices', uri='https://container-infra.example.com/v1/mservices',
json=dict(mservices=[magnum_service_obj]))]) json=dict(mservices=[magnum_service_obj]))])
mservices_list = self.op_cloud.list_magnum_services() mservices_list = self.cloud.list_magnum_services()
self.assertEqual( self.assertEqual(
mservices_list[0], mservices_list[0],
self.cloud._normalize_magnum_service(magnum_service_obj)) self.cloud._normalize_magnum_service(magnum_service_obj))

24
openstack/tests/unit/cloud/test_operator.py
View File

@ -13,7 +13,6 @@
import mock import mock
import testtools import testtools
import openstack.cloud
from openstack.cloud import exc from openstack.cloud import exc
from openstack.config import cloud_region from openstack.config import cloud_region
from openstack.tests import fakes from openstack.tests import fakes
@ -22,14 +21,11 @@ from openstack.tests.unit import base
class TestOperatorCloud(base.RequestsMockTestCase): class TestOperatorCloud(base.RequestsMockTestCase):
def test_operator_cloud(self):
self.assertIsInstance(self.op_cloud, openstack.cloud.OperatorCloud)
@mock.patch.object(cloud_region.CloudRegion, 'get_endpoint') @mock.patch.object(cloud_region.CloudRegion, 'get_endpoint')
def test_get_session_endpoint_provided(self, fake_get_endpoint): def test_get_session_endpoint_provided(self, fake_get_endpoint):
fake_get_endpoint.return_value = 'http://fake.url' fake_get_endpoint.return_value = 'http://fake.url'
self.assertEqual( self.assertEqual(
'http://fake.url', self.op_cloud.get_session_endpoint('image')) 'http://fake.url', self.cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_region.CloudRegion, 'get_session') @mock.patch.object(cloud_region.CloudRegion, 'get_session')
def test_get_session_endpoint_session(self, get_session_mock): def test_get_session_endpoint_session(self, get_session_mock):
@ -37,7 +33,7 @@ class TestOperatorCloud(base.RequestsMockTestCase):
session_mock.get_endpoint.return_value = 'http://fake.url' session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertEqual( self.assertEqual(
'http://fake.url', self.op_cloud.get_session_endpoint('image')) 'http://fake.url', self.cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_region.CloudRegion, 'get_session') @mock.patch.object(cloud_region.CloudRegion, 'get_session')
def test_get_session_endpoint_exception(self, get_session_mock): def test_get_session_endpoint_exception(self, get_session_mock):
@ -49,27 +45,27 @@ class TestOperatorCloud(base.RequestsMockTestCase):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.side_effect = side_effect session_mock.get_endpoint.side_effect = side_effect
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.op_cloud.name = 'testcloud' self.cloud.name = 'testcloud'
self.op_cloud.region_name = 'testregion' self.cloud.region_name = 'testregion'
with testtools.ExpectedException( with testtools.ExpectedException(
exc.OpenStackCloudException, exc.OpenStackCloudException,
"Error getting image endpoint on testcloud:testregion:" "Error getting image endpoint on testcloud:testregion:"
" No service"): " No service"):
self.op_cloud.get_session_endpoint("image") self.cloud.get_session_endpoint("image")
@mock.patch.object(cloud_region.CloudRegion, 'get_session') @mock.patch.object(cloud_region.CloudRegion, 'get_session')
def test_get_session_endpoint_unavailable(self, get_session_mock): def test_get_session_endpoint_unavailable(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
image_endpoint = self.op_cloud.get_session_endpoint("image") image_endpoint = self.cloud.get_session_endpoint("image")
self.assertIsNone(image_endpoint) self.assertIsNone(image_endpoint)
@mock.patch.object(cloud_region.CloudRegion, 'get_session') @mock.patch.object(cloud_region.CloudRegion, 'get_session')
def test_get_session_endpoint_identity(self, get_session_mock): def test_get_session_endpoint_identity(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.op_cloud.get_session_endpoint('identity') self.cloud.get_session_endpoint('identity')
kwargs = dict( kwargs = dict(
interface='public', region_name='RegionOne', interface='public', region_name='RegionOne',
service_name=None, service_type='identity') service_name=None, service_type='identity')
@ -81,14 +77,14 @@ class TestOperatorCloud(base.RequestsMockTestCase):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertFalse(self.op_cloud.has_service("image")) self.assertFalse(self.cloud.has_service("image"))
@mock.patch.object(cloud_region.CloudRegion, 'get_session') @mock.patch.object(cloud_region.CloudRegion, 'get_session')
def test_has_service_yes(self, get_session_mock): def test_has_service_yes(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = 'http://fake.url' session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertTrue(self.op_cloud.has_service("image")) self.assertTrue(self.cloud.has_service("image"))
def test_list_hypervisors(self): def test_list_hypervisors(self):
'''This test verifies that calling list_hypervisors results in a call '''This test verifies that calling list_hypervisors results in a call
@ -103,7 +99,7 @@ class TestOperatorCloud(base.RequestsMockTestCase):
]}), ]}),
]) ])
r = self.op_cloud.list_hypervisors() r = self.cloud.list_hypervisors()
self.assertEqual(2, len(r)) self.assertEqual(2, len(r))
self.assertEqual('testserver1', r[0]['hypervisor_hostname']) self.assertEqual('testserver1', r[0]['hypervisor_hostname'])

10
openstack/tests/unit/cloud/test_operator_noauth.py
View File

@ -18,7 +18,7 @@ from openstack.tests.unit import base
class TestOpenStackCloudOperatorNoAuth(base.RequestsMockTestCase): class TestOpenStackCloudOperatorNoAuth(base.RequestsMockTestCase):
def setUp(self): def setUp(self):
"""Setup Noauth OperatorCloud tests """Setup Noauth OpenStackCloud tests
Setup the test to utilize no authentication and an endpoint Setup the test to utilize no authentication and an endpoint
URL in the auth data. This is permits testing of the basic URL in the auth data. This is permits testing of the basic
@ -41,7 +41,7 @@ class TestOpenStackCloudOperatorNoAuth(base.RequestsMockTestCase):
]) ])
def test_ironic_noauth_none_auth_type(self): def test_ironic_noauth_none_auth_type(self):
"""Test noauth selection for Ironic in OperatorCloud """Test noauth selection for Ironic in OpenStackCloud
The new way of doing this is with the keystoneauth none plugin. The new way of doing this is with the keystoneauth none plugin.
""" """
@ -50,7 +50,7 @@ class TestOpenStackCloudOperatorNoAuth(base.RequestsMockTestCase):
# with 'v1'. As such, since we are overriding the endpoint, # with 'v1'. As such, since we are overriding the endpoint,
# we must explicitly do the same as we move away from the # we must explicitly do the same as we move away from the
# client library. # client library.
self.cloud_noauth = openstack.cloud.operator_cloud( self.cloud_noauth = openstack.cloud.openstack_cloud(
auth_type='none', auth_type='none',
baremetal_endpoint_override="https://bare-metal.example.com/v1") baremetal_endpoint_override="https://bare-metal.example.com/v1")
@ -59,11 +59,11 @@ class TestOpenStackCloudOperatorNoAuth(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_ironic_noauth_admin_token_auth_type(self): def test_ironic_noauth_admin_token_auth_type(self):
"""Test noauth selection for Ironic in OperatorCloud """Test noauth selection for Ironic in OpenStackCloud
The old way of doing this was to abuse admin_token. The old way of doing this was to abuse admin_token.
""" """
self.cloud_noauth = openstack.cloud.operator_cloud( self.cloud_noauth = openstack.cloud.openstack_cloud(
auth_type='admin_token', auth_type='admin_token',
auth=dict( auth=dict(
endpoint='https://bare-metal.example.com/v1', endpoint='https://bare-metal.example.com/v1',

24
openstack/tests/unit/cloud/test_project.py
View File

@ -41,7 +41,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, json=project_data.json_response, status_code=200, json=project_data.json_response,
validate=dict(json=project_data.json_request)) validate=dict(json=project_data.json_request))
]) ])
project = self.op_cloud.create_project( project = self.cloud.create_project(
name=project_data.project_name, name=project_data.project_name,
description=project_data.description) description=project_data.description)
self.assertThat(project.id, matchers.Equals(project_data.project_id)) self.assertThat(project.id, matchers.Equals(project_data.project_id))
@ -61,7 +61,7 @@ class TestProject(base.RequestsMockTestCase):
json=project_data.json_response, json=project_data.json_response,
validate=dict(json=reference_req)) validate=dict(json=reference_req))
]) ])
project = self.op_cloud.create_project( project = self.cloud.create_project(
name=project_data.project_name, name=project_data.project_name,
description=project_data.description, description=project_data.description,
domain_id=project_data.domain_id) domain_id=project_data.domain_id)
@ -80,7 +80,7 @@ class TestProject(base.RequestsMockTestCase):
"User or project creation requires an explicit" "User or project creation requires an explicit"
" domain_id argument." " domain_id argument."
): ):
self.op_cloud.create_project(name='foo', description='bar') self.cloud.create_project(name='foo', description='bar')
def test_delete_project_v2(self): def test_delete_project_v2(self):
self.use_keystone_v2() self.use_keystone_v2()
@ -95,7 +95,7 @@ class TestProject(base.RequestsMockTestCase):
v3=False, append=[project_data.project_id]), v3=False, append=[project_data.project_id]),
status_code=204) status_code=204)
]) ])
self.op_cloud.delete_project(project_data.project_id) self.cloud.delete_project(project_data.project_id)
self.assert_calls() self.assert_calls()
def test_delete_project_v3(self): def test_delete_project_v3(self):
@ -109,7 +109,7 @@ class TestProject(base.RequestsMockTestCase):
uri=self.get_mock_url(append=[project_data.project_id]), uri=self.get_mock_url(append=[project_data.project_id]),
status_code=204) status_code=204)
]) ])
self.op_cloud.delete_project(project_data.project_id) self.cloud.delete_project(project_data.project_id)
self.assert_calls() self.assert_calls()
def test_update_project_not_found(self): def test_update_project_not_found(self):
@ -129,7 +129,7 @@ class TestProject(base.RequestsMockTestCase):
openstack.cloud.OpenStackCloudException, openstack.cloud.OpenStackCloudException,
"Project %s not found." % project_data.project_id "Project %s not found." % project_data.project_id
): ):
self.op_cloud.update_project(project_data.project_id) self.cloud.update_project(project_data.project_id)
self.assert_calls() self.assert_calls()
def test_update_project_v2(self): def test_update_project_v2(self):
@ -152,7 +152,7 @@ class TestProject(base.RequestsMockTestCase):
json=project_data.json_response, json=project_data.json_response,
validate=dict(json=project_data.json_request)) validate=dict(json=project_data.json_request))
]) ])
project = self.op_cloud.update_project( project = self.cloud.update_project(
project_data.project_id, project_data.project_id,
description=project_data.description) description=project_data.description)
self.assertThat(project.id, matchers.Equals(project_data.project_id)) self.assertThat(project.id, matchers.Equals(project_data.project_id))
@ -182,7 +182,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, json=project_data.json_response, status_code=200, json=project_data.json_response,
validate=dict(json=reference_req)) validate=dict(json=reference_req))
]) ])
project = self.op_cloud.update_project( project = self.cloud.update_project(
project_data.project_id, project_data.project_id,
description=project_data.description, description=project_data.description,
domain_id=project_data.domain_id) domain_id=project_data.domain_id)
@ -204,7 +204,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'projects': [project_data.json_response['project']]}) json={'projects': [project_data.json_response['project']]})
]) ])
projects = self.op_cloud.list_projects(project_data.domain_id) projects = self.cloud.list_projects(project_data.domain_id)
self.assertThat(len(projects), matchers.Equals(1)) self.assertThat(len(projects), matchers.Equals(1))
self.assertThat( self.assertThat(
projects[0].id, matchers.Equals(project_data.project_id)) projects[0].id, matchers.Equals(project_data.project_id))
@ -221,7 +221,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'projects': [project_data.json_response['project']]}) json={'projects': [project_data.json_response['project']]})
]) ])
projects = self.op_cloud.list_projects( projects = self.cloud.list_projects(
domain_id=project_data.domain_id) domain_id=project_data.domain_id)
self.assertThat(len(projects), matchers.Equals(1)) self.assertThat(len(projects), matchers.Equals(1))
self.assertThat( self.assertThat(
@ -237,7 +237,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'projects': [project_data.json_response['project']]}) json={'projects': [project_data.json_response['project']]})
]) ])
projects = self.op_cloud.search_projects(project_data.project_id) projects = self.cloud.search_projects(project_data.project_id)
self.assertThat(len(projects), matchers.Equals(1)) self.assertThat(len(projects), matchers.Equals(1))
self.assertThat( self.assertThat(
projects[0].id, matchers.Equals(project_data.project_id)) projects[0].id, matchers.Equals(project_data.project_id))
@ -254,7 +254,7 @@ class TestProject(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'projects': [project_data.json_response['project']]}) json={'projects': [project_data.json_response['project']]})
]) ])
projects = self.op_cloud.search_projects( projects = self.cloud.search_projects(
domain_id=project_data.domain_id) domain_id=project_data.domain_id)
self.assertThat(len(projects), matchers.Equals(1)) self.assertThat(len(projects), matchers.Equals(1))
self.assertThat( self.assertThat(

22
openstack/tests/unit/cloud/test_quotas.py
View File

@ -54,7 +54,7 @@ class TestQuotas(base.RequestsMockTestCase):
}})), }})),
]) ])
self.op_cloud.set_compute_quotas(project.project_id, cores=1) self.cloud.set_compute_quotas(project.project_id, cores=1)
self.assert_calls() self.assert_calls()
@ -71,7 +71,7 @@ class TestQuotas(base.RequestsMockTestCase):
]) ])
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.set_compute_quotas, project.project_id) self.cloud.set_compute_quotas, project.project_id)
self.assert_calls() self.assert_calls()
@ -86,7 +86,7 @@ class TestQuotas(base.RequestsMockTestCase):
json={'quota_set': fake_quota_set}), json={'quota_set': fake_quota_set}),
]) ])
self.op_cloud.get_compute_quotas(project.project_id) self.cloud.get_compute_quotas(project.project_id)
self.assert_calls() self.assert_calls()
@ -101,7 +101,7 @@ class TestQuotas(base.RequestsMockTestCase):
append=['os-quota-sets', project.project_id])), append=['os-quota-sets', project.project_id])),
]) ])
self.op_cloud.delete_compute_quotas(project.project_id) self.cloud.delete_compute_quotas(project.project_id)
self.assert_calls() self.assert_calls()
@ -118,7 +118,7 @@ class TestQuotas(base.RequestsMockTestCase):
json={'quota_set': { json={'quota_set': {
'volumes': 1, 'volumes': 1,
'tenant_id': project.project_id}}))]) 'tenant_id': project.project_id}}))])
self.op_cloud.set_volume_quotas(project.project_id, volumes=1) self.cloud.set_volume_quotas(project.project_id, volumes=1)
self.assert_calls() self.assert_calls()
def test_cinder_get_quotas(self): def test_cinder_get_quotas(self):
@ -130,7 +130,7 @@ class TestQuotas(base.RequestsMockTestCase):
'volumev2', 'public', 'volumev2', 'public',
append=['os-quota-sets', project.project_id]), append=['os-quota-sets', project.project_id]),
json=dict(quota_set={'snapshots': 10, 'volumes': 20}))]) json=dict(quota_set={'snapshots': 10, 'volumes': 20}))])
self.op_cloud.get_volume_quotas(project.project_id) self.cloud.get_volume_quotas(project.project_id)
self.assert_calls() self.assert_calls()
def test_cinder_delete_quotas(self): def test_cinder_delete_quotas(self):
@ -141,7 +141,7 @@ class TestQuotas(base.RequestsMockTestCase):
uri=self.get_mock_url( uri=self.get_mock_url(
'volumev2', 'public', 'volumev2', 'public',
append=['os-quota-sets', project.project_id]))]) append=['os-quota-sets', project.project_id]))])
self.op_cloud.delete_volume_quotas(project.project_id) self.cloud.delete_volume_quotas(project.project_id)
self.assert_calls() self.assert_calls()
def test_neutron_update_quotas(self): def test_neutron_update_quotas(self):
@ -157,7 +157,7 @@ class TestQuotas(base.RequestsMockTestCase):
validate=dict( validate=dict(
json={'quota': {'network': 1}})) json={'quota': {'network': 1}}))
]) ])
self.op_cloud.set_network_quotas(project.project_id, network=1) self.cloud.set_network_quotas(project.project_id, network=1)
self.assert_calls() self.assert_calls()
def test_neutron_get_quotas(self): def test_neutron_get_quotas(self):
@ -182,7 +182,7 @@ class TestQuotas(base.RequestsMockTestCase):
'%s.json' % project.project_id]), '%s.json' % project.project_id]),
json={'quota': quota}) json={'quota': quota})
]) ])
received_quota = self.op_cloud.get_network_quotas(project.project_id) received_quota = self.cloud.get_network_quotas(project.project_id)
self.assertDictEqual(quota, received_quota) self.assertDictEqual(quota, received_quota)
self.assert_calls() self.assert_calls()
@ -235,7 +235,7 @@ class TestQuotas(base.RequestsMockTestCase):
'%s/details.json' % project.project_id]), '%s/details.json' % project.project_id]),
json={'quota': quota_details}) json={'quota': quota_details})
]) ])
received_quota_details = self.op_cloud.get_network_quotas( received_quota_details = self.cloud.get_network_quotas(
project.project_id, details=True) project.project_id, details=True)
self.assertDictEqual(quota_details, received_quota_details) self.assertDictEqual(quota_details, received_quota_details)
self.assert_calls() self.assert_calls()
@ -251,5 +251,5 @@ class TestQuotas(base.RequestsMockTestCase):
'%s.json' % project.project_id]), '%s.json' % project.project_id]),
json={}) json={})
]) ])
self.op_cloud.delete_network_quotas(project.project_id) self.cloud.delete_network_quotas(project.project_id)
self.assert_calls() self.assert_calls()

160
openstack/tests/unit/cloud/test_role_assignment.py
View File

@ -160,12 +160,12 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=201) status_code=201)
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -305,22 +305,22 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=201) status_code=201)
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data_v2.project_id)) project=self.project_data_v2.project_id))
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data_v2.project_id)) project=self.project_data_v2.project_id))
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data_v2.project_id)) project=self.project_data_v2.project_id))
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data_v2.project_id)) project=self.project_data_v2.project_id))
@ -354,7 +354,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': [self.role_data.json_response['role']]}), json={'roles': [self.role_data.json_response['role']]}),
]) ])
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data_v2.project_id)) project=self.project_data_v2.project_id))
@ -424,12 +424,12 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=204), status_code=204),
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -496,11 +496,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
entity_type='user', entity_type='user',
entity_id=self.user_data.user_id)}), entity_id=self.user_data.user_id)}),
]) ])
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -569,11 +569,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -640,11 +640,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
entity_type='group', entity_type='group',
entity_id=self.group_data.group_id)}), entity_id=self.group_data.group_id)}),
]) ])
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -777,19 +777,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
@ -914,19 +914,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
entity_type='user', entity_type='user',
entity_id=self.user_data.user_id)}), entity_id=self.user_data.user_id)}),
]) ])
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
@ -1059,19 +1059,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.grant_role( self.assertTrue(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
@ -1196,19 +1196,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
entity_type='group', entity_type='group',
entity_id=self.group_data.group_id)}), entity_id=self.group_data.group_id)}),
]) ])
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertFalse(self.op_cloud.grant_role( self.assertFalse(self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
@ -1292,11 +1292,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1406,19 +1406,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'roles': []}) json={'roles': []})
]) ])
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1462,7 +1462,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204), status_code=204),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1517,11 +1517,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
complete_qs=True, complete_qs=True,
json={'role_assignments': []}), json={'role_assignments': []}),
]) ])
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1602,11 +1602,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
'roles', 'roles',
self.role_data.role_id])), self.role_data.role_id])),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_id, self.role_data.role_id,
user=self.user_data.user_id, user=self.user_data.user_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1661,11 +1661,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
complete_qs=True, complete_qs=True,
json={'role_assignments': []}), json={'role_assignments': []}),
]) ])
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1746,11 +1746,11 @@ class TestRoleAssignment(base.RequestsMockTestCase):
'roles', 'roles',
self.role_data.role_id])), self.role_data.role_id])),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
project=self.project_data.project_id)) project=self.project_data.project_id))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
project=self.project_data.project_id)) project=self.project_data.project_id))
@ -1851,19 +1851,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
complete_qs=True, complete_qs=True,
json={'role_assignments': []}), json={'role_assignments': []}),
]) ])
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
@ -2016,19 +2016,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
'roles', 'roles',
self.role_data.role_id])), self.role_data.role_id])),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.user_id, user=self.user_data.user_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
@ -2129,19 +2129,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
complete_qs=True, complete_qs=True,
json={'role_assignments': []}), json={'role_assignments': []}),
]) ])
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertFalse(self.op_cloud.revoke_role( self.assertFalse(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
@ -2294,19 +2294,19 @@ class TestRoleAssignment(base.RequestsMockTestCase):
'roles', 'roles',
self.role_data.role_id])), self.role_data.role_id])),
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_name)) domain=self.domain_data.domain_name))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_id, group=self.group_data.group_id,
domain=self.domain_data.domain_id)) domain=self.domain_data.domain_id))
@ -2324,7 +2324,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Role {0} not found'.format(self.role_data.role_name) 'Role {0} not found'.format(self.role_data.role_name)
): ):
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name) domain=self.domain_data.domain_name)
@ -2342,7 +2342,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Role {0} not found'.format(self.role_data.role_name) 'Role {0} not found'.format(self.role_data.role_name)
): ):
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
group=self.group_data.group_name, group=self.group_data.group_name,
domain=self.domain_data.domain_name) domain=self.domain_data.domain_name)
@ -2359,7 +2359,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.op_cloud.grant_role(self.role_data.role_name) self.cloud.grant_role(self.role_data.role_name)
self.assert_calls() self.assert_calls()
def test_revoke_no_user_or_group_specified(self): def test_revoke_no_user_or_group_specified(self):
@ -2373,7 +2373,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.op_cloud.revoke_role(self.role_data.role_name) self.cloud.revoke_role(self.role_data.role_name)
self.assert_calls() self.assert_calls()
def test_grant_no_user_or_group(self): def test_grant_no_user_or_group(self):
@ -2391,7 +2391,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name) user=self.user_data.name)
self.assert_calls() self.assert_calls()
@ -2411,7 +2411,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name) user=self.user_data.name)
self.assert_calls() self.assert_calls()
@ -2435,7 +2435,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Specify either a group or a user, not both' 'Specify either a group or a user, not both'
): ):
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
group=self.group_data.group_name) group=self.group_data.group_name)
@ -2460,7 +2460,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Specify either a group or a user, not both' 'Specify either a group or a user, not both'
): ):
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
group=self.group_data.group_name) group=self.group_data.group_name)
@ -2508,7 +2508,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
status_code=204) status_code=204)
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id, project=self.project_data.project_id,
@ -2562,7 +2562,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
self.role_data.role_id]), self.role_data.role_id]),
status_code=204) status_code=204)
]) ])
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id, project=self.project_data.project_id,
@ -2592,7 +2592,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a domain or project' 'Must specify either a domain or project'
): ):
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name) user=self.user_data.name)
self.assert_calls() self.assert_calls()
@ -2626,7 +2626,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudException, exc.OpenStackCloudException,
'Must specify either a domain or project' 'Must specify either a domain or project'
): ):
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name) user=self.user_data.name)
self.assert_calls() self.assert_calls()
@ -2648,7 +2648,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudURINotFound, exc.OpenStackCloudURINotFound,
'Failed to get domain baddomain' 'Failed to get domain baddomain'
): ):
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain='baddomain') domain='baddomain')
@ -2671,7 +2671,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudURINotFound, exc.OpenStackCloudURINotFound,
'Failed to get domain baddomain' 'Failed to get domain baddomain'
): ):
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
domain='baddomain') domain='baddomain')
@ -2723,7 +2723,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
json={'roles': [self.role_data.json_response['role']]}), json={'roles': [self.role_data.json_response['role']]}),
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id, project=self.project_data.project_id,
@ -2784,7 +2784,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
json={'roles': []}), json={'roles': []}),
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.grant_role( self.cloud.grant_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id, project=self.project_data.project_id,
@ -2839,7 +2839,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
json={'roles': []}), json={'roles': []}),
]) ])
self.assertTrue( self.assertTrue(
self.op_cloud.revoke_role( self.cloud.revoke_role(
self.role_data.role_name, self.role_data.role_name,
user=self.user_data.name, user=self.user_data.name,
project=self.project_data.project_id, project=self.project_data.project_id,
@ -2897,7 +2897,7 @@ class TestRoleAssignment(base.RequestsMockTestCase):
exc.OpenStackCloudTimeout, exc.OpenStackCloudTimeout,
'Timeout waiting for role to be revoked' 'Timeout waiting for role to be revoked'
): ):
self.assertTrue(self.op_cloud.revoke_role( self.assertTrue(self.cloud.revoke_role(
self.role_data.role_name, user=self.user_data.name, self.role_data.role_name, user=self.user_data.name,
project=self.project_data.project_id, wait=True, timeout=0.01)) project=self.project_data.project_id, wait=True, timeout=0.01))
self.assert_calls(do_count=False) self.assert_calls(do_count=False)

32
openstack/tests/unit/cloud/test_services.py
View File

@ -50,7 +50,7 @@ class CloudServices(base.RequestsMockTestCase):
validate=dict(json={'OS-KSADM:service': reference_req})) validate=dict(json={'OS-KSADM:service': reference_req}))
]) ])
service = self.op_cloud.create_service( service = self.cloud.create_service(
name=service_data.service_name, name=service_data.service_name,
service_type=service_data.service_type, service_type=service_data.service_type,
description=service_data.description) description=service_data.description)
@ -74,7 +74,7 @@ class CloudServices(base.RequestsMockTestCase):
validate=dict(json={'service': service_data.json_request})) validate=dict(json={'service': service_data.json_request}))
]) ])
service = self.op_cloud.create_service( service = self.cloud.create_service(
name=service_data.service_name, name=service_data.service_name,
service_type=service_data.service_type, service_type=service_data.service_type,
description=service_data.description) description=service_data.description)
@ -91,7 +91,7 @@ class CloudServices(base.RequestsMockTestCase):
self.use_keystone_v2() self.use_keystone_v2()
# NOTE(SamYaple): Update service only works with v3 api # NOTE(SamYaple): Update service only works with v3 api
self.assertRaises(OpenStackCloudUnavailableFeature, self.assertRaises(OpenStackCloudUnavailableFeature,
self.op_cloud.update_service, self.cloud.update_service,
'service_id', name='new name') 'service_id', name='new name')
def test_update_service_v3(self): def test_update_service_v3(self):
@ -116,8 +116,8 @@ class CloudServices(base.RequestsMockTestCase):
validate=dict(json={'service': request})) validate=dict(json={'service': request}))
]) ])
service = self.op_cloud.update_service(service_data.service_id, service = self.cloud.update_service(
enabled=False) service_data.service_id, enabled=False)
self.assertThat(service.name, self.assertThat(service.name,
matchers.Equals(service_data.service_name)) matchers.Equals(service_data.service_name))
self.assertThat(service.id, matchers.Equals(service_data.service_id)) self.assertThat(service.id, matchers.Equals(service_data.service_id))
@ -135,7 +135,7 @@ class CloudServices(base.RequestsMockTestCase):
status_code=200, status_code=200,
json={'services': [service_data.json_response_v3['service']]}) json={'services': [service_data.json_response_v3['service']]})
]) ])
services = self.op_cloud.list_services() services = self.cloud.list_services()
self.assertThat(len(services), matchers.Equals(1)) self.assertThat(len(services), matchers.Equals(1))
self.assertThat(services[0].id, self.assertThat(services[0].id,
matchers.Equals(service_data.service_id)) matchers.Equals(service_data.service_id))
@ -173,22 +173,22 @@ class CloudServices(base.RequestsMockTestCase):
]) ])
# Search by id # Search by id
service = self.op_cloud.get_service(name_or_id=service_data.service_id) service = self.cloud.get_service(name_or_id=service_data.service_id)
self.assertThat(service.id, matchers.Equals(service_data.service_id)) self.assertThat(service.id, matchers.Equals(service_data.service_id))
# Search by name # Search by name
service = self.op_cloud.get_service( service = self.cloud.get_service(
name_or_id=service_data.service_name) name_or_id=service_data.service_name)
# test we are getting exactly 1 element # test we are getting exactly 1 element
self.assertThat(service.id, matchers.Equals(service_data.service_id)) self.assertThat(service.id, matchers.Equals(service_data.service_id))
# Not found # Not found
service = self.op_cloud.get_service(name_or_id='INVALID SERVICE') service = self.cloud.get_service(name_or_id='INVALID SERVICE')
self.assertIs(None, service) self.assertIs(None, service)
# Multiple matches # Multiple matches
# test we are getting an Exception # test we are getting an Exception
self.assertRaises(OpenStackCloudException, self.op_cloud.get_service, self.assertRaises(OpenStackCloudException, self.cloud.get_service,
name_or_id=None, filters={'type': 'type2'}) name_or_id=None, filters={'type': 'type2'})
self.assert_calls() self.assert_calls()
@ -223,7 +223,7 @@ class CloudServices(base.RequestsMockTestCase):
]) ])
# Search by id # Search by id
services = self.op_cloud.search_services( services = self.cloud.search_services(
name_or_id=service_data.service_id) name_or_id=service_data.service_id)
# test we are getting exactly 1 element # test we are getting exactly 1 element
self.assertThat(len(services), matchers.Equals(1)) self.assertThat(len(services), matchers.Equals(1))
@ -231,7 +231,7 @@ class CloudServices(base.RequestsMockTestCase):
matchers.Equals(service_data.service_id)) matchers.Equals(service_data.service_id))
# Search by name # Search by name
services = self.op_cloud.search_services( services = self.cloud.search_services(
name_or_id=service_data.service_name) name_or_id=service_data.service_name)
# test we are getting exactly 1 element # test we are getting exactly 1 element
self.assertThat(len(services), matchers.Equals(1)) self.assertThat(len(services), matchers.Equals(1))
@ -239,11 +239,11 @@ class CloudServices(base.RequestsMockTestCase):
matchers.Equals(service_data.service_name)) matchers.Equals(service_data.service_name))
# Not found # Not found
services = self.op_cloud.search_services(name_or_id='!INVALID!') services = self.cloud.search_services(name_or_id='!INVALID!')
self.assertThat(len(services), matchers.Equals(0)) self.assertThat(len(services), matchers.Equals(0))
# Multiple matches # Multiple matches
services = self.op_cloud.search_services( services = self.cloud.search_services(
filters={'type': service_data.service_type}) filters={'type': service_data.service_type})
# test we are getting exactly 2 elements # test we are getting exactly 2 elements
self.assertThat(len(services), matchers.Equals(2)) self.assertThat(len(services), matchers.Equals(2))
@ -275,9 +275,9 @@ class CloudServices(base.RequestsMockTestCase):
]) ])
# Delete by name # Delete by name
self.op_cloud.delete_service(name_or_id=service_data.service_name) self.cloud.delete_service(name_or_id=service_data.service_name)
# Delete by id # Delete by id
self.op_cloud.delete_service(service_data.service_id) self.cloud.delete_service(service_data.service_id)
self.assert_calls() self.assert_calls()

2
openstack/tests/unit/cloud/test_usage.py
View File

@ -60,6 +60,6 @@ class TestUsage(base.RequestsMockTestCase):
}}) }})
]) ])
self.op_cloud.get_compute_usage(project.project_id, start, end) self.cloud.get_compute_usage(project.project_id, start, end)
self.assert_calls() self.assert_calls()

20
openstack/tests/unit/cloud/test_users.py
View File

@ -54,7 +54,7 @@ class TestUsers(base.RequestsMockTestCase):
validate=dict(json=user_data.json_request)), validate=dict(json=user_data.json_request)),
]) ])
user = self.op_cloud.create_user( user = self.cloud.create_user(
name=user_data.name, email=user_data.email, name=user_data.name, email=user_data.email,
password=user_data.password) password=user_data.password)
@ -75,7 +75,7 @@ class TestUsers(base.RequestsMockTestCase):
validate=dict(json=user_data.json_request)), validate=dict(json=user_data.json_request)),
]) ])
user = self.op_cloud.create_user( user = self.cloud.create_user(
name=user_data.name, email=user_data.email, name=user_data.name, email=user_data.email,
password=user_data.password, password=user_data.password,
description=user_data.description, description=user_data.description,
@ -114,7 +114,7 @@ class TestUsers(base.RequestsMockTestCase):
json=user_data.json_response, json=user_data.json_response,
validate=dict(json={'user': {}}))]) validate=dict(json={'user': {}}))])
user = self.op_cloud.update_user( user = self.cloud.update_user(
user_data.user_id, password=user_data.password) user_data.user_id, password=user_data.password)
self.assertEqual(user_data.name, user.name) self.assertEqual(user_data.name, user.name)
self.assertEqual(user_data.email, user.email) self.assertEqual(user_data.email, user.email)
@ -128,7 +128,7 @@ class TestUsers(base.RequestsMockTestCase):
"User or project creation requires an explicit" "User or project creation requires an explicit"
" domain_id argument." " domain_id argument."
): ):
self.op_cloud.create_user( self.cloud.create_user(
name=user_data.name, email=user_data.email, name=user_data.name, email=user_data.email,
password=user_data.password) password=user_data.password)
@ -146,7 +146,7 @@ class TestUsers(base.RequestsMockTestCase):
json=user_data.json_response), json=user_data.json_response),
dict(method='DELETE', uri=user_resource_uri, status_code=204)]) dict(method='DELETE', uri=user_resource_uri, status_code=204)])
self.op_cloud.delete_user(user_data.name) self.cloud.delete_user(user_data.name)
self.assert_calls() self.assert_calls()
def test_delete_user_not_found(self): def test_delete_user_not_found(self):
@ -154,7 +154,7 @@ class TestUsers(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self._get_keystone_mock_url(resource='users'), uri=self._get_keystone_mock_url(resource='users'),
status_code=200, json={'users': []})]) status_code=200, json={'users': []})])
self.assertFalse(self.op_cloud.delete_user(self.getUniqueString())) self.assertFalse(self.cloud.delete_user(self.getUniqueString()))
def test_add_user_to_group(self): def test_add_user_to_group(self):
user_data = self._get_user_data() user_data = self._get_user_data()
@ -174,7 +174,7 @@ class TestUsers(base.RequestsMockTestCase):
resource='groups', resource='groups',
append=[group_data.group_id, 'users', user_data.user_id]), append=[group_data.group_id, 'users', user_data.user_id]),
status_code=200)]) status_code=200)])
self.op_cloud.add_user_to_group(user_data.user_id, group_data.group_id) self.cloud.add_user_to_group(user_data.user_id, group_data.group_id)
self.assert_calls() self.assert_calls()
def test_is_user_in_group(self): def test_is_user_in_group(self):
@ -196,7 +196,7 @@ class TestUsers(base.RequestsMockTestCase):
append=[group_data.group_id, 'users', user_data.user_id]), append=[group_data.group_id, 'users', user_data.user_id]),
status_code=204)]) status_code=204)])
self.assertTrue(self.op_cloud.is_user_in_group( self.assertTrue(self.cloud.is_user_in_group(
user_data.user_id, group_data.group_id)) user_data.user_id, group_data.group_id))
self.assert_calls() self.assert_calls()
@ -218,6 +218,6 @@ class TestUsers(base.RequestsMockTestCase):
append=[group_data.group_id, 'users', user_data.user_id]), append=[group_data.group_id, 'users', user_data.user_id]),
status_code=204)]) status_code=204)])
self.op_cloud.remove_user_from_group(user_data.user_id, self.cloud.remove_user_from_group(
group_data.group_id) user_data.user_id, group_data.group_id)
self.assert_calls() self.assert_calls()

14
openstack/tests/unit/cloud/test_volume_access.py
View File

@ -70,7 +70,7 @@ class TestVolumeAccess(base.RequestsMockTestCase):
'os-volume-type-access']), 'os-volume-type-access']),
json={'volume_type_access': volume_type_access})]) json={'volume_type_access': volume_type_access})])
self.assertEqual( self.assertEqual(
len(self.op_cloud.get_volume_type_access(volume_type['name'])), 2) len(self.cloud.get_volume_type_access(volume_type['name'])), 2)
self.assert_calls() self.assert_calls()
def test_remove_volume_type_access(self): def test_remove_volume_type_access(self):
@ -122,12 +122,12 @@ class TestVolumeAccess(base.RequestsMockTestCase):
'os-volume-type-access']), 'os-volume-type-access']),
json={'volume_type_access': [project_001]})]) json={'volume_type_access': [project_001]})])
self.assertEqual( self.assertEqual(
len(self.op_cloud.get_volume_type_access( len(self.cloud.get_volume_type_access(
volume_type['name'])), 2) volume_type['name'])), 2)
self.op_cloud.remove_volume_type_access( self.cloud.remove_volume_type_access(
volume_type['name'], project_001['project_id']) volume_type['name'], project_001['project_id'])
self.assertEqual( self.assertEqual(
len(self.op_cloud.get_volume_type_access(volume_type['name'])), 1) len(self.cloud.get_volume_type_access(volume_type['name'])), 1)
self.assert_calls() self.assert_calls()
def test_add_volume_type_access(self): def test_add_volume_type_access(self):
@ -167,10 +167,10 @@ class TestVolumeAccess(base.RequestsMockTestCase):
append=['types', volume_type['id'], append=['types', volume_type['id'],
'os-volume-type-access']), 'os-volume-type-access']),
json={'volume_type_access': volume_type_access})]) json={'volume_type_access': volume_type_access})])
self.op_cloud.add_volume_type_access( self.cloud.add_volume_type_access(
volume_type['name'], project_002['project_id']) volume_type['name'], project_002['project_id'])
self.assertEqual( self.assertEqual(
len(self.op_cloud.get_volume_type_access(volume_type['name'])), 2) len(self.cloud.get_volume_type_access(volume_type['name'])), 2)
self.assert_calls() self.assert_calls()
def test_add_volume_type_access_missing(self): def test_add_volume_type_access_missing(self):
@ -189,6 +189,6 @@ class TestVolumeAccess(base.RequestsMockTestCase):
with testtools.ExpectedException( with testtools.ExpectedException(
openstack.cloud.OpenStackCloudException, openstack.cloud.OpenStackCloudException,
"VolumeType not found: MISSING"): "VolumeType not found: MISSING"):
self.op_cloud.add_volume_type_access( self.cloud.add_volume_type_access(
"MISSING", project_001['project_id']) "MISSING", project_001['project_id'])
self.assert_calls() self.assert_calls()