openstack/openstacksdk
Code Issues Proposed changes

Remove use of FakeServer from tests

Browse Source 
FakeServer is a Fake of a novaclient object. Use actual json instead.

Speaking of - transform the dict through json dump/load so that it's
unicode where it's supposed to be. This makes diffs easier to make.

Change-Id: I45c1136078f604c73c1fea54a9eb52bbbc8c69b5
This commit is contained in:
Monty Taylor 2017-06-18 08:19:21 -05:00
parent b9a2c296e6
commit fb956cce7b
No known key found for this signature in database
GPG Key ID: 7BAE94BC7141A594
9 changed files with 226 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
shade/tests/fakes.py
View File

@ -18,6 +18,7 @@ Fakes used for testing
""" """
import datetime import datetime
import json
import uuid import uuid
from shade._heat import template_format from shade._heat import template_format
@ -83,33 +84,45 @@ outputs:
FAKE_TEMPLATE_CONTENT = template_format.parse(FAKE_TEMPLATE) FAKE_TEMPLATE_CONTENT = template_format.parse(FAKE_TEMPLATE)
def make_fake_server(server_id, name, status='ACTIVE'): def make_fake_server(
return { server_id, name, status='ACTIVE', admin_pass=None,
addresses=None, image=None, flavor=None):
if addresses is None:
if status == 'ACTIVE':
addresses = {
"private": [
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 6,
"addr": "fddb:b018:307:0:f816:3eff:fedf:b08d",
"OS-EXT-IPS:type": "fixed"},
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 4,
"addr": "10.1.0.9",
"OS-EXT-IPS:type": "fixed"},
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 4,
"addr": "172.24.5.5",
"OS-EXT-IPS:type": "floating"}]}
else:
addresses = {}
if image is None:
image = {"id": "217f3ab1-03e0-4450-bf27-63d52b421e9e",
"links": []}
if flavor is None:
flavor = {"id": "64",
"links": []}
server = {
"OS-EXT-STS:task_state": None, "OS-EXT-STS:task_state": None,
"addresses": { "addresses": addresses,
"private": [
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 6,
"addr": "fddb:b018:307:0:f816:3eff:fedf:b08d",
"OS-EXT-IPS:type": "fixed"},
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 4,
"addr": "10.1.0.9",
"OS-EXT-IPS:type": "fixed"},
{
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
"version": 4,
"addr": "172.24.5.5",
"OS-EXT-IPS:type": "floating"}]},
"links": [], "links": [],
"image": {"id": "217f3ab1-03e0-4450-bf27-63d52b421e9e", "image": image,
"links": []},
"OS-EXT-STS:vm_state": "active", "OS-EXT-STS:vm_state": "active",
"OS-SRV-USG:launched_at": "2017-03-23T23:57:38.000000", "OS-SRV-USG:launched_at": "2017-03-23T23:57:38.000000",
"flavor": {"id": "64", "flavor": flavor,
"links": []},
"id": server_id, "id": server_id,
"security_groups": [{"name": "default"}], "security_groups": [{"name": "default"}],
"user_id": "9c119f4beaaa438792ce89387362b3ad", "user_id": "9c119f4beaaa438792ce89387362b3ad",
@ -127,9 +140,12 @@ def make_fake_server(server_id, name, status='ACTIVE'):
"key_name": None, "key_name": None,
"name": name, "name": name,
"created": "2017-03-23T23:57:12Z", "created": "2017-03-23T23:57:12Z",
"tenant_id": "fdbf563e9d474696b35667254e65b45b", "tenant_id": PROJECT_ID,
"os-extended-volumes:volumes_attached": [], "os-extended-volumes:volumes_attached": [],
"config_drive": "True"} "config_drive": "True"}
if admin_pass:
server['adminPass'] = admin_pass
return json.loads(json.dumps(server))
def make_fake_keypair(name): def make_fake_keypair(name):
@ -242,38 +258,6 @@ class FakeFloatingIP(object):
self.instance_id = instance_id self.instance_id = instance_id
class FakeServer(object):
def __init__(
self, id, name, status, addresses=None,
accessIPv4='', accessIPv6='', private_v4='',
private_v6='', public_v4='', public_v6='',
interface_ip='',
flavor=None, image=None, adminPass=None,
metadata=None):
self.id = id
self.name = name
self.status = status
if not addresses:
self.addresses = {}
else:
self.addresses = addresses
if not flavor:
flavor = {}
self.flavor = flavor
if not image:
image = {}
self.image = image
self.accessIPv4 = accessIPv4
self.accessIPv6 = accessIPv6
self.private_v4 = private_v4
self.public_v4 = public_v4
self.private_v6 = private_v6
self.public_v6 = public_v6
self.adminPass = adminPass
self.metadata = metadata
self.interface_ip = interface_ip
class FakeServerGroup(object): class FakeServerGroup(object):
def __init__(self, id, name, policies): def __init__(self, id, name, policies):
self.id = id self.id = id
@ -354,13 +338,6 @@ class FakeNovaSecgroupRule(object):
self.parent_group_id = parent_group_id self.parent_group_id = parent_group_id
class FakeKeypair(object):
def __init__(self, id, name, public_key):
self.id = id
self.name = name
self.public_key = public_key
class FakeHypervisor(object): class FakeHypervisor(object):
def __init__(self, id, hostname): def __init__(self, id, hostname):
self.id = id self.id = id

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

@ -34,7 +34,7 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that an exception when attempting to get the server instance via Test that an exception when attempting to get the server instance via
the novaclient raises an exception in create_server. the novaclient raises an exception in create_server.
""" """
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -43,7 +43,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -66,8 +66,8 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that a server error before we return or begin waiting for the Test that a server error before we return or begin waiting for the
server instance spawn raises an exception in create_server. server instance spawn raises an exception in create_server.
""" """
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
error_server = fakes.FakeServer('1234', '', 'ERROR') error_server = fakes.make_fake_server('1234', '', 'ERROR')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -76,7 +76,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -87,7 +87,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(error_server).toDict()}), json={'server': error_server}),
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, self.cloud.create_server, exc.OpenStackCloudException, self.cloud.create_server,
@ -99,8 +99,8 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that a server error while waiting for the server to spawn Test that a server error while waiting for the server to spawn
raises an exception in create_server. raises an exception in create_server.
""" """
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
error_server = fakes.FakeServer('1234', '', 'ERROR') error_server = fakes.make_fake_server('1234', '', 'ERROR')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -109,7 +109,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -120,11 +120,11 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(build_server).toDict()]}), json={'servers': [build_server]}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(error_server).toDict()]}), json={'servers': [error_server]}),
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
@ -139,7 +139,7 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that a timeout while waiting for the server to spawn raises an Test that a timeout while waiting for the server to spawn raises an
exception in create_server. exception in create_server.
""" """
fake_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -148,7 +148,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(fake_server).toDict()}, json={'server': fake_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -159,7 +159,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(fake_server).toDict()]}), json={'servers': [fake_server]}),
]) ])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudTimeout, exc.OpenStackCloudTimeout,
@ -175,7 +175,7 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that create_server with no wait and no exception in the Test that create_server with no wait and no exception in the
novaclient create call returns the server instance. novaclient create call returns the server instance.
""" """
fake_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -184,7 +184,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(fake_server).toDict()}, json={'server': fake_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -195,11 +195,12 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(fake_server).toDict()}), json={'server': fake_server}),
]) ])
normalized = self.cloud._expand_server(
self.cloud._normalize_server(fake_server), False, False)
self.assertEqual( self.assertEqual(
self.cloud._normalize_server( normalized,
meta.obj_to_munch(fake_server)),
self.cloud.create_server( self.cloud.create_server(
name='server-name', name='server-name',
image=dict(id='image-id'), image=dict(id='image-id'),
@ -211,9 +212,10 @@ class TestCreateServer(base.RequestsMockTestCase):
""" """
Test that a server with an admin_pass passed returns the password Test that a server with an admin_pass passed returns the password
""" """
fake_server = fakes.FakeServer('1234', '', 'BUILD') admin_pass = self.getUniqueString('password')
fake_create_server = fakes.FakeServer('1234', '', 'BUILD', fake_server = fakes.make_fake_server('1234', '', 'BUILD')
adminPass='ooBootheiX0edoh') fake_create_server = fakes.make_fake_server(
'1234', '', 'BUILD', admin_pass=admin_pass)
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -222,11 +224,10 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch( json={'server': fake_create_server},
fake_create_server).toDict()},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'adminPass': 'ooBootheiX0edoh', u'adminPass': admin_pass,
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
u'imageRef': u'image-id', u'imageRef': u'image-id',
u'max_count': 1, u'max_count': 1,
@ -235,14 +236,14 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(fake_server).toDict()}), json={'server': fake_server}),
]) ])
self.assertEqual( self.assertEqual(
self.cloud._normalize_server( self.cloud._normalize_server(fake_create_server)['adminPass'],
meta.obj_to_munch(fake_create_server)),
self.cloud.create_server( self.cloud.create_server(
name='server-name', image=dict(id='image-id'), name='server-name', image=dict(id='image-id'),
flavor=dict(id='flavor-id'), admin_pass='ooBootheiX0edoh')) flavor=dict(id='flavor-id'),
admin_pass=admin_pass)['adminPass'])
self.assert_calls() self.assert_calls()
@ -251,9 +252,10 @@ class TestCreateServer(base.RequestsMockTestCase):
""" """
Test that a server with an admin_pass passed returns the password Test that a server with an admin_pass passed returns the password
""" """
fake_server = fakes.FakeServer('1234', '', 'BUILD') admin_pass = self.getUniqueString('password')
fake_server_with_pass = fakes.FakeServer('1234', '', 'BUILD', fake_server = fakes.make_fake_server('1234', '', 'BUILD')
adminPass='ooBootheiX0edoh') fake_server_with_pass = fakes.make_fake_server(
'1234', '', 'BUILD', admin_pass=admin_pass)
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -262,26 +264,24 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch( json={'server': fake_server_with_pass},
fake_server_with_pass).toDict()},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
u'imageRef': u'image-id', u'imageRef': u'image-id',
u'max_count': 1, u'max_count': 1,
u'min_count': 1, u'min_count': 1,
u'adminPass': 'ooBootheiX0edoh', u'adminPass': admin_pass,
u'name': u'server-name'}})), u'name': u'server-name'}})),
]) ])
# The wait returns non-password server # The wait returns non-password server
mock_wait.return_value = self.cloud._normalize_server( mock_wait.return_value = self.cloud._normalize_server(fake_server)
meta.obj_to_munch(fake_server))
server = self.cloud.create_server( server = self.cloud.create_server(
name='server-name', image=dict(id='image-id'), name='server-name', image=dict(id='image-id'),
flavor=dict(id='flavor-id'), flavor=dict(id='flavor-id'),
admin_pass='ooBootheiX0edoh', wait=True) admin_pass=admin_pass, wait=True)
# Assert that we did wait # Assert that we did wait
self.assertTrue(mock_wait.called) self.assertTrue(mock_wait.called)
@ -289,8 +289,7 @@ class TestCreateServer(base.RequestsMockTestCase):
# Even with the wait, we should still get back a passworded server # Even with the wait, we should still get back a passworded server
self.assertEqual( self.assertEqual(
server['adminPass'], server['adminPass'],
self.cloud._normalize_server( self.cloud._normalize_server(fake_server_with_pass)['adminPass']
meta.obj_to_munch(fake_server_with_pass))['adminPass']
) )
self.assert_calls() self.assert_calls()
@ -335,7 +334,7 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that create_server with a wait actually does the wait. Test that create_server with a wait actually does the wait.
""" """
# TODO(mordred) Make this a full proper response # TODO(mordred) Make this a full proper response
fake_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
@ -345,7 +344,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(fake_server).toDict()}, json={'server': fake_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -359,7 +358,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(id='image-id'), dict(id='flavor-id'), wait=True), dict(id='image-id'), dict(id='flavor-id'), wait=True),
mock_wait.assert_called_once_with( mock_wait.assert_called_once_with(
meta.obj_to_munch(fake_server), fake_server,
auto_ip=True, ips=None, auto_ip=True, ips=None,
ip_pool=None, reuse=True, timeout=180, ip_pool=None, reuse=True, timeout=180,
nat_destination=None, nat_destination=None,
@ -374,8 +373,9 @@ class TestCreateServer(base.RequestsMockTestCase):
Test that create_server with a wait throws an exception if the Test that create_server with a wait throws an exception if the
server doesn't have addresses. server doesn't have addresses.
""" """
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
fake_server = fakes.FakeServer('1234', '', 'ACTIVE') fake_server = fakes.make_fake_server(
'1234', '', 'ACTIVE', addresses={})
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -384,7 +384,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -395,11 +395,11 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(build_server).toDict()]}), json={'servers': [build_server]}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(fake_server).toDict()]}), json={'servers': [fake_server]}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'ports.json'], 'network', 'public', append=['v2.0', 'ports.json'],
@ -428,8 +428,7 @@ class TestCreateServer(base.RequestsMockTestCase):
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.
""" """
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.FakeServer('1234', '', 'ACTIVE')
network = { network = {
'id': 'network-id', 'id': 'network-id',
'name': 'network-name' 'name': 'network-name'
@ -442,7 +441,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -454,12 +453,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(active_server).toDict()}), json={'server': build_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'ports.json'],
qs_elements=['device_id=1234']),
json={'ports': []}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']), 'network', 'public', append=['v2.0', 'networks.json']),
@ -483,7 +477,7 @@ class TestCreateServer(base.RequestsMockTestCase):
'id': 'network-id', 'id': 'network-id',
'name': 'network-name' 'name': 'network-name'
} }
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
@ -492,7 +486,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': u'flavor-id', u'flavorRef': u'flavor-id',
@ -504,7 +498,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(build_server).toDict()}), json={'server': build_server}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']), 'network', 'public', append=['v2.0', 'networks.json']),
@ -525,8 +519,8 @@ class TestCreateServer(base.RequestsMockTestCase):
fake_image_dict = fakes.make_fake_image(image_id=image_id) fake_image_dict = fakes.make_fake_image(image_id=image_id)
fake_image_search_return = {'images': [fake_image_dict]} fake_image_search_return = {'images': [fake_image_dict]}
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.FakeServer('1234', '', 'BUILD') active_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
@ -540,7 +534,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers']), 'compute', 'public', append=['servers']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': fakes.FLAVOR_ID, u'flavorRef': fakes.FLAVOR_ID,
@ -552,7 +546,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(active_server).toDict()}), json={'server': active_server}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']), 'network', 'public', append=['v2.0', 'networks.json']),
@ -566,8 +560,8 @@ class TestCreateServer(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_create_boot_attach_volume(self): def test_create_boot_attach_volume(self):
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.FakeServer('1234', '', 'BUILD') active_server = fakes.make_fake_server('1234', '', 'BUILD')
vol = {'id': 'volume001', 'status': 'available', vol = {'id': 'volume001', 'status': 'available',
'name': '', 'attachments': []} 'name': '', 'attachments': []}
@ -581,7 +575,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['os-volumes_boot']), 'compute', 'public', append=['os-volumes_boot']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': 'flavor-id', u'flavorRef': 'flavor-id',
@ -608,7 +602,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(active_server).toDict()}), json={'server': active_server}),
]) ])
self.cloud.create_server( self.cloud.create_server(
@ -622,8 +616,8 @@ class TestCreateServer(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_create_boot_from_volume_image_terminate(self): def test_create_boot_from_volume_image_terminate(self):
build_server = fakes.FakeServer('1234', '', 'BUILD') build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.FakeServer('1234', '', 'BUILD') active_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
@ -633,7 +627,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['os-volumes_boot']), 'compute', 'public', append=['os-volumes_boot']),
json={'server': meta.obj_to_munch(build_server).toDict()}, json={'server': build_server},
validate=dict( validate=dict(
json={'server': { json={'server': {
u'flavorRef': 'flavor-id', u'flavorRef': 'flavor-id',
@ -651,7 +645,7 @@ class TestCreateServer(base.RequestsMockTestCase):
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']), 'compute', 'public', append=['servers', '1234']),
json={'server': meta.obj_to_munch(active_server).toDict()}), json={'server': active_server}),
]) ])
self.cloud.create_server( self.cloud.create_server(

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

@ -18,7 +18,6 @@ Tests for the `delete_server` command.
""" """
from shade import exc as shade_exc from shade import exc as shade_exc
from shade import meta
from shade.tests import fakes from shade.tests import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -29,12 +28,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
""" """
Test that server delete is called when wait=False Test that server delete is called when wait=False
""" """
server = fakes.FakeServer('1234', 'daffy', 'ACTIVE') server = fakes.make_fake_server('1234', 'daffy', 'ACTIVE')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(server).toDict()]}), json={'servers': [server]}),
dict(method='DELETE', dict(method='DELETE',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])), 'compute', 'public', append=['servers', '1234'])),
@ -71,19 +70,19 @@ class TestDeleteServer(base.RequestsMockTestCase):
""" """
Test that delete_server waits for the server to be gone Test that delete_server waits for the server to be gone
""" """
server = fakes.FakeServer('9999', 'wily', 'ACTIVE') server = fakes.make_fake_server('9999', 'wily', 'ACTIVE')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(server).toDict()]}), json={'servers': [server]}),
dict(method='DELETE', dict(method='DELETE',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '9999'])), 'compute', 'public', append=['servers', '9999'])),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(server).toDict()]}), json={'servers': [server]}),
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
@ -97,12 +96,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
""" """
Test that delete_server raises non-404 exceptions Test that delete_server raises non-404 exceptions
""" """
server = fakes.FakeServer('1212', 'speedy', 'ACTIVE') server = fakes.make_fake_server('1212', 'speedy', 'ACTIVE')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(server).toDict()]}), json={'servers': [server]}),
dict(method='DELETE', dict(method='DELETE',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1212']), 'compute', 'public', append=['servers', '1212']),
@ -128,12 +127,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
return orig_has_service(service_type) return orig_has_service(service_type)
self.cloud.has_service = fake_has_service self.cloud.has_service = fake_has_service
server = fakes.FakeServer('1234', 'porky', 'ACTIVE') server = fakes.make_fake_server('1234', 'porky', 'ACTIVE')
self.register_uris([ self.register_uris([
dict(method='GET', dict(method='GET',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']), 'compute', 'public', append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(server).toDict()]}), json={'servers': [server]}),
dict(method='DELETE', dict(method='DELETE',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])), 'compute', 'public', append=['servers', '1234'])),

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

@ -23,7 +23,7 @@ from mock import patch
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 import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -35,10 +35,10 @@ class TestFloatingIP(base.TestCase):
def test_add_auto_ip( def test_add_auto_ip(
self, mock_available_floating_ip, mock_attach_ip_to_server, self, mock_available_floating_ip, mock_attach_ip_to_server,
mock_get_floating_ip): mock_get_floating_ip):
server = FakeServer( server_dict = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", addresses={} server_id='server-id', name='test-server', status="ACTIVE",
addresses={}
) )
server_dict = meta.obj_to_munch(server)
floating_ip_dict = { floating_ip_dict = {
"id": "this-is-a-floating-ip-id", "id": "this-is-a-floating-ip-id",
"fixed_ip_address": None, "fixed_ip_address": None,
@ -59,10 +59,9 @@ class TestFloatingIP(base.TestCase):
@patch.object(OpenStackCloud, '_add_ip_from_pool') @patch.object(OpenStackCloud, '_add_ip_from_pool')
def test_add_ips_to_server_pool(self, mock_add_ip_from_pool): def test_add_ips_to_server_pool(self, mock_add_ip_from_pool):
server = FakeServer( server_dict = fakes.make_fake_server(
id='romeo', name='test-server', status="ACTIVE", addresses={} server_id='romeo', name='test-server', status="ACTIVE",
) addresses={})
server_dict = meta.obj_to_munch(server)
pool = 'nova' pool = 'nova'
self.cloud.add_ips_to_server(server_dict, ip_pool=pool) self.cloud.add_ips_to_server(server_dict, ip_pool=pool)
@ -82,8 +81,8 @@ class TestFloatingIP(base.TestCase):
self.cloud.force_ipv4 = False self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = True self.cloud._local_ipv6 = True
mock_has_service.return_value = False mock_has_service.return_value = False
server = FakeServer( server = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", server_id='server-id', name='test-server', status="ACTIVE",
addresses={ addresses={
'private': [{ 'private': [{
'addr': "10.223.160.141", 'addr': "10.223.160.141",
@ -97,8 +96,7 @@ class TestFloatingIP(base.TestCase):
}] }]
} }
) )
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(self.cloud, server)
self.cloud, meta.obj_to_munch(server))
new_server = self.cloud.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()
@ -122,8 +120,8 @@ class TestFloatingIP(base.TestCase):
self.cloud.force_ipv4 = False self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = True self.cloud._local_ipv6 = True
mock_has_service.return_value = False mock_has_service.return_value = False
server = FakeServer( server = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", server_id='server-id', name='test-server', status="ACTIVE",
addresses={ addresses={
'private': [{ 'private': [{
'addr': "10.223.160.141", 'addr': "10.223.160.141",
@ -138,8 +136,7 @@ class TestFloatingIP(base.TestCase):
}] }]
} }
) )
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(self.cloud, server)
self.cloud, meta.obj_to_munch(server))
new_server = self.cloud.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()
@ -159,8 +156,8 @@ class TestFloatingIP(base.TestCase):
self.cloud.force_ipv4 = False self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = False self.cloud._local_ipv6 = False
mock_has_service.return_value = False mock_has_service.return_value = False
server = FakeServer( server = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", server_id='server-id', name='test-server', status="ACTIVE",
addresses={ addresses={
'private': [{ 'private': [{
'addr': "10.223.160.141", 'addr': "10.223.160.141",
@ -175,8 +172,7 @@ class TestFloatingIP(base.TestCase):
}] }]
} }
) )
server_dict = meta.add_server_interfaces( server_dict = meta.add_server_interfaces(self.cloud, server)
self.cloud, meta.obj_to_munch(server))
new_server = self.cloud.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()
@ -185,10 +181,9 @@ class TestFloatingIP(base.TestCase):
@patch.object(OpenStackCloud, 'add_ip_list') @patch.object(OpenStackCloud, 'add_ip_list')
def test_add_ips_to_server_ip_list(self, mock_add_ip_list): def test_add_ips_to_server_ip_list(self, mock_add_ip_list):
server = FakeServer( server_dict = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", addresses={} server_id='server-id', name='test-server', status="ACTIVE",
) addresses={})
server_dict = meta.obj_to_munch(server)
ips = ['203.0.113.29', '172.24.4.229'] ips = ['203.0.113.29', '172.24.4.229']
self.cloud.add_ips_to_server(server_dict, ips=ips) self.cloud.add_ips_to_server(server_dict, ips=ips)
@ -200,10 +195,9 @@ class TestFloatingIP(base.TestCase):
@patch.object(OpenStackCloud, '_add_auto_ip') @patch.object(OpenStackCloud, '_add_auto_ip')
def test_add_ips_to_server_auto_ip( def test_add_ips_to_server_auto_ip(
self, mock_add_auto_ip, mock_needs_floating_ip): self, mock_add_auto_ip, mock_needs_floating_ip):
server = FakeServer( server_dict = fakes.make_fake_server(
id='server-id', name='test-server', status="ACTIVE", addresses={} server_id='server-id', name='test-server', status="ACTIVE",
) addresses={})
server_dict = meta.obj_to_munch(server)
# TODO(mordred) REMOVE THIS MOCK WHEN THE NEXT PATCH LANDS # TODO(mordred) REMOVE THIS MOCK WHEN THE NEXT PATCH LANDS
# SERIOUSLY THIS TIME. NEXT PATCH - WHICH SHOULD ADD MOCKS FOR # SERIOUSLY THIS TIME. NEXT PATCH - WHICH SHOULD ADD MOCKS FOR

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

@ -24,7 +24,6 @@ import datetime
import munch import munch
from shade import exc from shade import exc
from shade import meta
from shade.tests import fakes from shade.tests import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -136,15 +135,14 @@ class TestFloatingIP(base.RequestsMockTestCase):
def setUp(self): def setUp(self):
super(TestFloatingIP, self).setUp() super(TestFloatingIP, self).setUp()
self.fake_server = meta.obj_to_munch( self.fake_server = fakes.make_fake_server(
fakes.FakeServer( 'server-id', '', 'ACTIVE',
'server-id', '', 'ACTIVE', addresses={u'test_pnztt_net': [{
addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed',
u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129',
u'addr': '192.0.2.129', u'version': 4,
u'version': 4, u'OS-EXT-IPS-MAC:mac_addr':
u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'}]})
u'fa:16:3e:ae:7d:42'}]}))
self.floating_ip = self.cloud._normalize_floating_ips( self.floating_ip = self.cloud._normalize_floating_ips(
self.mock_floating_ip_list_rep['floatingips'])[0] self.mock_floating_ip_list_rep['floatingips'])[0]

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

@ -19,7 +19,6 @@ test_floating_ip_nova
Tests Floating IP resource methods for nova-network Tests Floating IP resource methods for nova-network
""" """
from shade import meta
from shade.tests import fakes from shade.tests import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -68,15 +67,14 @@ class TestFloatingIP(base.RequestsMockTestCase):
def setUp(self): def setUp(self):
super(TestFloatingIP, self).setUp() super(TestFloatingIP, self).setUp()
self.fake_server = meta.obj_to_munch( self.fake_server = fakes.make_fake_server(
fakes.FakeServer( 'server-id', '', 'ACTIVE',
'server-id', '', 'ACTIVE', addresses={u'test_pnztt_net': [{
addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed',
u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129',
u'addr': '192.0.2.129', u'version': 4,
u'version': 4, u'OS-EXT-IPS-MAC:mac_addr':
u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'}]})
u'fa:16:3e:ae:7d:42'}]}))
self.cloud.has_service = get_fake_has_service(self.cloud.has_service) self.cloud.has_service = get_fake_has_service(self.cloud.has_service)
@ -239,7 +237,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'compute',
append=['servers', self.fake_server.id, 'action']), append=['servers', self.fake_server['id'], 'action']),
validate=dict( validate=dict(
json={ json={
"addFloatingIp": { "addFloatingIp": {
@ -264,7 +262,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'compute',
append=['servers', self.fake_server.id, 'action']), append=['servers', self.fake_server['id'], 'action']),
validate=dict( validate=dict(
json={ json={
"removeFloatingIp": { "removeFloatingIp": {
@ -287,7 +285,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
dict(method='POST', dict(method='POST',
uri=self.get_mock_url( uri=self.get_mock_url(
'compute', 'compute',
append=['servers', self.fake_server.id, 'action']), append=['servers', self.fake_server['id'], 'action']),
validate=dict( validate=dict(
json={ json={
"addFloatingIp": { "addFloatingIp": {

5
shade/tests/unit/test_inventory.py
View File

@ -18,7 +18,6 @@ from os_client_config import exceptions as occ_exc
from shade import exc from shade import exc
from shade import inventory from shade import inventory
from shade import meta
from shade.tests import fakes from shade.tests import fakes
from shade.tests.unit import base from shade.tests.unit import base
@ -101,8 +100,8 @@ class TestInventory(base.TestCase):
inv = inventory.OpenStackInventory() inv = inventory.OpenStackInventory()
server = self.cloud._normalize_server( server = self.cloud._normalize_server(
meta.obj_to_munch(fakes.FakeServer( fakes.make_fake_server(
'1234', 'test', 'ACTIVE', addresses={}))) '1234', 'test', 'ACTIVE', addresses={}))
self.assertIsInstance(inv.clouds, list) self.assertIsInstance(inv.clouds, list)
self.assertEqual(1, len(inv.clouds)) self.assertEqual(1, len(inv.clouds))
inv.clouds[0].list_servers.return_value = [server] inv.clouds[0].list_servers.return_value = [server]

128
shade/tests/unit/test_meta.py
View File

@ -75,11 +75,10 @@ class FakeCloud(object):
def get_default_network(self): def get_default_network(self):
return None return None
standard_fake_server = fakes.FakeServer( standard_fake_server = fakes.make_fake_server(
id='test-id-0', server_id='test-id-0',
name='test-id-0', name='test-id-0',
status='ACTIVE', status='ACTIVE',
metadata={'group': 'test-group'},
addresses={'private': [{'OS-EXT-IPS:type': 'fixed', addresses={'private': [{'OS-EXT-IPS:type': 'fixed',
'addr': PRIVATE_V4, 'addr': PRIVATE_V4,
'version': 4}], 'version': 4}],
@ -88,9 +87,8 @@ standard_fake_server = fakes.FakeServer(
'version': 4}]}, 'version': 4}]},
flavor={'id': '101'}, flavor={'id': '101'},
image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'}, image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'},
accessIPv4='',
accessIPv6='',
) )
standard_fake_server['metadata'] = {'group': 'test-group'}
SUBNETS_WITH_NAT = [ SUBNETS_WITH_NAT = [
{ {
@ -286,15 +284,15 @@ class TestMeta(base.RequestsMockTestCase):
json={'subnets': SUBNETS_WITH_NAT}) json={'subnets': SUBNETS_WITH_NAT})
]) ])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'private': [{'OS-EXT-IPS:type': 'fixed', addresses={'private': [{'OS-EXT-IPS:type': 'fixed',
'addr': PRIVATE_V4, 'addr': PRIVATE_V4,
'version': 4}], 'version': 4}],
'public': [{'OS-EXT-IPS:type': 'floating', 'public': [{'OS-EXT-IPS:type': 'floating',
'addr': PUBLIC_V4, 'addr': PUBLIC_V4,
'version': 4}]} 'version': 4}]}
)) )
self.assertEqual( self.assertEqual(
PRIVATE_V4, meta.get_server_private_ip(srv, self.cloud)) PRIVATE_V4, meta.get_server_private_ip(srv, self.cloud))
@ -315,8 +313,8 @@ class TestMeta(base.RequestsMockTestCase):
shared_mac = '11:22:33:44:55:66' shared_mac = '11:22:33:44:55:66'
distinct_mac = '66:55:44:33:22:11' distinct_mac = '66:55:44:33:22:11'
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{'OS-EXT-IPS:type': 'fixed', addresses={'test-net': [{'OS-EXT-IPS:type': 'fixed',
'OS-EXT-IPS-MAC:mac_addr': distinct_mac, 'OS-EXT-IPS-MAC:mac_addr': distinct_mac,
'addr': '10.0.0.100', 'addr': '10.0.0.100',
@ -329,7 +327,7 @@ class TestMeta(base.RequestsMockTestCase):
'OS-EXT-IPS-MAC:mac_addr': shared_mac, 'OS-EXT-IPS-MAC:mac_addr': shared_mac,
'addr': PUBLIC_V4, 'addr': PUBLIC_V4,
'version': 4}]} 'version': 4}]}
)) )
self.assertEqual( self.assertEqual(
'10.0.0.101', meta.get_server_private_ip(srv, self.cloud)) '10.0.0.101', meta.get_server_private_ip(srv, self.cloud))
@ -383,8 +381,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -395,7 +393,7 @@ class TestMeta(base.RequestsMockTestCase):
u'version': 4, u'version': 4,
u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42' u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'
}]} }]}
))) ))
self.assertEqual(PRIVATE_V4, srv['private_v4']) self.assertEqual(PRIVATE_V4, srv['private_v4'])
self.assert_calls() self.assert_calls()
@ -433,8 +431,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -445,7 +443,7 @@ class TestMeta(base.RequestsMockTestCase):
u'version': 4, u'version': 4,
u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42' u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'
}]} }]}
))) ))
self.assertEqual(PRIVATE_V4, srv['private_v4']) self.assertEqual(PRIVATE_V4, srv['private_v4'])
self.assert_calls() self.assert_calls()
@ -483,8 +481,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -493,7 +491,7 @@ class TestMeta(base.RequestsMockTestCase):
u'addr': PRIVATE_V4, u'addr': PRIVATE_V4,
u'version': 4, u'version': 4,
}]} }]}
))) ))
self.assertEqual(PRIVATE_V4, srv['private_v4']) self.assertEqual(PRIVATE_V4, srv['private_v4'])
self.assert_calls() self.assert_calls()
@ -551,8 +549,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -562,7 +560,7 @@ class TestMeta(base.RequestsMockTestCase):
u'version': 4, u'version': 4,
'OS-EXT-IPS-MAC:mac_addr': 'fa:16:3e:ae:7d:42', 'OS-EXT-IPS-MAC:mac_addr': 'fa:16:3e:ae:7d:42',
}]} }]}
))) ))
self.assertEqual(PUBLIC_V4, srv['public_v4']) self.assertEqual(PUBLIC_V4, srv['public_v4'])
self.assert_calls() self.assert_calls()
@ -588,8 +586,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -607,7 +605,7 @@ class TestMeta(base.RequestsMockTestCase):
'version': 6 'version': 6
}] }]
} }
))) ))
self.assertEqual("10.223.160.141", srv['private_v4']) self.assertEqual("10.223.160.141", srv['private_v4'])
self.assertEqual("104.130.246.91", srv['public_v4']) self.assertEqual("104.130.246.91", srv['public_v4'])
@ -647,8 +645,8 @@ class TestMeta(base.RequestsMockTestCase):
json={'security_groups': []}) json={'security_groups': []})
]) ])
srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer( srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'}, flavor={u'id': u'1'},
image={ image={
'name': u'cirros-0.3.4-x86_64-uec', 'name': u'cirros-0.3.4-x86_64-uec',
@ -666,7 +664,7 @@ class TestMeta(base.RequestsMockTestCase):
'version': 6 'version': 6
}] }]
} }
))) ))
self.assertEqual("10.223.160.141", srv['private_v4']) self.assertEqual("10.223.160.141", srv['private_v4'])
self.assertEqual("104.130.246.91", srv['public_v4']) self.assertEqual("104.130.246.91", srv['public_v4'])
@ -690,12 +688,12 @@ class TestMeta(base.RequestsMockTestCase):
uri='https://network.example.com/v2.0/subnets.json', uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT}) json={'subnets': SUBNETS_WITH_NAT})
]) ])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{ addresses={'test-net': [{
'addr': PUBLIC_V4, 'addr': PUBLIC_V4,
'version': 4}]}, 'version': 4}]},
)) )
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip) self.assertEqual(PUBLIC_V4, ip)
@ -717,12 +715,12 @@ class TestMeta(base.RequestsMockTestCase):
json={'subnets': SUBNETS_WITH_NAT}) json={'subnets': SUBNETS_WITH_NAT})
]) ])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{ addresses={'test-net': [{
'addr': PUBLIC_V4, 'addr': PUBLIC_V4,
'version': 4}]}, 'version': 4}]},
)) )
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip) self.assertEqual(PUBLIC_V4, ip)
@ -744,12 +742,12 @@ class TestMeta(base.RequestsMockTestCase):
uri='https://network.example.com/v2.0/subnets.json', uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT}) json={'subnets': SUBNETS_WITH_NAT})
]) ])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{ addresses={'test-net': [{
'addr': PRIVATE_V4, 'addr': PRIVATE_V4,
'version': 4}]}, 'version': 4}]},
)) )
self.assertIsNone( self.assertIsNone(
meta.get_server_external_ipv4(cloud=self.cloud, server=srv)) meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv) int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
@ -772,29 +770,29 @@ class TestMeta(base.RequestsMockTestCase):
json={'subnets': SUBNETS_WITH_NAT}) json={'subnets': SUBNETS_WITH_NAT})
]) ])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{ addresses={'test-net': [{
'addr': PUBLIC_V4, 'addr': PUBLIC_V4,
'version': 4}]}, 'version': 4}]},
)) )
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(None, ip) self.assertEqual(None, ip)
self.assert_calls() self.assert_calls()
def test_get_server_external_ipv4_neutron_accessIPv4(self): def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE')
accessIPv4=PUBLIC_V4)) srv['accessIPv4'] = PUBLIC_V4
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip) self.assertEqual(PUBLIC_V4, ip)
def test_get_server_external_ipv4_neutron_accessIPv6(self): def test_get_server_external_ipv4_neutron_accessIPv6(self):
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE')
accessIPv6=PUBLIC_V6)) srv['accessIPv6'] = PUBLIC_V6
ip = meta.get_server_external_ipv6(server=srv) ip = meta.get_server_external_ipv6(server=srv)
self.assertEqual(PUBLIC_V6, ip) self.assertEqual(PUBLIC_V6, ip)
@ -806,10 +804,10 @@ class TestMeta(base.RequestsMockTestCase):
uri='https://network.example.com/v2.0/networks.json', uri='https://network.example.com/v2.0/networks.json',
status_code=404)]) status_code=404)])
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]} addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]}
)) )
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip) self.assertEqual(PUBLIC_V4, ip)
@ -819,9 +817,9 @@ class TestMeta(base.RequestsMockTestCase):
# Testing Clouds w/o Neutron and a network named public # Testing Clouds w/o Neutron and a network named public
self.cloud.cloud_config.config['has_network'] = False self.cloud.cloud_config.config['has_network'] = False
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]})) addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]})
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip) self.assertEqual(PUBLIC_V4, ip)
@ -830,23 +828,23 @@ class TestMeta(base.RequestsMockTestCase):
# Testing Clouds w/o Neutron or a globally routable IP # Testing Clouds w/o Neutron or a globally routable IP
self.cloud.cloud_config.config['has_network'] = False self.cloud.cloud_config.config['has_network'] = False
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{'addr': PRIVATE_V4}]})) addresses={'test-net': [{'addr': PRIVATE_V4}]})
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertIsNone(ip) self.assertIsNone(ip)
def test_get_server_external_ipv6(self): def test_get_server_external_ipv6(self):
srv = meta.obj_to_munch(fakes.FakeServer( srv = fakes.make_fake_server(
id='test-id', name='test-name', status='ACTIVE', server_id='test-id', name='test-name', status='ACTIVE',
addresses={ addresses={
'test-net': [ 'test-net': [
{'addr': PUBLIC_V4, 'version': 4}, {'addr': PUBLIC_V4, 'version': 4},
{'addr': PUBLIC_V6, 'version': 6} {'addr': PUBLIC_V6, 'version': 6}
] ]
} }
)) )
ip = meta.get_server_external_ipv6(srv) ip = meta.get_server_external_ipv6(srv)
self.assertEqual(PUBLIC_V6, ip) self.assertEqual(PUBLIC_V6, ip)
@ -925,10 +923,10 @@ class TestMeta(base.RequestsMockTestCase):
self.assertEqual('admin', hostvars['location']['project']['name']) self.assertEqual('admin', hostvars['location']['project']['name'])
self.assertEqual("test-image-name", hostvars['image']['name']) self.assertEqual("test-image-name", hostvars['image']['name'])
self.assertEqual( self.assertEqual(
standard_fake_server.image['id'], hostvars['image']['id']) standard_fake_server['image']['id'], hostvars['image']['id'])
self.assertNotIn('links', hostvars['image']) self.assertNotIn('links', hostvars['image'])
self.assertEqual( self.assertEqual(
standard_fake_server.flavor['id'], hostvars['flavor']['id']) standard_fake_server['flavor']['id'], hostvars['flavor']['id'])
self.assertEqual("test-flavor-name", hostvars['flavor']['name']) self.assertEqual("test-flavor-name", hostvars['flavor']['name'])
self.assertNotIn('links', hostvars['flavor']) self.assertNotIn('links', hostvars['flavor'])
# test having volumes # test having volumes
@ -964,14 +962,14 @@ class TestMeta(base.RequestsMockTestCase):
mock_get_server_external_ipv4.return_value = PUBLIC_V4 mock_get_server_external_ipv4.return_value = PUBLIC_V4
server = standard_fake_server server = standard_fake_server
server.image = 'fake-image-id' server['image'] = 'fake-image-id'
hostvars = meta.get_hostvars_from_server( hostvars = meta.get_hostvars_from_server(
FakeCloud(), meta.obj_to_munch(server)) FakeCloud(), meta.obj_to_munch(server))
self.assertEqual('fake-image-id', hostvars['image']['id']) self.assertEqual('fake-image-id', hostvars['image']['id'])
def test_az(self): def test_az(self):
server = standard_fake_server server = standard_fake_server
server.__dict__['OS-EXT-AZ:availability_zone'] = 'az1' server['OS-EXT-AZ:availability_zone'] = 'az1'
hostvars = self.cloud._normalize_server(meta.obj_to_munch(server)) hostvars = self.cloud._normalize_server(meta.obj_to_munch(server))
self.assertEqual('az1', hostvars['az']) self.assertEqual('az1', hostvars['az'])
@ -1036,12 +1034,12 @@ class TestMeta(base.RequestsMockTestCase):
def test_obj_to_munch(self): def test_obj_to_munch(self):
cloud = FakeCloud() cloud = FakeCloud()
cloud.server = standard_fake_server cloud.subcloud = FakeCloud()
cloud_dict = meta.obj_to_munch(cloud) cloud_dict = meta.obj_to_munch(cloud)
self.assertEqual(FakeCloud.name, cloud_dict['name']) self.assertEqual(FakeCloud.name, cloud_dict['name'])
self.assertNotIn('_unused', cloud_dict) self.assertNotIn('_unused', cloud_dict)
self.assertNotIn('get_flavor_name', cloud_dict) self.assertNotIn('get_flavor_name', cloud_dict)
self.assertNotIn('server', cloud_dict) self.assertNotIn('subcloud', cloud_dict)
self.assertTrue(hasattr(cloud_dict, 'name')) self.assertTrue(hasattr(cloud_dict, 'name'))
self.assertEqual(cloud_dict.name, cloud_dict['name']) self.assertEqual(cloud_dict.name, cloud_dict['name'])

12
shade/tests/unit/test_security_groups.py
View File

@ -617,7 +617,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
def test_add_security_group_to_server_neutron(self): def test_add_security_group_to_server_neutron(self):
# fake to get server by name, server-name must match # fake to get server by name, server-name must match
fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE') fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
# use neutron for secgroup list and return an existing fake # use neutron for secgroup list and return an existing fake
self.cloud.secgroup_source = 'neutron' self.cloud.secgroup_source = 'neutron'
@ -669,7 +669,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
def test_remove_security_group_from_server_neutron(self): def test_remove_security_group_from_server_neutron(self):
# fake to get server by name, server-name must match # fake to get server by name, server-name must match
fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE') fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
# use neutron for secgroup list and return an existing fake # use neutron for secgroup list and return an existing fake
self.cloud.secgroup_source = 'neutron' self.cloud.secgroup_source = 'neutron'
@ -697,8 +697,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
def test_add_bad_security_group_to_server_nova(self): def test_add_bad_security_group_to_server_nova(self):
# fake to get server by name, server-name must match # fake to get server by name, server-name must match
fake_server = meta.obj_to_munch( fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
fakes.FakeServer('1234', 'server-name', 'ACTIVE'))
# use nova for secgroup list and return an existing fake # use nova for secgroup list and return an existing fake
self.has_neutron = False self.has_neutron = False
@ -724,7 +723,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
def test_add_bad_security_group_to_server_neutron(self): def test_add_bad_security_group_to_server_neutron(self):
# fake to get server by name, server-name must match # fake to get server by name, server-name must match
fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE') fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
# use neutron for secgroup list and return an existing fake # use neutron for secgroup list and return an existing fake
self.cloud.secgroup_source = 'neutron' self.cloud.secgroup_source = 'neutron'
@ -747,8 +746,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
def test_add_security_group_to_bad_server(self): def test_add_security_group_to_bad_server(self):
# fake to get server by name, server-name must match # fake to get server by name, server-name must match
fake_server = meta.obj_to_munch( fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
fakes.FakeServer('1234', 'server-name', 'ACTIVE'))
self.register_uris([ self.register_uris([
dict( dict(