openstack/openstacksdk
Code Issues Proposed changes

Blackify openstack.compute (tests)

Browse Source 
Change Ic8e372a7ca999414ad93fb88e03b92798052cc3e ran black over the
openstack.compute module but forgot the associated tests. Correct this.

Black used with the '-l 79 -S' flags.

Change-Id: I6462d1423b57ff604e1ede977d27a9dd4f2c9c50
Signed-off-by: Stephen Finucane <stephenfin@redhat.com>
This commit is contained in:
Stephen Finucane
2023-05-03 11:58:51 +01:00
parent 0036620f0f
commit 69735d3bd8
30 changed files with 1119 additions and 874 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
openstack/tests/functional/compute/v2/test_extension.py
View File

@@ -15,7 +15,6 @@ from openstack.tests.functional import base
class TestExtension(base.BaseFunctionalTest): class TestExtension(base.BaseFunctionalTest):
def test_list(self): def test_list(self):
extensions = list(self.conn.compute.extensions()) extensions = list(self.conn.compute.extensions())
self.assertGreater(len(extensions), 0) self.assertGreater(len(extensions), 0)

45
openstack/tests/functional/compute/v2/test_flavor.py
View File

@@ -16,7 +16,6 @@ from openstack.tests.functional import base
class TestFlavor(base.BaseFunctionalTest): class TestFlavor(base.BaseFunctionalTest):
def setUp(self): def setUp(self):
super(TestFlavor, self).setUp() super(TestFlavor, self).setUp()
self.new_item_name = self.getUniqueString('flavor') self.new_item_name = self.getUniqueString('flavor')
@@ -42,14 +41,18 @@ class TestFlavor(base.BaseFunctionalTest):
self.assertEqual(rslt.name, self.one_flavor.name) self.assertEqual(rslt.name, self.one_flavor.name)
def test_find_flavors_no_match_ignore_true(self): def test_find_flavors_no_match_ignore_true(self):
rslt = self.conn.compute.find_flavor("not a flavor", rslt = self.conn.compute.find_flavor(
ignore_missing=True) "not a flavor", ignore_missing=True
)
self.assertIsNone(rslt) self.assertIsNone(rslt)
def test_find_flavors_no_match_ignore_false(self): def test_find_flavors_no_match_ignore_false(self):
self.assertRaises(exceptions.ResourceNotFound, self.assertRaises(
self.conn.compute.find_flavor, exceptions.ResourceNotFound,
"not a flavor", ignore_missing=False) self.conn.compute.find_flavor,
"not a flavor",
ignore_missing=False,
)
def test_list_flavors(self): def test_list_flavors(self):
pub_flavor_name = self.new_item_name + '_public' pub_flavor_name = self.new_item_name + '_public'
@@ -81,11 +84,8 @@ class TestFlavor(base.BaseFunctionalTest):
def test_flavor_access(self): def test_flavor_access(self):
flavor_name = uuid.uuid4().hex flavor_name = uuid.uuid4().hex
flv = self.operator_cloud.compute.create_flavor( flv = self.operator_cloud.compute.create_flavor(
is_public=False, is_public=False, name=flavor_name, ram=128, vcpus=1, disk=0
name=flavor_name, )
ram=128,
vcpus=1,
disk=0)
self.addCleanup(self.conn.compute.delete_flavor, flv.id) self.addCleanup(self.conn.compute.delete_flavor, flv.id)
# Validate the 'demo' user cannot see the new flavor # Validate the 'demo' user cannot see the new flavor
flv_cmp = self.user_cloud.compute.find_flavor(flavor_name) flv_cmp = self.user_cloud.compute.find_flavor(flavor_name)
@@ -101,34 +101,29 @@ class TestFlavor(base.BaseFunctionalTest):
# Now give 'demo' access # Now give 'demo' access
self.operator_cloud.compute.flavor_add_tenant_access( self.operator_cloud.compute.flavor_add_tenant_access(
flv.id, project['id']) flv.id, project['id']
)
# Now see if the 'demo' user has access to it # Now see if the 'demo' user has access to it
flv_cmp = self.user_cloud.compute.find_flavor( flv_cmp = self.user_cloud.compute.find_flavor(flavor_name)
flavor_name)
self.assertIsNotNone(flv_cmp) self.assertIsNotNone(flv_cmp)
# Now remove 'demo' access and check we can't find it # Now remove 'demo' access and check we can't find it
self.operator_cloud.compute.flavor_remove_tenant_access( self.operator_cloud.compute.flavor_remove_tenant_access(
flv.id, project['id']) flv.id, project['id']
)
flv_cmp = self.user_cloud.compute.find_flavor( flv_cmp = self.user_cloud.compute.find_flavor(flavor_name)
flavor_name)
self.assertIsNone(flv_cmp) self.assertIsNone(flv_cmp)
def test_extra_props_calls(self): def test_extra_props_calls(self):
flavor_name = uuid.uuid4().hex flavor_name = uuid.uuid4().hex
flv = self.conn.compute.create_flavor( flv = self.conn.compute.create_flavor(
is_public=False, is_public=False, name=flavor_name, ram=128, vcpus=1, disk=0
name=flavor_name, )
ram=128,
vcpus=1,
disk=0)
self.addCleanup(self.conn.compute.delete_flavor, flv.id) self.addCleanup(self.conn.compute.delete_flavor, flv.id)
# Create extra_specs # Create extra_specs
specs = { specs = {'a': 'b'}
'a': 'b'
}
self.conn.compute.create_flavor_extra_specs(flv, extra_specs=specs) self.conn.compute.create_flavor_extra_specs(flv, extra_specs=specs)
# verify specs # verify specs
flv_cmp = self.conn.compute.fetch_flavor_extra_specs(flv) flv_cmp = self.conn.compute.fetch_flavor_extra_specs(flv)

1
openstack/tests/functional/compute/v2/test_hypervisor.py
View File

@@ -14,7 +14,6 @@ from openstack.tests.functional import base
class TestHypervisor(base.BaseFunctionalTest): class TestHypervisor(base.BaseFunctionalTest):
def setUp(self): def setUp(self):
super(TestHypervisor, self).setUp() super(TestHypervisor, self).setUp()

1
openstack/tests/functional/compute/v2/test_image.py
View File

@@ -16,7 +16,6 @@ from openstack.tests.functional.image.v2.test_image import TEST_IMAGE_NAME
class TestImage(base.BaseFunctionalTest): class TestImage(base.BaseFunctionalTest):
def test_images(self): def test_images(self):
images = list(self.conn.compute.images()) images = list(self.conn.compute.images())
self.assertGreater(len(images), 0) self.assertGreater(len(images), 0)

7
openstack/tests/functional/compute/v2/test_keypair.py
View File

@@ -16,7 +16,6 @@ from openstack.tests.functional import base
class TestKeypair(base.BaseFunctionalTest): class TestKeypair(base.BaseFunctionalTest):
def setUp(self): def setUp(self):
super(TestKeypair, self).setUp() super(TestKeypair, self).setUp()
@@ -50,7 +49,6 @@ class TestKeypair(base.BaseFunctionalTest):
class TestKeypairAdmin(base.BaseFunctionalTest): class TestKeypairAdmin(base.BaseFunctionalTest):
def setUp(self): def setUp(self):
super(TestKeypairAdmin, self).setUp() super(TestKeypairAdmin, self).setUp()
self._set_operator_cloud(interface='admin') self._set_operator_cloud(interface='admin')
@@ -58,8 +56,9 @@ class TestKeypairAdmin(base.BaseFunctionalTest):
self.NAME = self.getUniqueString().split('.')[-1] self.NAME = self.getUniqueString().split('.')[-1]
self.USER = self.operator_cloud.list_users()[0] self.USER = self.operator_cloud.list_users()[0]
sot = self.conn.compute.create_keypair(name=self.NAME, sot = self.conn.compute.create_keypair(
user_id=self.USER.id) name=self.NAME, user_id=self.USER.id
)
assert isinstance(sot, keypair.Keypair) assert isinstance(sot, keypair.Keypair)
self.assertEqual(self.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
self.assertEqual(self.USER.id, sot.user_id) self.assertEqual(self.USER.id, sot.user_id)

1
openstack/tests/functional/compute/v2/test_limits.py
View File

@@ -14,7 +14,6 @@ from openstack.tests.functional import base
class TestLimits(base.BaseFunctionalTest): class TestLimits(base.BaseFunctionalTest):
def test_limits(self): def test_limits(self):
sot = self.conn.compute.get_limits() sot = self.conn.compute.get_limits()
self.assertIsNotNone(sot.absolute['instances']) self.assertIsNotNone(sot.absolute['instances'])

18
openstack/tests/functional/compute/v2/test_quota_set.py
View File

@@ -14,35 +14,31 @@ from openstack.tests.functional import base
class TestQS(base.BaseFunctionalTest): class TestQS(base.BaseFunctionalTest):
def test_qs(self): def test_qs(self):
sot = self.conn.compute.get_quota_set( sot = self.conn.compute.get_quota_set(self.conn.current_project_id)
self.conn.current_project_id
)
self.assertIsNotNone(sot.key_pairs) self.assertIsNotNone(sot.key_pairs)
def test_qs_user(self): def test_qs_user(self):
sot = self.conn.compute.get_quota_set( sot = self.conn.compute.get_quota_set(
self.conn.current_project_id, self.conn.current_project_id,
user_id=self.conn.session.auth.get_user_id(self.conn.compute) user_id=self.conn.session.auth.get_user_id(self.conn.compute),
) )
self.assertIsNotNone(sot.key_pairs) self.assertIsNotNone(sot.key_pairs)
def test_update(self): def test_update(self):
sot = self.conn.compute.get_quota_set( sot = self.conn.compute.get_quota_set(self.conn.current_project_id)
self.conn.current_project_id
)
self.conn.compute.update_quota_set( self.conn.compute.update_quota_set(
sot, sot,
query={ query={
'user_id': self.conn.session.auth.get_user_id( 'user_id': self.conn.session.auth.get_user_id(
self.conn.compute) self.conn.compute
)
}, },
key_pairs=100 key_pairs=100,
) )
def test_revert(self): def test_revert(self):
self.conn.compute.revert_quota_set( self.conn.compute.revert_quota_set(
self.conn.current_project_id, self.conn.current_project_id,
user_id=self.conn.session.auth.get_user_id(self.conn.compute) user_id=self.conn.session.auth.get_user_id(self.conn.compute),
) )

23
openstack/tests/functional/compute/v2/test_server.py
View File

@@ -16,7 +16,6 @@ from openstack.tests.functional.network.v2 import test_network
class TestServerAdmin(ft_base.BaseComputeTest): class TestServerAdmin(ft_base.BaseComputeTest):
def setUp(self): def setUp(self):
super(TestServerAdmin, self).setUp() super(TestServerAdmin, self).setUp()
self._set_operator_cloud(interface='admin') self._set_operator_cloud(interface='admin')
@@ -47,8 +46,9 @@ class TestServerAdmin(ft_base.BaseComputeTest):
def tearDown(self): def tearDown(self):
sot = self.conn.compute.delete_server(self.server.id) sot = self.conn.compute.delete_server(self.server.id)
self.conn.compute.wait_for_delete(self.server, self.conn.compute.wait_for_delete(
wait=self._wait_for_timeout) self.server, wait=self._wait_for_timeout
)
self.assertIsNone(sot) self.assertIsNone(sot)
super(TestServerAdmin, self).tearDown() super(TestServerAdmin, self).tearDown()
@@ -65,7 +65,6 @@ class TestServerAdmin(ft_base.BaseComputeTest):
class TestServer(ft_base.BaseComputeTest): class TestServer(ft_base.BaseComputeTest):
def setUp(self): def setUp(self):
super(TestServer, self).setUp() super(TestServer, self).setUp()
self.NAME = self.getUniqueString() self.NAME = self.getUniqueString()
@@ -75,9 +74,8 @@ class TestServer(ft_base.BaseComputeTest):
self.cidr = '10.99.99.0/16' self.cidr = '10.99.99.0/16'
self.network, self.subnet = test_network.create_network( self.network, self.subnet = test_network.create_network(
self.conn, self.conn, self.NAME, self.cidr
self.NAME, )
self.cidr)
self.assertIsNotNone(self.network) self.assertIsNotNone(self.network)
sot = self.conn.compute.create_server( sot = self.conn.compute.create_server(
@@ -95,8 +93,9 @@ class TestServer(ft_base.BaseComputeTest):
sot = self.conn.compute.delete_server(self.server.id) sot = self.conn.compute.delete_server(self.server.id)
self.assertIsNone(sot) self.assertIsNone(sot)
# Need to wait for the stack to go away before network delete # Need to wait for the stack to go away before network delete
self.conn.compute.wait_for_delete(self.server, self.conn.compute.wait_for_delete(
wait=self._wait_for_timeout) self.server, wait=self._wait_for_timeout
)
test_network.delete_network(self.conn, self.network, self.subnet) test_network.delete_network(self.conn, self.network, self.subnet)
super(TestServer, self).tearDown() super(TestServer, self).tearDown()
@@ -166,13 +165,15 @@ class TestServer(ft_base.BaseComputeTest):
# delete metadata # delete metadata
self.conn.compute.delete_server_metadata( self.conn.compute.delete_server_metadata(
test_server, test_server.metadata.keys()) test_server, test_server.metadata.keys()
)
test_server = self.conn.compute.get_server_metadata(test_server) test_server = self.conn.compute.get_server_metadata(test_server)
self.assertFalse(test_server.metadata) self.assertFalse(test_server.metadata)
def test_server_remote_console(self): def test_server_remote_console(self):
console = self.conn.compute.create_server_remote_console( console = self.conn.compute.create_server_remote_console(
self.server, protocol='vnc', type='novnc') self.server, protocol='vnc', type='novnc'
)
self.assertEqual('vnc', console.protocol) self.assertEqual('vnc', console.protocol)
self.assertEqual('novnc', console.type) self.assertEqual('novnc', console.type)
self.assertTrue(console.url.startswith('http')) self.assertTrue(console.url.startswith('http'))

10
openstack/tests/functional/compute/v2/test_service.py
View File

@@ -14,7 +14,6 @@ from openstack.tests.functional import base
class TestService(base.BaseFunctionalTest): class TestService(base.BaseFunctionalTest):
def setUp(self): def setUp(self):
super(TestService, self).setUp() super(TestService, self).setUp()
self._set_operator_cloud(interface='admin') self._set_operator_cloud(interface='admin')
@@ -34,9 +33,11 @@ class TestService(base.BaseFunctionalTest):
for srv in self.conn.compute.services(): for srv in self.conn.compute.services():
if srv.name == 'nova-compute': if srv.name == 'nova-compute':
self.conn.compute.update_service_forced_down( self.conn.compute.update_service_forced_down(
srv, None, None, True) srv, None, None, True
)
self.conn.compute.update_service_forced_down( self.conn.compute.update_service_forced_down(
srv, srv.host, srv.binary, False) srv, srv.host, srv.binary, False
)
self.conn.compute.update_service(srv, status='enabled') self.conn.compute.update_service(srv, status='enabled')
def test_find(self): def test_find(self):
@@ -44,4 +45,5 @@ class TestService(base.BaseFunctionalTest):
if srv.name != 'nova-conductor': if srv.name != 'nova-conductor':
# In devstack there are 2 nova-conductor instances on same host # In devstack there are 2 nova-conductor instances on same host
self.conn.compute.find_service( self.conn.compute.find_service(
srv.name, host=srv.host, ignore_missing=False) srv.name, host=srv.host, ignore_missing=False
)

1
openstack/tests/unit/compute/test_version.py
View File

@@ -24,7 +24,6 @@ EXAMPLE = {
class TestVersion(base.TestCase): class TestVersion(base.TestCase):
def test_basic(self): def test_basic(self):
sot = version.Version() sot = version.Version()
self.assertEqual('version', sot.resource_key) self.assertEqual('version', sot.resource_key)

15
openstack/tests/unit/compute/v2/test_aggregate.py
View File

@@ -29,12 +29,11 @@ EXAMPLE = {
"deleted_at": None, "deleted_at": None,
"id": 4, "id": 4,
"uuid": IDENTIFIER, "uuid": IDENTIFIER,
"metadata": {"type": "public", "family": "m-family"} "metadata": {"type": "public", "family": "m-family"},
} }
class TestAggregate(base.TestCase): class TestAggregate(base.TestCase):
def setUp(self): def setUp(self):
super(TestAggregate, self).setUp() super(TestAggregate, self).setUp()
self.resp = mock.Mock() self.resp = mock.Mock()
@@ -76,8 +75,7 @@ class TestAggregate(base.TestCase):
url = 'os-aggregates/4/action' url = 'os-aggregates/4/action'
body = {"add_host": {"host": "host1"}} body = {"add_host": {"host": "host1"}}
self.sess.post.assert_called_with( self.sess.post.assert_called_with(url, json=body, microversion=None)
url, json=body, microversion=None)
def test_remove_host(self): def test_remove_host(self):
sot = aggregate.Aggregate(**EXAMPLE) sot = aggregate.Aggregate(**EXAMPLE)
@@ -86,8 +84,7 @@ class TestAggregate(base.TestCase):
url = 'os-aggregates/4/action' url = 'os-aggregates/4/action'
body = {"remove_host": {"host": "host1"}} body = {"remove_host": {"host": "host1"}}
self.sess.post.assert_called_with( self.sess.post.assert_called_with(url, json=body, microversion=None)
url, json=body, microversion=None)
def test_set_metadata(self): def test_set_metadata(self):
sot = aggregate.Aggregate(**EXAMPLE) sot = aggregate.Aggregate(**EXAMPLE)
@@ -96,8 +93,7 @@ class TestAggregate(base.TestCase):
url = 'os-aggregates/4/action' url = 'os-aggregates/4/action'
body = {"set_metadata": {"metadata": {"key: value"}}} body = {"set_metadata": {"metadata": {"key: value"}}}
self.sess.post.assert_called_with( self.sess.post.assert_called_with(url, json=body, microversion=None)
url, json=body, microversion=None)
def test_precache_image(self): def test_precache_image(self):
sot = aggregate.Aggregate(**EXAMPLE) sot = aggregate.Aggregate(**EXAMPLE)
@@ -107,4 +103,5 @@ class TestAggregate(base.TestCase):
url = 'os-aggregates/4/images' url = 'os-aggregates/4/images'
body = {"cache": ['1']} body = {"cache": ['1']}
self.sess.post.assert_called_with( self.sess.post.assert_called_with(
url, json=body, microversion=sot._max_microversion) url, json=body, microversion=sot._max_microversion
)

3
openstack/tests/unit/compute/v2/test_availability_zone.py
View File

@@ -19,12 +19,11 @@ BASIC_EXAMPLE = {
'id': IDENTIFIER, 'id': IDENTIFIER,
'zoneState': 'available', 'zoneState': 'available',
'hosts': 'host1', 'hosts': 'host1',
'zoneName': 'zone1' 'zoneName': 'zone1',
} }
class TestAvailabilityZone(base.TestCase): class TestAvailabilityZone(base.TestCase):
def test_basic(self): def test_basic(self):
sot = az.AvailabilityZone() sot = az.AvailabilityZone()
self.assertEqual('availabilityZoneInfo', sot.resources_key) self.assertEqual('availabilityZoneInfo', sot.resources_key)

1
openstack/tests/unit/compute/v2/test_extension.py
View File

@@ -26,7 +26,6 @@ EXAMPLE = {
class TestExtension(base.TestCase): class TestExtension(base.TestCase):
def test_basic(self): def test_basic(self):
sot = extension.Extension() sot = extension.Extension()
self.assertEqual('extension', sot.resource_key) self.assertEqual('extension', sot.resource_key)

92
openstack/tests/unit/compute/v2/test_flavor.py
View File

@@ -31,7 +31,7 @@ BASIC_EXAMPLE = {
'swap': 8, 'swap': 8,
'OS-FLV-EXT-DATA:ephemeral': 9, 'OS-FLV-EXT-DATA:ephemeral': 9,
'OS-FLV-DISABLED:disabled': False, 'OS-FLV-DISABLED:disabled': False,
'rxtx_factor': 11.0 'rxtx_factor': 11.0,
} }
DEFAULTS_EXAMPLE = { DEFAULTS_EXAMPLE = {
'links': '2', 'links': '2',
@@ -41,7 +41,6 @@ DEFAULTS_EXAMPLE = {
class TestFlavor(base.TestCase): class TestFlavor(base.TestCase):
def setUp(self): def setUp(self):
super(TestFlavor, self).setUp() super(TestFlavor, self).setUp()
self.sess = mock.Mock(spec=adapter.Adapter) self.sess = mock.Mock(spec=adapter.Adapter)
@@ -59,14 +58,18 @@ class TestFlavor(base.TestCase):
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertTrue(sot.allow_commit) self.assertTrue(sot.allow_commit)
self.assertDictEqual({"sort_key": "sort_key", self.assertDictEqual(
"sort_dir": "sort_dir", {
"min_disk": "minDisk", "sort_key": "sort_key",
"min_ram": "minRam", "sort_dir": "sort_dir",
"limit": "limit", "min_disk": "minDisk",
"marker": "marker", "min_ram": "minRam",
"is_public": "is_public"}, "limit": "limit",
sot._query_mapping._mapping) "marker": "marker",
"is_public": "is_public",
},
sot._query_mapping._mapping,
)
def test_make_basic(self): def test_make_basic(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
@@ -74,15 +77,18 @@ class TestFlavor(base.TestCase):
self.assertEqual(BASIC_EXAMPLE['name'], sot.name) self.assertEqual(BASIC_EXAMPLE['name'], sot.name)
self.assertEqual(BASIC_EXAMPLE['description'], sot.description) self.assertEqual(BASIC_EXAMPLE['description'], sot.description)
self.assertEqual(BASIC_EXAMPLE['disk'], sot.disk) self.assertEqual(BASIC_EXAMPLE['disk'], sot.disk)
self.assertEqual(BASIC_EXAMPLE['os-flavor-access:is_public'], self.assertEqual(
sot.is_public) BASIC_EXAMPLE['os-flavor-access:is_public'], sot.is_public
)
self.assertEqual(BASIC_EXAMPLE['ram'], sot.ram) self.assertEqual(BASIC_EXAMPLE['ram'], sot.ram)
self.assertEqual(BASIC_EXAMPLE['vcpus'], sot.vcpus) self.assertEqual(BASIC_EXAMPLE['vcpus'], sot.vcpus)
self.assertEqual(BASIC_EXAMPLE['swap'], sot.swap) self.assertEqual(BASIC_EXAMPLE['swap'], sot.swap)
self.assertEqual(BASIC_EXAMPLE['OS-FLV-EXT-DATA:ephemeral'], self.assertEqual(
sot.ephemeral) BASIC_EXAMPLE['OS-FLV-EXT-DATA:ephemeral'], sot.ephemeral
self.assertEqual(BASIC_EXAMPLE['OS-FLV-DISABLED:disabled'], )
sot.is_disabled) self.assertEqual(
BASIC_EXAMPLE['OS-FLV-DISABLED:disabled'], sot.is_disabled
)
self.assertEqual(BASIC_EXAMPLE['rxtx_factor'], sot.rxtx_factor) self.assertEqual(BASIC_EXAMPLE['rxtx_factor'], sot.rxtx_factor)
def test_make_defaults(self): def test_make_defaults(self):
@@ -119,10 +125,8 @@ class TestFlavor(base.TestCase):
self.sess.post.assert_called_with( self.sess.post.assert_called_with(
'flavors/IDENTIFIER/action', 'flavors/IDENTIFIER/action',
json={ json={'addTenantAccess': {'tenant': 'fake_tenant'}},
'addTenantAccess': { headers={'Accept': ''},
'tenant': 'fake_tenant'}},
headers={'Accept': ''}
) )
def test_remove_tenant_access(self): def test_remove_tenant_access(self):
@@ -137,19 +141,18 @@ class TestFlavor(base.TestCase):
self.sess.post.assert_called_with( self.sess.post.assert_called_with(
'flavors/IDENTIFIER/action', 'flavors/IDENTIFIER/action',
json={ json={'removeTenantAccess': {'tenant': 'fake_tenant'}},
'removeTenantAccess': { headers={'Accept': ''},
'tenant': 'fake_tenant'}},
headers={'Accept': ''}
) )
def test_get_flavor_access(self): def test_get_flavor_access(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
resp = mock.Mock() resp = mock.Mock()
resp.body = {'flavor_access': [ resp.body = {
{'flavor_id': 'fake_flavor', 'flavor_access': [
'tenant_id': 'fake_tenant'} {'flavor_id': 'fake_flavor', 'tenant_id': 'fake_tenant'}
]} ]
}
resp.json = mock.Mock(return_value=resp.body) resp.json = mock.Mock(return_value=resp.body)
resp.status_code = 200 resp.status_code = 200
self.sess.get = mock.Mock(return_value=resp) self.sess.get = mock.Mock(return_value=resp)
@@ -165,11 +168,7 @@ class TestFlavor(base.TestCase):
def test_fetch_extra_specs(self): def test_fetch_extra_specs(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
resp = mock.Mock() resp = mock.Mock()
resp.body = { resp.body = {'extra_specs': {'a': 'b', 'c': 'd'}}
'extra_specs':
{'a': 'b',
'c': 'd'}
}
resp.json = mock.Mock(return_value=resp.body) resp.json = mock.Mock(return_value=resp.body)
resp.status_code = 200 resp.status_code = 200
self.sess.get = mock.Mock(return_value=resp) self.sess.get = mock.Mock(return_value=resp)
@@ -178,7 +177,7 @@ class TestFlavor(base.TestCase):
self.sess.get.assert_called_with( self.sess.get.assert_called_with(
'flavors/IDENTIFIER/os-extra_specs', 'flavors/IDENTIFIER/os-extra_specs',
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertEqual(resp.body['extra_specs'], rsp.extra_specs) self.assertEqual(resp.body['extra_specs'], rsp.extra_specs)
@@ -186,14 +185,9 @@ class TestFlavor(base.TestCase):
def test_create_extra_specs(self): def test_create_extra_specs(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
specs = { specs = {'a': 'b', 'c': 'd'}
'a': 'b',
'c': 'd'
}
resp = mock.Mock() resp = mock.Mock()
resp.body = { resp.body = {'extra_specs': specs}
'extra_specs': specs
}
resp.json = mock.Mock(return_value=resp.body) resp.json = mock.Mock(return_value=resp.body)
resp.status_code = 200 resp.status_code = 200
self.sess.post = mock.Mock(return_value=resp) self.sess.post = mock.Mock(return_value=resp)
@@ -203,7 +197,7 @@ class TestFlavor(base.TestCase):
self.sess.post.assert_called_with( self.sess.post.assert_called_with(
'flavors/IDENTIFIER/os-extra_specs', 'flavors/IDENTIFIER/os-extra_specs',
json={'extra_specs': specs}, json={'extra_specs': specs},
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertEqual(resp.body['extra_specs'], rsp.extra_specs) self.assertEqual(resp.body['extra_specs'], rsp.extra_specs)
@@ -212,9 +206,7 @@ class TestFlavor(base.TestCase):
def test_get_extra_specs_property(self): def test_get_extra_specs_property(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
resp = mock.Mock() resp = mock.Mock()
resp.body = { resp.body = {'a': 'b'}
'a': 'b'
}
resp.json = mock.Mock(return_value=resp.body) resp.json = mock.Mock(return_value=resp.body)
resp.status_code = 200 resp.status_code = 200
self.sess.get = mock.Mock(return_value=resp) self.sess.get = mock.Mock(return_value=resp)
@@ -223,7 +215,7 @@ class TestFlavor(base.TestCase):
self.sess.get.assert_called_with( self.sess.get.assert_called_with(
'flavors/IDENTIFIER/os-extra_specs/a', 'flavors/IDENTIFIER/os-extra_specs/a',
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertEqual('b', rsp) self.assertEqual('b', rsp)
@@ -231,9 +223,7 @@ class TestFlavor(base.TestCase):
def test_update_extra_specs_property(self): def test_update_extra_specs_property(self):
sot = flavor.Flavor(**BASIC_EXAMPLE) sot = flavor.Flavor(**BASIC_EXAMPLE)
resp = mock.Mock() resp = mock.Mock()
resp.body = { resp.body = {'a': 'b'}
'a': 'b'
}
resp.json = mock.Mock(return_value=resp.body) resp.json = mock.Mock(return_value=resp.body)
resp.status_code = 200 resp.status_code = 200
self.sess.put = mock.Mock(return_value=resp) self.sess.put = mock.Mock(return_value=resp)
@@ -243,7 +233,7 @@ class TestFlavor(base.TestCase):
self.sess.put.assert_called_with( self.sess.put.assert_called_with(
'flavors/IDENTIFIER/os-extra_specs/a', 'flavors/IDENTIFIER/os-extra_specs/a',
json={'a': 'b'}, json={'a': 'b'},
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertEqual('b', rsp) self.assertEqual('b', rsp)
@@ -260,7 +250,7 @@ class TestFlavor(base.TestCase):
self.sess.delete.assert_called_with( self.sess.delete.assert_called_with(
'flavors/IDENTIFIER/os-extra_specs/a', 'flavors/IDENTIFIER/os-extra_specs/a',
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertIsNone(rsp) self.assertIsNone(rsp)

62
openstack/tests/unit/compute/v2/test_hypervisor.py
View File

@@ -25,27 +25,20 @@ EXAMPLE = {
"arch": "x86_64", "arch": "x86_64",
"model": "Nehalem", "model": "Nehalem",
"vendor": "Intel", "vendor": "Intel",
"features": [ "features": ["pge", "clflush"],
"pge", "topology": {"cores": 1, "threads": 1, "sockets": 4},
"clflush"
],
"topology": {
"cores": 1,
"threads": 1,
"sockets": 4
}
}, },
"state": "up", "state": "up",
"status": "enabled", "status": "enabled",
"servers": [ "servers": [
{ {
"name": "test_server1", "name": "test_server1",
"uuid": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" "uuid": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
}, },
{ {
"name": "test_server2", "name": "test_server2",
"uuid": "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb" "uuid": "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
} },
], ],
"host_ip": "1.1.1.1", "host_ip": "1.1.1.1",
"hypervisor_hostname": "fake-mini", "hypervisor_hostname": "fake-mini",
@@ -54,11 +47,12 @@ EXAMPLE = {
"id": "b1e43b5f-eec1-44e0-9f10-7b4945c0226d", "id": "b1e43b5f-eec1-44e0-9f10-7b4945c0226d",
"uptime": ( "uptime": (
" 08:32:11 up 93 days, 18:25, 12 users, " " 08:32:11 up 93 days, 18:25, 12 users, "
"load average: 0.20, 0.12, 0.14"), "load average: 0.20, 0.12, 0.14"
),
"service": { "service": {
"host": "043b3cacf6f34c90a7245151fc8ebcda", "host": "043b3cacf6f34c90a7245151fc8ebcda",
"id": "5d343e1d-938e-4284-b98b-6a2b5406ba76", "id": "5d343e1d-938e-4284-b98b-6a2b5406ba76",
"disabled_reason": None "disabled_reason": None,
}, },
# deprecated attributes # deprecated attributes
"vcpus_used": 0, "vcpus_used": 0,
@@ -76,7 +70,6 @@ EXAMPLE = {
class TestHypervisor(base.TestCase): class TestHypervisor(base.TestCase):
def setUp(self): def setUp(self):
super(TestHypervisor, self).setUp() super(TestHypervisor, self).setUp()
self.sess = mock.Mock(spec=adapter.Adapter) self.sess = mock.Mock(spec=adapter.Adapter)
@@ -91,12 +84,15 @@ class TestHypervisor(base.TestCase):
self.assertTrue(sot.allow_fetch) self.assertTrue(sot.allow_fetch)
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertDictEqual({'hypervisor_hostname_pattern': self.assertDictEqual(
'hypervisor_hostname_pattern', {
'limit': 'limit', 'hypervisor_hostname_pattern': 'hypervisor_hostname_pattern',
'marker': 'marker', 'limit': 'limit',
'with_servers': 'with_servers'}, 'marker': 'marker',
sot._query_mapping._mapping) 'with_servers': 'with_servers',
},
sot._query_mapping._mapping,
)
def test_make_it(self): def test_make_it(self):
sot = hypervisor.Hypervisor(**EXAMPLE) sot = hypervisor.Hypervisor(**EXAMPLE)
@@ -126,8 +122,11 @@ class TestHypervisor(base.TestCase):
self.assertEqual(EXAMPLE['local_gb'], sot.local_disk_size) self.assertEqual(EXAMPLE['local_gb'], sot.local_disk_size)
self.assertEqual(EXAMPLE['free_ram_mb'], sot.memory_free) self.assertEqual(EXAMPLE['free_ram_mb'], sot.memory_free)
@mock.patch('openstack.utils.supports_microversion', autospec=True, @mock.patch(
return_value=False) 'openstack.utils.supports_microversion',
autospec=True,
return_value=False,
)
def test_get_uptime(self, mv_mock): def test_get_uptime(self, mv_mock):
sot = hypervisor.Hypervisor(**copy.deepcopy(EXAMPLE)) sot = hypervisor.Hypervisor(**copy.deepcopy(EXAMPLE))
rsp = { rsp = {
@@ -136,7 +135,7 @@ class TestHypervisor(base.TestCase):
"id": sot.id, "id": sot.id,
"state": "up", "state": "up",
"status": "enabled", "status": "enabled",
"uptime": "08:32:11 up 93 days, 18:25, 12 users" "uptime": "08:32:11 up 93 days, 18:25, 12 users",
} }
} }
resp = mock.Mock() resp = mock.Mock()
@@ -149,17 +148,16 @@ class TestHypervisor(base.TestCase):
hyp = sot.get_uptime(self.sess) hyp = sot.get_uptime(self.sess)
self.sess.get.assert_called_with( self.sess.get.assert_called_with(
'os-hypervisors/{id}/uptime'.format(id=sot.id), 'os-hypervisors/{id}/uptime'.format(id=sot.id),
microversion=self.sess.default_microversion microversion=self.sess.default_microversion,
) )
self.assertEqual(rsp['hypervisor']['uptime'], hyp.uptime) self.assertEqual(rsp['hypervisor']['uptime'], hyp.uptime)
self.assertEqual(rsp['hypervisor']['status'], sot.status) self.assertEqual(rsp['hypervisor']['status'], sot.status)
@mock.patch('openstack.utils.supports_microversion', autospec=True, @mock.patch(
return_value=True) 'openstack.utils.supports_microversion',
autospec=True,
return_value=True,
)
def test_get_uptime_after_2_88(self, mv_mock): def test_get_uptime_after_2_88(self, mv_mock):
sot = hypervisor.Hypervisor(**copy.deepcopy(EXAMPLE)) sot = hypervisor.Hypervisor(**copy.deepcopy(EXAMPLE))
self.assertRaises( self.assertRaises(exceptions.SDKException, sot.get_uptime, self.sess)
exceptions.SDKException,
sot.get_uptime,
self.sess
)

27
openstack/tests/unit/compute/v2/test_image.py
View File

@@ -27,12 +27,11 @@ EXAMPLE = {
'progress': 5, 'progress': 5,
'status': '6', 'status': '6',
'updated': '2015-03-09T12:15:57.233772', 'updated': '2015-03-09T12:15:57.233772',
'OS-EXT-IMG-SIZE:size': 8 'OS-EXT-IMG-SIZE:size': 8,
} }
class TestImage(base.TestCase): class TestImage(base.TestCase):
def test_basic(self): def test_basic(self):
sot = image.Image() sot = image.Image()
self.assertEqual('image', sot.resource_key) self.assertEqual('image', sot.resource_key)
@@ -44,16 +43,20 @@ class TestImage(base.TestCase):
self.assertTrue(sot.allow_delete) self.assertTrue(sot.allow_delete)
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertDictEqual({"server": "server", self.assertDictEqual(
"name": "name", {
"status": "status", "server": "server",
"type": "type", "name": "name",
"min_disk": "minDisk", "status": "status",
"min_ram": "minRam", "type": "type",
"changes_since": "changes-since", "min_disk": "minDisk",
"limit": "limit", "min_ram": "minRam",
"marker": "marker"}, "changes_since": "changes-since",
sot._query_mapping._mapping) "limit": "limit",
"marker": "marker",
},
sot._query_mapping._mapping,
)
def test_make_basic(self): def test_make_basic(self):
sot = image.Image(**EXAMPLE) sot = image.Image(**EXAMPLE)

11
openstack/tests/unit/compute/v2/test_keypair.py
View File

@@ -22,12 +22,11 @@ EXAMPLE = {
'public_key': '3', 'public_key': '3',
'private_key': '4', 'private_key': '4',
'type': 'ssh', 'type': 'ssh',
'user_id': '5' 'user_id': '5',
} }
class TestKeypair(base.TestCase): class TestKeypair(base.TestCase):
def test_basic(self): def test_basic(self):
sot = keypair.Keypair() sot = keypair.Keypair()
self.assertEqual('keypair', sot.resource_key) self.assertEqual('keypair', sot.resource_key)
@@ -39,10 +38,10 @@ class TestKeypair(base.TestCase):
self.assertTrue(sot.allow_delete) self.assertTrue(sot.allow_delete)
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertDictEqual({'limit': 'limit', self.assertDictEqual(
'marker': 'marker', {'limit': 'limit', 'marker': 'marker', 'user_id': 'user_id'},
'user_id': 'user_id'}, sot._query_mapping._mapping,
sot._query_mapping._mapping) )
def test_make_it(self): def test_make_it(self):
sot = keypair.Keypair(**EXAMPLE) sot = keypair.Keypair(**EXAMPLE)

170
openstack/tests/unit/compute/v2/test_limits.py
View File

@@ -35,7 +35,7 @@ ABSOLUTE_LIMITS = {
"totalRAMUsed": 4, "totalRAMUsed": 4,
"totalInstancesUsed": 5, "totalInstancesUsed": 5,
"totalServerGroupsUsed": 6, "totalServerGroupsUsed": 6,
"totalCoresUsed": 7 "totalCoresUsed": 7,
} }
RATE_LIMIT = { RATE_LIMIT = {
@@ -45,23 +45,17 @@ RATE_LIMIT = {
"remaining": 120, "remaining": 120,
"unit": "MINUTE", "unit": "MINUTE",
"value": 120, "value": 120,
"verb": "POST" "verb": "POST",
}, },
], ],
"regex": ".*", "regex": ".*",
"uri": "*" "uri": "*",
} }
LIMITS_BODY = { LIMITS_BODY = {"limits": {"absolute": ABSOLUTE_LIMITS, "rate": [RATE_LIMIT]}}
"limits": {
"absolute": ABSOLUTE_LIMITS,
"rate": [RATE_LIMIT]
}
}
class TestAbsoluteLimits(base.TestCase): class TestAbsoluteLimits(base.TestCase):
def test_basic(self): def test_basic(self):
sot = limits.AbsoluteLimits() sot = limits.AbsoluteLimits()
self.assertIsNone(sot.resource_key) self.assertIsNone(sot.resource_key)
@@ -76,38 +70,44 @@ class TestAbsoluteLimits(base.TestCase):
def test_make_it(self): def test_make_it(self):
sot = limits.AbsoluteLimits(**ABSOLUTE_LIMITS) sot = limits.AbsoluteLimits(**ABSOLUTE_LIMITS)
self.assertEqual(ABSOLUTE_LIMITS["maxImageMeta"], sot.image_meta) self.assertEqual(ABSOLUTE_LIMITS["maxImageMeta"], sot.image_meta)
self.assertEqual(ABSOLUTE_LIMITS["maxSecurityGroupRules"], self.assertEqual(
sot.security_group_rules) ABSOLUTE_LIMITS["maxSecurityGroupRules"], sot.security_group_rules
self.assertEqual(ABSOLUTE_LIMITS["maxSecurityGroups"], )
sot.security_groups) self.assertEqual(
ABSOLUTE_LIMITS["maxSecurityGroups"], sot.security_groups
)
self.assertEqual(ABSOLUTE_LIMITS["maxServerMeta"], sot.server_meta) self.assertEqual(ABSOLUTE_LIMITS["maxServerMeta"], sot.server_meta)
self.assertEqual(ABSOLUTE_LIMITS["maxTotalCores"], sot.total_cores) self.assertEqual(ABSOLUTE_LIMITS["maxTotalCores"], sot.total_cores)
self.assertEqual(ABSOLUTE_LIMITS["maxTotalFloatingIps"], self.assertEqual(
sot.floating_ips) ABSOLUTE_LIMITS["maxTotalFloatingIps"], sot.floating_ips
self.assertEqual(ABSOLUTE_LIMITS["maxTotalInstances"], )
sot.instances) self.assertEqual(ABSOLUTE_LIMITS["maxTotalInstances"], sot.instances)
self.assertEqual(ABSOLUTE_LIMITS["maxTotalKeypairs"], self.assertEqual(ABSOLUTE_LIMITS["maxTotalKeypairs"], sot.keypairs)
sot.keypairs) self.assertEqual(ABSOLUTE_LIMITS["maxTotalRAMSize"], sot.total_ram)
self.assertEqual(ABSOLUTE_LIMITS["maxTotalRAMSize"],
sot.total_ram)
self.assertEqual(ABSOLUTE_LIMITS["maxServerGroups"], sot.server_groups) self.assertEqual(ABSOLUTE_LIMITS["maxServerGroups"], sot.server_groups)
self.assertEqual(ABSOLUTE_LIMITS["maxServerGroupMembers"], self.assertEqual(
sot.server_group_members) ABSOLUTE_LIMITS["maxServerGroupMembers"], sot.server_group_members
self.assertEqual(ABSOLUTE_LIMITS["totalFloatingIpsUsed"], )
sot.floating_ips_used) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["totalSecurityGroupsUsed"], ABSOLUTE_LIMITS["totalFloatingIpsUsed"], sot.floating_ips_used
sot.security_groups_used) )
self.assertEqual(
ABSOLUTE_LIMITS["totalSecurityGroupsUsed"],
sot.security_groups_used,
)
self.assertEqual(ABSOLUTE_LIMITS["totalRAMUsed"], sot.total_ram_used) self.assertEqual(ABSOLUTE_LIMITS["totalRAMUsed"], sot.total_ram_used)
self.assertEqual(ABSOLUTE_LIMITS["totalInstancesUsed"], self.assertEqual(
sot.instances_used) ABSOLUTE_LIMITS["totalInstancesUsed"], sot.instances_used
self.assertEqual(ABSOLUTE_LIMITS["totalServerGroupsUsed"], )
sot.server_groups_used) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["totalCoresUsed"], ABSOLUTE_LIMITS["totalServerGroupsUsed"], sot.server_groups_used
sot.total_cores_used) )
self.assertEqual(
ABSOLUTE_LIMITS["totalCoresUsed"], sot.total_cores_used
)
class TestRateLimit(base.TestCase): class TestRateLimit(base.TestCase):
def test_basic(self): def test_basic(self):
sot = limits.RateLimit() sot = limits.RateLimit()
self.assertIsNone(sot.resource_key) self.assertIsNone(sot.resource_key)
@@ -128,7 +128,6 @@ class TestRateLimit(base.TestCase):
class TestLimits(base.TestCase): class TestLimits(base.TestCase):
def test_basic(self): def test_basic(self):
sot = limits.Limits() sot = limits.Limits()
self.assertEqual("limits", sot.resource_key) self.assertEqual("limits", sot.resource_key)
@@ -139,11 +138,7 @@ class TestLimits(base.TestCase):
self.assertFalse(sot.allow_delete) self.assertFalse(sot.allow_delete)
self.assertFalse(sot.allow_list) self.assertFalse(sot.allow_list)
self.assertDictEqual( self.assertDictEqual(
{ {'limit': 'limit', 'marker': 'marker', 'tenant_id': 'tenant_id'},
'limit': 'limit',
'marker': 'marker',
'tenant_id': 'tenant_id'
},
sot._query_mapping._mapping, sot._query_mapping._mapping,
) )
@@ -158,40 +153,62 @@ class TestLimits(base.TestCase):
sot = limits.Limits().fetch(sess) sot = limits.Limits().fetch(sess)
self.assertEqual(ABSOLUTE_LIMITS["maxImageMeta"], self.assertEqual(
sot.absolute.image_meta) ABSOLUTE_LIMITS["maxImageMeta"], sot.absolute.image_meta
self.assertEqual(ABSOLUTE_LIMITS["maxSecurityGroupRules"], )
sot.absolute.security_group_rules) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["maxSecurityGroups"], ABSOLUTE_LIMITS["maxSecurityGroupRules"],
sot.absolute.security_groups) sot.absolute.security_group_rules,
self.assertEqual(ABSOLUTE_LIMITS["maxServerMeta"], )
sot.absolute.server_meta) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["maxTotalCores"], ABSOLUTE_LIMITS["maxSecurityGroups"], sot.absolute.security_groups
sot.absolute.total_cores) )
self.assertEqual(ABSOLUTE_LIMITS["maxTotalFloatingIps"], self.assertEqual(
sot.absolute.floating_ips) ABSOLUTE_LIMITS["maxServerMeta"], sot.absolute.server_meta
self.assertEqual(ABSOLUTE_LIMITS["maxTotalInstances"], )
sot.absolute.instances) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["maxTotalKeypairs"], ABSOLUTE_LIMITS["maxTotalCores"], sot.absolute.total_cores
sot.absolute.keypairs) )
self.assertEqual(ABSOLUTE_LIMITS["maxTotalRAMSize"], self.assertEqual(
sot.absolute.total_ram) ABSOLUTE_LIMITS["maxTotalFloatingIps"], sot.absolute.floating_ips
self.assertEqual(ABSOLUTE_LIMITS["maxServerGroups"], )
sot.absolute.server_groups) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["maxServerGroupMembers"], ABSOLUTE_LIMITS["maxTotalInstances"], sot.absolute.instances
sot.absolute.server_group_members) )
self.assertEqual(ABSOLUTE_LIMITS["totalFloatingIpsUsed"], self.assertEqual(
sot.absolute.floating_ips_used) ABSOLUTE_LIMITS["maxTotalKeypairs"], sot.absolute.keypairs
self.assertEqual(ABSOLUTE_LIMITS["totalSecurityGroupsUsed"], )
sot.absolute.security_groups_used) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["totalRAMUsed"], ABSOLUTE_LIMITS["maxTotalRAMSize"], sot.absolute.total_ram
sot.absolute.total_ram_used) )
self.assertEqual(ABSOLUTE_LIMITS["totalInstancesUsed"], self.assertEqual(
sot.absolute.instances_used) ABSOLUTE_LIMITS["maxServerGroups"], sot.absolute.server_groups
self.assertEqual(ABSOLUTE_LIMITS["totalServerGroupsUsed"], )
sot.absolute.server_groups_used) self.assertEqual(
self.assertEqual(ABSOLUTE_LIMITS["totalCoresUsed"], ABSOLUTE_LIMITS["maxServerGroupMembers"],
sot.absolute.total_cores_used) sot.absolute.server_group_members,
)
self.assertEqual(
ABSOLUTE_LIMITS["totalFloatingIpsUsed"],
sot.absolute.floating_ips_used,
)
self.assertEqual(
ABSOLUTE_LIMITS["totalSecurityGroupsUsed"],
sot.absolute.security_groups_used,
)
self.assertEqual(
ABSOLUTE_LIMITS["totalRAMUsed"], sot.absolute.total_ram_used
)
self.assertEqual(
ABSOLUTE_LIMITS["totalInstancesUsed"], sot.absolute.instances_used
)
self.assertEqual(
ABSOLUTE_LIMITS["totalServerGroupsUsed"],
sot.absolute.server_groups_used,
)
self.assertEqual(
ABSOLUTE_LIMITS["totalCoresUsed"], sot.absolute.total_cores_used
)
self.assertEqual(RATE_LIMIT["uri"], sot.rate[0].uri) self.assertEqual(RATE_LIMIT["uri"], sot.rate[0].uri)
self.assertEqual(RATE_LIMIT["regex"], sot.rate[0].regex) self.assertEqual(RATE_LIMIT["regex"], sot.rate[0].regex)
@@ -204,4 +221,5 @@ class TestLimits(base.TestCase):
self.assertEqual(RATE_LIMIT["uri"], dsot['rate'][0]['uri']) self.assertEqual(RATE_LIMIT["uri"], dsot['rate'][0]['uri'])
self.assertEqual( self.assertEqual(
ABSOLUTE_LIMITS["totalSecurityGroupsUsed"], ABSOLUTE_LIMITS["totalSecurityGroupsUsed"],
dsot['absolute']['security_groups_used']) dsot['absolute']['security_groups_used'],
)

1
openstack/tests/unit/compute/v2/test_migration.py
View File

@@ -33,7 +33,6 @@ EXAMPLE = {
class TestMigration(base.TestCase): class TestMigration(base.TestCase):
def test_basic(self): def test_basic(self):
sot = migration.Migration() sot = migration.Migration()
self.assertIsNone(sot.resource_key) # we don't support fetch self.assertIsNone(sot.resource_key) # we don't support fetch

608
openstack/tests/unit/compute/v2/test_proxy.py
View File

File diff suppressed because it is too large Load Diff

689
openstack/tests/unit/compute/v2/test_server.py
View File

File diff suppressed because it is too large Load Diff

3
openstack/tests/unit/compute/v2/test_server_actions.py
View File

@@ -26,7 +26,7 @@ EXAMPLE = {
'result': 'Success', 'result': 'Success',
'start_time': '2018-04-25T01:26:36.539271', 'start_time': '2018-04-25T01:26:36.539271',
'traceback': None, 'traceback': None,
'details': None 'details': None,
} }
], ],
'instance_uuid': '4bf3473b-d550-4b65-9409-292d44ab14a2', 'instance_uuid': '4bf3473b-d550-4b65-9409-292d44ab14a2',
@@ -40,7 +40,6 @@ EXAMPLE = {
class TestServerAction(base.TestCase): class TestServerAction(base.TestCase):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.resp = mock.Mock() self.resp = mock.Mock()

20
openstack/tests/unit/compute/v2/test_server_diagnostics.py
View File

@@ -17,29 +17,20 @@ from openstack.tests.unit import base
IDENTIFIER = 'IDENTIFIER' IDENTIFIER = 'IDENTIFIER'
EXAMPLE = { EXAMPLE = {
"config_drive": True, "config_drive": True,
"cpu_details": [ "cpu_details": [{"id": 0, "time": 17300000000, "utilisation": 15}],
{
"id": 0,
"time": 17300000000,
"utilisation": 15
}
],
"disk_details": [ "disk_details": [
{ {
"errors_count": 1, "errors_count": 1,
"read_bytes": 262144, "read_bytes": 262144,
"read_requests": 112, "read_requests": 112,
"write_bytes": 5778432, "write_bytes": 5778432,
"write_requests": 488 "write_requests": 488,
} }
], ],
"driver": "libvirt", "driver": "libvirt",
"hypervisor": "kvm", "hypervisor": "kvm",
"hypervisor_os": "ubuntu", "hypervisor_os": "ubuntu",
"memory_details": { "memory_details": {"maximum": 524288, "used": 0},
"maximum": 524288,
"used": 0
},
"nic_details": [ "nic_details": [
{ {
"mac_address": "01:23:45:67:89:ab", "mac_address": "01:23:45:67:89:ab",
@@ -52,19 +43,18 @@ EXAMPLE = {
"tx_errors": 400, "tx_errors": 400,
"tx_octets": 140208, "tx_octets": 140208,
"tx_packets": 662, "tx_packets": 662,
"tx_rate": 600 "tx_rate": 600,
} }
], ],
"num_cpus": 1, "num_cpus": 1,
"num_disks": 1, "num_disks": 1,
"num_nics": 1, "num_nics": 1,
"state": "running", "state": "running",
"uptime": 46664 "uptime": 46664,
} }
class TestServerInterface(base.TestCase): class TestServerInterface(base.TestCase):
def test_basic(self): def test_basic(self):
sot = server_diagnostics.ServerDiagnostics() sot = server_diagnostics.ServerDiagnostics()
self.assertEqual('diagnostics', sot.resource_key) self.assertEqual('diagnostics', sot.resource_key)

12
openstack/tests/unit/compute/v2/test_server_group.py
View File

@@ -27,7 +27,6 @@ EXAMPLE = {
class TestServerGroup(base.TestCase): class TestServerGroup(base.TestCase):
def test_basic(self): def test_basic(self):
sot = server_group.ServerGroup() sot = server_group.ServerGroup()
self.assertEqual('server_group', sot.resource_key) self.assertEqual('server_group', sot.resource_key)
@@ -39,9 +38,14 @@ class TestServerGroup(base.TestCase):
self.assertTrue(sot.allow_delete) self.assertTrue(sot.allow_delete)
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertDictEqual({"all_projects": "all_projects", self.assertDictEqual(
"limit": "limit", "marker": "marker"}, {
sot._query_mapping._mapping) "all_projects": "all_projects",
"limit": "limit",
"marker": "marker",
},
sot._query_mapping._mapping,
)
def test_make_it(self): def test_make_it(self):
sot = server_group.ServerGroup(**EXAMPLE) sot = server_group.ServerGroup(**EXAMPLE)

3
openstack/tests/unit/compute/v2/test_server_interface.py
View File

@@ -19,7 +19,7 @@ EXAMPLE = {
'fixed_ips': [ 'fixed_ips': [
{ {
'ip_address': '192.168.1.1', 'ip_address': '192.168.1.1',
'subnet_id': 'f8a6e8f8-c2ec-497c-9f23-da9616de54ef' 'subnet_id': 'f8a6e8f8-c2ec-497c-9f23-da9616de54ef',
} }
], ],
'mac_addr': '2', 'mac_addr': '2',
@@ -32,7 +32,6 @@ EXAMPLE = {
class TestServerInterface(base.TestCase): class TestServerInterface(base.TestCase):
def test_basic(self): def test_basic(self):
sot = server_interface.ServerInterface() sot = server_interface.ServerInterface()
self.assertEqual('interfaceAttachment', sot.resource_key) self.assertEqual('interfaceAttachment', sot.resource_key)

30
openstack/tests/unit/compute/v2/test_server_ip.py
View File

@@ -24,7 +24,6 @@ EXAMPLE = {
class TestServerIP(base.TestCase): class TestServerIP(base.TestCase):
def test_basic(self): def test_basic(self):
sot = server_ip.ServerIP() sot = server_ip.ServerIP()
self.assertEqual('addresses', sot.resources_key) self.assertEqual('addresses', sot.resources_key)
@@ -46,10 +45,17 @@ class TestServerIP(base.TestCase):
resp = mock.Mock() resp = mock.Mock()
sess.get.return_value = resp sess.get.return_value = resp
resp.json.return_value = { resp.json.return_value = {
"addresses": {"label1": [{"version": 1, "addr": "a1"}, "addresses": {
{"version": 2, "addr": "a2"}], "label1": [
"label2": [{"version": 3, "addr": "a3"}, {"version": 1, "addr": "a1"},
{"version": 4, "addr": "a4"}]}} {"version": 2, "addr": "a2"},
],
"label2": [
{"version": 3, "addr": "a3"},
{"version": 4, "addr": "a4"},
],
}
}
ips = list(server_ip.ServerIP.list(sess, server_id=IDENTIFIER)) ips = list(server_ip.ServerIP.list(sess, server_id=IDENTIFIER))
@@ -78,13 +84,15 @@ class TestServerIP(base.TestCase):
sess = mock.Mock() sess = mock.Mock()
resp = mock.Mock() resp = mock.Mock()
sess.get.return_value = resp sess.get.return_value = resp
resp.json.return_value = {label: [{"version": 1, resp.json.return_value = {
"addr": "a1"}, label: [{"version": 1, "addr": "a1"}, {"version": 2, "addr": "a2"}]
{"version": 2, }
"addr": "a2"}]}
ips = list(server_ip.ServerIP.list(sess, server_id=IDENTIFIER, ips = list(
network_label=label)) server_ip.ServerIP.list(
sess, server_id=IDENTIFIER, network_label=label
)
)
self.assertEqual(2, len(ips)) self.assertEqual(2, len(ips))
ips = sorted(ips, key=lambda ip: ip.version) ips = sorted(ips, key=lambda ip: ip.version)

12
openstack/tests/unit/compute/v2/test_server_migration.py
View File

@@ -38,7 +38,6 @@ EXAMPLE = {
class TestServerMigration(base.TestCase): class TestServerMigration(base.TestCase):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.resp = mock.Mock() self.resp = mock.Mock()
@@ -96,7 +95,9 @@ class TestServerMigration(base.TestCase):
self.assertEqual(EXAMPLE['disk_total_bytes'], sot.disk_total_bytes) self.assertEqual(EXAMPLE['disk_total_bytes'], sot.disk_total_bytes)
@mock.patch.object( @mock.patch.object(
server_migration.ServerMigration, '_get_session', lambda self, x: x, server_migration.ServerMigration,
'_get_session',
lambda self, x: x,
) )
def test_force_complete(self): def test_force_complete(self):
sot = server_migration.ServerMigration(**EXAMPLE) sot = server_migration.ServerMigration(**EXAMPLE)
@@ -104,9 +105,12 @@ class TestServerMigration(base.TestCase):
self.assertIsNone(sot.force_complete(self.sess)) self.assertIsNone(sot.force_complete(self.sess))
url = 'servers/%s/migrations/%s/action' % ( url = 'servers/%s/migrations/%s/action' % (
EXAMPLE['server_uuid'], EXAMPLE['id'] EXAMPLE['server_uuid'],
EXAMPLE['id'],
) )
body = {'force_complete': None} body = {'force_complete': None}
self.sess.post.assert_called_with( self.sess.post.assert_called_with(
url, microversion=mock.ANY, json=body, url,
microversion=mock.ANY,
json=body,
) )

22
openstack/tests/unit/compute/v2/test_server_remote_console.py
View File

@@ -19,15 +19,10 @@ from openstack.tests.unit import base
IDENTIFIER = 'IDENTIFIER' IDENTIFIER = 'IDENTIFIER'
EXAMPLE = { EXAMPLE = {'protocol': 'rdp', 'type': 'rdp', 'url': 'fake'}
'protocol': 'rdp',
'type': 'rdp',
'url': 'fake'
}
class TestServerRemoteConsole(base.TestCase): class TestServerRemoteConsole(base.TestCase):
def setUp(self): def setUp(self):
super(TestServerRemoteConsole, self).setUp() super(TestServerRemoteConsole, self).setUp()
self.sess = mock.Mock(spec=adapter.Adapter) self.sess = mock.Mock(spec=adapter.Adapter)
@@ -43,8 +38,9 @@ class TestServerRemoteConsole(base.TestCase):
def test_basic(self): def test_basic(self):
sot = server_remote_console.ServerRemoteConsole() sot = server_remote_console.ServerRemoteConsole()
self.assertEqual('remote_console', sot.resource_key) self.assertEqual('remote_console', sot.resource_key)
self.assertEqual('/servers/%(server_id)s/remote-consoles', self.assertEqual(
sot.base_path) '/servers/%(server_id)s/remote-consoles', sot.base_path
)
self.assertTrue(sot.allow_create) self.assertTrue(sot.allow_create)
self.assertFalse(sot.allow_fetch) self.assertFalse(sot.allow_fetch)
self.assertFalse(sot.allow_commit) self.assertFalse(sot.allow_commit)
@@ -57,15 +53,13 @@ class TestServerRemoteConsole(base.TestCase):
def test_create_type_mks_old(self): def test_create_type_mks_old(self):
sot = server_remote_console.ServerRemoteConsole( sot = server_remote_console.ServerRemoteConsole(
server_id='fake_server', type='webmks') server_id='fake_server', type='webmks'
)
class FakeEndpointData: class FakeEndpointData:
min_microversion = '2' min_microversion = '2'
max_microversion = '2.5' max_microversion = '2.5'
self.sess.get_endpoint_data.return_value = FakeEndpointData() self.sess.get_endpoint_data.return_value = FakeEndpointData()
self.assertRaises( self.assertRaises(ValueError, sot.create, self.sess)
ValueError,
sot.create,
self.sess
)

86
openstack/tests/unit/compute/v2/test_service.py
View File

@@ -23,12 +23,11 @@ EXAMPLE = {
'host': 'host1', 'host': 'host1',
'status': 'enabled', 'status': 'enabled',
'state': 'up', 'state': 'up',
'zone': 'nova' 'zone': 'nova',
} }
class TestService(base.TestCase): class TestService(base.TestCase):
def setUp(self): def setUp(self):
super(TestService, self).setUp() super(TestService, self).setUp()
self.resp = mock.Mock() self.resp = mock.Mock()
@@ -49,14 +48,16 @@ class TestService(base.TestCase):
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertFalse(sot.allow_fetch) self.assertFalse(sot.allow_fetch)
self.assertDictEqual({ self.assertDictEqual(
'binary': 'binary', {
'host': 'host', 'binary': 'binary',
'limit': 'limit', 'host': 'host',
'marker': 'marker', 'limit': 'limit',
'name': 'binary', 'marker': 'marker',
}, 'name': 'binary',
sot._query_mapping._mapping) },
sot._query_mapping._mapping,
)
def test_make_it(self): def test_make_it(self):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -91,16 +92,14 @@ class TestService(base.TestCase):
list_mock.return_value = data list_mock.return_value = data
sot = service.Service.find( sot = service.Service.find(
self.sess, '2', ignore_missing=True, self.sess, '2', ignore_missing=True, binary='bin1', host='host'
binary='bin1', host='host'
) )
self.assertEqual(data[1], sot) self.assertEqual(data[1], sot)
# Verify find when ID is int # Verify find when ID is int
sot = service.Service.find( sot = service.Service.find(
self.sess, 1, ignore_missing=True, self.sess, 1, ignore_missing=True, binary='bin1', host='host'
binary='bin1', host='host'
) )
self.assertEqual(data[0], sot) self.assertEqual(data[0], sot)
@@ -113,9 +112,11 @@ class TestService(base.TestCase):
with mock.patch.object(service.Service, 'list') as list_mock: with mock.patch.object(service.Service, 'list') as list_mock:
list_mock.return_value = data list_mock.return_value = data
self.assertIsNone(service.Service.find( self.assertIsNone(
self.sess, 'fake', ignore_missing=True, host='host' service.Service.find(
)) self.sess, 'fake', ignore_missing=True, host='host'
)
)
def test_find_no_match_exception(self): def test_find_no_match_exception(self):
data = [ data = [
@@ -128,7 +129,10 @@ class TestService(base.TestCase):
self.assertRaises( self.assertRaises(
exceptions.ResourceNotFound, exceptions.ResourceNotFound,
service.Service.find, service.Service.find,
self.sess, 'fake', ignore_missing=False, host='host' self.sess,
'fake',
ignore_missing=False,
host='host',
) )
def test_find_multiple_match(self): def test_find_multiple_match(self):
@@ -142,11 +146,17 @@ class TestService(base.TestCase):
self.assertRaises( self.assertRaises(
exceptions.DuplicateResource, exceptions.DuplicateResource,
service.Service.find, service.Service.find,
self.sess, 'bin1', ignore_missing=False, host='host' self.sess,
'bin1',
ignore_missing=False,
host='host',
) )
@mock.patch('openstack.utils.supports_microversion', autospec=True, @mock.patch(
return_value=False) 'openstack.utils.supports_microversion',
autospec=True,
return_value=False,
)
def test_set_forced_down_before_211(self, mv_mock): def test_set_forced_down_before_211(self, mv_mock):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -159,10 +169,14 @@ class TestService(base.TestCase):
'host': 'host1', 'host': 'host1',
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(
url, json=body, microversion=self.sess.default_microversion) url, json=body, microversion=self.sess.default_microversion
)
@mock.patch('openstack.utils.supports_microversion', autospec=True, @mock.patch(
return_value=True) 'openstack.utils.supports_microversion',
autospec=True,
return_value=True,
)
def test_set_forced_down_after_211(self, mv_mock): def test_set_forced_down_after_211(self, mv_mock):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -175,11 +189,13 @@ class TestService(base.TestCase):
'host': 'host1', 'host': 'host1',
'forced_down': True, 'forced_down': True,
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(url, json=body, microversion='2.11')
url, json=body, microversion='2.11')
@mock.patch('openstack.utils.supports_microversion', autospec=True, @mock.patch(
return_value=True) 'openstack.utils.supports_microversion',
autospec=True,
return_value=True,
)
def test_set_forced_down_after_253(self, mv_mock): def test_set_forced_down_after_253(self, mv_mock):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -192,8 +208,7 @@ class TestService(base.TestCase):
'host': sot.host, 'host': sot.host,
'forced_down': True, 'forced_down': True,
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(url, json=body, microversion='2.11')
url, json=body, microversion='2.11')
def test_enable(self): def test_enable(self):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -207,7 +222,8 @@ class TestService(base.TestCase):
'host': 'host1', 'host': 'host1',
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(
url, json=body, microversion=self.sess.default_microversion) url, json=body, microversion=self.sess.default_microversion
)
def test_disable(self): def test_disable(self):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -221,7 +237,8 @@ class TestService(base.TestCase):
'host': 'host1', 'host': 'host1',
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(
url, json=body, microversion=self.sess.default_microversion) url, json=body, microversion=self.sess.default_microversion
)
def test_disable_with_reason(self): def test_disable_with_reason(self):
sot = service.Service(**EXAMPLE) sot = service.Service(**EXAMPLE)
@@ -235,7 +252,8 @@ class TestService(base.TestCase):
body = { body = {
'binary': 'nova-compute', 'binary': 'nova-compute',
'host': 'host1', 'host': 'host1',
'disabled_reason': reason 'disabled_reason': reason,
} }
self.sess.put.assert_called_with( self.sess.put.assert_called_with(
url, json=body, microversion=self.sess.default_microversion) url, json=body, microversion=self.sess.default_microversion
)

18
openstack/tests/unit/compute/v2/test_volume_attachment.py
View File

@@ -26,29 +26,31 @@ EXAMPLE = {
class TestServerInterface(base.TestCase): class TestServerInterface(base.TestCase):
def test_basic(self): def test_basic(self):
sot = volume_attachment.VolumeAttachment() sot = volume_attachment.VolumeAttachment()
self.assertEqual('volumeAttachment', sot.resource_key) self.assertEqual('volumeAttachment', sot.resource_key)
self.assertEqual('volumeAttachments', sot.resources_key) self.assertEqual('volumeAttachments', sot.resources_key)
self.assertEqual('/servers/%(server_id)s/os-volume_attachments', self.assertEqual(
sot.base_path) '/servers/%(server_id)s/os-volume_attachments',
sot.base_path,
)
self.assertTrue(sot.allow_create) self.assertTrue(sot.allow_create)
self.assertTrue(sot.allow_fetch) self.assertTrue(sot.allow_fetch)
self.assertTrue(sot.allow_commit) self.assertTrue(sot.allow_commit)
self.assertTrue(sot.allow_delete) self.assertTrue(sot.allow_delete)
self.assertTrue(sot.allow_list) self.assertTrue(sot.allow_list)
self.assertDictEqual({"limit": "limit", self.assertDictEqual(
"offset": "offset", {"limit": "limit", "offset": "offset", "marker": "marker"},
"marker": "marker"}, sot._query_mapping._mapping,
sot._query_mapping._mapping) )
def test_make_it(self): def test_make_it(self):
sot = volume_attachment.VolumeAttachment(**EXAMPLE) sot = volume_attachment.VolumeAttachment(**EXAMPLE)
self.assertEqual(EXAMPLE['volumeId'], sot.id) self.assertEqual(EXAMPLE['volumeId'], sot.id)
self.assertEqual(EXAMPLE['attachment_id'], sot.attachment_id) self.assertEqual(EXAMPLE['attachment_id'], sot.attachment_id)
self.assertEqual( self.assertEqual(
EXAMPLE['delete_on_termination'], sot.delete_on_termination, EXAMPLE['delete_on_termination'],
sot.delete_on_termination,
) )
self.assertEqual(EXAMPLE['device'], sot.device) self.assertEqual(EXAMPLE['device'], sot.device)
# FIXME(stephenfin): This conflicts since there is a server ID in the # FIXME(stephenfin): This conflicts since there is a server ID in the