openstack/shade
Code Issues Proposed changes

Use cloud fixtures from the unittest base class

Browse Source 
We need to do things to protect against local environment leaking into
the test fixtures when we create the cloud objects. Those things are all
done in the base unittest TestCase class, but for reasons that are hard
to fathom, we ignore that and create our own clouds in many of the
unitttest classes. This leads to problems if a user running the
unittests has cache config information in their local clouds.yaml.

Fix it.

Change-Id: I022d541d8e98bf4b6691bf0a91e3b7d20b2b7456
This commit is contained in:
Monty Taylor 2016-08-20 13:08:43 -05:00
parent aa6505af09
commit c40cc19381
No known key found for this signature in database
GPG Key ID: 7BAE94BC7141A594
29 changed files with 502 additions and 582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
shade/tests/unit/base.py
View File

@ -67,11 +67,24 @@ class TestCase(base.TestCase):
test_cloud = os.environ.get('SHADE_OS_CLOUD', '_test_cloud_')
self.config = occ.OpenStackConfig(
config_files=[config.name],
vendor_files=[vendor.name])
self.cloud_config = self.config.get_one_cloud(cloud=test_cloud)
vendor_files=[vendor.name],
secure_files=['non-existant'])
self.cloud_config = self.config.get_one_cloud(
cloud=test_cloud, validate=False)
self.cloud = shade.OpenStackCloud(
cloud_config=self.cloud_config,
log_inner_exceptions=True)
self.op_cloud = shade.OperatorCloud(
cloud_config=self.cloud_config,
log_inner_exceptions=True)
# Any unit tests using betamax directly need a ksa.Session with
# an auth dict.
self.full_cloud_config = self.config.get_one_cloud(
cloud=test_cloud)
self.full_cloud = shade.OpenStackCloud(
cloud_config=self.full_cloud_config,
log_inner_exceptions=True)
self.full_op_cloud = shade.OperatorCloud(
cloud_config=self.full_cloud_config,
log_inner_exceptions=True)

22
shade/tests/unit/test_aggregate.py
View File

@ -22,14 +22,10 @@ from shade.tests import fakes
class TestAggregate(base.TestCase):
def setUp(self):
super(TestAggregate, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'nova_client')
def test_create_aggregate(self, mock_nova):
aggregate_name = 'aggr1'
self.cloud.create_aggregate(name=aggregate_name)
self.op_cloud.create_aggregate(name=aggregate_name)
mock_nova.aggregates.create.assert_called_once_with(
name=aggregate_name, availability_zone=None
@ -39,8 +35,8 @@ class TestAggregate(base.TestCase):
def test_create_aggregate_with_az(self, mock_nova):
aggregate_name = 'aggr1'
availability_zone = 'az1'
self.cloud.create_aggregate(name=aggregate_name,
availability_zone=availability_zone)
self.op_cloud.create_aggregate(
name=aggregate_name, availability_zone=availability_zone)
mock_nova.aggregates.create.assert_called_once_with(
name=aggregate_name, availability_zone=availability_zone
@ -51,7 +47,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name')
]
self.assertTrue(self.cloud.delete_aggregate('1234'))
self.assertTrue(self.op_cloud.delete_aggregate('1234'))
mock_nova.aggregates.list.assert_called_once_with()
mock_nova.aggregates.delete.assert_called_once_with(
aggregate='1234'
@ -62,7 +58,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name')
]
self.cloud.update_aggregate('1234', availability_zone='az')
self.op_cloud.update_aggregate('1234', availability_zone='az')
mock_nova.aggregates.update.assert_called_once_with(
aggregate='1234',
values={'availability_zone': 'az'},
@ -73,7 +69,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name', availability_zone='az')
]
self.cloud.update_aggregate('1234', availability_zone=None)
self.op_cloud.update_aggregate('1234', availability_zone=None)
mock_nova.aggregates.update.assert_called_once_with(
aggregate='1234',
values={'availability_zone': None},
@ -85,7 +81,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name')
]
self.cloud.set_aggregate_metadata('1234', metadata)
self.op_cloud.set_aggregate_metadata('1234', metadata)
mock_nova.aggregates.set_metadata.assert_called_once_with(
aggregate='1234',
metadata=metadata
@ -97,7 +93,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name')
]
self.cloud.add_host_to_aggregate('1234', hostname)
self.op_cloud.add_host_to_aggregate('1234', hostname)
mock_nova.aggregates.add_host.assert_called_once_with(
aggregate='1234',
host=hostname
@ -109,7 +105,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name', hosts=[hostname])
]
self.cloud.remove_host_from_aggregate('1234', hostname)
self.op_cloud.remove_host_from_aggregate('1234', hostname)
mock_nova.aggregates.remove_host.assert_called_once_with(
aggregate='1234',
host=hostname

55
shade/tests/unit/test_create_server.py
View File

@ -21,23 +21,16 @@ Tests for the `create_server` command.
from mock import patch, Mock
import mock
import os_client_config
from shade import _utils
from shade import meta
from shade import OpenStackCloud
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
class TestCreateServer(base.TestCase):
def setUp(self):
super(TestCreateServer, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.client._SERVER_AGE = 0
def test_create_server_with_create_exception(self):
"""
Test that an exception in the novaclient create raises an exception in
@ -49,7 +42,7 @@ class TestCreateServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.create_server,
OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id')
def test_create_server_with_get_exception(self):
@ -64,7 +57,7 @@ class TestCreateServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.create_server,
OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id')
def test_create_server_with_server_error(self):
@ -81,7 +74,7 @@ class TestCreateServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.create_server,
OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id')
def test_create_server_wait_server_error(self):
@ -105,7 +98,7 @@ class TestCreateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException,
self.client.create_server,
self.cloud.create_server,
'server-name', 'image-id', 'flavor-id', wait=True)
def test_create_server_with_timeout(self):
@ -123,8 +116,9 @@ class TestCreateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudTimeout,
self.client.create_server,
'server-name', 'image-id', 'flavor-id', wait=True, timeout=1)
self.cloud.create_server,
'server-name', 'image-id', 'flavor-id',
wait=True, timeout=0.01)
def test_create_server_no_wait(self):
"""
@ -145,9 +139,9 @@ class TestCreateServer(base.TestCase):
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(fake_server),
cloud_name=self.client.name,
region_name=self.client.region_name),
self.client.create_server(
cloud_name=self.cloud.name,
region_name=self.cloud.region_name),
self.cloud.create_server(
name='server-name', image='image=id',
flavor='flavor-id'))
@ -171,9 +165,9 @@ class TestCreateServer(base.TestCase):
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(fake_create_server),
cloud_name=self.client.name,
region_name=self.client.region_name),
self.client.create_server(
cloud_name=self.cloud.name,
region_name=self.cloud.region_name),
self.cloud.create_server(
name='server-name', image='image=id',
flavor='flavor-id', admin_pass='ooBootheiX0edoh'))
@ -193,7 +187,7 @@ class TestCreateServer(base.TestCase):
mock_wait.return_value = _utils.normalize_server(
meta.obj_to_dict(fake_server), None, None)
server = self.client.create_server(
server = self.cloud.create_server(
name='server-name', image='image-id',
flavor='flavor-id', admin_pass='ooBootheiX0edoh', wait=True)
@ -221,7 +215,7 @@ class TestCreateServer(base.TestCase):
mock_get_active_server.side_effect = iter([
building_server, active_server])
server = self.client.wait_for_server(building_server)
server = self.cloud.wait_for_server(building_server)
self.assertEqual(2, mock_get_server.call_count)
mock_get_server.assert_has_calls([
@ -250,7 +244,7 @@ class TestCreateServer(base.TestCase):
fake_server = {'id': 'fake_server_id', 'status': 'BUILDING'}
mock_nova.servers.create.return_value = fake_server
self.client.create_server(
self.cloud.create_server(
'server-name', 'image-id', 'flavor-id', wait=True),
mock_wait.assert_called_once_with(
@ -280,11 +274,11 @@ class TestCreateServer(base.TestCase):
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.client._SERVER_AGE = 0
self.cloud._SERVER_AGE = 0
with patch.object(OpenStackCloud, "add_ips_to_server",
return_value=fake_server):
self.assertRaises(
OpenStackCloudException, self.client.create_server,
OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id',
wait=True)
@ -296,8 +290,8 @@ class TestCreateServer(base.TestCase):
Verify that if 'network' is supplied, and 'nics' is not, that we
attempt to get the network for the server.
"""
self.client.create_server('server-name', 'image-id', 'flavor-id',
network='network-name')
self.cloud.create_server(
'server-name', 'image-id', 'flavor-id', network='network-name')
mock_get_network.assert_called_once_with(name_or_id='network-name')
@patch('shade.OpenStackCloud.nova_client')
@ -309,6 +303,7 @@ class TestCreateServer(base.TestCase):
Verify that if 'network' is supplied, along with an empty 'nics' list,
it's treated the same as if 'nics' were not included.
"""
self.client.create_server('server-name', 'image-id', 'flavor-id',
network='network-name', nics=[])
self.cloud.create_server(
'server-name', 'image-id', 'flavor-id',
network='network-name', nics=[])
mock_get_network.assert_called_once_with(name_or_id='network-name')

19
shade/tests/unit/test_create_volume_snapshot.py
View File

@ -20,22 +20,16 @@ Tests for the `create_volume_snapshot` command.
"""
from mock import patch
import os_client_config
from shade import _utils
from shade import meta
from shade import OpenStackCloud
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
class TestCreateVolumeSnapshot(base.TestCase):
def setUp(self):
super(TestCreateVolumeSnapshot, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@patch.object(OpenStackCloud, 'cinder_client')
def test_create_volume_snapshot_wait(self, mock_cinder):
"""
@ -55,8 +49,7 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertEqual(
_utils.normalize_volumes(
[meta.obj_to_dict(fake_snapshot)])[0],
self.client.create_volume_snapshot(volume_id='1234',
wait=True)
self.cloud.create_volume_snapshot(volume_id='1234', wait=True)
)
mock_cinder.volume_snapshots.create.assert_called_with(
@ -81,8 +74,8 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertRaises(
OpenStackCloudTimeout,
self.client.create_volume_snapshot, volume_id='1234',
wait=True, timeout=1)
self.cloud.create_volume_snapshot, volume_id='1234',
wait=True, timeout=0.01)
mock_cinder.volume_snapshots.create.assert_called_with(
force=False, volume_id='1234'
@ -108,7 +101,7 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertRaises(
OpenStackCloudException,
self.client.create_volume_snapshot, volume_id='1234',
self.cloud.create_volume_snapshot, volume_id='1234',
wait=True, timeout=5)
mock_cinder.volume_snapshots.create.assert_called_with(

8
shade/tests/unit/test_delete_server.py
View File

@ -21,9 +21,7 @@ Tests for the `delete_server` command.
import mock
from novaclient import exceptions as nova_exc
import os_client_config
from shade import OpenStackCloud
from shade import exc as shade_exc
from shade.tests import fakes
from shade.tests.unit import base
@ -39,12 +37,6 @@ class TestDeleteServer(base.TestCase):
nova_exc.RateLimit,
nova_exc.HTTPNotImplemented)
def setUp(self):
super(TestDeleteServer, self).setUp()
config = os_client_config.OpenStackConfig()
self.cloud = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@mock.patch('shade.OpenStackCloud.nova_client')
def test_delete_server(self, nova_mock):
"""

19
shade/tests/unit/test_delete_volume_snapshot.py
View File

@ -20,20 +20,14 @@ Tests for the `delete_volume_snapshot` command.
"""
from mock import patch
import os_client_config
from shade import OpenStackCloud
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
class TestDeleteVolumeSnapshot(base.TestCase):
def setUp(self):
super(TestDeleteVolumeSnapshot, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@patch.object(OpenStackCloud, 'cinder_client')
def test_delete_volume_snapshot(self, mock_cinder):
"""
@ -47,7 +41,7 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertEqual(
True,
self.client.delete_volume_snapshot(name_or_id='1234', wait=False)
self.cloud.delete_volume_snapshot(name_or_id='1234', wait=False)
)
mock_cinder.volume_snapshots.list.assert_called_with(detailed=True,
@ -68,8 +62,7 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertRaises(
OpenStackCloudException,
self.client.delete_volume_snapshot, name_or_id='1234',
wait=True, timeout=1)
self.cloud.delete_volume_snapshot, name_or_id='1234')
mock_cinder.volume_snapshots.delete.assert_called_with(
snapshot='1234')
@ -87,8 +80,8 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertRaises(
OpenStackCloudTimeout,
self.client.delete_volume_snapshot, name_or_id='1234',
wait=True, timeout=1)
self.cloud.delete_volume_snapshot, name_or_id='1234',
wait=True, timeout=0.01)
mock_cinder.volume_snapshots.list.assert_called_with(detailed=True,
search_opts=None)

49
shade/tests/unit/test_domains.py
View File

@ -32,19 +32,15 @@ domain_obj = fakes.FakeDomain(
class TestDomains(base.TestCase):
def setUp(self):
super(TestDomains, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_domains(self, mock_keystone):
self.cloud.list_domains()
self.op_cloud.list_domains()
self.assertTrue(mock_keystone.domains.list.called)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_domain(self, mock_keystone):
mock_keystone.domains.get.return_value = domain_obj
domain = self.cloud.get_domain(domain_id='1234')
domain = self.op_cloud.get_domain(domain_id='1234')
self.assertFalse(mock_keystone.domains.list.called)
self.assertTrue(mock_keystone.domains.get.called)
self.assertEqual(domain['name'], 'a-domain')
@ -52,7 +48,7 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade._utils, '_get_entity')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_domain_with_name_or_id(self, mock_keystone, mock_get):
self.cloud.get_domain(name_or_id='1234')
self.op_cloud.get_domain(name_or_id='1234')
mock_get.assert_called_once_with(mock.ANY,
None, '1234')
@ -60,8 +56,8 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.create.return_value = domain_obj
self.cloud.create_domain(domain_obj.name,
domain_obj.description)
self.op_cloud.create_domain(
domain_obj.name, domain_obj.description)
mock_keystone.domains.create.assert_called_once_with(
name=domain_obj.name, description=domain_obj.description,
enabled=True)
@ -74,13 +70,13 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException,
"Failed to create domain domain_name"
):
self.cloud.create_domain('domain_name')
self.op_cloud.create_domain('domain_name')
@mock.patch.object(shade.OperatorCloud, 'update_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_domain(self, mock_keystone, mock_update):
mock_update.return_value = dict(id='update_domain_id')
self.cloud.delete_domain('domain_id')
self.op_cloud.delete_domain('domain_id')
mock_update.assert_called_once_with('domain_id', enabled=False)
mock_keystone.domains.delete.assert_called_once_with(
domain='update_domain_id')
@ -88,10 +84,11 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OperatorCloud, 'get_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_domain_name_or_id(self, mock_keystone, mock_get):
self.cloud.update_domain(name_or_id='a-domain',
name='new name',
description='new description',
enabled=False)
self.op_cloud.update_domain(
name_or_id='a-domain',
name='new name',
description='new description',
enabled=False)
mock_get.assert_called_once_with(None, 'a-domain')
@mock.patch.object(shade.OperatorCloud, 'update_domain')
@ -102,16 +99,17 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException,
"Failed to delete domain domain_id"
):
self.cloud.delete_domain('domain_id')
self.op_cloud.delete_domain('domain_id')
@mock.patch.object(shade._utils, 'normalize_domains')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.update.return_value = domain_obj
self.cloud.update_domain('domain_id',
name='new name',
description='new description',
enabled=False)
self.op_cloud.update_domain(
'domain_id',
name='new name',
description='new description',
enabled=False)
mock_keystone.domains.update.assert_called_once_with(
domain='domain_id', name='new name',
description='new description', enabled=False)
@ -121,10 +119,11 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OperatorCloud, 'get_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_domain_name_or_id(self, mock_keystone, mock_get):
self.cloud.update_domain(name_or_id='a-domain',
name='new name',
description='new description',
enabled=False)
self.op_cloud.update_domain(
name_or_id='a-domain',
name='new name',
description='new description',
enabled=False)
mock_get.assert_called_once_with(None, 'a-domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -134,4 +133,4 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException,
"Error in updating domain domain_id"
):
self.cloud.delete_domain('domain_id')
self.op_cloud.delete_domain('domain_id')

27
shade/tests/unit/test_endpoints.py
View File

@ -49,9 +49,6 @@ class TestCloudEndpoints(base.TestCase):
def setUp(self):
super(TestCloudEndpoints, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OperatorCloud(cloud_config=config.get_one_cloud(
validate=False))
self.mock_ks_endpoints = \
[FakeEndpoint(**kwa) for kwa in self.mock_endpoints]
self.mock_ks_endpoints_v3 = \
@ -74,7 +71,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.return_value = \
self.mock_ks_endpoints[2]
endpoints = self.client.create_endpoint(
endpoints = self.op_cloud.create_endpoint(
service_name_or_id='service1',
region='mock_region',
public_url='mock_public_url',
@ -99,12 +96,12 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints[0]
self.assertRaises(OpenStackCloudException,
self.client.create_endpoint,
self.op_cloud.create_endpoint,
service_name_or_id='service1',
interface='mock_admin_url',
url='admin')
endpoints_3on2 = self.client.create_endpoint(
endpoints_3on2 = self.op_cloud.create_endpoint(
service_name_or_id='service1',
region='mock_region',
interface='public',
@ -132,7 +129,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.return_value = \
self.mock_ks_endpoints_v3[0]
endpoints = self.client.create_endpoint(
endpoints = self.op_cloud.create_endpoint(
service_name_or_id='service1',
region='mock_region',
url='mock_url',
@ -155,7 +152,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.side_effect = \
self.mock_ks_endpoints_v3
endpoints_2on3 = self.client.create_endpoint(
endpoints_2on3 = self.op_cloud.create_endpoint(
service_name_or_id='service1',
region='mock_region',
public_url='mock_public_url',
@ -176,7 +173,7 @@ class TestCloudEndpoints(base.TestCase):
mock_api_version.return_value = '2.0'
# NOTE(SamYaple): Update endpoint only works with v3 api
self.assertRaises(OpenStackCloudUnavailableFeature,
self.client.update_endpoint, 'endpoint_id')
self.op_cloud.update_endpoint, 'endpoint_id')
@patch.object(OperatorCloud, 'keystone_client')
@patch.object(os_client_config.cloud_config.CloudConfig, 'get_api_version')
@ -185,7 +182,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.update.return_value = \
self.mock_ks_endpoints_v3[0]
endpoint = self.client.update_endpoint(
endpoint = self.op_cloud.update_endpoint(
'id1',
service_name_or_id='service_id1',
region='mock_region',
@ -211,7 +208,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.list.return_value = \
self.mock_ks_endpoints
endpoints = self.client.list_endpoints()
endpoints = self.op_cloud.list_endpoints()
mock_keystone_client.endpoints.list.assert_called_with()
# test we are getting exactly len(self.mock_endpoints) elements
@ -236,18 +233,18 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints
# Search by id
endpoints = self.client.search_endpoints(id='id3')
endpoints = self.op_cloud.search_endpoints(id='id3')
# # test we are getting exactly 1 element
self.assertEqual(1, len(endpoints))
for k, v in self.mock_endpoints[2].items():
self.assertEquals(v, endpoints[0].get(k))
# Not found
endpoints = self.client.search_endpoints(id='blah!')
endpoints = self.op_cloud.search_endpoints(id='blah!')
self.assertEqual(0, len(endpoints))
# Multiple matches
endpoints = self.client.search_endpoints(
endpoints = self.op_cloud.search_endpoints(
filters={'region': 'region1'})
# # test we are getting exactly 2 elements
self.assertEqual(2, len(endpoints))
@ -258,5 +255,5 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints
# Delete by id
self.client.delete_endpoint(id='id2')
self.op_cloud.delete_endpoint(id='id2')
mock_keystone_client.endpoints.delete.assert_called_with(id='id2')

11
shade/tests/unit/test_flavors.py
View File

@ -24,9 +24,6 @@ from shade.tests.unit import base
class TestFlavors(base.TestCase):
def setUp(self):
super(TestFlavors, self).setUp()
def test_create_flavor(self):
self.useFixture(keystoneauth_betamax.BetamaxFixture(
cassette_name='test_create_flavor',
@ -34,13 +31,13 @@ class TestFlavors(base.TestCase):
record=self.record_fixtures,
serializer=serializer.YamlJsonSerializer))
old_flavors = self.op_cloud.list_flavors()
self.op_cloud.create_flavor(
old_flavors = self.full_op_cloud.list_flavors()
self.full_op_cloud.create_flavor(
'vanilla', 12345, 4, 100
)
# test that we have a new flavor added
new_flavors = self.op_cloud.list_flavors()
new_flavors = self.full_op_cloud.list_flavors()
self.assertEquals(len(new_flavors) - len(old_flavors), 1)
# test that new flavor is created correctly
@ -56,7 +53,7 @@ class TestFlavors(base.TestCase):
self.assertTrue(needed_keys.issubset(flavor.keys()))
# delete created flavor
self.op_cloud.delete_flavor('vanilla')
self.full_op_cloud.delete_flavor('vanilla')
@mock.patch.object(shade.OpenStackCloud, '_compute_client')
@mock.patch.object(shade.OpenStackCloud, 'nova_client')

20
shade/tests/unit/test_floating_ip_common.py
View File

@ -20,7 +20,6 @@ Tests floating IP resource methods for Neutron and Nova-network.
"""
from mock import patch
import os_client_config
from shade import meta
from shade import OpenStackCloud
from shade.tests.fakes import FakeServer
@ -28,11 +27,6 @@ from shade.tests.unit import base
class TestFloatingIP(base.TestCase):
def setUp(self):
super(TestFloatingIP, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@patch.object(OpenStackCloud, 'get_floating_ip')
@patch.object(OpenStackCloud, '_attach_ip_to_server')
@ -56,7 +50,7 @@ class TestFloatingIP(base.TestCase):
mock_available_floating_ip.return_value = floating_ip_dict
self.client.add_auto_ip(server=server_dict)
self.cloud.add_auto_ip(server=server_dict)
mock_attach_ip_to_server.assert_called_with(
timeout=60, wait=False, server=server_dict,
@ -74,7 +68,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.servers.get.return_value = server
self.client.add_ips_to_server(server_dict, ip_pool=pool)
self.cloud.add_ips_to_server(server_dict, ip_pool=pool)
mock_add_ip_from_pool.assert_called_with(
server_dict, pool, reuse=True, wait=False, timeout=60,
@ -109,7 +103,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server))
new_server = self.client.add_ips_to_server(server=server_dict)
new_server = self.cloud.add_ips_to_server(server=server_dict)
mock_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called()
self.assertEqual(
@ -150,7 +144,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server))
new_server = self.client.add_ips_to_server(server=server_dict)
new_server = self.cloud.add_ips_to_server(server=server_dict)
mock_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called()
self.assertEqual(
@ -187,7 +181,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server))
new_server = self.client.add_ips_to_server(server=server_dict)
new_server = self.cloud.add_ips_to_server(server=server_dict)
mock_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called()
self.assertEqual(new_server['interface_ip'], '104.130.246.91')
@ -203,7 +197,7 @@ class TestFloatingIP(base.TestCase):
ips = ['203.0.113.29', '172.24.4.229']
mock_nova_client.servers.get.return_value = server
self.client.add_ips_to_server(server_dict, ips=ips)
self.cloud.add_ips_to_server(server_dict, ips=ips)
mock_add_ip_list.assert_called_with(
server_dict, ips, wait=False, timeout=60, fixed_address=None)
@ -219,7 +213,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.servers.get.return_value = server
self.client.add_ips_to_server(server_dict)
self.cloud.add_ips_to_server(server_dict)
mock_add_auto_ip.assert_called_with(
server_dict, wait=False, timeout=60, reuse=True)

51
shade/tests/unit/test_floating_ip_neutron.py
View File

@ -21,7 +21,6 @@ Tests Floating IP resource methods for Neutron
import mock
from mock import patch
import os_client_config
from neutronclient.common import exceptions as n_exc
@ -138,10 +137,6 @@ class TestFloatingIP(base.TestCase):
def setUp(self):
super(TestFloatingIP, self).setUp()
# floating_ip_source='neutron' is default for OpenStackCloud()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.fake_server = meta.obj_to_dict(
fakes.FakeServer(
@ -162,7 +157,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep
floating_ips = self.client.list_floating_ips()
floating_ips = self.cloud.list_floating_ips()
mock_neutron_client.list_floatingips.assert_called_with()
self.assertIsInstance(floating_ips, list)
@ -176,7 +171,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep
floating_ips = self.client.search_floating_ips(
floating_ips = self.cloud.search_floating_ips(
filters={'attached': False})
mock_neutron_client.list_floatingips.assert_called_with()
@ -191,7 +186,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep
floating_ip = self.client.get_floating_ip(
floating_ip = self.cloud.get_floating_ip(
id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')
mock_neutron_client.list_floatingips.assert_called_with()
@ -206,7 +201,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep
floating_ip = self.client.get_floating_ip(id='non-existent')
floating_ip = self.cloud.get_floating_ip(id='non-existent')
self.assertIsNone(floating_ip)
@ -220,7 +215,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.create_floatingip.return_value = \
self.mock_floating_ip_new_rep
ip = self.client.create_floating_ip(network='my-network')
ip = self.cloud.create_floating_ip(network='my-network')
mock_neutron_client.create_floatingip.assert_called_with(
body={'floatingip': {'floating_network_id': 'my-network-id'}}
@ -241,7 +236,7 @@ class TestFloatingIP(base.TestCase):
self.assertRaises(
exc.OpenStackCloudException,
self.client.create_floating_ip,
self.cloud.create_floating_ip,
network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ab')
@patch.object(OpenStackCloud, 'neutron_client')
@ -254,7 +249,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.create_floatingip.return_value = \
self.mock_floating_ip_port_rep
ip = self.client.create_floating_ip(
ip = self.cloud.create_floating_ip(
network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ab')
mock_neutron_client.create_floatingip.assert_called_with(
@ -283,7 +278,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.return_value = True
mock__neutron_call.return_value = []
self.client.available_floating_ip(network='netname')
self.cloud.available_floating_ip(network='netname')
mock_has_service.assert_called_once_with('network')
mock__neutron_call.assert_called_once_with(network='netname',
@ -311,7 +306,7 @@ class TestFloatingIP(base.TestCase):
mock__filter_list.return_value = []
# Test if first network is selected if no network is given
self.client._neutron_available_floating_ips()
self.cloud._neutron_available_floating_ips()
mock_keystone_session.get_project_id.assert_called_once_with()
mock_get_ext_nets.assert_called_once_with()
@ -347,7 +342,7 @@ class TestFloatingIP(base.TestCase):
mock__neutron_list_fips.return_value = []
mock__filter_list.return_value = []
self.client._neutron_available_floating_ips(
self.cloud._neutron_available_floating_ips(
network=self.mock_get_network_rep['name']
)
@ -377,7 +372,7 @@ class TestFloatingIP(base.TestCase):
mock_keystone_session.get_project_id.return_value = 'proj-id'
mock_get_ext_nets.return_value = []
self.assertRaises(exc.OpenStackCloudException,
self.client._neutron_available_floating_ips,
self.cloud._neutron_available_floating_ips,
network='INVALID')
@patch.object(OpenStackCloud, 'nova_client')
@ -399,7 +394,7 @@ class TestFloatingIP(base.TestCase):
'4969c491a3c74ee4af974e6d800c62df'
fake_server = meta.obj_to_dict(fakes.FakeServer('1234', '', 'ACTIVE'))
self.client.add_ips_to_server(
self.cloud.add_ips_to_server(
fake_server, ip_pool='my-network', reuse=False)
mock__neutron_create_floating_ip.assert_called_once_with(
@ -426,7 +421,7 @@ class TestFloatingIP(base.TestCase):
mock_keystone_session.get_project_id.return_value = \
'4969c491a3c74ee4af974e6d800c62df'
ip = self.client.available_floating_ip(network='my-network')
ip = self.cloud.available_floating_ip(network='my-network')
self.assertEqual(
self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'],
@ -446,7 +441,7 @@ class TestFloatingIP(base.TestCase):
mock_get_floating_ip.side_effect = [fake_fip, fake_fip, None]
mock_neutron_client.delete_floatingip.return_value = None
ret = self.client.delete_floating_ip(
ret = self.cloud.delete_floating_ip(
floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
retry=2)
@ -472,7 +467,7 @@ class TestFloatingIP(base.TestCase):
self.assertRaises(
exc.OpenStackCloudException,
self.client.delete_floating_ip,
self.cloud.delete_floating_ip,
floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
retry=2)
@ -489,7 +484,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.delete_floatingip.side_effect = \
n_exc.NotFound()
ret = self.client.delete_floating_ip(
ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears')
self.assertFalse(ret)
@ -506,7 +501,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep
self.client._attach_ip_to_server(
self.cloud._attach_ip_to_server(
server=self.fake_server,
floating_ip=self.floating_ip)
@ -535,9 +530,9 @@ class TestFloatingIP(base.TestCase):
self.assertRaises(
exc.OpenStackCloudTimeout,
self.client._add_auto_ip,
self.cloud._add_auto_ip,
server=self.fake_server,
wait=True, timeout=2,
wait=True, timeout=0.01,
reuse=False)
mock_delete_floating_ip.assert_called_once_with(
@ -554,7 +549,7 @@ class TestFloatingIP(base.TestCase):
_utils.normalize_neutron_floating_ips(
self.mock_floating_ip_list_rep['floatingips'])[0]
self.client.detach_ip_from_server(
self.cloud.detach_ip_from_server(
server_id='server-id',
floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')
@ -579,7 +574,7 @@ class TestFloatingIP(base.TestCase):
self.mock_floating_ip_new_rep['floatingip']])[0]
mock_attach_ip_to_server.return_value = self.fake_server
server = self.client._add_ip_from_pool(
server = self.cloud._add_ip_from_pool(
server=self.fake_server,
network='network-name',
fixed_address='192.0.2.129')
@ -613,7 +608,7 @@ class TestFloatingIP(base.TestCase):
mock_list_floating_ips.return_value = floating_ips
self.client.delete_unattached_floating_ips()
self.cloud.delete_unattached_floating_ips()
mock_delete_floating_ip.assert_called_once_with(
floating_ip_id='this-is-a-floating-ip-id', retry=1)
@ -631,5 +626,5 @@ class TestFloatingIP(base.TestCase):
self.assertRaises(
exc.OpenStackCloudException,
self.client._neutron_create_floating_ip,
self.cloud._neutron_create_floating_ip,
server=dict(id='some-server'))

30
shade/tests/unit/test_floating_ip_nova.py
View File

@ -21,7 +21,6 @@ Tests Floating IP resource methods for nova-network
from mock import patch
from novaclient import exceptions as n_exc
import os_client_config
from shade import _utils
from shade import meta
@ -71,9 +70,6 @@ class TestFloatingIP(base.TestCase):
def setUp(self):
super(TestFloatingIP, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.floating_ips = [
fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep
]
@ -97,7 +93,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
floating_ips = self.client.list_floating_ips()
floating_ips = self.cloud.list_floating_ips()
mock_nova_client.floating_ips.list.assert_called_with()
self.assertIsInstance(floating_ips, list)
@ -110,7 +106,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
floating_ips = self.client.search_floating_ips(
floating_ips = self.cloud.search_floating_ips(
filters={'attached': False})
mock_nova_client.floating_ips.list.assert_called_with()
@ -124,7 +120,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
floating_ip = self.client.get_floating_ip(id='29')
floating_ip = self.cloud.get_floating_ip(id='29')
mock_nova_client.floating_ips.list.assert_called_with()
self.assertIsInstance(floating_ip, dict)
@ -137,7 +133,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
floating_ip = self.client.get_floating_ip(id='666')
floating_ip = self.cloud.get_floating_ip(id='666')
self.assertIsNone(floating_ip)
@ -148,7 +144,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.floating_ips.create.return_value =\
fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[1])
self.client.create_floating_ip(network='nova')
self.cloud.create_floating_ip(network='nova')
mock_nova_client.floating_ips.create.assert_called_with(pool='nova')
@ -160,7 +156,7 @@ class TestFloatingIP(base.TestCase):
mock__nova_list_floating_ips.return_value = \
self.mock_floating_ip_list_rep[:1]
ip = self.client.available_floating_ip(network='nova')
ip = self.cloud.available_floating_ip(network='nova')
self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'],
ip['floating_ip_address'])
@ -176,7 +172,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.floating_ips.create.return_value = \
fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[0])
ip = self.client.available_floating_ip(network='nova')
ip = self.cloud.available_floating_ip(network='nova')
self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'],
ip['floating_ip_address'])
@ -188,7 +184,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.delete.return_value = None
ret = self.client.delete_floating_ip(
ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears')
mock_nova_client.floating_ips.delete.assert_called_with(
@ -203,7 +199,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.floating_ips.delete.side_effect = n_exc.NotFound(
code=404)
ret = self.client.delete_floating_ip(
ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears')
self.assertFalse(ret)
@ -214,7 +210,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
self.client._attach_ip_to_server(
self.cloud._attach_ip_to_server(
server=self.fake_server, floating_ip=self.floating_ip,
fixed_address='192.0.2.129')
@ -230,7 +226,7 @@ class TestFloatingIP(base.TestCase):
fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep
]
self.client.detach_ip_from_server(
self.cloud.detach_ip_from_server(
server_id='server-id', floating_ip_id=1)
mock_nova_client.servers.remove_floating_ip.assert_called_with(
@ -242,7 +238,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips
server = self.client._add_ip_from_pool(
server = self.cloud._add_ip_from_pool(
server=self.fake_server,
network='nova',
fixed_address='192.0.2.129')
@ -257,7 +253,7 @@ class TestFloatingIP(base.TestCase):
mock_delete_floating_ip):
mock_use_neutron_floating.return_value = False
self.client.delete_unattached_floating_ips()
self.cloud.delete_unattached_floating_ips()
mock_delete_floating_ip.assert_not_called()
mock_list_floating_ips.assert_not_called()

11
shade/tests/unit/test_floating_ip_pool.py
View File

@ -20,7 +20,6 @@ Test floating IP pool resource (managed by nova)
"""
from mock import patch
import os_client_config
from shade import OpenStackCloud
from shade import OpenStackCloudException
from shade.tests.unit import base
@ -32,12 +31,6 @@ class TestFloatingIPPool(base.TestCase):
{'id': 'pool1_id', 'name': 'pool1'},
{'id': 'pool2_id', 'name': 'pool2'}]
def setUp(self):
super(TestFloatingIPPool, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@patch.object(OpenStackCloud, '_has_nova_extension')
@patch.object(OpenStackCloud, 'nova_client')
def test_list_floating_ip_pools(
@ -47,7 +40,7 @@ class TestFloatingIPPool(base.TestCase):
]
mock__has_nova_extension.return_value = True
floating_ip_pools = self.client.list_floating_ip_pools()
floating_ip_pools = self.cloud.list_floating_ip_pools()
self.assertItemsEqual(floating_ip_pools, self.mock_pools)
@ -60,4 +53,4 @@ class TestFloatingIPPool(base.TestCase):
mock__has_nova_extension.return_value = True
self.assertRaises(
OpenStackCloudException, self.client.list_floating_ip_pools)
OpenStackCloudException, self.cloud.list_floating_ip_pools)

14
shade/tests/unit/test_groups.py
View File

@ -20,18 +20,14 @@ from shade.tests import fakes
class TestGroups(base.TestCase):
def setUp(self):
super(TestGroups, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_groups(self, mock_keystone):
self.cloud.list_groups()
self.op_cloud.list_groups()
mock_keystone.groups.list.assert_called_once_with()
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_group(self, mock_keystone):
self.cloud.get_group('1234')
self.op_cloud.get_group('1234')
mock_keystone.groups.list.assert_called_once_with()
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -39,7 +35,7 @@ class TestGroups(base.TestCase):
mock_keystone.groups.list.return_value = [
fakes.FakeGroup('1234', 'name', 'desc')
]
self.assertTrue(self.cloud.delete_group('1234'))
self.assertTrue(self.op_cloud.delete_group('1234'))
mock_keystone.groups.list.assert_called_once_with()
mock_keystone.groups.delete.assert_called_once_with(
group='1234'
@ -47,7 +43,7 @@ class TestGroups(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_group(self, mock_keystone):
self.cloud.create_group('test-group', 'test desc')
self.op_cloud.create_group('test-group', 'test desc')
mock_keystone.groups.create.assert_called_once_with(
name='test-group', description='test desc', domain=None
)
@ -57,7 +53,7 @@ class TestGroups(base.TestCase):
mock_keystone.groups.list.return_value = [
fakes.FakeGroup('1234', 'name', 'desc')
]
self.cloud.update_group('1234', 'test-group', 'test desc')
self.op_cloud.update_group('1234', 'test-group', 'test desc')
mock_keystone.groups.list.assert_called_once_with()
mock_keystone.groups.update.assert_called_once_with(
group='1234', name='test-group', description='test desc'

52
shade/tests/unit/test_identity_roles.py
View File

@ -40,13 +40,9 @@ RAW_ROLE_ASSIGNMENTS = [
class TestIdentityRoles(base.TestCase):
def setUp(self):
super(TestIdentityRoles, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_roles(self, mock_keystone):
self.cloud.list_roles()
self.op_cloud.list_roles()
self.assertTrue(mock_keystone.roles.list.called)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -54,7 +50,7 @@ class TestIdentityRoles(base.TestCase):
role_obj = fakes.FakeRole(id='1234', name='fake_role')
mock_keystone.roles.list.return_value = [role_obj]
role = self.cloud.get_role('fake_role')
role = self.op_cloud.get_role('fake_role')
self.assertTrue(mock_keystone.roles.list.called)
self.assertIsNotNone(role)
@ -67,7 +63,7 @@ class TestIdentityRoles(base.TestCase):
role_obj = fakes.FakeRole(id='1234', name=role_name)
mock_keystone.roles.create.return_value = role_obj
role = self.cloud.create_role(role_name)
role = self.op_cloud.create_role(role_name)
mock_keystone.roles.create.assert_called_once_with(
name=role_name
@ -80,7 +76,7 @@ class TestIdentityRoles(base.TestCase):
def test_delete_role(self, mock_keystone, mock_get):
role_obj = fakes.FakeRole(id='1234', name='aaa')
mock_get.return_value = meta.obj_to_dict(role_obj)
self.assertTrue(self.cloud.delete_role('1234'))
self.assertTrue(self.op_cloud.delete_role('1234'))
self.assertTrue(mock_keystone.roles.delete.called)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@ -88,7 +84,7 @@ class TestIdentityRoles(base.TestCase):
def test_list_role_assignments(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '3'
mock_keystone.role_assignments.list.return_value = RAW_ROLE_ASSIGNMENTS
ret = self.cloud.list_role_assignments()
ret = self.op_cloud.list_role_assignments()
mock_keystone.role_assignments.list.assert_called_once_with()
normalized_assignments = _utils.normalize_role_assignments(
RAW_ROLE_ASSIGNMENTS
@ -101,7 +97,7 @@ class TestIdentityRoles(base.TestCase):
mock_api_version):
mock_api_version.return_value = '3'
params = dict(user='123', domain='456', effective=True)
self.cloud.list_role_assignments(filters=params)
self.op_cloud.list_role_assignments(filters=params)
mock_keystone.role_assignments.list.assert_called_once_with(**params)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@ -114,7 +110,7 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException,
"Failed to list role assignments"
):
self.cloud.list_role_assignments()
self.op_cloud.list_role_assignments()
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -123,11 +119,15 @@ class TestIdentityRoles(base.TestCase):
fake_role = fakes.FakeRole(id='1234', name='fake_role')
mock_api_version.return_value = '2.0'
mock_keystone.roles.roles_for_user.return_value = [fake_role]
ret = self.cloud.list_role_assignments(filters={'user': '2222',
'project': '3333'})
self.assertEqual(ret, [{'id': fake_role.id,
'project': '3333',
'user': '2222'}])
ret = self.op_cloud.list_role_assignments(
filters={
'user': '2222',
'project': '3333'})
self.assertEqual(
ret, [{
'id': fake_role.id,
'project': '3333',
'user': '2222'}])
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -138,12 +138,16 @@ class TestIdentityRoles(base.TestCase):
mock_api_version.return_value = '2.0'
mock_keystone.roles.roles_for_user.return_value = [fake_role1,
fake_role2]
ret = self.cloud.list_role_assignments(filters={'role': fake_role1.id,
'user': '2222',
'project': '3333'})
self.assertEqual(ret, [{'id': fake_role1.id,
'project': '3333',
'user': '2222'}])
ret = self.op_cloud.list_role_assignments(
filters={
'role': fake_role1.id,
'user': '2222',
'project': '3333'})
self.assertEqual(
ret, [{
'id': fake_role1.id,
'project': '3333',
'user': '2222'}])
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -154,7 +158,7 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException,
"Must provide project and user for keystone v2"
):
self.cloud.list_role_assignments()
self.op_cloud.list_role_assignments()
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -165,4 +169,4 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException,
"Must provide project and user for keystone v2"
):
self.cloud.list_role_assignments(filters={'user': '12345'})
self.op_cloud.list_role_assignments(filters={'user': '12345'})

3
shade/tests/unit/test_image_snapshot.py
View File

@ -39,7 +39,8 @@ class TestImageSnapshot(base.TestCase):
mock_get.return_value = {'status': 'saving', 'id': self.image_id}
self.assertRaises(exc.OpenStackCloudTimeout,
self.cloud.create_image_snapshot,
'test-snapshot', 'fake-server', wait=True, timeout=2)
'test-snapshot', 'fake-server',
wait=True, timeout=0.01)
@mock.patch.object(shade.OpenStackCloud, 'nova_client')
@mock.patch.object(shade.OpenStackCloud, 'get_image')

6
shade/tests/unit/test_magnum_services.py
View File

@ -33,13 +33,9 @@ magnum_service_obj = munch.Munch(
class TestMagnumServices(base.TestCase):
def setUp(self):
super(TestMagnumServices, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'magnum_client')
def test_list_magnum_services(self, mock_magnum):
mock_magnum.mservices.list.return_value = [magnum_service_obj, ]
mservices_list = self.cloud.list_magnum_services()
mservices_list = self.op_cloud.list_magnum_services()
mock_magnum.mservices.list.assert_called_with(detail=False)
self.assertEqual(mservices_list[0], magnum_service_obj)

8
shade/tests/unit/test_object.py
View File

@ -14,7 +14,6 @@
# under the License.
import mock
import os_client_config
from os_client_config import cloud_config
from swiftclient import service as swift_service
from swiftclient import exceptions as swift_exc
@ -23,18 +22,11 @@ import testtools
import shade
import shade.openstackcloud
from shade import exc
from shade import OpenStackCloud
from shade.tests.unit import base
class TestObject(base.TestCase):
def setUp(self):
super(TestObject, self).setUp()
config = os_client_config.OpenStackConfig()
self.cloud = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_swift_client_no_endpoint(self, get_session_mock):
session_mock = mock.Mock()

31
shade/tests/unit/test_port.py
View File

@ -20,7 +20,6 @@ Test port resource (managed by neutron)
"""
from mock import patch
import os_client_config
from shade import OpenStackCloud
from shade.exc import OpenStackCloudException
from shade.tests.unit import base
@ -142,18 +141,12 @@ class TestPort(base.TestCase):
]
}
def setUp(self):
super(TestPort, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
@patch.object(OpenStackCloud, 'neutron_client')
def test_create_port(self, mock_neutron_client):
mock_neutron_client.create_port.return_value = \
self.mock_neutron_port_create_rep
port = self.client.create_port(
port = self.cloud.create_port(
network_id='test-net-id', name='test-port-name',
admin_state_up=True)
@ -165,7 +158,7 @@ class TestPort(base.TestCase):
def test_create_port_parameters(self):
"""Test that we detect invalid arguments passed to create_port"""
self.assertRaises(
TypeError, self.client.create_port,
TypeError, self.cloud.create_port,
network_id='test-net-id', nome='test-port-name',
stato_amministrativo_porta=True)
@ -174,7 +167,7 @@ class TestPort(base.TestCase):
mock_neutron_client.create_port.side_effect = Exception('blah')
self.assertRaises(
OpenStackCloudException, self.client.create_port,
OpenStackCloudException, self.cloud.create_port,
network_id='test-net-id', name='test-port-name',
admin_state_up=True)
@ -185,7 +178,7 @@ class TestPort(base.TestCase):
mock_neutron_client.update_port.return_value = \
self.mock_neutron_port_update_rep
port = self.client.update_port(
port = self.cloud.update_port(
name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b',
name='test-port-name-updated')
@ -197,7 +190,7 @@ class TestPort(base.TestCase):
def test_update_port_parameters(self):
"""Test that we detect invalid arguments passed to update_port"""
self.assertRaises(
TypeError, self.client.update_port,
TypeError, self.cloud.update_port,
name_or_id='test-port-id', nome='test-port-name-updated')
@patch.object(OpenStackCloud, 'neutron_client')
@ -207,7 +200,7 @@ class TestPort(base.TestCase):
mock_neutron_client.update_port.side_effect = Exception('blah')
self.assertRaises(
OpenStackCloudException, self.client.update_port,
OpenStackCloudException, self.cloud.update_port,
name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b',
name='test-port-name-updated')
@ -216,7 +209,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep
ports = self.client.list_ports()
ports = self.cloud.list_ports()
mock_neutron_client.list_ports.assert_called_with()
self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports)
@ -225,14 +218,14 @@ class TestPort(base.TestCase):
def test_list_ports_exception(self, mock_neutron_client):
mock_neutron_client.list_ports.side_effect = Exception('blah')
self.assertRaises(OpenStackCloudException, self.client.list_ports)
self.assertRaises(OpenStackCloudException, self.cloud.list_ports)
@patch.object(OpenStackCloud, 'neutron_client')
def test_search_ports_by_id(self, mock_neutron_client):
mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep
ports = self.client.search_ports(
ports = self.cloud.search_ports(
name_or_id='f71a6703-d6de-4be1-a91a-a570ede1d159')
mock_neutron_client.list_ports.assert_called_with()
@ -244,7 +237,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep
ports = self.client.search_ports(name_or_id='first-port')
ports = self.cloud.search_ports(name_or_id='first-port')
mock_neutron_client.list_ports.assert_called_with()
self.assertEquals(1, len(ports))
@ -255,7 +248,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep
ports = self.client.search_ports(name_or_id='non-existent')
ports = self.cloud.search_ports(name_or_id='non-existent')
mock_neutron_client.list_ports.assert_called_with()
self.assertEquals(0, len(ports))
@ -265,7 +258,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep
self.client.delete_port(name_or_id='first-port')
self.cloud.delete_port(name_or_id='first-port')
mock_neutron_client.delete_port.assert_called_with(
port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b')

24
shade/tests/unit/test_project.py
View File

@ -25,17 +25,13 @@ from shade.tests.unit import base
class TestProject(base.TestCase):
def setUp(self):
super(TestProject, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_project_v2(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '2'
name = 'project_name'
description = 'Project description'
self.cloud.create_project(name=name, description=description)
self.op_cloud.create_project(name=name, description=description)
mock_keystone.tenants.create.assert_called_once_with(
project_name=name, description=description, enabled=True,
tenant_name=name
@ -48,8 +44,8 @@ class TestProject(base.TestCase):
name = 'project_name'
description = 'Project description'
domain_id = '123'
self.cloud.create_project(name=name, description=description,
domain_id=domain_id)
self.op_cloud.create_project(
name=name, description=description, domain_id=domain_id)
mock_keystone.projects.create.assert_called_once_with(
project_name=name, description=description, enabled=True,
name=name, domain=domain_id
@ -65,7 +61,7 @@ class TestProject(base.TestCase):
"User or project creation requires an explicit"
" domain_id argument."
):
self.cloud.create_project(name='foo', description='bar')
self.op_cloud.create_project(name='foo', description='bar')
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'get_project')
@ -74,7 +70,7 @@ class TestProject(base.TestCase):
mock_api_version):
mock_api_version.return_value = '2'
mock_get.return_value = dict(id='123')
self.assertTrue(self.cloud.delete_project('123'))
self.assertTrue(self.op_cloud.delete_project('123'))
mock_get.assert_called_once_with('123', domain_id=None)
mock_keystone.tenants.delete.assert_called_once_with(tenant='123')
@ -85,7 +81,7 @@ class TestProject(base.TestCase):
mock_api_version):
mock_api_version.return_value = '3'
mock_get.return_value = dict(id='123')
self.assertTrue(self.cloud.delete_project('123'))
self.assertTrue(self.op_cloud.delete_project('123'))
mock_get.assert_called_once_with('123', domain_id=None)
mock_keystone.projects.delete.assert_called_once_with(project='123')
@ -96,7 +92,7 @@ class TestProject(base.TestCase):
shade.OpenStackCloudException,
"Project ABC not found."
):
self.cloud.update_project('ABC')
self.op_cloud.update_project('ABC')
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'get_project')
@ -105,7 +101,7 @@ class TestProject(base.TestCase):
mock_api_version):
mock_api_version.return_value = '2'
mock_get_project.return_value = munch.Munch(dict(id='123'))
self.cloud.update_project('123', description='new', enabled=False)
self.op_cloud.update_project('123', description='new', enabled=False)
mock_keystone.tenants.update.assert_called_once_with(
description='new', enabled=False, tenant_id='123')
@ -116,7 +112,7 @@ class TestProject(base.TestCase):
mock_api_version):
mock_api_version.return_value = '3'
mock_get_project.return_value = munch.Munch(dict(id='123'))
self.cloud.update_project('123', description='new', enabled=False)
self.op_cloud.update_project('123', description='new', enabled=False)
mock_keystone.projects.update.assert_called_once_with(
description='new', enabled=False, project='123')
@ -124,6 +120,6 @@ class TestProject(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_projects_v3(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '3'
self.cloud.list_projects('123')
self.op_cloud.list_projects('123')
mock_keystone.projects.list.assert_called_once_with(
domain='123')

22
shade/tests/unit/test_quotas.py
View File

@ -22,16 +22,12 @@ from shade.tests import fakes
class TestQuotas(base.TestCase):
def setUp(self):
super(TestQuotas, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(shade.OpenStackCloud, 'nova_client')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.set_compute_quotas(project, cores=1)
self.op_cloud.set_compute_quotas(project, cores=1)
mock_nova.quotas.update.assert_called_once_with(
cores=1, force=True, tenant_id='project_a')
@ -41,7 +37,7 @@ class TestQuotas(base.TestCase):
def test_get_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.get_compute_quotas(project)
self.op_cloud.get_compute_quotas(project)
mock_nova.quotas.get.assert_called_once_with(tenant_id='project_a')
@ -50,7 +46,7 @@ class TestQuotas(base.TestCase):
def test_delete_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.delete_compute_quotas(project)
self.op_cloud.delete_compute_quotas(project)
mock_nova.quotas.delete.assert_called_once_with(tenant_id='project_a')
@ -59,7 +55,7 @@ class TestQuotas(base.TestCase):
def test_cinder_update_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.set_volume_quotas(project, volumes=1)
self.op_cloud.set_volume_quotas(project, volumes=1)
mock_cinder.quotas.update.assert_called_once_with(
volumes=1, tenant_id='project_a')
@ -69,7 +65,7 @@ class TestQuotas(base.TestCase):
def test_cinder_get_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.get_volume_quotas(project)
self.op_cloud.get_volume_quotas(project)
mock_cinder.quotas.get.assert_called_once_with(tenant_id='project_a')
@ -78,7 +74,7 @@ class TestQuotas(base.TestCase):
def test_cinder_delete_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.delete_volume_quotas(project)
self.op_cloud.delete_volume_quotas(project)
mock_cinder.quotas.delete.assert_called_once_with(
tenant_id='project_a')
@ -88,7 +84,7 @@ class TestQuotas(base.TestCase):
def test_neutron_update_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.set_network_quotas(project, network=1)
self.op_cloud.set_network_quotas(project, network=1)
mock_neutron.update_quota.assert_called_once_with(
body={'quota': {'network': 1}}, tenant_id='project_a')
@ -98,7 +94,7 @@ class TestQuotas(base.TestCase):
def test_neutron_get_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.get_network_quotas(project)
self.op_cloud.get_network_quotas(project)
mock_neutron.show_quota.assert_called_once_with(
tenant_id='project_a')
@ -108,7 +104,7 @@ class TestQuotas(base.TestCase):
def test_neutron_delete_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.cloud.delete_network_quotas(project)
self.op_cloud.delete_network_quotas(project)
mock_neutron.delete_quota.assert_called_once_with(
tenant_id='project_a')

36
shade/tests/unit/test_rebuild_server.py
View File

@ -20,22 +20,16 @@ Tests for the `rebuild_server` command.
"""
from mock import patch, Mock
import os_client_config
from shade import _utils
from shade import meta
from shade import OpenStackCloud
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
class TestRebuildServer(base.TestCase):
def setUp(self):
super(TestRebuildServer, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
def test_rebuild_server_rebuild_exception(self):
"""
Test that an exception in the novaclient rebuild raises an exception in
@ -47,7 +41,7 @@ class TestRebuildServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.rebuild_server, "a", "b")
OpenStackCloudException, self.cloud.rebuild_server, "a", "b")
def test_rebuild_server_server_error(self):
"""
@ -68,7 +62,7 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException,
self.client.rebuild_server, "a", "b", wait=True)
self.cloud.rebuild_server, "a", "b", wait=True)
def test_rebuild_server_timeout(self):
"""
@ -84,7 +78,7 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudTimeout,
self.client.rebuild_server, "a", "b", wait=True, timeout=0.001)
self.cloud.rebuild_server, "a", "b", wait=True, timeout=0.001)
def test_rebuild_server_no_wait(self):
"""
@ -98,7 +92,7 @@ class TestRebuildServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(meta.obj_to_dict(rebuild_server),
self.client.rebuild_server("a", "b"))
self.cloud.rebuild_server("a", "b"))
def test_rebuild_server_with_admin_pass_no_wait(self):
"""
@ -113,8 +107,8 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
meta.obj_to_dict(rebuild_server),
self.client.rebuild_server('a', 'b',
admin_pass='ooBootheiX0edoh'))
self.cloud.rebuild_server(
'a', 'b', admin_pass='ooBootheiX0edoh'))
def test_rebuild_server_with_admin_pass_wait(self):
"""
@ -135,13 +129,13 @@ class TestRebuildServer(base.TestCase):
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.client.name = 'cloud-name'
self.cloud.name = 'cloud-name'
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(ret_active_server),
cloud_name='cloud-name', region_name=''),
self.client.rebuild_server("a", "b", wait=True,
admin_pass='ooBootheiX0edoh'))
cloud_name='cloud-name', region_name='RegionOne'),
self.cloud.rebuild_server(
"a", "b", wait=True, admin_pass='ooBootheiX0edoh'))
def test_rebuild_server_wait(self):
"""
@ -160,9 +154,9 @@ class TestRebuildServer(base.TestCase):
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.client.name = 'cloud-name'
self.cloud.name = 'cloud-name'
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(active_server),
cloud_name='cloud-name', region_name=''),
self.client.rebuild_server("a", "b", wait=True))
cloud_name='cloud-name', region_name='RegionOne'),
self.cloud.rebuild_server("a", "b", wait=True))

296
shade/tests/unit/test_role_assignment.py
View File

@ -13,10 +13,11 @@
from mock import patch
import os_client_config as occ
from shade import OperatorCloud, operator_cloud
from shade import OperatorCloud
from shade.exc import OpenStackCloudException, OpenStackCloudTimeout
from shade.meta import obj_to_dict
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
import testtools
@ -24,7 +25,6 @@ class TestRoleAssignment(base.TestCase):
def setUp(self):
super(TestRoleAssignment, self).setUp()
self.cloud = operator_cloud(validate=False)
self.fake_role = obj_to_dict(fakes.FakeRole('12345', 'test'))
self.fake_user = obj_to_dict(fakes.FakeUser('12345',
'test@nobody.org',
@ -102,12 +102,16 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.roles.roles_for_user.return_value = []
mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -118,18 +122,26 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = []
mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(self.fake_role['id'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(self.fake_role['id'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['id'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['id'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -141,7 +153,7 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [self.fake_role]
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
@ -154,12 +166,16 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -172,11 +188,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment]
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['id'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@ -189,11 +205,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
project=self.fake_project['id']))
@ -209,11 +225,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = \
[self.group_project_assignment]
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
project=self.fake_project['id']))
@ -226,19 +242,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['name']))
@ -254,19 +270,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \
[self.user_domain_assignment]
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['id']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['id']))
@ -279,19 +295,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['id']))
@ -307,19 +323,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \
[self.group_domain_assignment]
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['id']))
self.assertFalse(self.cloud.grant_role(
self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['id']))
@ -333,11 +349,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.roles.roles_for_user.return_value = [self.fake_role]
mock_keystone.roles.remove_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@ -352,19 +368,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = []
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['id'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['id'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@ -380,7 +396,7 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [self.fake_role]
mock_keystone.roles.remove_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
@ -393,11 +409,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@ -413,11 +429,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment]
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['id'],
user=self.fake_user['id'],
project=self.fake_project['id']))
@ -430,11 +446,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
project=self.fake_project['id']))
@ -450,11 +466,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = \
[self.group_project_assignment]
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
project=self.fake_project['id']))
@ -467,19 +483,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['name']))
@ -495,19 +511,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \
[self.user_domain_assignment]
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain=self.fake_domain['id']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['id'],
domain=self.fake_domain['id']))
@ -520,19 +536,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role(
self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['id']))
@ -548,19 +564,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \
[self.group_domain_assignment]
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['id']))
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['id'],
domain=self.fake_domain['id']))
@ -575,9 +591,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Role {0} not found'.format(self.fake_role['name'])
):
self.cloud.grant_role(self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name'])
self.op_cloud.grant_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -588,9 +605,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Role {0} not found'.format(self.fake_role['name'])
):
self.cloud.revoke_role(self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name'])
self.op_cloud.revoke_role(
self.fake_role['name'],
group=self.fake_group['name'],
domain=self.fake_domain['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -603,7 +621,7 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a user or a group'
):
self.cloud.grant_role(self.fake_role['name'])
self.op_cloud.grant_role(self.fake_role['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -616,7 +634,7 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a user or a group'
):
self.cloud.revoke_role(self.fake_role['name'])
self.op_cloud.revoke_role(self.fake_role['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -628,8 +646,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a user or a group'
):
self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'])
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -641,8 +660,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a user or a group'
):
self.cloud.revoke_role(self.fake_role['name'],
user=self.fake_user['name'])
self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -655,9 +675,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Specify either a group or a user, not both'
):
self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
group=self.fake_group['name'])
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
group=self.fake_group['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -670,9 +691,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Specify either a group or a user, not both'
):
self.cloud.revoke_role(self.fake_role['name'],
user=self.fake_user['name'],
group=self.fake_group['name'])
self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
group=self.fake_group['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -688,10 +710,12 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user, fake_user2]
mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.domains.get.return_value = self.fake_domain
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
domain=self.fake_domain['name']))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
domain=self.fake_domain['name']))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -709,7 +733,7 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment]
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
@ -727,8 +751,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a domain or project'
):
self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'])
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -746,8 +771,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Must specify either a domain or project'
):
self.cloud.revoke_role(self.fake_role['name'],
user=self.fake_user['name'])
self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -761,9 +787,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Failed to get domain baddomain \(Inner Exception: test\)'
):
self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
domain='baddomain')
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain='baddomain')
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -777,9 +804,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException,
'Failed to get domain baddomain \(Inner Exception: test\)'
):
self.cloud.revoke_role(self.fake_role['name'],
user=self.fake_user['name'],
domain='baddomain')
self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
domain='baddomain')
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -793,10 +821,12 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.roles_for_user.side_effect = [
[], [], [self.fake_role]]
mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
self.assertTrue(
self.op_cloud.grant_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -807,23 +837,21 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.side_effect = [
[], [], [self.fake_role]]
mock_keystone.roles.roles_for_user.return_value = []
mock_keystone.roles.add_user_role.return_value = self.fake_role
with testtools.ExpectedException(
OpenStackCloudTimeout,
'Timeout waiting for role to be granted'
):
self.assertTrue(self.cloud.grant_role(
self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], user=self.fake_user['name'],
project=self.fake_project['id'], wait=True, timeout=1))
project=self.fake_project['id'], wait=True, timeout=0.01))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
def test_revoke_role_user_project_v2_wait(self,
mock_keystone,
mock_api_version):
def test_revoke_role_user_project_v2_wait(
self, mock_keystone, mock_api_version):
mock_api_version.return_value = '2.0'
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project]
@ -832,10 +860,12 @@ class TestRoleAssignment(base.TestCase):
[self.fake_role], [self.fake_role],
[]]
mock_keystone.roles.remove_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.revoke_role(self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
self.assertTrue(
self.op_cloud.revoke_role(
self.fake_role['name'],
user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client')
@ -846,14 +876,12 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.side_effect = [
[self.fake_role], [self.fake_role],
[]]
mock_keystone.roles.roles_for_user.return_value = [self.fake_role]
mock_keystone.roles.remove_user_role.return_value = self.fake_role
with testtools.ExpectedException(
OpenStackCloudTimeout,
'Timeout waiting for role to be revoked'
):
self.assertTrue(self.cloud.revoke_role(
self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], user=self.fake_user['name'],
project=self.fake_project['id'], wait=True, timeout=1))
project=self.fake_project['id'], wait=True, timeout=0.01))

13
shade/tests/unit/test_server_delete_metadata.py
View File

@ -20,19 +20,12 @@ Tests for the `delete_server_metadata` command.
"""
from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud
from shade.exc import OpenStackCloudException
from shade.tests import base
from shade.tests.unit import base
class TestServerDeleteMetadata(base.TestCase):
def setUp(self):
super(TestServerDeleteMetadata, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.client._SERVER_AGE = 0
def test_server_delete_metadata_with_delete_meta_exception(self):
"""
@ -46,7 +39,7 @@ class TestServerDeleteMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.delete_server_metadata,
OpenStackCloudException, self.cloud.delete_server_metadata,
{'id': 'server-id'}, ['key'])
def test_server_delete_metadata_with_exception_reraise(self):
@ -62,5 +55,5 @@ class TestServerDeleteMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.delete_server_metadata,
OpenStackCloudException, self.cloud.delete_server_metadata,
'server-id', ['key'])

14
shade/tests/unit/test_server_set_metadata.py
View File

@ -20,21 +20,13 @@ Tests for the `set_server_metadata` command.
"""
from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud
from shade.exc import OpenStackCloudException
from shade.tests import base
from shade.tests.unit import base
class TestServerSetMetadata(base.TestCase):
def setUp(self):
super(TestServerSetMetadata, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.client._SERVER_AGE = 0
def test_server_set_metadata_with_set_meta_exception(self):
"""
Test that a generic exception in the novaclient set_meta raises
@ -47,7 +39,7 @@ class TestServerSetMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.set_server_metadata,
OpenStackCloudException, self.cloud.set_server_metadata,
{'id': 'server-id'}, {'meta': 'data'})
def test_server_set_metadata_with_exception_reraise(self):
@ -63,5 +55,5 @@ class TestServerSetMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.set_server_metadata,
OpenStackCloudException, self.cloud.set_server_metadata,
'server-id', {'meta': 'data'})

33
shade/tests/unit/test_services.py
View File

@ -44,9 +44,6 @@ class CloudServices(base.TestCase):
def setUp(self):
super(CloudServices, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OperatorCloud(cloud_config=config.get_one_cloud(
validate=False))
self.mock_ks_services = [FakeService(**kwa) for kwa in
self.mock_services]
@ -62,7 +59,7 @@ class CloudServices(base.TestCase):
'description': 'This is a test service'
}
self.client.create_service(**kwargs)
self.op_cloud.create_service(**kwargs)
kwargs['service_type'] = kwargs.pop('type')
mock_keystone_client.services.create.assert_called_with(**kwargs)
self.assertTrue(mock_norm.called)
@ -80,7 +77,7 @@ class CloudServices(base.TestCase):
'enabled': False
}
self.client.create_service(**kwargs)
self.op_cloud.create_service(**kwargs)
mock_keystone_client.services.create.assert_called_with(**kwargs)
self.assertTrue(mock_norm.called)
@ -89,7 +86,7 @@ class CloudServices(base.TestCase):
mock_api_version.return_value = '2.0'
# NOTE(SamYaple): Update service only works with v3 api
self.assertRaises(OpenStackCloudUnavailableFeature,
self.client.update_service,
self.op_cloud.update_service,
'service_id', name='new name')
@patch.object(_utils, 'normalize_keystone_services')
@ -109,7 +106,7 @@ class CloudServices(base.TestCase):
service_obj = FakeService(id='id1', **kwargs)
mock_keystone_client.services.update.return_value = service_obj
self.client.update_service('id1', **kwargs)
self.op_cloud.update_service('id1', **kwargs)
del kwargs['service_type']
mock_keystone_client.services.update.assert_called_once_with(
service='id1', **kwargs
@ -120,7 +117,7 @@ class CloudServices(base.TestCase):
def test_list_services(self, mock_keystone_client):
mock_keystone_client.services.list.return_value = \
self.mock_ks_services
services = self.client.list_services()
services = self.op_cloud.list_services()
mock_keystone_client.services.list.assert_called_with()
self.assertItemsEqual(self.mock_services, services)
@ -130,22 +127,22 @@ class CloudServices(base.TestCase):
self.mock_ks_services
# Search by id
service = self.client.get_service(name_or_id='id4')
service = self.op_cloud.get_service(name_or_id='id4')
# test we are getting exactly 1 element
self.assertEqual(service, self.mock_services[3])
# Search by name
service = self.client.get_service(name_or_id='service2')
service = self.op_cloud.get_service(name_or_id='service2')
# test we are getting exactly 1 element
self.assertEqual(service, self.mock_services[1])
# Not found
service = self.client.get_service(name_or_id='blah!')
service = self.op_cloud.get_service(name_or_id='blah!')
self.assertIs(None, service)
# Multiple matches
# test we are getting an Exception
self.assertRaises(OpenStackCloudException, self.client.get_service,
self.assertRaises(OpenStackCloudException, self.op_cloud.get_service,
name_or_id=None, filters={'type': 'type2'})
@patch.object(OperatorCloud, 'keystone_client')
@ -154,23 +151,23 @@ class CloudServices(base.TestCase):
self.mock_ks_services
# Search by id
services = self.client.search_services(name_or_id='id4')
services = self.op_cloud.search_services(name_or_id='id4')
# test we are getting exactly 1 element
self.assertEqual(1, len(services))
self.assertEqual(services, [self.mock_services[3]])
# Search by name
services = self.client.search_services(name_or_id='service2')
services = self.op_cloud.search_services(name_or_id='service2')
# test we are getting exactly 1 element
self.assertEqual(1, len(services))
self.assertEqual(services, [self.mock_services[1]])
# Not found
services = self.client.search_services(name_or_id='blah!')
services = self.op_cloud.search_services(name_or_id='blah!')
self.assertEqual(0, len(services))
# Multiple matches
services = self.client.search_services(
services = self.op_cloud.search_services(
filters={'type': 'type2'})
# test we are getting exactly 2 elements
self.assertEqual(2, len(services))
@ -183,9 +180,9 @@ class CloudServices(base.TestCase):
self.mock_ks_services
# Delete by name
self.client.delete_service(name_or_id='service3')
self.op_cloud.delete_service(name_or_id='service3')
mock_keystone_client.services.delete.assert_called_with(id='id3')
# Delete by id
self.client.delete_service('id1')
self.op_cloud.delete_service('id1')
mock_keystone_client.services.delete.assert_called_with(id='id1')

143
shade/tests/unit/test_shade_operator.py
View File

@ -27,19 +27,15 @@ from shade.tests.unit import base
class TestShadeOperator(base.TestCase):
def setUp(self):
super(TestShadeOperator, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
def test_operator_cloud(self):
self.assertIsInstance(self.cloud, shade.OperatorCloud)
self.assertIsInstance(self.op_cloud, shade.OperatorCloud)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_get_machine(self, mock_client):
node = fakes.FakeMachine(id='00000000-0000-0000-0000-000000000000',
name='bigOlFaker')
mock_client.node.get.return_value = node
machine = self.cloud.get_machine('bigOlFaker')
machine = self.op_cloud.get_machine('bigOlFaker')
mock_client.node.get.assert_called_with(node_id='bigOlFaker')
self.assertEqual(meta.obj_to_dict(node), machine)
@ -57,7 +53,7 @@ class TestShadeOperator(base.TestCase):
mock_client.port.get_by_address.return_value = port_value
mock_client.node.get.return_value = node_value
machine = self.cloud.get_machine_by_mac('00:00:00:00:00:00')
machine = self.op_cloud.get_machine_by_mac('00:00:00:00:00:00')
mock_client.port.get_by_address.assert_called_with(
address='00:00:00:00:00:00')
mock_client.node.get.assert_called_with(
@ -68,14 +64,14 @@ class TestShadeOperator(base.TestCase):
def test_list_machines(self, mock_client):
m1 = fakes.FakeMachine(1, 'fake_machine1')
mock_client.node.list.return_value = [m1]
machines = self.cloud.list_machines()
machines = self.op_cloud.list_machines()
self.assertTrue(mock_client.node.list.called)
self.assertEqual(meta.obj_to_dict(m1), machines[0])
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_validate_node(self, mock_client):
node_uuid = '123'
self.cloud.validate_node(node_uuid)
self.op_cloud.validate_node(node_uuid)
mock_client.node.validate.assert_called_once_with(
node_uuid=node_uuid
)
@ -88,7 +84,7 @@ class TestShadeOperator(base.TestCase):
port_dict_list = meta.obj_list_to_dict(port_list)
mock_client.port.list.return_value = port_list
nics = self.cloud.list_nics()
nics = self.op_cloud.list_nics()
self.assertTrue(mock_client.port.list.called)
self.assertEqual(port_dict_list, nics)
@ -97,26 +93,26 @@ class TestShadeOperator(base.TestCase):
def test_list_nics_failure(self, mock_client):
mock_client.port.list.side_effect = Exception()
self.assertRaises(exc.OpenStackCloudException,
self.cloud.list_nics)
self.op_cloud.list_nics)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_list_nics_for_machine(self, mock_client):
mock_client.node.list_ports.return_value = []
self.cloud.list_nics_for_machine("123")
self.op_cloud.list_nics_for_machine("123")
mock_client.node.list_ports.assert_called_with(node_id="123")
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_list_nics_for_machine_failure(self, mock_client):
mock_client.node.list_ports.side_effect = Exception()
self.assertRaises(exc.OpenStackCloudException,
self.cloud.list_nics_for_machine, None)
self.op_cloud.list_nics_for_machine, None)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_patch_machine(self, mock_client):
node_id = 'node01'
patch = []
patch.append({'op': 'remove', 'path': '/instance_info'})
self.cloud.patch_machine(node_id, patch)
self.op_cloud.patch_machine(node_id, patch)
self.assertTrue(mock_client.node.update.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
@ -132,7 +128,7 @@ class TestShadeOperator(base.TestCase):
)
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine('node01')
update_dict = self.op_cloud.update_machine('node01')
self.assertIsNone(update_dict['changes'])
self.assertFalse(mock_patch.called)
self.assertDictEqual(expected_machine, update_dict['node'])
@ -151,7 +147,7 @@ class TestShadeOperator(base.TestCase):
)
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine('node01', name='node01')
update_dict = self.op_cloud.update_machine('node01', name='node01')
self.assertIsNone(update_dict['changes'])
self.assertFalse(mock_patch.called)
self.assertDictEqual(expected_machine, update_dict['node'])
@ -168,7 +164,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine('evil', name='good')
update_dict = self.op_cloud.update_machine('evil', name='good')
self.assertIsNotNone(update_dict['changes'])
self.assertEqual('/name', update_dict['changes'][0])
self.assertTrue(mock_patch.called)
@ -188,7 +184,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine('evil', name='good')
update_dict = self.op_cloud.update_machine('evil', name='good')
self.assertIsNotNone(update_dict['changes'])
self.assertEqual('/name', update_dict['changes'][0])
self.assertTrue(mock_patch.called)
@ -213,7 +209,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
chassis_uuid='00000000-0000-0000-0000-000000000001')
self.assertIsNotNone(update_dict['changes'])
@ -240,7 +236,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
driver='fake'
)
@ -268,7 +264,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
driver_info=dict(var="fake")
)
@ -296,7 +292,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
instance_info=dict(var="fake")
)
@ -324,7 +320,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
instance_uuid='00000000-0000-0000-0000-000000000002'
)
@ -352,7 +348,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value
update_dict = self.cloud.update_machine(
update_dict = self.op_cloud.update_machine(
'00000000-0000-0000-0000-000000000000',
properties=dict(var="fake")
)
@ -375,7 +371,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = active_machine
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.inspect_machine,
self.op_cloud.inspect_machine,
machine_uuid,
wait=True,
timeout=1)
@ -391,7 +387,7 @@ class TestShadeOperator(base.TestCase):
last_error = "kaboom"
mock_client.node.get.return_value = inspect_failed_machine
self.cloud.inspect_machine(machine_uuid)
self.op_cloud.inspect_machine(machine_uuid)
self.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual(
mock_client.node.set_provision_state.call_count, 1)
@ -406,7 +402,7 @@ class TestShadeOperator(base.TestCase):
provision_state = "manageable"
mock_client.node.get.return_value = manageable_machine
self.cloud.inspect_machine(machine_uuid)
self.op_cloud.inspect_machine(machine_uuid)
self.assertEqual(
mock_client.node.set_provision_state.call_count, 1)
@ -433,7 +429,7 @@ class TestShadeOperator(base.TestCase):
manageable_machine,
manageable_machine,
inspecting_machine])
self.cloud.inspect_machine(machine_uuid)
self.op_cloud.inspect_machine(machine_uuid)
self.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual(
mock_client.node.set_provision_state.call_count, 3)
@ -468,7 +464,7 @@ class TestShadeOperator(base.TestCase):
provision_state="available"
)
return_value = self.cloud.inspect_machine(
return_value = self.op_cloud.inspect_machine(
machine_uuid, wait=True, timeout=1)
self.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual(
@ -499,7 +495,7 @@ class TestShadeOperator(base.TestCase):
manageable_machine,
manageable_machine])
return_value = self.cloud.inspect_machine(
return_value = self.op_cloud.inspect_machine(
machine_uuid, wait=True, timeout=1)
self.assertDictEqual(expected_return_value, return_value)
@ -529,7 +525,7 @@ class TestShadeOperator(base.TestCase):
inspect_failed_machine])
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.inspect_machine,
self.op_cloud.inspect_machine,
machine_uuid,
wait=True,
timeout=1)
@ -554,7 +550,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.create.return_value = fake_node
mock_client.node.get.return_value = fake_node
nics = [{'mac': '00:00:00:00:00:00'}]
return_value = self.cloud.register_machine(nics)
return_value = self.op_cloud.register_machine(nics)
self.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called)
@ -612,7 +608,7 @@ class TestShadeOperator(base.TestCase):
fake_node_post_provide])
mock_client.node.create.return_value = fake_node_init_state
nics = [{'mac': '00:00:00:00:00:00'}]
return_value = self.cloud.register_machine(nics)
return_value = self.op_cloud.register_machine(nics)
self.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called)
@ -623,7 +619,7 @@ class TestShadeOperator(base.TestCase):
fake_node_post_manage,
fake_node_post_manage_done,
fake_node_post_provide])
return_value = self.cloud.register_machine(nics, wait=True)
return_value = self.op_cloud.register_machine(nics, wait=True)
self.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called)
@ -635,11 +631,11 @@ class TestShadeOperator(base.TestCase):
fake_node_post_enroll_failure])
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.register_machine,
self.op_cloud.register_machine,
nics)
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.register_machine,
self.op_cloud.register_machine,
nics,
wait=True)
@ -662,7 +658,7 @@ class TestShadeOperator(base.TestCase):
nics = [{'mac': '00:00:00:00:00:00'}]
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.register_machine,
self.op_cloud.register_machine,
nics,
lock_timeout=0.001)
self.assertTrue(mock_client.node.create.called)
@ -672,7 +668,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.create.reset_mock()
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.register_machine,
self.op_cloud.register_machine,
nics,
wait=True,
timeout=0.001)
@ -693,7 +689,7 @@ class TestShadeOperator(base.TestCase):
mock_client.port.create.side_effect = (
exc.OpenStackCloudException("Error"))
self.assertRaises(exc.OpenStackCloudException,
self.cloud.register_machine,
self.op_cloud.register_machine,
nics)
self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called)
@ -711,7 +707,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = fake_node
nics = [{'mac': '00:00:00:00:00:00'}]
uuid = "00000000-0000-0000-0000-000000000000"
self.cloud.unregister_machine(nics, uuid)
self.op_cloud.unregister_machine(nics, uuid)
self.assertTrue(mock_client.node.delete.called)
self.assertTrue(mock_client.port.get_by_address.called)
self.assertTrue(mock_client.port.delete.called)
@ -733,7 +729,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = fake_node
self.assertRaises(
exc.OpenStackCloudException,
self.cloud.unregister_machine,
self.op_cloud.unregister_machine,
nics,
uuid)
self.assertFalse(mock_client.node.delete.called)
@ -753,7 +749,7 @@ class TestShadeOperator(base.TestCase):
uuid = "00000000-0000-0000-0000-000000000000"
self.assertRaises(
exc.OpenStackCloudException,
self.cloud.unregister_machine,
self.op_cloud.unregister_machine,
nics,
uuid,
wait=True,
@ -768,7 +764,8 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
reason = 'no reason'
self.cloud.set_machine_maintenance_state(node_id, True, reason=reason)
self.op_cloud.set_machine_maintenance_state(
node_id, True, reason=reason)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='true',
@ -778,7 +775,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_maintenace_state_false(self, mock_client):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
self.cloud.set_machine_maintenance_state(node_id, False)
self.op_cloud.set_machine_maintenance_state(node_id, False)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='false')
@ -787,7 +784,7 @@ class TestShadeOperator(base.TestCase):
def test_remove_machine_from_maintenance(self, mock_client):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
self.cloud.remove_machine_from_maintenance(node_id)
self.op_cloud.remove_machine_from_maintenance(node_id)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='false')
@ -796,7 +793,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_on(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.cloud.set_machine_power_on(node_id)
return_value = self.op_cloud.set_machine_power_on(node_id)
self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
@ -806,7 +803,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_off(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.cloud.set_machine_power_off(node_id)
return_value = self.op_cloud.set_machine_power_off(node_id)
self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
@ -816,7 +813,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_reboot(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.cloud.set_machine_power_reboot(node_id)
return_value = self.op_cloud.set_machine_power_reboot(node_id)
self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
@ -826,7 +823,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_reboot_failure(self, mock_client):
mock_client.node.set_power_state.return_value = 'failure'
self.assertRaises(shade.OpenStackCloudException,
self.cloud.set_machine_power_reboot,
self.op_cloud.set_machine_power_reboot,
'node01')
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
@ -844,7 +841,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_provision_state.return_value = None
mock_client.node.get.return_value = active_node_state
node_id = 'node01'
return_value = self.cloud.node_set_provision_state(
return_value = self.op_cloud.node_set_provision_state(
node_id,
'active',
configdrive='http://127.0.0.1/file.iso')
@ -874,7 +871,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = active_node_state
mock_client.node.set_provision_state.return_value = None
node_id = 'node01'
return_value = self.cloud.node_set_provision_state(
return_value = self.op_cloud.node_set_provision_state(
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
@ -890,7 +887,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = deploying_node_state
self.assertRaises(
shade.OpenStackCloudException,
self.cloud.node_set_provision_state,
self.op_cloud.node_set_provision_state,
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
@ -917,7 +914,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.side_effect = iter([
managable_node_state,
available_node_state])
return_value = self.cloud.node_set_provision_state(
return_value = self.op_cloud.node_set_provision_state(
'test_node',
'provide',
wait=True)
@ -929,7 +926,7 @@ class TestShadeOperator(base.TestCase):
def test_activate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None
node_id = 'node02'
return_value = self.cloud.activate_node(
return_value = self.op_cloud.activate_node(
node_id,
configdrive='http://127.0.0.1/file.iso')
self.assertEqual(None, return_value)
@ -954,7 +951,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_provision_state.return_value = None
node_id = 'node04'
return_value = self.cloud.activate_node(
return_value = self.op_cloud.activate_node(
node_id,
configdrive='http://127.0.0.1/file.iso',
wait=True,
@ -971,7 +968,7 @@ class TestShadeOperator(base.TestCase):
def test_deactivate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None
node_id = 'node03'
return_value = self.cloud.deactivate_node(
return_value = self.op_cloud.deactivate_node(
node_id, wait=False)
self.assertEqual(None, return_value)
mock_client.node.set_provision_state.assert_called_with(
@ -995,7 +992,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_provision_state.return_value = None
node_id = 'node03'
return_value = self.cloud.deactivate_node(
return_value = self.op_cloud.deactivate_node(
node_id, wait=True, timeout=2)
self.assertEqual(None, return_value)
mock_client.node.set_provision_state.assert_called_with(
@ -1008,7 +1005,7 @@ class TestShadeOperator(base.TestCase):
def test_set_node_instance_info(self, mock_client):
uuid = 'aaa'
patch = [{'op': 'add', 'foo': 'bar'}]
self.cloud.set_node_instance_info(uuid, patch)
self.op_cloud.set_node_instance_info(uuid, patch)
mock_client.node.update.assert_called_with(
node_id=uuid, patch=patch
)
@ -1017,7 +1014,7 @@ class TestShadeOperator(base.TestCase):
def test_purge_node_instance_info(self, mock_client):
uuid = 'aaa'
expected_patch = [{'op': 'remove', 'path': '/instance_info'}]
self.cloud.purge_node_instance_info(uuid)
self.op_cloud.purge_node_instance_info(uuid)
mock_client.node.update.assert_called_with(
node_id=uuid, patch=expected_patch
)
@ -1031,8 +1028,8 @@ class TestShadeOperator(base.TestCase):
status = 'success'
fake_image = Image()
glance_mock.images.list.return_value = [fake_image]
self.assertEqual('22 name', self.cloud.get_image_name('22'))
self.assertEqual('22 name', self.cloud.get_image_name('22 name'))
self.assertEqual('22 name', self.op_cloud.get_image_name('22'))
self.assertEqual('22 name', self.op_cloud.get_image_name('22 name'))
@mock.patch.object(shade.OpenStackCloud, 'glance_client')
def test_get_image_id(self, glance_mock):
@ -1043,14 +1040,14 @@ class TestShadeOperator(base.TestCase):
status = 'success'
fake_image = Image()
glance_mock.images.list.return_value = [fake_image]
self.assertEqual('22', self.cloud.get_image_id('22'))
self.assertEqual('22', self.cloud.get_image_id('22 name'))
self.assertEqual('22', self.op_cloud.get_image_id('22'))
self.assertEqual('22', self.op_cloud.get_image_id('22 name'))
@mock.patch.object(cloud_config.CloudConfig, 'get_endpoint')
def test_get_session_endpoint_provided(self, fake_get_endpoint):
fake_get_endpoint.return_value = 'http://fake.url'
self.assertEqual(
'http://fake.url', self.cloud.get_session_endpoint('image'))
'http://fake.url', self.op_cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_session(self, get_session_mock):
@ -1058,7 +1055,7 @@ class TestShadeOperator(base.TestCase):
session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock
self.assertEqual(
'http://fake.url', self.cloud.get_session_endpoint('image'))
'http://fake.url', self.op_cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_exception(self, get_session_mock):
@ -1070,27 +1067,27 @@ class TestShadeOperator(base.TestCase):
session_mock = mock.Mock()
session_mock.get_endpoint.side_effect = side_effect
get_session_mock.return_value = session_mock
self.cloud.name = 'testcloud'
self.cloud.region_name = 'testregion'
self.op_cloud.name = 'testcloud'
self.op_cloud.region_name = 'testregion'
with testtools.ExpectedException(
exc.OpenStackCloudException,
"Error getting image endpoint on testcloud:testregion:"
" No service"):
self.cloud.get_session_endpoint("image")
self.op_cloud.get_session_endpoint("image")
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_unavailable(self, get_session_mock):
session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock
image_endpoint = self.cloud.get_session_endpoint("image")
image_endpoint = self.op_cloud.get_session_endpoint("image")
self.assertIsNone(image_endpoint)
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_identity(self, get_session_mock):
session_mock = mock.Mock()
get_session_mock.return_value = session_mock
self.cloud.get_session_endpoint('identity')
self.op_cloud.get_session_endpoint('identity')
session_mock.get_endpoint.assert_called_with(
interface=ksa_plugin.AUTH_INTERFACE)
@ -1099,14 +1096,14 @@ class TestShadeOperator(base.TestCase):
session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock
self.assertFalse(self.cloud.has_service("image"))
self.assertFalse(self.op_cloud.has_service("image"))
@mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_has_service_yes(self, get_session_mock):
session_mock = mock.Mock()
session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock
self.assertTrue(self.cloud.has_service("image"))
self.assertTrue(self.op_cloud.has_service("image"))
@mock.patch.object(shade.OpenStackCloud, 'nova_client')
def test_list_hypervisors(self, mock_nova):
@ -1117,7 +1114,7 @@ class TestShadeOperator(base.TestCase):
fakes.FakeHypervisor('2', 'testserver2'),
]
r = self.cloud.list_hypervisors()
r = self.op_cloud.list_hypervisors()
mock_nova.hypervisors.list.assert_called_once_with()
self.assertEquals(2, len(r))
self.assertEquals('testserver1', r[0]['hypervisor_hostname'])

15
shade/tests/unit/test_update_server.py
View File

@ -20,21 +20,14 @@ Tests for the `update_server` command.
"""
from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud
from shade.exc import OpenStackCloudException
from shade.tests import base, fakes
from shade.tests import fakes
from shade.tests.unit import base
class TestUpdateServer(base.TestCase):
def setUp(self):
super(TestUpdateServer, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.client._SERVER_AGE = 0
def test_update_server_with_update_exception(self):
"""
Test that an exception in the novaclient update raises an exception in
@ -46,7 +39,7 @@ class TestUpdateServer(base.TestCase):
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudException, self.client.update_server,
OpenStackCloudException, self.cloud.update_server,
'server-name')
def test_update_server_name(self):
@ -68,5 +61,5 @@ class TestUpdateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
'server-name2',
self.client.update_server(
self.cloud.update_server(
'server-name', name='server-name2')['name'])

35
shade/tests/unit/test_users.py
View File

@ -26,10 +26,6 @@ from shade.tests.unit import base
class TestUsers(base.TestCase):
def setUp(self):
super(TestUsers, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_user_v2(self, mock_keystone, mock_api_version):
@ -39,8 +35,8 @@ class TestUsers(base.TestCase):
password = 'mice-rule'
fake_user = fakes.FakeUser('1', email, name)
mock_keystone.users.create.return_value = fake_user
user = self.cloud.create_user(name=name, email=email,
password=password)
user = self.op_cloud.create_user(
name=name, email=email, password=password)
mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email, enabled=True,
)
@ -57,9 +53,10 @@ class TestUsers(base.TestCase):
domain_id = '456'
fake_user = fakes.FakeUser('1', email, name)
mock_keystone.users.create.return_value = fake_user
user = self.cloud.create_user(name=name, email=email,
password=password,
domain_id=domain_id)
user = self.op_cloud.create_user(
name=name, email=email,
password=password,
domain_id=domain_id)
mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email, enabled=True,
domain=domain_id
@ -82,9 +79,10 @@ class TestUsers(base.TestCase):
mock_keystone.users.get.return_value = fake_user
mock_keystone.users.update.return_value = fake_user
mock_keystone.users.update_password.return_value = fake_user
user = self.cloud.update_user(name, name=name, email=email,
password=password,
domain_id=domain_id)
user = self.op_cloud.update_user(
name, name=name, email=email,
password=password,
domain_id=domain_id)
mock_keystone.users.update.assert_called_once_with(
user=munch_fake_user, name=name, email=email)
mock_keystone.users.update_password.assert_called_once_with(
@ -104,7 +102,8 @@ class TestUsers(base.TestCase):
"User or project creation requires an explicit"
" domain_id argument."
):
self.cloud.create_user(name=name, email=email, password=password)
self.op_cloud.create_user(
name=name, email=email, password=password)
@mock.patch.object(shade.OpenStackCloud, 'get_user_by_id')
@mock.patch.object(shade.OpenStackCloud, 'get_user')
@ -113,7 +112,7 @@ class TestUsers(base.TestCase):
mock_get_user.return_value = dict(id='123')
fake_user = fakes.FakeUser('123', 'email', 'name')
mock_get_by_id.return_value = fake_user
self.assertTrue(self.cloud.delete_user('name'))
self.assertTrue(self.op_cloud.delete_user('name'))
mock_get_by_id.assert_called_once_with('123', normalize=False)
mock_keystone.users.delete.assert_called_once_with(user=fake_user)
@ -121,7 +120,7 @@ class TestUsers(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_user_not_found(self, mock_keystone, mock_get_user):
mock_get_user.return_value = None
self.assertFalse(self.cloud.delete_user('name'))
self.assertFalse(self.op_cloud.delete_user('name'))
self.assertFalse(mock_keystone.users.delete.called)
@mock.patch.object(shade.OpenStackCloud, 'get_user')
@ -130,7 +129,7 @@ class TestUsers(base.TestCase):
def test_add_user_to_group(self, mock_keystone, mock_group, mock_user):
mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2))
self.cloud.add_user_to_group("user", "group")
self.op_cloud.add_user_to_group("user", "group")
mock_keystone.users.add_to_group.assert_called_once_with(
user=1, group=2
)
@ -142,7 +141,7 @@ class TestUsers(base.TestCase):
mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2))
mock_keystone.users.check_in_group.return_value = True
self.assertTrue(self.cloud.is_user_in_group("user", "group"))
self.assertTrue(self.op_cloud.is_user_in_group("user", "group"))
mock_keystone.users.check_in_group.assert_called_once_with(
user=1, group=2
)
@ -154,7 +153,7 @@ class TestUsers(base.TestCase):
mock_user):
mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2))
self.cloud.remove_user_from_group("user", "group")
self.op_cloud.remove_user_from_group("user", "group")
mock_keystone.users.remove_from_group.assert_called_once_with(
user=1, group=2
)