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_') test_cloud = os.environ.get('SHADE_OS_CLOUD', '_test_cloud_')
self.config = occ.OpenStackConfig( self.config = occ.OpenStackConfig(
config_files=[config.name], config_files=[config.name],
vendor_files=[vendor.name]) vendor_files=[vendor.name],
self.cloud_config = self.config.get_one_cloud(cloud=test_cloud) secure_files=['non-existant'])
self.cloud_config = self.config.get_one_cloud(
cloud=test_cloud, validate=False)
self.cloud = shade.OpenStackCloud( self.cloud = shade.OpenStackCloud(
cloud_config=self.cloud_config, cloud_config=self.cloud_config,
log_inner_exceptions=True) log_inner_exceptions=True)
self.op_cloud = shade.OperatorCloud( self.op_cloud = shade.OperatorCloud(
cloud_config=self.cloud_config, cloud_config=self.cloud_config,
log_inner_exceptions=True) 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): 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') @mock.patch.object(shade.OpenStackCloud, 'nova_client')
def test_create_aggregate(self, mock_nova): def test_create_aggregate(self, mock_nova):
aggregate_name = 'aggr1' 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( mock_nova.aggregates.create.assert_called_once_with(
name=aggregate_name, availability_zone=None name=aggregate_name, availability_zone=None
@ -39,8 +35,8 @@ class TestAggregate(base.TestCase):
def test_create_aggregate_with_az(self, mock_nova): def test_create_aggregate_with_az(self, mock_nova):
aggregate_name = 'aggr1' aggregate_name = 'aggr1'
availability_zone = 'az1' availability_zone = 'az1'
self.cloud.create_aggregate(name=aggregate_name, self.op_cloud.create_aggregate(
availability_zone=availability_zone) name=aggregate_name, availability_zone=availability_zone)
mock_nova.aggregates.create.assert_called_once_with( mock_nova.aggregates.create.assert_called_once_with(
name=aggregate_name, availability_zone=availability_zone name=aggregate_name, availability_zone=availability_zone
@ -51,7 +47,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name') 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.list.assert_called_once_with()
mock_nova.aggregates.delete.assert_called_once_with( mock_nova.aggregates.delete.assert_called_once_with(
aggregate='1234' aggregate='1234'
@ -62,7 +58,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name') 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( mock_nova.aggregates.update.assert_called_once_with(
aggregate='1234', aggregate='1234',
values={'availability_zone': 'az'}, values={'availability_zone': 'az'},
@ -73,7 +69,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name', availability_zone='az') 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( mock_nova.aggregates.update.assert_called_once_with(
aggregate='1234', aggregate='1234',
values={'availability_zone': None}, values={'availability_zone': None},
@ -85,7 +81,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name') 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( mock_nova.aggregates.set_metadata.assert_called_once_with(
aggregate='1234', aggregate='1234',
metadata=metadata metadata=metadata
@ -97,7 +93,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name') 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( mock_nova.aggregates.add_host.assert_called_once_with(
aggregate='1234', aggregate='1234',
host=hostname host=hostname
@ -109,7 +105,7 @@ class TestAggregate(base.TestCase):
mock_nova.aggregates.list.return_value = [ mock_nova.aggregates.list.return_value = [
fakes.FakeAggregate('1234', 'name', hosts=[hostname]) 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( mock_nova.aggregates.remove_host.assert_called_once_with(
aggregate='1234', aggregate='1234',
host=hostname 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 from mock import patch, Mock
import mock import mock
import os_client_config
from shade import _utils from shade import _utils
from shade import meta from shade import meta
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout) 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): 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): def test_create_server_with_create_exception(self):
""" """
Test that an exception in the novaclient create raises an exception in 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) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.create_server, OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id') 'server-name', 'image-id', 'flavor-id')
def test_create_server_with_get_exception(self): def test_create_server_with_get_exception(self):
@ -64,7 +57,7 @@ class TestCreateServer(base.TestCase):
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.create_server, OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id') 'server-name', 'image-id', 'flavor-id')
def test_create_server_with_server_error(self): def test_create_server_with_server_error(self):
@ -81,7 +74,7 @@ class TestCreateServer(base.TestCase):
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.create_server, OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id') 'server-name', 'image-id', 'flavor-id')
def test_create_server_wait_server_error(self): def test_create_server_wait_server_error(self):
@ -105,7 +98,7 @@ class TestCreateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, OpenStackCloudException,
self.client.create_server, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id', wait=True) 'server-name', 'image-id', 'flavor-id', wait=True)
def test_create_server_with_timeout(self): def test_create_server_with_timeout(self):
@ -123,8 +116,9 @@ class TestCreateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudTimeout, OpenStackCloudTimeout,
self.client.create_server, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id', wait=True, timeout=1) 'server-name', 'image-id', 'flavor-id',
wait=True, timeout=0.01)
def test_create_server_no_wait(self): def test_create_server_no_wait(self):
""" """
@ -145,9 +139,9 @@ class TestCreateServer(base.TestCase):
self.assertEqual( self.assertEqual(
_utils.normalize_server( _utils.normalize_server(
meta.obj_to_dict(fake_server), meta.obj_to_dict(fake_server),
cloud_name=self.client.name, cloud_name=self.cloud.name,
region_name=self.client.region_name), region_name=self.cloud.region_name),
self.client.create_server( self.cloud.create_server(
name='server-name', image='image=id', name='server-name', image='image=id',
flavor='flavor-id')) flavor='flavor-id'))
@ -171,9 +165,9 @@ class TestCreateServer(base.TestCase):
self.assertEqual( self.assertEqual(
_utils.normalize_server( _utils.normalize_server(
meta.obj_to_dict(fake_create_server), meta.obj_to_dict(fake_create_server),
cloud_name=self.client.name, cloud_name=self.cloud.name,
region_name=self.client.region_name), region_name=self.cloud.region_name),
self.client.create_server( self.cloud.create_server(
name='server-name', image='image=id', name='server-name', image='image=id',
flavor='flavor-id', admin_pass='ooBootheiX0edoh')) flavor='flavor-id', admin_pass='ooBootheiX0edoh'))
@ -193,7 +187,7 @@ class TestCreateServer(base.TestCase):
mock_wait.return_value = _utils.normalize_server( mock_wait.return_value = _utils.normalize_server(
meta.obj_to_dict(fake_server), None, None) meta.obj_to_dict(fake_server), None, None)
server = self.client.create_server( server = self.cloud.create_server(
name='server-name', image='image-id', name='server-name', image='image-id',
flavor='flavor-id', admin_pass='ooBootheiX0edoh', wait=True) flavor='flavor-id', admin_pass='ooBootheiX0edoh', wait=True)
@ -221,7 +215,7 @@ class TestCreateServer(base.TestCase):
mock_get_active_server.side_effect = iter([ mock_get_active_server.side_effect = iter([
building_server, active_server]) 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) self.assertEqual(2, mock_get_server.call_count)
mock_get_server.assert_has_calls([ mock_get_server.assert_has_calls([
@ -250,7 +244,7 @@ class TestCreateServer(base.TestCase):
fake_server = {'id': 'fake_server_id', 'status': 'BUILDING'} fake_server = {'id': 'fake_server_id', 'status': 'BUILDING'}
mock_nova.servers.create.return_value = fake_server mock_nova.servers.create.return_value = fake_server
self.client.create_server( self.cloud.create_server(
'server-name', 'image-id', 'flavor-id', wait=True), 'server-name', 'image-id', 'flavor-id', wait=True),
mock_wait.assert_called_once_with( mock_wait.assert_called_once_with(
@ -280,11 +274,11 @@ class TestCreateServer(base.TestCase):
"floating_ips.list.return_value": [fake_floating_ip] "floating_ips.list.return_value": [fake_floating_ip]
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.client._SERVER_AGE = 0 self.cloud._SERVER_AGE = 0
with patch.object(OpenStackCloud, "add_ips_to_server", with patch.object(OpenStackCloud, "add_ips_to_server",
return_value=fake_server): return_value=fake_server):
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.create_server, OpenStackCloudException, self.cloud.create_server,
'server-name', 'image-id', 'flavor-id', 'server-name', 'image-id', 'flavor-id',
wait=True) wait=True)
@ -296,8 +290,8 @@ class TestCreateServer(base.TestCase):
Verify that if 'network' is supplied, and 'nics' is not, that we Verify that if 'network' is supplied, and 'nics' is not, that we
attempt to get the network for the server. attempt to get the network for the server.
""" """
self.client.create_server('server-name', 'image-id', 'flavor-id', self.cloud.create_server(
network='network-name') 'server-name', 'image-id', 'flavor-id', network='network-name')
mock_get_network.assert_called_once_with(name_or_id='network-name') mock_get_network.assert_called_once_with(name_or_id='network-name')
@patch('shade.OpenStackCloud.nova_client') @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, Verify that if 'network' is supplied, along with an empty 'nics' list,
it's treated the same as if 'nics' were not included. it's treated the same as if 'nics' were not included.
""" """
self.client.create_server('server-name', 'image-id', 'flavor-id', self.cloud.create_server(
network='network-name', nics=[]) 'server-name', 'image-id', 'flavor-id',
network='network-name', nics=[])
mock_get_network.assert_called_once_with(name_or_id='network-name') 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 from mock import patch
import os_client_config
from shade import _utils from shade import _utils
from shade import meta from shade import meta
from shade import OpenStackCloud 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) from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
class TestCreateVolumeSnapshot(base.TestCase): 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') @patch.object(OpenStackCloud, 'cinder_client')
def test_create_volume_snapshot_wait(self, mock_cinder): def test_create_volume_snapshot_wait(self, mock_cinder):
""" """
@ -55,8 +49,7 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertEqual( self.assertEqual(
_utils.normalize_volumes( _utils.normalize_volumes(
[meta.obj_to_dict(fake_snapshot)])[0], [meta.obj_to_dict(fake_snapshot)])[0],
self.client.create_volume_snapshot(volume_id='1234', self.cloud.create_volume_snapshot(volume_id='1234', wait=True)
wait=True)
) )
mock_cinder.volume_snapshots.create.assert_called_with( mock_cinder.volume_snapshots.create.assert_called_with(
@ -81,8 +74,8 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertRaises( self.assertRaises(
OpenStackCloudTimeout, OpenStackCloudTimeout,
self.client.create_volume_snapshot, volume_id='1234', self.cloud.create_volume_snapshot, volume_id='1234',
wait=True, timeout=1) wait=True, timeout=0.01)
mock_cinder.volume_snapshots.create.assert_called_with( mock_cinder.volume_snapshots.create.assert_called_with(
force=False, volume_id='1234' force=False, volume_id='1234'
@ -108,7 +101,7 @@ class TestCreateVolumeSnapshot(base.TestCase):
self.assertRaises( self.assertRaises(
OpenStackCloudException, OpenStackCloudException,
self.client.create_volume_snapshot, volume_id='1234', self.cloud.create_volume_snapshot, volume_id='1234',
wait=True, timeout=5) wait=True, timeout=5)
mock_cinder.volume_snapshots.create.assert_called_with( 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 import mock
from novaclient import exceptions as nova_exc from novaclient import exceptions as nova_exc
import os_client_config
from shade import OpenStackCloud
from shade import exc as shade_exc from shade import exc as shade_exc
from shade.tests import fakes from shade.tests import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -39,12 +37,6 @@ class TestDeleteServer(base.TestCase):
nova_exc.RateLimit, nova_exc.RateLimit,
nova_exc.HTTPNotImplemented) 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') @mock.patch('shade.OpenStackCloud.nova_client')
def test_delete_server(self, nova_mock): 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 from mock import patch
import os_client_config
from shade import OpenStackCloud 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) from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout)
class TestDeleteVolumeSnapshot(base.TestCase): 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') @patch.object(OpenStackCloud, 'cinder_client')
def test_delete_volume_snapshot(self, mock_cinder): def test_delete_volume_snapshot(self, mock_cinder):
""" """
@ -47,7 +41,7 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertEqual( self.assertEqual(
True, 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, mock_cinder.volume_snapshots.list.assert_called_with(detailed=True,
@ -68,8 +62,7 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertRaises( self.assertRaises(
OpenStackCloudException, OpenStackCloudException,
self.client.delete_volume_snapshot, name_or_id='1234', self.cloud.delete_volume_snapshot, name_or_id='1234')
wait=True, timeout=1)
mock_cinder.volume_snapshots.delete.assert_called_with( mock_cinder.volume_snapshots.delete.assert_called_with(
snapshot='1234') snapshot='1234')
@ -87,8 +80,8 @@ class TestDeleteVolumeSnapshot(base.TestCase):
self.assertRaises( self.assertRaises(
OpenStackCloudTimeout, OpenStackCloudTimeout,
self.client.delete_volume_snapshot, name_or_id='1234', self.cloud.delete_volume_snapshot, name_or_id='1234',
wait=True, timeout=1) wait=True, timeout=0.01)
mock_cinder.volume_snapshots.list.assert_called_with(detailed=True, mock_cinder.volume_snapshots.list.assert_called_with(detailed=True,
search_opts=None) search_opts=None)

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

@ -32,19 +32,15 @@ domain_obj = fakes.FakeDomain(
class TestDomains(base.TestCase): 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') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_domains(self, mock_keystone): def test_list_domains(self, mock_keystone):
self.cloud.list_domains() self.op_cloud.list_domains()
self.assertTrue(mock_keystone.domains.list.called) self.assertTrue(mock_keystone.domains.list.called)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_domain(self, mock_keystone): def test_get_domain(self, mock_keystone):
mock_keystone.domains.get.return_value = domain_obj 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.assertFalse(mock_keystone.domains.list.called)
self.assertTrue(mock_keystone.domains.get.called) self.assertTrue(mock_keystone.domains.get.called)
self.assertEqual(domain['name'], 'a-domain') 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._utils, '_get_entity')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_domain_with_name_or_id(self, mock_keystone, mock_get): 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, mock_get.assert_called_once_with(mock.ANY,
None, '1234') None, '1234')
@ -60,8 +56,8 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_domain(self, mock_keystone, mock_normalize): def test_create_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.create.return_value = domain_obj mock_keystone.domains.create.return_value = domain_obj
self.cloud.create_domain(domain_obj.name, self.op_cloud.create_domain(
domain_obj.description) domain_obj.name, domain_obj.description)
mock_keystone.domains.create.assert_called_once_with( mock_keystone.domains.create.assert_called_once_with(
name=domain_obj.name, description=domain_obj.description, name=domain_obj.name, description=domain_obj.description,
enabled=True) enabled=True)
@ -74,13 +70,13 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Failed to create domain domain_name" "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.OperatorCloud, 'update_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_domain(self, mock_keystone, mock_update): def test_delete_domain(self, mock_keystone, mock_update):
mock_update.return_value = dict(id='update_domain_id') 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_update.assert_called_once_with('domain_id', enabled=False)
mock_keystone.domains.delete.assert_called_once_with( mock_keystone.domains.delete.assert_called_once_with(
domain='update_domain_id') domain='update_domain_id')
@ -88,10 +84,11 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OperatorCloud, 'get_domain') @mock.patch.object(shade.OperatorCloud, 'get_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_domain_name_or_id(self, mock_keystone, mock_get): def test_delete_domain_name_or_id(self, mock_keystone, mock_get):
self.cloud.update_domain(name_or_id='a-domain', self.op_cloud.update_domain(
name='new name', name_or_id='a-domain',
description='new description', name='new name',
enabled=False) description='new description',
enabled=False)
mock_get.assert_called_once_with(None, 'a-domain') mock_get.assert_called_once_with(None, 'a-domain')
@mock.patch.object(shade.OperatorCloud, 'update_domain') @mock.patch.object(shade.OperatorCloud, 'update_domain')
@ -102,16 +99,17 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Failed to delete domain domain_id" "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._utils, 'normalize_domains')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_domain(self, mock_keystone, mock_normalize): def test_update_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.update.return_value = domain_obj mock_keystone.domains.update.return_value = domain_obj
self.cloud.update_domain('domain_id', self.op_cloud.update_domain(
name='new name', 'domain_id',
description='new description', name='new name',
enabled=False) description='new description',
enabled=False)
mock_keystone.domains.update.assert_called_once_with( mock_keystone.domains.update.assert_called_once_with(
domain='domain_id', name='new name', domain='domain_id', name='new name',
description='new description', enabled=False) description='new description', enabled=False)
@ -121,10 +119,11 @@ class TestDomains(base.TestCase):
@mock.patch.object(shade.OperatorCloud, 'get_domain') @mock.patch.object(shade.OperatorCloud, 'get_domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_domain_name_or_id(self, mock_keystone, mock_get): def test_update_domain_name_or_id(self, mock_keystone, mock_get):
self.cloud.update_domain(name_or_id='a-domain', self.op_cloud.update_domain(
name='new name', name_or_id='a-domain',
description='new description', name='new name',
enabled=False) description='new description',
enabled=False)
mock_get.assert_called_once_with(None, 'a-domain') mock_get.assert_called_once_with(None, 'a-domain')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -134,4 +133,4 @@ class TestDomains(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Error in updating domain domain_id" "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): def setUp(self):
super(TestCloudEndpoints, self).setUp() super(TestCloudEndpoints, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OperatorCloud(cloud_config=config.get_one_cloud(
validate=False))
self.mock_ks_endpoints = \ self.mock_ks_endpoints = \
[FakeEndpoint(**kwa) for kwa in self.mock_endpoints] [FakeEndpoint(**kwa) for kwa in self.mock_endpoints]
self.mock_ks_endpoints_v3 = \ self.mock_ks_endpoints_v3 = \
@ -74,7 +71,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.return_value = \ mock_keystone_client.endpoints.create.return_value = \
self.mock_ks_endpoints[2] self.mock_ks_endpoints[2]
endpoints = self.client.create_endpoint( endpoints = self.op_cloud.create_endpoint(
service_name_or_id='service1', service_name_or_id='service1',
region='mock_region', region='mock_region',
public_url='mock_public_url', public_url='mock_public_url',
@ -99,12 +96,12 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints[0] self.mock_ks_endpoints[0]
self.assertRaises(OpenStackCloudException, self.assertRaises(OpenStackCloudException,
self.client.create_endpoint, self.op_cloud.create_endpoint,
service_name_or_id='service1', service_name_or_id='service1',
interface='mock_admin_url', interface='mock_admin_url',
url='admin') url='admin')
endpoints_3on2 = self.client.create_endpoint( endpoints_3on2 = self.op_cloud.create_endpoint(
service_name_or_id='service1', service_name_or_id='service1',
region='mock_region', region='mock_region',
interface='public', interface='public',
@ -132,7 +129,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.return_value = \ mock_keystone_client.endpoints.create.return_value = \
self.mock_ks_endpoints_v3[0] self.mock_ks_endpoints_v3[0]
endpoints = self.client.create_endpoint( endpoints = self.op_cloud.create_endpoint(
service_name_or_id='service1', service_name_or_id='service1',
region='mock_region', region='mock_region',
url='mock_url', url='mock_url',
@ -155,7 +152,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.create.side_effect = \ mock_keystone_client.endpoints.create.side_effect = \
self.mock_ks_endpoints_v3 self.mock_ks_endpoints_v3
endpoints_2on3 = self.client.create_endpoint( endpoints_2on3 = self.op_cloud.create_endpoint(
service_name_or_id='service1', service_name_or_id='service1',
region='mock_region', region='mock_region',
public_url='mock_public_url', public_url='mock_public_url',
@ -176,7 +173,7 @@ class TestCloudEndpoints(base.TestCase):
mock_api_version.return_value = '2.0' mock_api_version.return_value = '2.0'
# NOTE(SamYaple): Update endpoint only works with v3 api # NOTE(SamYaple): Update endpoint only works with v3 api
self.assertRaises(OpenStackCloudUnavailableFeature, self.assertRaises(OpenStackCloudUnavailableFeature,
self.client.update_endpoint, 'endpoint_id') self.op_cloud.update_endpoint, 'endpoint_id')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@patch.object(os_client_config.cloud_config.CloudConfig, 'get_api_version') @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 = \ mock_keystone_client.endpoints.update.return_value = \
self.mock_ks_endpoints_v3[0] self.mock_ks_endpoints_v3[0]
endpoint = self.client.update_endpoint( endpoint = self.op_cloud.update_endpoint(
'id1', 'id1',
service_name_or_id='service_id1', service_name_or_id='service_id1',
region='mock_region', region='mock_region',
@ -211,7 +208,7 @@ class TestCloudEndpoints(base.TestCase):
mock_keystone_client.endpoints.list.return_value = \ mock_keystone_client.endpoints.list.return_value = \
self.mock_ks_endpoints self.mock_ks_endpoints
endpoints = self.client.list_endpoints() endpoints = self.op_cloud.list_endpoints()
mock_keystone_client.endpoints.list.assert_called_with() mock_keystone_client.endpoints.list.assert_called_with()
# test we are getting exactly len(self.mock_endpoints) elements # test we are getting exactly len(self.mock_endpoints) elements
@ -236,18 +233,18 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints self.mock_ks_endpoints
# Search by id # 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 # # test we are getting exactly 1 element
self.assertEqual(1, len(endpoints)) self.assertEqual(1, len(endpoints))
for k, v in self.mock_endpoints[2].items(): for k, v in self.mock_endpoints[2].items():
self.assertEquals(v, endpoints[0].get(k)) self.assertEquals(v, endpoints[0].get(k))
# Not found # Not found
endpoints = self.client.search_endpoints(id='blah!') endpoints = self.op_cloud.search_endpoints(id='blah!')
self.assertEqual(0, len(endpoints)) self.assertEqual(0, len(endpoints))
# Multiple matches # Multiple matches
endpoints = self.client.search_endpoints( endpoints = self.op_cloud.search_endpoints(
filters={'region': 'region1'}) filters={'region': 'region1'})
# # test we are getting exactly 2 elements # # test we are getting exactly 2 elements
self.assertEqual(2, len(endpoints)) self.assertEqual(2, len(endpoints))
@ -258,5 +255,5 @@ class TestCloudEndpoints(base.TestCase):
self.mock_ks_endpoints self.mock_ks_endpoints
# Delete by id # 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') 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): class TestFlavors(base.TestCase):
def setUp(self):
super(TestFlavors, self).setUp()
def test_create_flavor(self): def test_create_flavor(self):
self.useFixture(keystoneauth_betamax.BetamaxFixture( self.useFixture(keystoneauth_betamax.BetamaxFixture(
cassette_name='test_create_flavor', cassette_name='test_create_flavor',
@ -34,13 +31,13 @@ class TestFlavors(base.TestCase):
record=self.record_fixtures, record=self.record_fixtures,
serializer=serializer.YamlJsonSerializer)) serializer=serializer.YamlJsonSerializer))
old_flavors = self.op_cloud.list_flavors() old_flavors = self.full_op_cloud.list_flavors()
self.op_cloud.create_flavor( self.full_op_cloud.create_flavor(
'vanilla', 12345, 4, 100 'vanilla', 12345, 4, 100
) )
# test that we have a new flavor added # 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) self.assertEquals(len(new_flavors) - len(old_flavors), 1)
# test that new flavor is created correctly # test that new flavor is created correctly
@ -56,7 +53,7 @@ class TestFlavors(base.TestCase):
self.assertTrue(needed_keys.issubset(flavor.keys())) self.assertTrue(needed_keys.issubset(flavor.keys()))
# delete created flavor # 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, '_compute_client')
@mock.patch.object(shade.OpenStackCloud, 'nova_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 from mock import patch
import os_client_config
from shade import meta from shade import meta
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.tests.fakes import FakeServer from shade.tests.fakes import FakeServer
@ -28,11 +27,6 @@ from shade.tests.unit import base
class TestFloatingIP(base.TestCase): 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, 'get_floating_ip')
@patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, '_attach_ip_to_server')
@ -56,7 +50,7 @@ class TestFloatingIP(base.TestCase):
mock_available_floating_ip.return_value = floating_ip_dict 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( mock_attach_ip_to_server.assert_called_with(
timeout=60, wait=False, server=server_dict, timeout=60, wait=False, server=server_dict,
@ -74,7 +68,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.servers.get.return_value = server 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( mock_add_ip_from_pool.assert_called_with(
server_dict, pool, reuse=True, wait=False, timeout=60, server_dict, pool, reuse=True, wait=False, timeout=60,
@ -109,7 +103,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server)) 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_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called() mock_add_auto_ip.assert_not_called()
self.assertEqual( self.assertEqual(
@ -150,7 +144,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server)) 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_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called() mock_add_auto_ip.assert_not_called()
self.assertEqual( self.assertEqual(
@ -187,7 +181,7 @@ class TestFloatingIP(base.TestCase):
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(
self.cloud, meta.obj_to_dict(server)) 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_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called() mock_add_auto_ip.assert_not_called()
self.assertEqual(new_server['interface_ip'], '104.130.246.91') 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'] ips = ['203.0.113.29', '172.24.4.229']
mock_nova_client.servers.get.return_value = server 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( mock_add_ip_list.assert_called_with(
server_dict, ips, wait=False, timeout=60, fixed_address=None) 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 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( mock_add_auto_ip.assert_called_with(
server_dict, wait=False, timeout=60, reuse=True) 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 import mock
from mock import patch from mock import patch
import os_client_config
from neutronclient.common import exceptions as n_exc from neutronclient.common import exceptions as n_exc
@ -138,10 +137,6 @@ class TestFloatingIP(base.TestCase):
def setUp(self): def setUp(self):
super(TestFloatingIP, self).setUp() 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( self.fake_server = meta.obj_to_dict(
fakes.FakeServer( fakes.FakeServer(
@ -162,7 +157,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \ mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep 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() mock_neutron_client.list_floatingips.assert_called_with()
self.assertIsInstance(floating_ips, list) self.assertIsInstance(floating_ips, list)
@ -176,7 +171,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \ mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep self.mock_floating_ip_list_rep
floating_ips = self.client.search_floating_ips( floating_ips = self.cloud.search_floating_ips(
filters={'attached': False}) filters={'attached': False})
mock_neutron_client.list_floatingips.assert_called_with() mock_neutron_client.list_floatingips.assert_called_with()
@ -191,7 +186,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \ mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep 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') id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')
mock_neutron_client.list_floatingips.assert_called_with() mock_neutron_client.list_floatingips.assert_called_with()
@ -206,7 +201,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \ mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep 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) self.assertIsNone(floating_ip)
@ -220,7 +215,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.create_floatingip.return_value = \ mock_neutron_client.create_floatingip.return_value = \
self.mock_floating_ip_new_rep 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( mock_neutron_client.create_floatingip.assert_called_with(
body={'floatingip': {'floating_network_id': 'my-network-id'}} body={'floatingip': {'floating_network_id': 'my-network-id'}}
@ -241,7 +236,7 @@ class TestFloatingIP(base.TestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.client.create_floating_ip, self.cloud.create_floating_ip,
network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ab') network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ab')
@patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'neutron_client')
@ -254,7 +249,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.create_floatingip.return_value = \ mock_neutron_client.create_floatingip.return_value = \
self.mock_floating_ip_port_rep 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') network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ab')
mock_neutron_client.create_floatingip.assert_called_with( mock_neutron_client.create_floatingip.assert_called_with(
@ -283,7 +278,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.return_value = True mock_has_service.return_value = True
mock__neutron_call.return_value = [] 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_has_service.assert_called_once_with('network')
mock__neutron_call.assert_called_once_with(network='netname', mock__neutron_call.assert_called_once_with(network='netname',
@ -311,7 +306,7 @@ class TestFloatingIP(base.TestCase):
mock__filter_list.return_value = [] mock__filter_list.return_value = []
# Test if first network is selected if no network is given # 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_keystone_session.get_project_id.assert_called_once_with()
mock_get_ext_nets.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__neutron_list_fips.return_value = []
mock__filter_list.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'] 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_keystone_session.get_project_id.return_value = 'proj-id'
mock_get_ext_nets.return_value = [] mock_get_ext_nets.return_value = []
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.client._neutron_available_floating_ips, self.cloud._neutron_available_floating_ips,
network='INVALID') network='INVALID')
@patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'nova_client')
@ -399,7 +394,7 @@ class TestFloatingIP(base.TestCase):
'4969c491a3c74ee4af974e6d800c62df' '4969c491a3c74ee4af974e6d800c62df'
fake_server = meta.obj_to_dict(fakes.FakeServer('1234', '', 'ACTIVE')) 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) fake_server, ip_pool='my-network', reuse=False)
mock__neutron_create_floating_ip.assert_called_once_with( 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 = \ mock_keystone_session.get_project_id.return_value = \
'4969c491a3c74ee4af974e6d800c62df' '4969c491a3c74ee4af974e6d800c62df'
ip = self.client.available_floating_ip(network='my-network') ip = self.cloud.available_floating_ip(network='my-network')
self.assertEqual( self.assertEqual(
self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], 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_get_floating_ip.side_effect = [fake_fip, fake_fip, None]
mock_neutron_client.delete_floatingip.return_value = 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', floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
retry=2) retry=2)
@ -472,7 +467,7 @@ class TestFloatingIP(base.TestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.client.delete_floating_ip, self.cloud.delete_floating_ip,
floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7', floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
retry=2) retry=2)
@ -489,7 +484,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.delete_floatingip.side_effect = \ mock_neutron_client.delete_floatingip.side_effect = \
n_exc.NotFound() n_exc.NotFound()
ret = self.client.delete_floating_ip( ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears') floating_ip_id='a-wild-id-appears')
self.assertFalse(ret) self.assertFalse(ret)
@ -506,7 +501,7 @@ class TestFloatingIP(base.TestCase):
mock_neutron_client.list_floatingips.return_value = \ mock_neutron_client.list_floatingips.return_value = \
self.mock_floating_ip_list_rep self.mock_floating_ip_list_rep
self.client._attach_ip_to_server( self.cloud._attach_ip_to_server(
server=self.fake_server, server=self.fake_server,
floating_ip=self.floating_ip) floating_ip=self.floating_ip)
@ -535,9 +530,9 @@ class TestFloatingIP(base.TestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudTimeout, exc.OpenStackCloudTimeout,
self.client._add_auto_ip, self.cloud._add_auto_ip,
server=self.fake_server, server=self.fake_server,
wait=True, timeout=2, wait=True, timeout=0.01,
reuse=False) reuse=False)
mock_delete_floating_ip.assert_called_once_with( mock_delete_floating_ip.assert_called_once_with(
@ -554,7 +549,7 @@ class TestFloatingIP(base.TestCase):
_utils.normalize_neutron_floating_ips( _utils.normalize_neutron_floating_ips(
self.mock_floating_ip_list_rep['floatingips'])[0] self.mock_floating_ip_list_rep['floatingips'])[0]
self.client.detach_ip_from_server( self.cloud.detach_ip_from_server(
server_id='server-id', server_id='server-id',
floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')
@ -579,7 +574,7 @@ class TestFloatingIP(base.TestCase):
self.mock_floating_ip_new_rep['floatingip']])[0] self.mock_floating_ip_new_rep['floatingip']])[0]
mock_attach_ip_to_server.return_value = self.fake_server 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, server=self.fake_server,
network='network-name', network='network-name',
fixed_address='192.0.2.129') fixed_address='192.0.2.129')
@ -613,7 +608,7 @@ class TestFloatingIP(base.TestCase):
mock_list_floating_ips.return_value = floating_ips 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( mock_delete_floating_ip.assert_called_once_with(
floating_ip_id='this-is-a-floating-ip-id', retry=1) floating_ip_id='this-is-a-floating-ip-id', retry=1)
@ -631,5 +626,5 @@ class TestFloatingIP(base.TestCase):
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.client._neutron_create_floating_ip, self.cloud._neutron_create_floating_ip,
server=dict(id='some-server')) 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 mock import patch
from novaclient import exceptions as n_exc from novaclient import exceptions as n_exc
import os_client_config
from shade import _utils from shade import _utils
from shade import meta from shade import meta
@ -71,9 +70,6 @@ class TestFloatingIP(base.TestCase):
def setUp(self): def setUp(self):
super(TestFloatingIP, self).setUp() super(TestFloatingIP, self).setUp()
config = os_client_config.OpenStackConfig()
self.client = OpenStackCloud(
cloud_config=config.get_one_cloud(validate=False))
self.floating_ips = [ self.floating_ips = [
fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep 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_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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() mock_nova_client.floating_ips.list.assert_called_with()
self.assertIsInstance(floating_ips, list) self.assertIsInstance(floating_ips, list)
@ -110,7 +106,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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}) filters={'attached': False})
mock_nova_client.floating_ips.list.assert_called_with() 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_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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() mock_nova_client.floating_ips.list.assert_called_with()
self.assertIsInstance(floating_ip, dict) self.assertIsInstance(floating_ip, dict)
@ -137,7 +133,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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) self.assertIsNone(floating_ip)
@ -148,7 +144,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.floating_ips.create.return_value =\ mock_nova_client.floating_ips.create.return_value =\
fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[1]) 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') 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 = \ mock__nova_list_floating_ips.return_value = \
self.mock_floating_ip_list_rep[:1] 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'], self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'],
ip['floating_ip_address']) ip['floating_ip_address'])
@ -176,7 +172,7 @@ class TestFloatingIP(base.TestCase):
mock_nova_client.floating_ips.create.return_value = \ mock_nova_client.floating_ips.create.return_value = \
fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[0]) 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'], self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'],
ip['floating_ip_address']) ip['floating_ip_address'])
@ -188,7 +184,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.delete.return_value = None 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') floating_ip_id='a-wild-id-appears')
mock_nova_client.floating_ips.delete.assert_called_with( 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( mock_nova_client.floating_ips.delete.side_effect = n_exc.NotFound(
code=404) code=404)
ret = self.client.delete_floating_ip( ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears') floating_ip_id='a-wild-id-appears')
self.assertFalse(ret) self.assertFalse(ret)
@ -214,7 +210,7 @@ class TestFloatingIP(base.TestCase):
mock_has_service.side_effect = has_service_side_effect mock_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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, server=self.fake_server, floating_ip=self.floating_ip,
fixed_address='192.0.2.129') 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 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) server_id='server-id', floating_ip_id=1)
mock_nova_client.servers.remove_floating_ip.assert_called_with( 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_has_service.side_effect = has_service_side_effect
mock_nova_client.floating_ips.list.return_value = self.floating_ips 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, server=self.fake_server,
network='nova', network='nova',
fixed_address='192.0.2.129') fixed_address='192.0.2.129')
@ -257,7 +253,7 @@ class TestFloatingIP(base.TestCase):
mock_delete_floating_ip): mock_delete_floating_ip):
mock_use_neutron_floating.return_value = False 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_delete_floating_ip.assert_not_called()
mock_list_floating_ips.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 from mock import patch
import os_client_config
from shade import OpenStackCloud from shade import OpenStackCloud
from shade import OpenStackCloudException from shade import OpenStackCloudException
from shade.tests.unit import base from shade.tests.unit import base
@ -32,12 +31,6 @@ class TestFloatingIPPool(base.TestCase):
{'id': 'pool1_id', 'name': 'pool1'}, {'id': 'pool1_id', 'name': 'pool1'},
{'id': 'pool2_id', 'name': 'pool2'}] {'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, '_has_nova_extension')
@patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'nova_client')
def test_list_floating_ip_pools( def test_list_floating_ip_pools(
@ -47,7 +40,7 @@ class TestFloatingIPPool(base.TestCase):
] ]
mock__has_nova_extension.return_value = True 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) self.assertItemsEqual(floating_ip_pools, self.mock_pools)
@ -60,4 +53,4 @@ class TestFloatingIPPool(base.TestCase):
mock__has_nova_extension.return_value = True mock__has_nova_extension.return_value = True
self.assertRaises( 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): 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') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_groups(self, mock_keystone): 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_keystone.groups.list.assert_called_once_with()
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_get_group(self, mock_keystone): 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_keystone.groups.list.assert_called_once_with()
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -39,7 +35,7 @@ class TestGroups(base.TestCase):
mock_keystone.groups.list.return_value = [ mock_keystone.groups.list.return_value = [
fakes.FakeGroup('1234', 'name', 'desc') 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.list.assert_called_once_with()
mock_keystone.groups.delete.assert_called_once_with( mock_keystone.groups.delete.assert_called_once_with(
group='1234' group='1234'
@ -47,7 +43,7 @@ class TestGroups(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_group(self, mock_keystone): 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( mock_keystone.groups.create.assert_called_once_with(
name='test-group', description='test desc', domain=None name='test-group', description='test desc', domain=None
) )
@ -57,7 +53,7 @@ class TestGroups(base.TestCase):
mock_keystone.groups.list.return_value = [ mock_keystone.groups.list.return_value = [
fakes.FakeGroup('1234', 'name', 'desc') 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.list.assert_called_once_with()
mock_keystone.groups.update.assert_called_once_with( mock_keystone.groups.update.assert_called_once_with(
group='1234', name='test-group', description='test desc' 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): 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') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_roles(self, mock_keystone): def test_list_roles(self, mock_keystone):
self.cloud.list_roles() self.op_cloud.list_roles()
self.assertTrue(mock_keystone.roles.list.called) self.assertTrue(mock_keystone.roles.list.called)
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -54,7 +50,7 @@ class TestIdentityRoles(base.TestCase):
role_obj = fakes.FakeRole(id='1234', name='fake_role') role_obj = fakes.FakeRole(id='1234', name='fake_role')
mock_keystone.roles.list.return_value = [role_obj] 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.assertTrue(mock_keystone.roles.list.called)
self.assertIsNotNone(role) self.assertIsNotNone(role)
@ -67,7 +63,7 @@ class TestIdentityRoles(base.TestCase):
role_obj = fakes.FakeRole(id='1234', name=role_name) role_obj = fakes.FakeRole(id='1234', name=role_name)
mock_keystone.roles.create.return_value = role_obj 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( mock_keystone.roles.create.assert_called_once_with(
name=role_name name=role_name
@ -80,7 +76,7 @@ class TestIdentityRoles(base.TestCase):
def test_delete_role(self, mock_keystone, mock_get): def test_delete_role(self, mock_keystone, mock_get):
role_obj = fakes.FakeRole(id='1234', name='aaa') role_obj = fakes.FakeRole(id='1234', name='aaa')
mock_get.return_value = meta.obj_to_dict(role_obj) 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) self.assertTrue(mock_keystone.roles.delete.called)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @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): def test_list_role_assignments(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '3' mock_api_version.return_value = '3'
mock_keystone.role_assignments.list.return_value = RAW_ROLE_ASSIGNMENTS 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() mock_keystone.role_assignments.list.assert_called_once_with()
normalized_assignments = _utils.normalize_role_assignments( normalized_assignments = _utils.normalize_role_assignments(
RAW_ROLE_ASSIGNMENTS RAW_ROLE_ASSIGNMENTS
@ -101,7 +97,7 @@ class TestIdentityRoles(base.TestCase):
mock_api_version): mock_api_version):
mock_api_version.return_value = '3' mock_api_version.return_value = '3'
params = dict(user='123', domain='456', effective=True) 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_keystone.role_assignments.list.assert_called_once_with(**params)
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@ -114,7 +110,7 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Failed to list role assignments" "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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -123,11 +119,15 @@ class TestIdentityRoles(base.TestCase):
fake_role = fakes.FakeRole(id='1234', name='fake_role') fake_role = fakes.FakeRole(id='1234', name='fake_role')
mock_api_version.return_value = '2.0' mock_api_version.return_value = '2.0'
mock_keystone.roles.roles_for_user.return_value = [fake_role] mock_keystone.roles.roles_for_user.return_value = [fake_role]
ret = self.cloud.list_role_assignments(filters={'user': '2222', ret = self.op_cloud.list_role_assignments(
'project': '3333'}) filters={
self.assertEqual(ret, [{'id': fake_role.id, 'user': '2222',
'project': '3333', 'project': '3333'})
'user': '2222'}]) self.assertEqual(
ret, [{
'id': fake_role.id,
'project': '3333',
'user': '2222'}])
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -138,12 +138,16 @@ class TestIdentityRoles(base.TestCase):
mock_api_version.return_value = '2.0' mock_api_version.return_value = '2.0'
mock_keystone.roles.roles_for_user.return_value = [fake_role1, mock_keystone.roles.roles_for_user.return_value = [fake_role1,
fake_role2] fake_role2]
ret = self.cloud.list_role_assignments(filters={'role': fake_role1.id, ret = self.op_cloud.list_role_assignments(
'user': '2222', filters={
'project': '3333'}) 'role': fake_role1.id,
self.assertEqual(ret, [{'id': fake_role1.id, 'user': '2222',
'project': '3333', 'project': '3333'})
'user': '2222'}]) self.assertEqual(
ret, [{
'id': fake_role1.id,
'project': '3333',
'user': '2222'}])
@mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @mock.patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -154,7 +158,7 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Must provide project and user for keystone v2" "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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
@ -165,4 +169,4 @@ class TestIdentityRoles(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Must provide project and user for keystone v2" "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} mock_get.return_value = {'status': 'saving', 'id': self.image_id}
self.assertRaises(exc.OpenStackCloudTimeout, self.assertRaises(exc.OpenStackCloudTimeout,
self.cloud.create_image_snapshot, 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, 'nova_client')
@mock.patch.object(shade.OpenStackCloud, 'get_image') @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): 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') @mock.patch.object(shade.OpenStackCloud, 'magnum_client')
def test_list_magnum_services(self, mock_magnum): def test_list_magnum_services(self, mock_magnum):
mock_magnum.mservices.list.return_value = [magnum_service_obj, ] 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) mock_magnum.mservices.list.assert_called_with(detail=False)
self.assertEqual(mservices_list[0], magnum_service_obj) self.assertEqual(mservices_list[0], magnum_service_obj)

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

@ -14,7 +14,6 @@
# under the License. # under the License.
import mock import mock
import os_client_config
from os_client_config import cloud_config from os_client_config import cloud_config
from swiftclient import service as swift_service from swiftclient import service as swift_service
from swiftclient import exceptions as swift_exc from swiftclient import exceptions as swift_exc
@ -23,18 +22,11 @@ import testtools
import shade import shade
import shade.openstackcloud import shade.openstackcloud
from shade import exc from shade import exc
from shade import OpenStackCloud
from shade.tests.unit import base from shade.tests.unit import base
class TestObject(base.TestCase): 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') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_swift_client_no_endpoint(self, get_session_mock): def test_swift_client_no_endpoint(self, get_session_mock):
session_mock = mock.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 from mock import patch
import os_client_config
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import OpenStackCloudException from shade.exc import OpenStackCloudException
from shade.tests.unit import base 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') @patch.object(OpenStackCloud, 'neutron_client')
def test_create_port(self, mock_neutron_client): def test_create_port(self, mock_neutron_client):
mock_neutron_client.create_port.return_value = \ mock_neutron_client.create_port.return_value = \
self.mock_neutron_port_create_rep 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', network_id='test-net-id', name='test-port-name',
admin_state_up=True) admin_state_up=True)
@ -165,7 +158,7 @@ class TestPort(base.TestCase):
def test_create_port_parameters(self): def test_create_port_parameters(self):
"""Test that we detect invalid arguments passed to create_port""" """Test that we detect invalid arguments passed to create_port"""
self.assertRaises( self.assertRaises(
TypeError, self.client.create_port, TypeError, self.cloud.create_port,
network_id='test-net-id', nome='test-port-name', network_id='test-net-id', nome='test-port-name',
stato_amministrativo_porta=True) stato_amministrativo_porta=True)
@ -174,7 +167,7 @@ class TestPort(base.TestCase):
mock_neutron_client.create_port.side_effect = Exception('blah') mock_neutron_client.create_port.side_effect = Exception('blah')
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.create_port, OpenStackCloudException, self.cloud.create_port,
network_id='test-net-id', name='test-port-name', network_id='test-net-id', name='test-port-name',
admin_state_up=True) admin_state_up=True)
@ -185,7 +178,7 @@ class TestPort(base.TestCase):
mock_neutron_client.update_port.return_value = \ mock_neutron_client.update_port.return_value = \
self.mock_neutron_port_update_rep 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_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b',
name='test-port-name-updated') name='test-port-name-updated')
@ -197,7 +190,7 @@ class TestPort(base.TestCase):
def test_update_port_parameters(self): def test_update_port_parameters(self):
"""Test that we detect invalid arguments passed to update_port""" """Test that we detect invalid arguments passed to update_port"""
self.assertRaises( self.assertRaises(
TypeError, self.client.update_port, TypeError, self.cloud.update_port,
name_or_id='test-port-id', nome='test-port-name-updated') name_or_id='test-port-id', nome='test-port-name-updated')
@patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'neutron_client')
@ -207,7 +200,7 @@ class TestPort(base.TestCase):
mock_neutron_client.update_port.side_effect = Exception('blah') mock_neutron_client.update_port.side_effect = Exception('blah')
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.update_port, OpenStackCloudException, self.cloud.update_port,
name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b',
name='test-port-name-updated') name='test-port-name-updated')
@ -216,7 +209,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \ mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep self.mock_neutron_port_list_rep
ports = self.client.list_ports() ports = self.cloud.list_ports()
mock_neutron_client.list_ports.assert_called_with() mock_neutron_client.list_ports.assert_called_with()
self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports) 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): def test_list_ports_exception(self, mock_neutron_client):
mock_neutron_client.list_ports.side_effect = Exception('blah') 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') @patch.object(OpenStackCloud, 'neutron_client')
def test_search_ports_by_id(self, mock_neutron_client): def test_search_ports_by_id(self, mock_neutron_client):
mock_neutron_client.list_ports.return_value = \ mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep self.mock_neutron_port_list_rep
ports = self.client.search_ports( ports = self.cloud.search_ports(
name_or_id='f71a6703-d6de-4be1-a91a-a570ede1d159') name_or_id='f71a6703-d6de-4be1-a91a-a570ede1d159')
mock_neutron_client.list_ports.assert_called_with() mock_neutron_client.list_ports.assert_called_with()
@ -244,7 +237,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \ mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep 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() mock_neutron_client.list_ports.assert_called_with()
self.assertEquals(1, len(ports)) self.assertEquals(1, len(ports))
@ -255,7 +248,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \ mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep 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() mock_neutron_client.list_ports.assert_called_with()
self.assertEquals(0, len(ports)) self.assertEquals(0, len(ports))
@ -265,7 +258,7 @@ class TestPort(base.TestCase):
mock_neutron_client.list_ports.return_value = \ mock_neutron_client.list_ports.return_value = \
self.mock_neutron_port_list_rep 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( mock_neutron_client.delete_port.assert_called_with(
port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b') 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): 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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_project_v2(self, mock_keystone, mock_api_version): def test_create_project_v2(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '2' mock_api_version.return_value = '2'
name = 'project_name' name = 'project_name'
description = 'Project description' 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( mock_keystone.tenants.create.assert_called_once_with(
project_name=name, description=description, enabled=True, project_name=name, description=description, enabled=True,
tenant_name=name tenant_name=name
@ -48,8 +44,8 @@ class TestProject(base.TestCase):
name = 'project_name' name = 'project_name'
description = 'Project description' description = 'Project description'
domain_id = '123' domain_id = '123'
self.cloud.create_project(name=name, description=description, self.op_cloud.create_project(
domain_id=domain_id) name=name, description=description, domain_id=domain_id)
mock_keystone.projects.create.assert_called_once_with( mock_keystone.projects.create.assert_called_once_with(
project_name=name, description=description, enabled=True, project_name=name, description=description, enabled=True,
name=name, domain=domain_id name=name, domain=domain_id
@ -65,7 +61,7 @@ class TestProject(base.TestCase):
"User or project creation requires an explicit" "User or project creation requires an explicit"
" domain_id argument." " 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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'get_project') @mock.patch.object(shade.OpenStackCloud, 'get_project')
@ -74,7 +70,7 @@ class TestProject(base.TestCase):
mock_api_version): mock_api_version):
mock_api_version.return_value = '2' mock_api_version.return_value = '2'
mock_get.return_value = dict(id='123') 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_get.assert_called_once_with('123', domain_id=None)
mock_keystone.tenants.delete.assert_called_once_with(tenant='123') mock_keystone.tenants.delete.assert_called_once_with(tenant='123')
@ -85,7 +81,7 @@ class TestProject(base.TestCase):
mock_api_version): mock_api_version):
mock_api_version.return_value = '3' mock_api_version.return_value = '3'
mock_get.return_value = dict(id='123') 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_get.assert_called_once_with('123', domain_id=None)
mock_keystone.projects.delete.assert_called_once_with(project='123') mock_keystone.projects.delete.assert_called_once_with(project='123')
@ -96,7 +92,7 @@ class TestProject(base.TestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Project ABC not found." "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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'get_project') @mock.patch.object(shade.OpenStackCloud, 'get_project')
@ -105,7 +101,7 @@ class TestProject(base.TestCase):
mock_api_version): mock_api_version):
mock_api_version.return_value = '2' mock_api_version.return_value = '2'
mock_get_project.return_value = munch.Munch(dict(id='123')) 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( mock_keystone.tenants.update.assert_called_once_with(
description='new', enabled=False, tenant_id='123') description='new', enabled=False, tenant_id='123')
@ -116,7 +112,7 @@ class TestProject(base.TestCase):
mock_api_version): mock_api_version):
mock_api_version.return_value = '3' mock_api_version.return_value = '3'
mock_get_project.return_value = munch.Munch(dict(id='123')) 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( mock_keystone.projects.update.assert_called_once_with(
description='new', enabled=False, project='123') description='new', enabled=False, project='123')
@ -124,6 +120,6 @@ class TestProject(base.TestCase):
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_list_projects_v3(self, mock_keystone, mock_api_version): def test_list_projects_v3(self, mock_keystone, mock_api_version):
mock_api_version.return_value = '3' 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( mock_keystone.projects.list.assert_called_once_with(
domain='123') domain='123')

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

@ -22,16 +22,12 @@ from shade.tests import fakes
class TestQuotas(base.TestCase): 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, 'nova_client')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_update_quotas(self, mock_keystone, mock_nova): def test_update_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_nova.quotas.update.assert_called_once_with(
cores=1, force=True, tenant_id='project_a') 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): def test_get_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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') 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): def test_delete_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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') 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): def test_cinder_update_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_cinder.quotas.update.assert_called_once_with(
volumes=1, tenant_id='project_a') volumes=1, tenant_id='project_a')
@ -69,7 +65,7 @@ class TestQuotas(base.TestCase):
def test_cinder_get_quotas(self, mock_keystone, mock_cinder): def test_cinder_get_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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') 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): def test_cinder_delete_quotas(self, mock_keystone, mock_cinder):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_cinder.quotas.delete.assert_called_once_with(
tenant_id='project_a') tenant_id='project_a')
@ -88,7 +84,7 @@ class TestQuotas(base.TestCase):
def test_neutron_update_quotas(self, mock_keystone, mock_neutron): def test_neutron_update_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_neutron.update_quota.assert_called_once_with(
body={'quota': {'network': 1}}, tenant_id='project_a') 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): def test_neutron_get_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_neutron.show_quota.assert_called_once_with(
tenant_id='project_a') tenant_id='project_a')
@ -108,7 +104,7 @@ class TestQuotas(base.TestCase):
def test_neutron_delete_quotas(self, mock_keystone, mock_neutron): def test_neutron_delete_quotas(self, mock_keystone, mock_neutron):
project = fakes.FakeProject('project_a') project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project] 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( mock_neutron.delete_quota.assert_called_once_with(
tenant_id='project_a') 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 from mock import patch, Mock
import os_client_config
from shade import _utils from shade import _utils
from shade import meta from shade import meta
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import (OpenStackCloudException, OpenStackCloudTimeout) 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): 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): def test_rebuild_server_rebuild_exception(self):
""" """
Test that an exception in the novaclient rebuild raises an exception in 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) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.rebuild_server, "a", "b") OpenStackCloudException, self.cloud.rebuild_server, "a", "b")
def test_rebuild_server_server_error(self): def test_rebuild_server_server_error(self):
""" """
@ -68,7 +62,7 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, OpenStackCloudException,
self.client.rebuild_server, "a", "b", wait=True) self.cloud.rebuild_server, "a", "b", wait=True)
def test_rebuild_server_timeout(self): def test_rebuild_server_timeout(self):
""" """
@ -84,7 +78,7 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudTimeout, 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): def test_rebuild_server_no_wait(self):
""" """
@ -98,7 +92,7 @@ class TestRebuildServer(base.TestCase):
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(meta.obj_to_dict(rebuild_server), 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): def test_rebuild_server_with_admin_pass_no_wait(self):
""" """
@ -113,8 +107,8 @@ class TestRebuildServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertEqual( self.assertEqual(
meta.obj_to_dict(rebuild_server), meta.obj_to_dict(rebuild_server),
self.client.rebuild_server('a', 'b', self.cloud.rebuild_server(
admin_pass='ooBootheiX0edoh')) 'a', 'b', admin_pass='ooBootheiX0edoh'))
def test_rebuild_server_with_admin_pass_wait(self): 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] "floating_ips.list.return_value": [fake_floating_ip]
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.client.name = 'cloud-name' self.cloud.name = 'cloud-name'
self.assertEqual( self.assertEqual(
_utils.normalize_server( _utils.normalize_server(
meta.obj_to_dict(ret_active_server), meta.obj_to_dict(ret_active_server),
cloud_name='cloud-name', region_name=''), cloud_name='cloud-name', region_name='RegionOne'),
self.client.rebuild_server("a", "b", wait=True, self.cloud.rebuild_server(
admin_pass='ooBootheiX0edoh')) "a", "b", wait=True, admin_pass='ooBootheiX0edoh'))
def test_rebuild_server_wait(self): def test_rebuild_server_wait(self):
""" """
@ -160,9 +154,9 @@ class TestRebuildServer(base.TestCase):
"floating_ips.list.return_value": [fake_floating_ip] "floating_ips.list.return_value": [fake_floating_ip]
} }
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.client.name = 'cloud-name' self.cloud.name = 'cloud-name'
self.assertEqual( self.assertEqual(
_utils.normalize_server( _utils.normalize_server(
meta.obj_to_dict(active_server), meta.obj_to_dict(active_server),
cloud_name='cloud-name', region_name=''), cloud_name='cloud-name', region_name='RegionOne'),
self.client.rebuild_server("a", "b", wait=True)) 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 from mock import patch
import os_client_config as occ import os_client_config as occ
from shade import OperatorCloud, operator_cloud from shade import OperatorCloud
from shade.exc import OpenStackCloudException, OpenStackCloudTimeout from shade.exc import OpenStackCloudException, OpenStackCloudTimeout
from shade.meta import obj_to_dict 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 import testtools
@ -24,7 +25,6 @@ class TestRoleAssignment(base.TestCase):
def setUp(self): def setUp(self):
super(TestRoleAssignment, self).setUp() super(TestRoleAssignment, self).setUp()
self.cloud = operator_cloud(validate=False)
self.fake_role = obj_to_dict(fakes.FakeRole('12345', 'test')) self.fake_role = obj_to_dict(fakes.FakeRole('12345', 'test'))
self.fake_user = obj_to_dict(fakes.FakeUser('12345', self.fake_user = obj_to_dict(fakes.FakeUser('12345',
'test@nobody.org', 'test@nobody.org',
@ -102,12 +102,16 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project] mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.roles.roles_for_user.return_value = [] mock_keystone.roles.roles_for_user.return_value = []
mock_keystone.roles.add_user_role.return_value = self.fake_role mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.grant_role(
project=self.fake_project['id'])) self.fake_role['name'],
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], user=self.fake_user['name'],
user=self.fake_user['id'], project=self.fake_project['id']))
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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -118,18 +122,26 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [] mock_keystone.roles.roles_for_user.return_value = []
mock_keystone.roles.add_user_role.return_value = self.fake_role mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.grant_role(
project=self.fake_project['id'])) self.fake_role['name'],
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], user=self.fake_user['name'],
user=self.fake_user['id'], project=self.fake_project['id']))
project=self.fake_project['id'])) self.assertTrue(
self.assertTrue(self.cloud.grant_role(self.fake_role['id'], self.op_cloud.grant_role(
user=self.fake_user['name'], self.fake_role['name'],
project=self.fake_project['id'])) user=self.fake_user['id'],
self.assertTrue(self.cloud.grant_role(self.fake_role['id'], project=self.fake_project['id']))
user=self.fake_user['id'], self.assertTrue(
project=self.fake_project['id'])) 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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -141,7 +153,7 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.tenants.list.return_value = [self.fake_project] mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [self.fake_role] 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'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
@ -154,12 +166,16 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project] mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.grant_role(
project=self.fake_project['id'])) self.fake_role['name'],
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], user=self.fake_user['name'],
user=self.fake_user['id'], project=self.fake_project['id']))
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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -172,11 +188,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment] [self.user_project_assignment]
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['id'], self.fake_role['id'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['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.projects.list.return_value = [self.fake_project]
mock_keystone.groups.list.return_value = [self.fake_group] mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
project=self.fake_project['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.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.group_project_assignment] [self.group_project_assignment]
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
project=self.fake_project['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.users.list.return_value = [self.fake_user]
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
@ -254,19 +270,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.user_domain_assignment] [self.user_domain_assignment]
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['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.roles.list.return_value = [self.fake_role]
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertTrue(self.cloud.grant_role( self.assertTrue(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['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.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.group_domain_assignment] [self.group_domain_assignment]
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertFalse(self.cloud.grant_role( self.assertFalse(self.op_cloud.grant_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['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.tenants.list.return_value = [self.fake_project]
mock_keystone.roles.roles_for_user.return_value = [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 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'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['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.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [] 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'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['id'], self.fake_role['id'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['id'], self.fake_role['id'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['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.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.return_value = [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 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'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
@ -393,11 +409,11 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.projects.list.return_value = [self.fake_project] mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['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.users.list.return_value = [self.fake_user]
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment] [self.user_project_assignment]
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['id'], self.fake_role['id'],
user=self.fake_user['id'], user=self.fake_user['id'],
project=self.fake_project['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.projects.list.return_value = [self.fake_project]
mock_keystone.groups.list.return_value = [self.fake_group] mock_keystone.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
project=self.fake_project['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.groups.list.return_value = [self.fake_group]
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.group_project_assignment] [self.group_project_assignment]
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
project=self.fake_project['id'])) project=self.fake_project['id']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
project=self.fake_project['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.users.list.return_value = [self.fake_user]
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
@ -495,19 +511,19 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.user_domain_assignment] [self.user_domain_assignment]
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['id'], user=self.fake_user['id'],
domain=self.fake_domain['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.roles.list.return_value = [self.fake_role]
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = [] mock_keystone.role_assignments.list.return_value = []
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertFalse(self.cloud.revoke_role( self.assertFalse(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['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.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.group_domain_assignment] [self.group_domain_assignment]
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['name'])) domain=self.fake_domain['name']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['name'], group=self.fake_group['name'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
group=self.fake_group['id'], group=self.fake_group['id'],
domain=self.fake_domain['id'])) domain=self.fake_domain['id']))
@ -575,9 +591,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Role {0} not found'.format(self.fake_role['name']) 'Role {0} not found'.format(self.fake_role['name'])
): ):
self.cloud.grant_role(self.fake_role['name'], self.op_cloud.grant_role(
group=self.fake_group['name'], self.fake_role['name'],
domain=self.fake_domain['name']) group=self.fake_group['name'],
domain=self.fake_domain['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -588,9 +605,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Role {0} not found'.format(self.fake_role['name']) 'Role {0} not found'.format(self.fake_role['name'])
): ):
self.cloud.revoke_role(self.fake_role['name'], self.op_cloud.revoke_role(
group=self.fake_group['name'], self.fake_role['name'],
domain=self.fake_domain['name']) group=self.fake_group['name'],
domain=self.fake_domain['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -603,7 +621,7 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a user or a group' '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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -616,7 +634,7 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a user or a group' '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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -628,8 +646,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.cloud.grant_role(self.fake_role['name'], self.op_cloud.grant_role(
user=self.fake_user['name']) self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -641,8 +660,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a user or a group' 'Must specify either a user or a group'
): ):
self.cloud.revoke_role(self.fake_role['name'], self.op_cloud.revoke_role(
user=self.fake_user['name']) self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -655,9 +675,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Specify either a group or a user, not both' 'Specify either a group or a user, not both'
): ):
self.cloud.grant_role(self.fake_role['name'], self.op_cloud.grant_role(
user=self.fake_user['name'], self.fake_role['name'],
group=self.fake_group['name']) user=self.fake_user['name'],
group=self.fake_group['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -670,9 +691,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Specify either a group or a user, not both' 'Specify either a group or a user, not both'
): ):
self.cloud.revoke_role(self.fake_role['name'], self.op_cloud.revoke_role(
user=self.fake_user['name'], self.fake_role['name'],
group=self.fake_group['name']) user=self.fake_user['name'],
group=self.fake_group['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @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.users.list.return_value = [self.fake_user, fake_user2]
mock_keystone.projects.list.return_value = [self.fake_project] mock_keystone.projects.list.return_value = [self.fake_project]
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.grant_role(
project=self.fake_project['id'], self.fake_role['name'],
domain=self.fake_domain['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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -709,7 +733,7 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.domains.get.return_value = self.fake_domain mock_keystone.domains.get.return_value = self.fake_domain
mock_keystone.role_assignments.list.return_value = \ mock_keystone.role_assignments.list.return_value = \
[self.user_project_assignment] [self.user_project_assignment]
self.assertTrue(self.cloud.revoke_role( self.assertTrue(self.op_cloud.revoke_role(
self.fake_role['name'], self.fake_role['name'],
user=self.fake_user['name'], user=self.fake_user['name'],
project=self.fake_project['id'], project=self.fake_project['id'],
@ -727,8 +751,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a domain or project' 'Must specify either a domain or project'
): ):
self.cloud.grant_role(self.fake_role['name'], self.op_cloud.grant_role(
user=self.fake_user['name']) self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -746,8 +771,9 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Must specify either a domain or project' 'Must specify either a domain or project'
): ):
self.cloud.revoke_role(self.fake_role['name'], self.op_cloud.revoke_role(
user=self.fake_user['name']) self.fake_role['name'],
user=self.fake_user['name'])
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -761,9 +787,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Failed to get domain baddomain \(Inner Exception: test\)' 'Failed to get domain baddomain \(Inner Exception: test\)'
): ):
self.cloud.grant_role(self.fake_role['name'], self.op_cloud.grant_role(
user=self.fake_user['name'], self.fake_role['name'],
domain='baddomain') user=self.fake_user['name'],
domain='baddomain')
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -777,9 +804,10 @@ class TestRoleAssignment(base.TestCase):
OpenStackCloudException, OpenStackCloudException,
'Failed to get domain baddomain \(Inner Exception: test\)' 'Failed to get domain baddomain \(Inner Exception: test\)'
): ):
self.cloud.revoke_role(self.fake_role['name'], self.op_cloud.revoke_role(
user=self.fake_user['name'], self.fake_role['name'],
domain='baddomain') user=self.fake_user['name'],
domain='baddomain')
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -793,10 +821,12 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.roles_for_user.side_effect = [ mock_keystone.roles.roles_for_user.side_effect = [
[], [], [self.fake_role]] [], [], [self.fake_role]]
mock_keystone.roles.add_user_role.return_value = self.fake_role mock_keystone.roles.add_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.grant_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.grant_role(
project=self.fake_project['id'], self.fake_role['name'],
wait=True)) user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -807,23 +837,21 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role] mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project] mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.side_effect = [ mock_keystone.roles.roles_for_user.return_value = []
[], [], [self.fake_role]]
mock_keystone.roles.add_user_role.return_value = self.fake_role mock_keystone.roles.add_user_role.return_value = self.fake_role
with testtools.ExpectedException( with testtools.ExpectedException(
OpenStackCloudTimeout, OpenStackCloudTimeout,
'Timeout waiting for role to be granted' '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'], 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(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
def test_revoke_role_user_project_v2_wait(self, def test_revoke_role_user_project_v2_wait(
mock_keystone, self, mock_keystone, mock_api_version):
mock_api_version):
mock_api_version.return_value = '2.0' mock_api_version.return_value = '2.0'
mock_keystone.roles.list.return_value = [self.fake_role] mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project] mock_keystone.tenants.list.return_value = [self.fake_project]
@ -832,10 +860,12 @@ class TestRoleAssignment(base.TestCase):
[self.fake_role], [self.fake_role], [self.fake_role], [self.fake_role],
[]] []]
mock_keystone.roles.remove_user_role.return_value = self.fake_role mock_keystone.roles.remove_user_role.return_value = self.fake_role
self.assertTrue(self.cloud.revoke_role(self.fake_role['name'], self.assertTrue(
user=self.fake_user['name'], self.op_cloud.revoke_role(
project=self.fake_project['id'], self.fake_role['name'],
wait=True)) user=self.fake_user['name'],
project=self.fake_project['id'],
wait=True))
@patch.object(occ.cloud_config.CloudConfig, 'get_api_version') @patch.object(occ.cloud_config.CloudConfig, 'get_api_version')
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -846,14 +876,12 @@ class TestRoleAssignment(base.TestCase):
mock_keystone.roles.list.return_value = [self.fake_role] mock_keystone.roles.list.return_value = [self.fake_role]
mock_keystone.tenants.list.return_value = [self.fake_project] mock_keystone.tenants.list.return_value = [self.fake_project]
mock_keystone.users.list.return_value = [self.fake_user] mock_keystone.users.list.return_value = [self.fake_user]
mock_keystone.roles.roles_for_user.side_effect = [ mock_keystone.roles.roles_for_user.return_value = [self.fake_role]
[self.fake_role], [self.fake_role],
[]]
mock_keystone.roles.remove_user_role.return_value = self.fake_role mock_keystone.roles.remove_user_role.return_value = self.fake_role
with testtools.ExpectedException( with testtools.ExpectedException(
OpenStackCloudTimeout, OpenStackCloudTimeout,
'Timeout waiting for role to be revoked' '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'], 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 from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import OpenStackCloudException from shade.exc import OpenStackCloudException
from shade.tests import base from shade.tests.unit import base
class TestServerDeleteMetadata(base.TestCase): 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): def test_server_delete_metadata_with_delete_meta_exception(self):
""" """
@ -46,7 +39,7 @@ class TestServerDeleteMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.delete_server_metadata, OpenStackCloudException, self.cloud.delete_server_metadata,
{'id': 'server-id'}, ['key']) {'id': 'server-id'}, ['key'])
def test_server_delete_metadata_with_exception_reraise(self): def test_server_delete_metadata_with_exception_reraise(self):
@ -62,5 +55,5 @@ class TestServerDeleteMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.delete_server_metadata, OpenStackCloudException, self.cloud.delete_server_metadata,
'server-id', ['key']) '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 from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import OpenStackCloudException from shade.exc import OpenStackCloudException
from shade.tests import base from shade.tests.unit import base
class TestServerSetMetadata(base.TestCase): 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): def test_server_set_metadata_with_set_meta_exception(self):
""" """
Test that a generic exception in the novaclient set_meta raises Test that a generic exception in the novaclient set_meta raises
@ -47,7 +39,7 @@ class TestServerSetMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.set_server_metadata, OpenStackCloudException, self.cloud.set_server_metadata,
{'id': 'server-id'}, {'meta': 'data'}) {'id': 'server-id'}, {'meta': 'data'})
def test_server_set_metadata_with_exception_reraise(self): def test_server_set_metadata_with_exception_reraise(self):
@ -63,5 +55,5 @@ class TestServerSetMetadata(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.set_server_metadata, OpenStackCloudException, self.cloud.set_server_metadata,
'server-id', {'meta': 'data'}) 'server-id', {'meta': 'data'})

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

@ -44,9 +44,6 @@ class CloudServices(base.TestCase):
def setUp(self): def setUp(self):
super(CloudServices, self).setUp() 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_ks_services = [FakeService(**kwa) for kwa in
self.mock_services] self.mock_services]
@ -62,7 +59,7 @@ class CloudServices(base.TestCase):
'description': 'This is a test service' 'description': 'This is a test service'
} }
self.client.create_service(**kwargs) self.op_cloud.create_service(**kwargs)
kwargs['service_type'] = kwargs.pop('type') kwargs['service_type'] = kwargs.pop('type')
mock_keystone_client.services.create.assert_called_with(**kwargs) mock_keystone_client.services.create.assert_called_with(**kwargs)
self.assertTrue(mock_norm.called) self.assertTrue(mock_norm.called)
@ -80,7 +77,7 @@ class CloudServices(base.TestCase):
'enabled': False 'enabled': False
} }
self.client.create_service(**kwargs) self.op_cloud.create_service(**kwargs)
mock_keystone_client.services.create.assert_called_with(**kwargs) mock_keystone_client.services.create.assert_called_with(**kwargs)
self.assertTrue(mock_norm.called) self.assertTrue(mock_norm.called)
@ -89,7 +86,7 @@ class CloudServices(base.TestCase):
mock_api_version.return_value = '2.0' mock_api_version.return_value = '2.0'
# NOTE(SamYaple): Update service only works with v3 api # NOTE(SamYaple): Update service only works with v3 api
self.assertRaises(OpenStackCloudUnavailableFeature, self.assertRaises(OpenStackCloudUnavailableFeature,
self.client.update_service, self.op_cloud.update_service,
'service_id', name='new name') 'service_id', name='new name')
@patch.object(_utils, 'normalize_keystone_services') @patch.object(_utils, 'normalize_keystone_services')
@ -109,7 +106,7 @@ class CloudServices(base.TestCase):
service_obj = FakeService(id='id1', **kwargs) service_obj = FakeService(id='id1', **kwargs)
mock_keystone_client.services.update.return_value = service_obj 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'] del kwargs['service_type']
mock_keystone_client.services.update.assert_called_once_with( mock_keystone_client.services.update.assert_called_once_with(
service='id1', **kwargs service='id1', **kwargs
@ -120,7 +117,7 @@ class CloudServices(base.TestCase):
def test_list_services(self, mock_keystone_client): def test_list_services(self, mock_keystone_client):
mock_keystone_client.services.list.return_value = \ mock_keystone_client.services.list.return_value = \
self.mock_ks_services self.mock_ks_services
services = self.client.list_services() services = self.op_cloud.list_services()
mock_keystone_client.services.list.assert_called_with() mock_keystone_client.services.list.assert_called_with()
self.assertItemsEqual(self.mock_services, services) self.assertItemsEqual(self.mock_services, services)
@ -130,22 +127,22 @@ class CloudServices(base.TestCase):
self.mock_ks_services self.mock_ks_services
# Search by id # 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 # test we are getting exactly 1 element
self.assertEqual(service, self.mock_services[3]) self.assertEqual(service, self.mock_services[3])
# Search by name # 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 # test we are getting exactly 1 element
self.assertEqual(service, self.mock_services[1]) self.assertEqual(service, self.mock_services[1])
# Not found # 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) self.assertIs(None, service)
# Multiple matches # Multiple matches
# test we are getting an Exception # 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'}) name_or_id=None, filters={'type': 'type2'})
@patch.object(OperatorCloud, 'keystone_client') @patch.object(OperatorCloud, 'keystone_client')
@ -154,23 +151,23 @@ class CloudServices(base.TestCase):
self.mock_ks_services self.mock_ks_services
# Search by id # 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 # test we are getting exactly 1 element
self.assertEqual(1, len(services)) self.assertEqual(1, len(services))
self.assertEqual(services, [self.mock_services[3]]) self.assertEqual(services, [self.mock_services[3]])
# Search by name # 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 # test we are getting exactly 1 element
self.assertEqual(1, len(services)) self.assertEqual(1, len(services))
self.assertEqual(services, [self.mock_services[1]]) self.assertEqual(services, [self.mock_services[1]])
# Not found # 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)) self.assertEqual(0, len(services))
# Multiple matches # Multiple matches
services = self.client.search_services( services = self.op_cloud.search_services(
filters={'type': 'type2'}) filters={'type': 'type2'})
# test we are getting exactly 2 elements # test we are getting exactly 2 elements
self.assertEqual(2, len(services)) self.assertEqual(2, len(services))
@ -183,9 +180,9 @@ class CloudServices(base.TestCase):
self.mock_ks_services self.mock_ks_services
# Delete by name # 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') mock_keystone_client.services.delete.assert_called_with(id='id3')
# Delete by id # Delete by id
self.client.delete_service('id1') self.op_cloud.delete_service('id1')
mock_keystone_client.services.delete.assert_called_with(id='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): class TestShadeOperator(base.TestCase):
def setUp(self):
super(TestShadeOperator, self).setUp()
self.cloud = shade.operator_cloud(validate=False)
def test_operator_cloud(self): 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') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_get_machine(self, mock_client): def test_get_machine(self, mock_client):
node = fakes.FakeMachine(id='00000000-0000-0000-0000-000000000000', node = fakes.FakeMachine(id='00000000-0000-0000-0000-000000000000',
name='bigOlFaker') name='bigOlFaker')
mock_client.node.get.return_value = node 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') mock_client.node.get.assert_called_with(node_id='bigOlFaker')
self.assertEqual(meta.obj_to_dict(node), machine) 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.port.get_by_address.return_value = port_value
mock_client.node.get.return_value = node_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( mock_client.port.get_by_address.assert_called_with(
address='00:00:00:00:00:00') address='00:00:00:00:00:00')
mock_client.node.get.assert_called_with( mock_client.node.get.assert_called_with(
@ -68,14 +64,14 @@ class TestShadeOperator(base.TestCase):
def test_list_machines(self, mock_client): def test_list_machines(self, mock_client):
m1 = fakes.FakeMachine(1, 'fake_machine1') m1 = fakes.FakeMachine(1, 'fake_machine1')
mock_client.node.list.return_value = [m1] 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.assertTrue(mock_client.node.list.called)
self.assertEqual(meta.obj_to_dict(m1), machines[0]) self.assertEqual(meta.obj_to_dict(m1), machines[0])
@mock.patch.object(shade.OperatorCloud, 'ironic_client') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_validate_node(self, mock_client): def test_validate_node(self, mock_client):
node_uuid = '123' node_uuid = '123'
self.cloud.validate_node(node_uuid) self.op_cloud.validate_node(node_uuid)
mock_client.node.validate.assert_called_once_with( mock_client.node.validate.assert_called_once_with(
node_uuid=node_uuid node_uuid=node_uuid
) )
@ -88,7 +84,7 @@ class TestShadeOperator(base.TestCase):
port_dict_list = meta.obj_list_to_dict(port_list) port_dict_list = meta.obj_list_to_dict(port_list)
mock_client.port.list.return_value = 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.assertTrue(mock_client.port.list.called)
self.assertEqual(port_dict_list, nics) self.assertEqual(port_dict_list, nics)
@ -97,26 +93,26 @@ class TestShadeOperator(base.TestCase):
def test_list_nics_failure(self, mock_client): def test_list_nics_failure(self, mock_client):
mock_client.port.list.side_effect = Exception() mock_client.port.list.side_effect = Exception()
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.cloud.list_nics) self.op_cloud.list_nics)
@mock.patch.object(shade.OperatorCloud, 'ironic_client') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_list_nics_for_machine(self, mock_client): def test_list_nics_for_machine(self, mock_client):
mock_client.node.list_ports.return_value = [] 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_client.node.list_ports.assert_called_with(node_id="123")
@mock.patch.object(shade.OperatorCloud, 'ironic_client') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_list_nics_for_machine_failure(self, mock_client): def test_list_nics_for_machine_failure(self, mock_client):
mock_client.node.list_ports.side_effect = Exception() mock_client.node.list_ports.side_effect = Exception()
self.assertRaises(exc.OpenStackCloudException, 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') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_patch_machine(self, mock_client): def test_patch_machine(self, mock_client):
node_id = 'node01' node_id = 'node01'
patch = [] patch = []
patch.append({'op': 'remove', 'path': '/instance_info'}) 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) self.assertTrue(mock_client.node.update.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client') @mock.patch.object(shade.OperatorCloud, 'ironic_client')
@ -132,7 +128,7 @@ class TestShadeOperator(base.TestCase):
) )
mock_client.node.get.return_value = client_return_value 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.assertIsNone(update_dict['changes'])
self.assertFalse(mock_patch.called) self.assertFalse(mock_patch.called)
self.assertDictEqual(expected_machine, update_dict['node']) self.assertDictEqual(expected_machine, update_dict['node'])
@ -151,7 +147,7 @@ class TestShadeOperator(base.TestCase):
) )
mock_client.node.get.return_value = client_return_value 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.assertIsNone(update_dict['changes'])
self.assertFalse(mock_patch.called) self.assertFalse(mock_patch.called)
self.assertDictEqual(expected_machine, update_dict['node']) self.assertDictEqual(expected_machine, update_dict['node'])
@ -168,7 +164,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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.assertIsNotNone(update_dict['changes'])
self.assertEqual('/name', update_dict['changes'][0]) self.assertEqual('/name', update_dict['changes'][0])
self.assertTrue(mock_patch.called) self.assertTrue(mock_patch.called)
@ -188,7 +184,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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.assertIsNotNone(update_dict['changes'])
self.assertEqual('/name', update_dict['changes'][0]) self.assertEqual('/name', update_dict['changes'][0])
self.assertTrue(mock_patch.called) self.assertTrue(mock_patch.called)
@ -213,7 +209,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
chassis_uuid='00000000-0000-0000-0000-000000000001') chassis_uuid='00000000-0000-0000-0000-000000000001')
self.assertIsNotNone(update_dict['changes']) self.assertIsNotNone(update_dict['changes'])
@ -240,7 +236,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
driver='fake' driver='fake'
) )
@ -268,7 +264,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
driver_info=dict(var="fake") driver_info=dict(var="fake")
) )
@ -296,7 +292,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
instance_info=dict(var="fake") instance_info=dict(var="fake")
) )
@ -324,7 +320,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
instance_uuid='00000000-0000-0000-0000-000000000002' instance_uuid='00000000-0000-0000-0000-000000000002'
) )
@ -352,7 +348,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = client_return_value 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', '00000000-0000-0000-0000-000000000000',
properties=dict(var="fake") properties=dict(var="fake")
) )
@ -375,7 +371,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = active_machine mock_client.node.get.return_value = active_machine
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.inspect_machine, self.op_cloud.inspect_machine,
machine_uuid, machine_uuid,
wait=True, wait=True,
timeout=1) timeout=1)
@ -391,7 +387,7 @@ class TestShadeOperator(base.TestCase):
last_error = "kaboom" last_error = "kaboom"
mock_client.node.get.return_value = inspect_failed_machine 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.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual( self.assertEqual(
mock_client.node.set_provision_state.call_count, 1) mock_client.node.set_provision_state.call_count, 1)
@ -406,7 +402,7 @@ class TestShadeOperator(base.TestCase):
provision_state = "manageable" provision_state = "manageable"
mock_client.node.get.return_value = manageable_machine mock_client.node.get.return_value = manageable_machine
self.cloud.inspect_machine(machine_uuid) self.op_cloud.inspect_machine(machine_uuid)
self.assertEqual( self.assertEqual(
mock_client.node.set_provision_state.call_count, 1) mock_client.node.set_provision_state.call_count, 1)
@ -433,7 +429,7 @@ class TestShadeOperator(base.TestCase):
manageable_machine, manageable_machine,
manageable_machine, manageable_machine,
inspecting_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.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual( self.assertEqual(
mock_client.node.set_provision_state.call_count, 3) mock_client.node.set_provision_state.call_count, 3)
@ -468,7 +464,7 @@ class TestShadeOperator(base.TestCase):
provision_state="available" provision_state="available"
) )
return_value = self.cloud.inspect_machine( return_value = self.op_cloud.inspect_machine(
machine_uuid, wait=True, timeout=1) machine_uuid, wait=True, timeout=1)
self.assertTrue(mock_client.node.set_provision_state.called) self.assertTrue(mock_client.node.set_provision_state.called)
self.assertEqual( self.assertEqual(
@ -499,7 +495,7 @@ class TestShadeOperator(base.TestCase):
manageable_machine, manageable_machine,
manageable_machine]) manageable_machine])
return_value = self.cloud.inspect_machine( return_value = self.op_cloud.inspect_machine(
machine_uuid, wait=True, timeout=1) machine_uuid, wait=True, timeout=1)
self.assertDictEqual(expected_return_value, return_value) self.assertDictEqual(expected_return_value, return_value)
@ -529,7 +525,7 @@ class TestShadeOperator(base.TestCase):
inspect_failed_machine]) inspect_failed_machine])
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.inspect_machine, self.op_cloud.inspect_machine,
machine_uuid, machine_uuid,
wait=True, wait=True,
timeout=1) timeout=1)
@ -554,7 +550,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.create.return_value = fake_node mock_client.node.create.return_value = fake_node
mock_client.node.get.return_value = fake_node mock_client.node.get.return_value = fake_node
nics = [{'mac': '00:00:00:00:00:00'}] 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.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called) self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called) self.assertTrue(mock_client.port.create.called)
@ -612,7 +608,7 @@ class TestShadeOperator(base.TestCase):
fake_node_post_provide]) fake_node_post_provide])
mock_client.node.create.return_value = fake_node_init_state mock_client.node.create.return_value = fake_node_init_state
nics = [{'mac': '00:00:00:00:00:00'}] 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.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called) self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.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,
fake_node_post_manage_done, fake_node_post_manage_done,
fake_node_post_provide]) 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.assertDictEqual(expected_return_value, return_value)
self.assertTrue(mock_client.node.create.called) self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.create.called) self.assertTrue(mock_client.port.create.called)
@ -635,11 +631,11 @@ class TestShadeOperator(base.TestCase):
fake_node_post_enroll_failure]) fake_node_post_enroll_failure])
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.register_machine, self.op_cloud.register_machine,
nics) nics)
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.register_machine, self.op_cloud.register_machine,
nics, nics,
wait=True) wait=True)
@ -662,7 +658,7 @@ class TestShadeOperator(base.TestCase):
nics = [{'mac': '00:00:00:00:00:00'}] nics = [{'mac': '00:00:00:00:00:00'}]
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.register_machine, self.op_cloud.register_machine,
nics, nics,
lock_timeout=0.001) lock_timeout=0.001)
self.assertTrue(mock_client.node.create.called) self.assertTrue(mock_client.node.create.called)
@ -672,7 +668,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.create.reset_mock() mock_client.node.create.reset_mock()
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.register_machine, self.op_cloud.register_machine,
nics, nics,
wait=True, wait=True,
timeout=0.001) timeout=0.001)
@ -693,7 +689,7 @@ class TestShadeOperator(base.TestCase):
mock_client.port.create.side_effect = ( mock_client.port.create.side_effect = (
exc.OpenStackCloudException("Error")) exc.OpenStackCloudException("Error"))
self.assertRaises(exc.OpenStackCloudException, self.assertRaises(exc.OpenStackCloudException,
self.cloud.register_machine, self.op_cloud.register_machine,
nics) nics)
self.assertTrue(mock_client.node.create.called) self.assertTrue(mock_client.node.create.called)
self.assertTrue(mock_client.port.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 mock_client.node.get.return_value = fake_node
nics = [{'mac': '00:00:00:00:00:00'}] nics = [{'mac': '00:00:00:00:00:00'}]
uuid = "00000000-0000-0000-0000-000000000000" 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.node.delete.called)
self.assertTrue(mock_client.port.get_by_address.called) self.assertTrue(mock_client.port.get_by_address.called)
self.assertTrue(mock_client.port.delete.called) self.assertTrue(mock_client.port.delete.called)
@ -733,7 +729,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.return_value = fake_node mock_client.node.get.return_value = fake_node
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.cloud.unregister_machine, self.op_cloud.unregister_machine,
nics, nics,
uuid) uuid)
self.assertFalse(mock_client.node.delete.called) self.assertFalse(mock_client.node.delete.called)
@ -753,7 +749,7 @@ class TestShadeOperator(base.TestCase):
uuid = "00000000-0000-0000-0000-000000000000" uuid = "00000000-0000-0000-0000-000000000000"
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
self.cloud.unregister_machine, self.op_cloud.unregister_machine,
nics, nics,
uuid, uuid,
wait=True, wait=True,
@ -768,7 +764,8 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_maintenance.return_value = None mock_client.node.set_maintenance.return_value = None
node_id = 'node01' node_id = 'node01'
reason = 'no reason' 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( mock_client.node.set_maintenance.assert_called_with(
node_id='node01', node_id='node01',
state='true', state='true',
@ -778,7 +775,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_maintenace_state_false(self, mock_client): def test_set_machine_maintenace_state_false(self, mock_client):
mock_client.node.set_maintenance.return_value = None mock_client.node.set_maintenance.return_value = None
node_id = 'node01' 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( mock_client.node.set_maintenance.assert_called_with(
node_id='node01', node_id='node01',
state='false') state='false')
@ -787,7 +784,7 @@ class TestShadeOperator(base.TestCase):
def test_remove_machine_from_maintenance(self, mock_client): def test_remove_machine_from_maintenance(self, mock_client):
mock_client.node.set_maintenance.return_value = None mock_client.node.set_maintenance.return_value = None
node_id = 'node01' 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( mock_client.node.set_maintenance.assert_called_with(
node_id='node01', node_id='node01',
state='false') state='false')
@ -796,7 +793,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_on(self, mock_client): def test_set_machine_power_on(self, mock_client):
mock_client.node.set_power_state.return_value = None mock_client.node.set_power_state.return_value = None
node_id = 'node01' 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) self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with( mock_client.node.set_power_state.assert_called_with(
node_id='node01', node_id='node01',
@ -806,7 +803,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_off(self, mock_client): def test_set_machine_power_off(self, mock_client):
mock_client.node.set_power_state.return_value = None mock_client.node.set_power_state.return_value = None
node_id = 'node01' 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) self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with( mock_client.node.set_power_state.assert_called_with(
node_id='node01', node_id='node01',
@ -816,7 +813,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_reboot(self, mock_client): def test_set_machine_power_reboot(self, mock_client):
mock_client.node.set_power_state.return_value = None mock_client.node.set_power_state.return_value = None
node_id = 'node01' 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) self.assertEqual(None, return_value)
mock_client.node.set_power_state.assert_called_with( mock_client.node.set_power_state.assert_called_with(
node_id='node01', node_id='node01',
@ -826,7 +823,7 @@ class TestShadeOperator(base.TestCase):
def test_set_machine_power_reboot_failure(self, mock_client): def test_set_machine_power_reboot_failure(self, mock_client):
mock_client.node.set_power_state.return_value = 'failure' mock_client.node.set_power_state.return_value = 'failure'
self.assertRaises(shade.OpenStackCloudException, self.assertRaises(shade.OpenStackCloudException,
self.cloud.set_machine_power_reboot, self.op_cloud.set_machine_power_reboot,
'node01') 'node01')
mock_client.node.set_power_state.assert_called_with( mock_client.node.set_power_state.assert_called_with(
node_id='node01', node_id='node01',
@ -844,7 +841,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_provision_state.return_value = None mock_client.node.set_provision_state.return_value = None
mock_client.node.get.return_value = active_node_state mock_client.node.get.return_value = active_node_state
node_id = 'node01' node_id = 'node01'
return_value = self.cloud.node_set_provision_state( return_value = self.op_cloud.node_set_provision_state(
node_id, node_id,
'active', 'active',
configdrive='http://127.0.0.1/file.iso') 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.get.return_value = active_node_state
mock_client.node.set_provision_state.return_value = None mock_client.node.set_provision_state.return_value = None
node_id = 'node01' node_id = 'node01'
return_value = self.cloud.node_set_provision_state( return_value = self.op_cloud.node_set_provision_state(
node_id, node_id,
'active', 'active',
configdrive='http://127.0.0.1/file.iso', 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 mock_client.node.get.return_value = deploying_node_state
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.node_set_provision_state, self.op_cloud.node_set_provision_state,
node_id, node_id,
'active', 'active',
configdrive='http://127.0.0.1/file.iso', configdrive='http://127.0.0.1/file.iso',
@ -917,7 +914,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.get.side_effect = iter([ mock_client.node.get.side_effect = iter([
managable_node_state, managable_node_state,
available_node_state]) available_node_state])
return_value = self.cloud.node_set_provision_state( return_value = self.op_cloud.node_set_provision_state(
'test_node', 'test_node',
'provide', 'provide',
wait=True) wait=True)
@ -929,7 +926,7 @@ class TestShadeOperator(base.TestCase):
def test_activate_node(self, mock_timeout, mock_client): def test_activate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None mock_client.node.set_provision_state.return_value = None
node_id = 'node02' node_id = 'node02'
return_value = self.cloud.activate_node( return_value = self.op_cloud.activate_node(
node_id, node_id,
configdrive='http://127.0.0.1/file.iso') configdrive='http://127.0.0.1/file.iso')
self.assertEqual(None, return_value) self.assertEqual(None, return_value)
@ -954,7 +951,7 @@ class TestShadeOperator(base.TestCase):
mock_client.node.set_provision_state.return_value = None mock_client.node.set_provision_state.return_value = None
node_id = 'node04' node_id = 'node04'
return_value = self.cloud.activate_node( return_value = self.op_cloud.activate_node(
node_id, node_id,
configdrive='http://127.0.0.1/file.iso', configdrive='http://127.0.0.1/file.iso',
wait=True, wait=True,
@ -971,7 +968,7 @@ class TestShadeOperator(base.TestCase):
def test_deactivate_node(self, mock_timeout, mock_client): def test_deactivate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None mock_client.node.set_provision_state.return_value = None
node_id = 'node03' node_id = 'node03'
return_value = self.cloud.deactivate_node( return_value = self.op_cloud.deactivate_node(
node_id, wait=False) node_id, wait=False)
self.assertEqual(None, return_value) self.assertEqual(None, return_value)
mock_client.node.set_provision_state.assert_called_with( 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 mock_client.node.set_provision_state.return_value = None
node_id = 'node03' node_id = 'node03'
return_value = self.cloud.deactivate_node( return_value = self.op_cloud.deactivate_node(
node_id, wait=True, timeout=2) node_id, wait=True, timeout=2)
self.assertEqual(None, return_value) self.assertEqual(None, return_value)
mock_client.node.set_provision_state.assert_called_with( 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): def test_set_node_instance_info(self, mock_client):
uuid = 'aaa' uuid = 'aaa'
patch = [{'op': 'add', 'foo': 'bar'}] 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( mock_client.node.update.assert_called_with(
node_id=uuid, patch=patch node_id=uuid, patch=patch
) )
@ -1017,7 +1014,7 @@ class TestShadeOperator(base.TestCase):
def test_purge_node_instance_info(self, mock_client): def test_purge_node_instance_info(self, mock_client):
uuid = 'aaa' uuid = 'aaa'
expected_patch = [{'op': 'remove', 'path': '/instance_info'}] 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( mock_client.node.update.assert_called_with(
node_id=uuid, patch=expected_patch node_id=uuid, patch=expected_patch
) )
@ -1031,8 +1028,8 @@ class TestShadeOperator(base.TestCase):
status = 'success' status = 'success'
fake_image = Image() fake_image = Image()
glance_mock.images.list.return_value = [fake_image] glance_mock.images.list.return_value = [fake_image]
self.assertEqual('22 name', self.cloud.get_image_name('22')) self.assertEqual('22 name', self.op_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 name'))
@mock.patch.object(shade.OpenStackCloud, 'glance_client') @mock.patch.object(shade.OpenStackCloud, 'glance_client')
def test_get_image_id(self, glance_mock): def test_get_image_id(self, glance_mock):
@ -1043,14 +1040,14 @@ class TestShadeOperator(base.TestCase):
status = 'success' status = 'success'
fake_image = Image() fake_image = Image()
glance_mock.images.list.return_value = [fake_image] glance_mock.images.list.return_value = [fake_image]
self.assertEqual('22', self.cloud.get_image_id('22')) self.assertEqual('22', self.op_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 name'))
@mock.patch.object(cloud_config.CloudConfig, 'get_endpoint') @mock.patch.object(cloud_config.CloudConfig, 'get_endpoint')
def test_get_session_endpoint_provided(self, fake_get_endpoint): def test_get_session_endpoint_provided(self, fake_get_endpoint):
fake_get_endpoint.return_value = 'http://fake.url' fake_get_endpoint.return_value = 'http://fake.url'
self.assertEqual( self.assertEqual(
'http://fake.url', self.cloud.get_session_endpoint('image')) 'http://fake.url', self.op_cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_config.CloudConfig, 'get_session') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_session(self, get_session_mock): 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' session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertEqual( self.assertEqual(
'http://fake.url', self.cloud.get_session_endpoint('image')) 'http://fake.url', self.op_cloud.get_session_endpoint('image'))
@mock.patch.object(cloud_config.CloudConfig, 'get_session') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_exception(self, get_session_mock): def test_get_session_endpoint_exception(self, get_session_mock):
@ -1070,27 +1067,27 @@ class TestShadeOperator(base.TestCase):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.side_effect = side_effect session_mock.get_endpoint.side_effect = side_effect
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.cloud.name = 'testcloud' self.op_cloud.name = 'testcloud'
self.cloud.region_name = 'testregion' self.op_cloud.region_name = 'testregion'
with testtools.ExpectedException( with testtools.ExpectedException(
exc.OpenStackCloudException, exc.OpenStackCloudException,
"Error getting image endpoint on testcloud:testregion:" "Error getting image endpoint on testcloud:testregion:"
" No service"): " No service"):
self.cloud.get_session_endpoint("image") self.op_cloud.get_session_endpoint("image")
@mock.patch.object(cloud_config.CloudConfig, 'get_session') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_unavailable(self, get_session_mock): def test_get_session_endpoint_unavailable(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
image_endpoint = self.cloud.get_session_endpoint("image") image_endpoint = self.op_cloud.get_session_endpoint("image")
self.assertIsNone(image_endpoint) self.assertIsNone(image_endpoint)
@mock.patch.object(cloud_config.CloudConfig, 'get_session') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_get_session_endpoint_identity(self, get_session_mock): def test_get_session_endpoint_identity(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.cloud.get_session_endpoint('identity') self.op_cloud.get_session_endpoint('identity')
session_mock.get_endpoint.assert_called_with( session_mock.get_endpoint.assert_called_with(
interface=ksa_plugin.AUTH_INTERFACE) interface=ksa_plugin.AUTH_INTERFACE)
@ -1099,14 +1096,14 @@ class TestShadeOperator(base.TestCase):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = None session_mock.get_endpoint.return_value = None
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertFalse(self.cloud.has_service("image")) self.assertFalse(self.op_cloud.has_service("image"))
@mock.patch.object(cloud_config.CloudConfig, 'get_session') @mock.patch.object(cloud_config.CloudConfig, 'get_session')
def test_has_service_yes(self, get_session_mock): def test_has_service_yes(self, get_session_mock):
session_mock = mock.Mock() session_mock = mock.Mock()
session_mock.get_endpoint.return_value = 'http://fake.url' session_mock.get_endpoint.return_value = 'http://fake.url'
get_session_mock.return_value = session_mock get_session_mock.return_value = session_mock
self.assertTrue(self.cloud.has_service("image")) self.assertTrue(self.op_cloud.has_service("image"))
@mock.patch.object(shade.OpenStackCloud, 'nova_client') @mock.patch.object(shade.OpenStackCloud, 'nova_client')
def test_list_hypervisors(self, mock_nova): def test_list_hypervisors(self, mock_nova):
@ -1117,7 +1114,7 @@ class TestShadeOperator(base.TestCase):
fakes.FakeHypervisor('2', 'testserver2'), fakes.FakeHypervisor('2', 'testserver2'),
] ]
r = self.cloud.list_hypervisors() r = self.op_cloud.list_hypervisors()
mock_nova.hypervisors.list.assert_called_once_with() mock_nova.hypervisors.list.assert_called_once_with()
self.assertEquals(2, len(r)) self.assertEquals(2, len(r))
self.assertEquals('testserver1', r[0]['hypervisor_hostname']) 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 from mock import patch, Mock
import os_client_config
from shade import OpenStackCloud from shade import OpenStackCloud
from shade.exc import OpenStackCloudException 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): 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): def test_update_server_with_update_exception(self):
""" """
Test that an exception in the novaclient update raises an exception in 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) OpenStackCloud.nova_client = Mock(**config)
self.assertRaises( self.assertRaises(
OpenStackCloudException, self.client.update_server, OpenStackCloudException, self.cloud.update_server,
'server-name') 'server-name')
def test_update_server_name(self): def test_update_server_name(self):
@ -68,5 +61,5 @@ class TestUpdateServer(base.TestCase):
OpenStackCloud.nova_client = Mock(**config) OpenStackCloud.nova_client = Mock(**config)
self.assertEqual( self.assertEqual(
'server-name2', 'server-name2',
self.client.update_server( self.cloud.update_server(
'server-name', name='server-name2')['name']) '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): 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(occ.cloud_config.CloudConfig, 'get_api_version')
@mock.patch.object(shade.OpenStackCloud, 'keystone_client') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_create_user_v2(self, mock_keystone, mock_api_version): def test_create_user_v2(self, mock_keystone, mock_api_version):
@ -39,8 +35,8 @@ class TestUsers(base.TestCase):
password = 'mice-rule' password = 'mice-rule'
fake_user = fakes.FakeUser('1', email, name) fake_user = fakes.FakeUser('1', email, name)
mock_keystone.users.create.return_value = fake_user mock_keystone.users.create.return_value = fake_user
user = self.cloud.create_user(name=name, email=email, user = self.op_cloud.create_user(
password=password) name=name, email=email, password=password)
mock_keystone.users.create.assert_called_once_with( mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email, enabled=True, name=name, password=password, email=email, enabled=True,
) )
@ -57,9 +53,10 @@ class TestUsers(base.TestCase):
domain_id = '456' domain_id = '456'
fake_user = fakes.FakeUser('1', email, name) fake_user = fakes.FakeUser('1', email, name)
mock_keystone.users.create.return_value = fake_user mock_keystone.users.create.return_value = fake_user
user = self.cloud.create_user(name=name, email=email, user = self.op_cloud.create_user(
password=password, name=name, email=email,
domain_id=domain_id) password=password,
domain_id=domain_id)
mock_keystone.users.create.assert_called_once_with( mock_keystone.users.create.assert_called_once_with(
name=name, password=password, email=email, enabled=True, name=name, password=password, email=email, enabled=True,
domain=domain_id domain=domain_id
@ -82,9 +79,10 @@ class TestUsers(base.TestCase):
mock_keystone.users.get.return_value = fake_user mock_keystone.users.get.return_value = fake_user
mock_keystone.users.update.return_value = fake_user mock_keystone.users.update.return_value = fake_user
mock_keystone.users.update_password.return_value = fake_user mock_keystone.users.update_password.return_value = fake_user
user = self.cloud.update_user(name, name=name, email=email, user = self.op_cloud.update_user(
password=password, name, name=name, email=email,
domain_id=domain_id) password=password,
domain_id=domain_id)
mock_keystone.users.update.assert_called_once_with( mock_keystone.users.update.assert_called_once_with(
user=munch_fake_user, name=name, email=email) user=munch_fake_user, name=name, email=email)
mock_keystone.users.update_password.assert_called_once_with( mock_keystone.users.update_password.assert_called_once_with(
@ -104,7 +102,8 @@ class TestUsers(base.TestCase):
"User or project creation requires an explicit" "User or project creation requires an explicit"
" domain_id argument." " 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_by_id')
@mock.patch.object(shade.OpenStackCloud, 'get_user') @mock.patch.object(shade.OpenStackCloud, 'get_user')
@ -113,7 +112,7 @@ class TestUsers(base.TestCase):
mock_get_user.return_value = dict(id='123') mock_get_user.return_value = dict(id='123')
fake_user = fakes.FakeUser('123', 'email', 'name') fake_user = fakes.FakeUser('123', 'email', 'name')
mock_get_by_id.return_value = fake_user 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_get_by_id.assert_called_once_with('123', normalize=False)
mock_keystone.users.delete.assert_called_once_with(user=fake_user) 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') @mock.patch.object(shade.OpenStackCloud, 'keystone_client')
def test_delete_user_not_found(self, mock_keystone, mock_get_user): def test_delete_user_not_found(self, mock_keystone, mock_get_user):
mock_get_user.return_value = None 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) self.assertFalse(mock_keystone.users.delete.called)
@mock.patch.object(shade.OpenStackCloud, 'get_user') @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): def test_add_user_to_group(self, mock_keystone, mock_group, mock_user):
mock_user.return_value = munch.Munch(dict(id=1)) mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2)) 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( mock_keystone.users.add_to_group.assert_called_once_with(
user=1, group=2 user=1, group=2
) )
@ -142,7 +141,7 @@ class TestUsers(base.TestCase):
mock_user.return_value = munch.Munch(dict(id=1)) mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2)) mock_group.return_value = munch.Munch(dict(id=2))
mock_keystone.users.check_in_group.return_value = True 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( mock_keystone.users.check_in_group.assert_called_once_with(
user=1, group=2 user=1, group=2
) )
@ -154,7 +153,7 @@ class TestUsers(base.TestCase):
mock_user): mock_user):
mock_user.return_value = munch.Munch(dict(id=1)) mock_user.return_value = munch.Munch(dict(id=1))
mock_group.return_value = munch.Munch(dict(id=2)) 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( mock_keystone.users.remove_from_group.assert_called_once_with(
user=1, group=2 user=1, group=2
) )