openstack/nova
Code Issues Proposed changes

Fix invalid uuid warnings

Browse Source 
Currently, unit testcases of conductor, image and network
emit FutureWarnings from oslo.versionedobjects about invalid
uuids as documented here[1].

This commit changes these tests to use valid uuids so
that when they are run these warnings are no longer emitted.

Fake constants are defined for project_id and user_id as they
are used without '-' at keystone side

[1] http://docs.openstack.org/developer/oslo.versionedobjects/api/fields.html#oslo_versionedobjects.fields.UUIDField

Partial-Bug: #1557378
Change-Id: I93cd3782e5b40e381d15bacbe8720a8c4a3bef45
This commit is contained in:
srushti 2016-03-30 05:40:26 +00:00 committed by Srushti Gadadare
parent 433edb6cf6
commit 60aa0a18c6
8 changed files with 260 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
nova/tests/unit/conductor/tasks/test_live_migrate.py
View File

@ -24,6 +24,7 @@ from nova.scheduler import utils as scheduler_utils
from nova import servicegroup from nova import servicegroup
from nova import test from nova import test
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
from nova.tests import uuidsentinel as uuids
from nova import utils from nova import utils
@ -32,7 +33,7 @@ class LiveMigrationTaskTestCase(test.NoDBTestCase):
super(LiveMigrationTaskTestCase, self).setUp() super(LiveMigrationTaskTestCase, self).setUp()
self.context = "context" self.context = "context"
self.instance_host = "host" self.instance_host = "host"
self.instance_uuid = "uuid" self.instance_uuid = uuids.instance
self.instance_image = "image_ref" self.instance_image = "image_ref"
db_instance = fake_instance.fake_db_instance( db_instance = fake_instance.fake_db_instance(
host=self.instance_host, host=self.instance_host,

38
nova/tests/unit/conductor/test_conductor.py
View File

@ -46,6 +46,7 @@ from nova.scheduler import client as scheduler_client
from nova.scheduler import utils as scheduler_utils from nova.scheduler import utils as scheduler_utils
from nova import test from nova import test
from nova.tests import fixtures from nova.tests import fixtures
from nova.tests.unit.api.openstack import fakes
from nova.tests.unit import cast_as_call from nova.tests.unit import cast_as_call
from nova.tests.unit.compute import test_compute from nova.tests.unit.compute import test_compute
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
@ -53,6 +54,7 @@ from nova.tests.unit import fake_notifier
from nova.tests.unit import fake_request_spec from nova.tests.unit import fake_request_spec
from nova.tests.unit import fake_server_actions from nova.tests.unit import fake_server_actions
from nova.tests.unit import fake_utils from nova.tests.unit import fake_utils
from nova.tests import uuidsentinel as uuids
from nova import utils from nova import utils
@ -67,8 +69,8 @@ class FakeContext(context.RequestContext):
class _BaseTestCase(object): class _BaseTestCase(object):
def setUp(self): def setUp(self):
super(_BaseTestCase, self).setUp() super(_BaseTestCase, self).setUp()
self.user_id = 'fake' self.user_id = fakes.FAKE_USER_ID
self.project_id = 'fake' self.project_id = fakes.FAKE_PROJECT_ID
self.context = FakeContext(self.user_id, self.project_id) self.context = FakeContext(self.user_id, self.project_id)
fake_notifier.stub_notifier(self.stubs) fake_notifier.stub_notifier(self.stubs)
@ -280,8 +282,8 @@ class ConductorImportTest(test.NoDBTestCase):
class _BaseTaskTestCase(object): class _BaseTaskTestCase(object):
def setUp(self): def setUp(self):
super(_BaseTaskTestCase, self).setUp() super(_BaseTaskTestCase, self).setUp()
self.user_id = 'fake' self.user_id = fakes.FAKE_USER_ID
self.project_id = 'fake' self.project_id = fakes.FAKE_PROJECT_ID
self.context = FakeContext(self.user_id, self.project_id) self.context = FakeContext(self.user_id, self.project_id)
fake_server_actions.stub_out_action_events(self.stubs) fake_server_actions.stub_out_action_events(self.stubs)
@ -1245,7 +1247,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
@mock.patch.object(live_migrate.LiveMigrationTask, 'execute') @mock.patch.object(live_migrate.LiveMigrationTask, 'execute')
def _test_migrate_server_deals_with_expected_exceptions(self, ex, def _test_migrate_server_deals_with_expected_exceptions(self, ex,
mock_execute, mock_set): mock_execute, mock_set):
instance = fake_instance.fake_db_instance(uuid='uuid', instance = fake_instance.fake_db_instance(uuid=uuids.instance,
vm_state=vm_states.ACTIVE) vm_state=vm_states.ACTIVE)
inst_obj = objects.Instance._from_db_object( inst_obj = objects.Instance._from_db_object(
self.context, objects.Instance(), instance, []) self.context, objects.Instance(), instance, [])
@ -1266,7 +1268,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
ex, self._build_request_spec(inst_obj)) ex, self._build_request_spec(inst_obj))
def test_migrate_server_deals_with_invalidcpuinfo_exception(self): def test_migrate_server_deals_with_invalidcpuinfo_exception(self):
instance = fake_instance.fake_db_instance(uuid='uuid', instance = fake_instance.fake_db_instance(uuid=uuids.instance,
vm_state=vm_states.ACTIVE) vm_state=vm_states.ACTIVE)
inst_obj = objects.Instance._from_db_object( inst_obj = objects.Instance._from_db_object(
self.context, objects.Instance(), instance, []) self.context, objects.Instance(), instance, [])
@ -1370,8 +1372,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
vm_state=vm_states.ACTIVE, vm_state=vm_states.ACTIVE,
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
request_spec = dict(instance_type=dict(extra_specs=dict()), request_spec = dict(instance_type=dict(extra_specs=dict()),
instance_properties=dict()) instance_properties=dict())
filter_props = dict(context=None) filter_props = dict(context=None)
@ -1421,8 +1423,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
image = 'fake-image' image = 'fake-image'
request_spec = dict(instance_type=dict(extra_specs=dict()), request_spec = dict(instance_type=dict(extra_specs=dict()),
instance_properties=dict(), instance_properties=dict(),
@ -1463,8 +1465,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
request_spec = dict(instance_type=dict(extra_specs=dict()), request_spec = dict(instance_type=dict(extra_specs=dict()),
instance_properties=dict()) instance_properties=dict())
filter_props = dict(context=None) filter_props = dict(context=None)
@ -1507,8 +1509,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
request_spec = dict(instance_type=dict(extra_specs=dict()), request_spec = dict(instance_type=dict(extra_specs=dict()),
instance_properties=dict()) instance_properties=dict())
filter_props = dict(context=None) filter_props = dict(context=None)
@ -1550,8 +1552,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
image = 'fake-image' image = 'fake-image'
request_spec = dict(instance_type=dict(), request_spec = dict(instance_type=dict(),
instance_properties=dict(), instance_properties=dict(),
@ -1605,8 +1607,8 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=flavor['id'],
system_metadata={}, system_metadata={},
uuid='fake', uuid=uuids.instance,
user_id='fake') user_id=fakes.FAKE_USER_ID)
request_spec = dict(instance_type=dict(extra_specs=dict()), request_spec = dict(instance_type=dict(extra_specs=dict()),
instance_properties=dict()) instance_properties=dict())

11
nova/tests/unit/image/test_glance.py
View File

@ -29,6 +29,7 @@ from nova import context
from nova import exception from nova import exception
from nova.image import glance from nova.image import glance
from nova import test from nova import test
from nova.tests import uuidsentinel as uuids
CONF = nova.conf.CONF CONF = nova.conf.CONF
NOW_GLANCE_FORMAT = "2010-10-11T10:30:22.000000" NOW_GLANCE_FORMAT = "2010-10-11T10:30:22.000000"
@ -724,7 +725,7 @@ class TestDownloadSignatureVerification(test.NoDBTestCase):
'properties': { 'properties': {
'img_signature': 'signature', 'img_signature': 'signature',
'img_signature_hash_method': 'SHA-224', 'img_signature_hash_method': 'SHA-224',
'img_signature_certificate_uuid': 'uuid', 'img_signature_certificate_uuid': uuids.img_sig_cert_uuid,
'img_signature_key_type': 'RSA-PSS', 'img_signature_key_type': 'RSA-PSS',
} }
} }
@ -745,7 +746,9 @@ class TestDownloadSignatureVerification(test.NoDBTestCase):
res = self.service.download(context=None, image_id=None, res = self.service.download(context=None, image_id=None,
data=None, dst_path=None) data=None, dst_path=None)
self.assertEqual(self.fake_img_data, res) self.assertEqual(self.fake_img_data, res)
mock_get_verifier.assert_called_once_with(None, 'uuid', 'SHA-224', mock_get_verifier.assert_called_once_with(None,
uuids.img_sig_cert_uuid,
'SHA-224',
'signature', 'RSA-PSS') 'signature', 'RSA-PSS')
mock_log.info.assert_called_once_with(mock.ANY, mock.ANY) mock_log.info.assert_called_once_with(mock.ANY, mock.ANY)
@ -765,7 +768,9 @@ class TestDownloadSignatureVerification(test.NoDBTestCase):
mock_open.return_value = mock_dest mock_open.return_value = mock_dest
self.service.download(context=None, image_id=None, self.service.download(context=None, image_id=None,
data=None, dst_path=fake_path) data=None, dst_path=fake_path)
mock_get_verifier.assert_called_once_with(None, 'uuid', 'SHA-224', mock_get_verifier.assert_called_once_with(None,
uuids.img_sig_cert_uuid,
'SHA-224',
'signature', 'RSA-PSS') 'signature', 'RSA-PSS')
mock_log.info.assert_called_once_with(mock.ANY, mock.ANY) mock_log.info.assert_called_once_with(mock.ANY, mock.ANY)
self.assertEqual(len(self.fake_img_data), mock_dest.write.call_count) self.assertEqual(len(self.fake_img_data), mock_dest.write.call_count)

29
nova/tests/unit/network/test_api.py
View File

@ -35,9 +35,11 @@ from nova import objects
from nova.objects import fields from nova.objects import fields
from nova import policy from nova import policy
from nova import test from nova import test
from nova.tests.unit.api.openstack import fakes
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
from nova.tests.unit.objects import test_fixed_ip from nova.tests.unit.objects import test_fixed_ip
from nova.tests.unit.objects import test_virtual_interface from nova.tests.unit.objects import test_virtual_interface
from nova.tests import uuidsentinel as uuids
FAKE_UUID = 'a47ae74e-ab08-547f-9eee-ffd23fc46c16' FAKE_UUID = 'a47ae74e-ab08-547f-9eee-ffd23fc46c16'
@ -46,7 +48,7 @@ fake_info_cache = {
'updated_at': None, 'updated_at': None,
'deleted_at': None, 'deleted_at': None,
'deleted': False, 'deleted': False,
'instance_uuid': 'fake-uuid', 'instance_uuid': uuids.instance,
'network_info': '[]', 'network_info': '[]',
} }
@ -90,7 +92,7 @@ class ApiTestCase(test.TestCase):
super(ApiTestCase, self).setUp() super(ApiTestCase, self).setUp()
self.network_api = network.API() self.network_api = network.API()
self.context = context.RequestContext('fake-user', self.context = context.RequestContext('fake-user',
'fake-project') fakes.FAKE_PROJECT_ID)
@mock.patch('nova.objects.NetworkList.get_all') @mock.patch('nova.objects.NetworkList.get_all')
def test_get_all(self, mock_get_all): def test_get_all(self, mock_get_all):
@ -120,7 +122,7 @@ class ApiTestCase(test.TestCase):
def test_get(self, mock_get): def test_get(self, mock_get):
mock_get.return_value = mock.sentinel.get_by_uuid mock_get.return_value = mock.sentinel.get_by_uuid
self.assertEqual(mock.sentinel.get_by_uuid, self.assertEqual(mock.sentinel.get_by_uuid,
self.network_api.get(self.context, 'fake-uuid')) self.network_api.get(self.context, uuids.instance))
@mock.patch('nova.objects.Network.get_by_id') @mock.patch('nova.objects.Network.get_by_id')
@mock.patch('nova.db.virtual_interface_get_by_instance') @mock.patch('nova.db.virtual_interface_get_by_instance')
@ -130,15 +132,15 @@ class ApiTestCase(test.TestCase):
dict(test_virtual_interface.fake_vif, dict(test_virtual_interface.fake_vif,
network_id=123)] network_id=123)]
mock_get_by_id.return_value = objects.Network() mock_get_by_id.return_value = objects.Network()
mock_get_by_id.return_value.uuid = mock.sentinel.network_uuid mock_get_by_id.return_value.uuid = uuids.network_1
instance = objects.Instance(uuid=mock.sentinel.inst_uuid) instance = objects.Instance(uuid=uuids.instance)
vifs = self.network_api.get_vifs_by_instance(self.context, vifs = self.network_api.get_vifs_by_instance(self.context,
instance) instance)
self.assertEqual(1, len(vifs)) self.assertEqual(1, len(vifs))
self.assertEqual(123, vifs[0].network_id) self.assertEqual(123, vifs[0].network_id)
self.assertEqual(str(mock.sentinel.network_uuid), vifs[0].net_uuid) self.assertEqual(uuids.network_1, vifs[0].net_uuid)
mock_get_by_instance.assert_called_once_with( mock_get_by_instance.assert_called_once_with(
self.context, str(mock.sentinel.inst_uuid)) self.context, uuids.instance)
mock_get_by_id.assert_called_once_with(self.context, 123, mock_get_by_id.assert_called_once_with(self.context, 123,
project_only='allow_none') project_only='allow_none')
@ -149,11 +151,11 @@ class ApiTestCase(test.TestCase):
mock_get_by_address.return_value = dict( mock_get_by_address.return_value = dict(
test_virtual_interface.fake_vif, network_id=123) test_virtual_interface.fake_vif, network_id=123)
mock_get_by_id.return_value = objects.Network( mock_get_by_id.return_value = objects.Network(
uuid=mock.sentinel.network_uuid) uuid=uuids.network_1)
vif = self.network_api.get_vif_by_mac_address(self.context, vif = self.network_api.get_vif_by_mac_address(self.context,
mock.sentinel.mac) mock.sentinel.mac)
self.assertEqual(123, vif.network_id) self.assertEqual(123, vif.network_id)
self.assertEqual(str(mock.sentinel.network_uuid), vif.net_uuid) self.assertEqual(uuids.network_1, vif.net_uuid)
mock_get_by_address.assert_called_once_with(self.context, mock_get_by_address.assert_called_once_with(self.context,
mock.sentinel.mac) mock.sentinel.mac)
mock_get_by_id.assert_called_once_with(self.context, 123, mock_get_by_id.assert_called_once_with(self.context, 123,
@ -176,7 +178,8 @@ class ApiTestCase(test.TestCase):
self.mox.ReplayAll() self.mox.ReplayAll()
flavor = flavors.get_default_flavor() flavor = flavors.get_default_flavor()
flavor['rxtx_factor'] = 0 flavor['rxtx_factor'] = 0
instance = objects.Instance(id=1, uuid='uuid', project_id='project_id', instance = objects.Instance(id=1, uuid=uuids.instance,
project_id='project_id',
host='host', system_metadata={}, host='host', system_metadata={},
flavor=flavor) flavor=flavor)
self.network_api.allocate_for_instance( self.network_api.allocate_for_instance(
@ -240,7 +243,7 @@ class ApiTestCase(test.TestCase):
'10.0.0.2') '10.0.0.2')
def test_associate_preassociated_floating_ip(self): def test_associate_preassociated_floating_ip(self):
self._do_test_associate_floating_ip('orig-uuid') self._do_test_associate_floating_ip(uuids.orig_uuid)
def test_associate_unassociated_floating_ip(self): def test_associate_unassociated_floating_ip(self):
self._do_test_associate_floating_ip(None) self._do_test_associate_floating_ip(None)
@ -502,8 +505,8 @@ class ApiTestCase(test.TestCase):
@mock.patch('nova.objects.FixedIP.get_by_floating_address') @mock.patch('nova.objects.FixedIP.get_by_floating_address')
def test_get_instance_by_floating_address(self, mock_get_by_floating): def test_get_instance_by_floating_address(self, mock_get_by_floating):
mock_get_by_floating.return_value = objects.FixedIP( mock_get_by_floating.return_value = objects.FixedIP(
instance_uuid = mock.sentinel.instance_uuid) instance_uuid = uuids.instance)
self.assertEqual(str(mock.sentinel.instance_uuid), self.assertEqual(uuids.instance,
self.network_api.get_instance_id_by_floating_address( self.network_api.get_instance_id_by_floating_address(
self.context, mock.sentinel.floating)) self.context, mock.sentinel.floating))
mock_get_by_floating.assert_called_once_with(self.context, mock_get_by_floating.assert_called_once_with(self.context,

29
nova/tests/unit/network/test_linux_net.py
View File

@ -36,29 +36,30 @@ from nova.network import linux_net
from nova.network import model as network_model from nova.network import model as network_model
from nova import objects from nova import objects
from nova import test from nova import test
from nova.tests import uuidsentinel as uuids
from nova import utils from nova import utils
CONF = nova.conf.CONF CONF = nova.conf.CONF
HOST = "testhost" HOST = "testhost"
instances = {'00000000-0000-0000-0000-0000000000000000': instances = {uuids.instance_1:
{'id': 0, {'id': 0,
'uuid': '00000000-0000-0000-0000-0000000000000000', 'uuid': uuids.instance_1,
'host': 'fake_instance00', 'host': 'fake_instance00',
'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0), 'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0),
'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0), 'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0),
'hostname': 'fake_instance00'}, 'hostname': 'fake_instance00'},
'00000000-0000-0000-0000-0000000000000001': uuids.instance_2:
{'id': 1, {'id': 1,
'uuid': '00000000-0000-0000-0000-0000000000000001', 'uuid': uuids.instance_2,
'host': 'fake_instance01', 'host': 'fake_instance01',
'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0), 'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0),
'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0), 'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0),
'hostname': 'fake_instance01'}, 'hostname': 'fake_instance01'},
'00000000-0000-0000-0000-0000000000000002': uuids.instance_3:
{'id': 2, {'id': 2,
'uuid': '00000000-0000-0000-0000-0000000000000002', 'uuid': uuids.instance_3,
'host': 'fake_instance02', 'host': 'fake_instance02',
'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0), 'created_at': datetime.datetime(1955, 11, 5, 0, 0, 0),
'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0), 'updated_at': datetime.datetime(1985, 10, 26, 1, 35, 0),
@ -159,7 +160,7 @@ fixed_ips = [{'id': 0,
'leased': True, 'leased': True,
'virtual_interface_id': 0, 'virtual_interface_id': 0,
'default_route': True, 'default_route': True,
'instance_uuid': '00000000-0000-0000-0000-0000000000000000', 'instance_uuid': uuids.instance_1,
'floating_ips': []}, 'floating_ips': []},
{'id': 1, {'id': 1,
'network_id': 1, 'network_id': 1,
@ -169,7 +170,7 @@ fixed_ips = [{'id': 0,
'leased': True, 'leased': True,
'virtual_interface_id': 1, 'virtual_interface_id': 1,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000000', 'instance_uuid': uuids.instance_1,
'floating_ips': []}, 'floating_ips': []},
{'id': 2, {'id': 2,
'network_id': 1, 'network_id': 1,
@ -179,7 +180,7 @@ fixed_ips = [{'id': 0,
'leased': True, 'leased': True,
'virtual_interface_id': 2, 'virtual_interface_id': 2,
'default_route': True, 'default_route': True,
'instance_uuid': '00000000-0000-0000-0000-0000000000000001', 'instance_uuid': uuids.instance_2,
'floating_ips': []}, 'floating_ips': []},
{'id': 3, {'id': 3,
'network_id': 0, 'network_id': 0,
@ -189,7 +190,7 @@ fixed_ips = [{'id': 0,
'leased': True, 'leased': True,
'virtual_interface_id': 3, 'virtual_interface_id': 3,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000001', 'instance_uuid': uuids.instance_2,
'floating_ips': []}, 'floating_ips': []},
{'id': 4, {'id': 4,
'network_id': 0, 'network_id': 0,
@ -199,7 +200,7 @@ fixed_ips = [{'id': 0,
'leased': False, 'leased': False,
'virtual_interface_id': 4, 'virtual_interface_id': 4,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000000', 'instance_uuid': uuids.instance_1,
'floating_ips': []}, 'floating_ips': []},
{'id': 5, {'id': 5,
'network_id': 1, 'network_id': 1,
@ -209,7 +210,7 @@ fixed_ips = [{'id': 0,
'leased': False, 'leased': False,
'virtual_interface_id': 5, 'virtual_interface_id': 5,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000001', 'instance_uuid': uuids.instance_2,
'floating_ips': []}, 'floating_ips': []},
{'id': 6, {'id': 6,
'network_id': 1, 'network_id': 1,
@ -219,7 +220,7 @@ fixed_ips = [{'id': 0,
'leased': True, 'leased': True,
'virtual_interface_id': 6, 'virtual_interface_id': 6,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000001', 'instance_uuid': uuids.instance_2,
'floating_ips': []}, 'floating_ips': []},
{'id': 7, {'id': 7,
'network_id': 2, 'network_id': 2,
@ -229,7 +230,7 @@ fixed_ips = [{'id': 0,
'leased': False, 'leased': False,
'virtual_interface_id': 7, 'virtual_interface_id': 7,
'default_route': False, 'default_route': False,
'instance_uuid': '00000000-0000-0000-0000-0000000000000002', 'instance_uuid': uuids.instance_3,
'floating_ips': []}] 'floating_ips': []}]

210
nova/tests/unit/network/test_manager.py
View File

@ -43,6 +43,7 @@ from nova.objects import network as network_obj
from nova.objects import virtual_interface as vif_obj from nova.objects import virtual_interface as vif_obj
from nova import quota from nova import quota
from nova import test from nova import test
from nova.tests.unit.api.openstack import fakes
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
from nova.tests.unit import fake_ldap from nova.tests.unit import fake_ldap
from nova.tests.unit import fake_network from nova.tests.unit import fake_network
@ -85,7 +86,7 @@ networks = [{'id': 0,
'dns2': '192.168.0.2', 'dns2': '192.168.0.2',
'vlan': None, 'vlan': None,
'host': HOST, 'host': HOST,
'project_id': 'fake_project', 'project_id': fakes.FAKE_PROJECT_ID,
'vpn_public_address': '192.168.0.2', 'vpn_public_address': '192.168.0.2',
'vpn_public_port': '22', 'vpn_public_port': '22',
'vpn_private_address': '10.0.0.2'}, 'vpn_private_address': '10.0.0.2'},
@ -108,7 +109,7 @@ networks = [{'id': 0,
'dns2': '192.168.0.2', 'dns2': '192.168.0.2',
'vlan': None, 'vlan': None,
'host': HOST, 'host': HOST,
'project_id': 'fake_project', 'project_id': fakes.FAKE_PROJECT_ID,
'vpn_public_address': '192.168.1.2', 'vpn_public_address': '192.168.1.2',
'vpn_public_port': '22', 'vpn_public_port': '22',
'vpn_private_address': '10.0.0.2'}] 'vpn_private_address': '10.0.0.2'}]
@ -154,9 +155,9 @@ vifs = [{'id': 0,
'deleted_at': None, 'deleted_at': None,
'deleted': 0, 'deleted': 0,
'address': 'DE:AD:BE:EF:00:00', 'address': 'DE:AD:BE:EF:00:00',
'uuid': '00000000-0000-0000-0000-0000000000000000', 'uuid': uuids.vif1_uuid,
'network_id': 0, 'network_id': 0,
'instance_uuid': 0, 'instance_uuid': uuids.instance,
'tag': 'fake-tag1'}, 'tag': 'fake-tag1'},
{'id': 1, {'id': 1,
'created_at': None, 'created_at': None,
@ -166,7 +167,7 @@ vifs = [{'id': 0,
'address': 'DE:AD:BE:EF:00:01', 'address': 'DE:AD:BE:EF:00:01',
'uuid': '00000000-0000-0000-0000-0000000000000001', 'uuid': '00000000-0000-0000-0000-0000000000000001',
'network_id': 1, 'network_id': 1,
'instance_uuid': 0, 'instance_uuid': uuids.instance,
'tag': 'fake-tag2'}, 'tag': 'fake-tag2'},
{'id': 2, {'id': 2,
'created_at': None, 'created_at': None,
@ -176,7 +177,7 @@ vifs = [{'id': 0,
'address': 'DE:AD:BE:EF:00:02', 'address': 'DE:AD:BE:EF:00:02',
'uuid': '00000000-0000-0000-0000-0000000000000002', 'uuid': '00000000-0000-0000-0000-0000000000000002',
'network_id': 2, 'network_id': 2,
'instance_uuid': 0, 'instance_uuid': uuids.instance,
'tag': 'fake-tag3'}] 'tag': 'fake-tag3'}]
@ -191,7 +192,8 @@ class FlatNetworkTestCase(test.TestCase):
self.network = network_manager.FlatManager(host=HOST) self.network = network_manager.FlatManager(host=HOST)
self.network.instance_dns_domain = '' self.network.instance_dns_domain = ''
self.network.db = db self.network.db = db
self.context = context.RequestContext('testuser', 'testproject', self.context = context.RequestContext('testuser',
fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
@testtools.skipIf(test_utils.is_osx(), @testtools.skipIf(test_utils.is_osx(),
@ -326,8 +328,9 @@ class FlatNetworkTestCase(test.TestCase):
self.network.validate_networks(self.context, requested_networks) self.network.validate_networks(self.context, requested_networks)
def test_validate_reserved(self): def test_validate_reserved(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
nets = self.network.create_networks(context_admin, 'fake', nets = self.network.create_networks(context_admin, 'fake',
'192.168.0.0/24', False, 1, '192.168.0.0/24', False, 1,
256, None, None, None, None, None) 256, None, None, None, None, None)
@ -337,8 +340,9 @@ class FlatNetworkTestCase(test.TestCase):
network['id'])) network['id']))
def test_validate_reserved_start_end(self): def test_validate_reserved_start_end(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
nets = self.network.create_networks(context_admin, 'fake', nets = self.network.create_networks(context_admin, 'fake',
'192.168.0.0/24', False, 1, '192.168.0.0/24', False, 1,
256, dhcp_server='192.168.0.11', 256, dhcp_server='192.168.0.11',
@ -359,32 +363,36 @@ class FlatNetworkTestCase(test.TestCase):
network['id'])) network['id']))
def test_validate_reserved_start_out_of_range(self): def test_validate_reserved_start_out_of_range(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
self.assertRaises(exception.AddressOutOfRange, self.assertRaises(exception.AddressOutOfRange,
self.network.create_networks, self.network.create_networks,
context_admin, 'fake', '192.168.0.0/24', False, context_admin, 'fake', '192.168.0.0/24', False,
1, 256, allowed_start='192.168.1.10') 1, 256, allowed_start='192.168.1.10')
def test_validate_reserved_end_invalid(self): def test_validate_reserved_end_invalid(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
self.assertRaises(exception.InvalidAddress, self.assertRaises(exception.InvalidAddress,
self.network.create_networks, self.network.create_networks,
context_admin, 'fake', '192.168.0.0/24', False, context_admin, 'fake', '192.168.0.0/24', False,
1, 256, allowed_end='invalid') 1, 256, allowed_end='invalid')
def test_validate_cidr_invalid(self): def test_validate_cidr_invalid(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
self.assertRaises(exception.InvalidCidr, self.assertRaises(exception.InvalidCidr,
self.network.create_networks, self.network.create_networks,
context_admin, 'fake', 'invalid', False, context_admin, 'fake', 'invalid', False,
1, 256) 1, 256)
def test_validate_non_int_size(self): def test_validate_non_int_size(self):
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
self.assertRaises(exception.InvalidIntValue, self.assertRaises(exception.InvalidIntValue,
self.network.create_networks, self.network.create_networks,
context_admin, 'fake', '192.168.0.0/24', False, context_admin, 'fake', '192.168.0.0/24', False,
@ -434,11 +442,11 @@ class FlatNetworkTestCase(test.TestCase):
def test_get_instance_nw_info(self, get): def test_get_instance_nw_info(self, get):
def make_ip(index): def make_ip(index):
vif = objects.VirtualInterface(uuid=index, address=index) vif = objects.VirtualInterface(uuid=uuids.vif1_uuid, address=index)
network = objects.Network(uuid=index, network = objects.Network(uuid=uuids.network_1,
bridge=index, bridge=index,
label=index, label=index,
project_id=index, project_id=fakes.FAKE_PROJECT_ID,
injected=False, injected=False,
netmask='255.255.255.0', netmask='255.255.255.0',
dns1=None, dns1=None,
@ -639,7 +647,7 @@ class FlatNetworkTestCase(test.TestCase):
def test_allocate_calculates_quota_auth(self, util_method, reserve, def test_allocate_calculates_quota_auth(self, util_method, reserve,
get_by_uuid): get_by_uuid):
inst = objects.Instance() inst = objects.Instance()
inst['uuid'] = 'nosuch' inst['uuid'] = uuids.instance
get_by_uuid.return_value = inst get_by_uuid.return_value = inst
usages = {'fixed_ips': {'in_use': 10, 'reserved': 1}} usages = {'fixed_ips': {'in_use': 10, 'reserved': 1}}
reserve.side_effect = exception.OverQuota(overs='testing', reserve.side_effect = exception.OverQuota(overs='testing',
@ -648,7 +656,7 @@ class FlatNetworkTestCase(test.TestCase):
util_method.return_value = ('foo', 'bar') util_method.return_value = ('foo', 'bar')
self.assertRaises(exception.FixedIpLimitExceeded, self.assertRaises(exception.FixedIpLimitExceeded,
self.network.allocate_fixed_ip, self.network.allocate_fixed_ip,
self.context, 123, {'uuid': 'nosuch'}) self.context, 123, {'uuid': uuids.instance})
util_method.assert_called_once_with(self.context, inst) util_method.assert_called_once_with(self.context, inst)
@mock.patch('nova.objects.fixed_ip.FixedIP.get_by_address') @mock.patch('nova.objects.fixed_ip.FixedIP.get_by_address')
@ -656,8 +664,8 @@ class FlatNetworkTestCase(test.TestCase):
@mock.patch('nova.objects.quotas.ids_from_instance') @mock.patch('nova.objects.quotas.ids_from_instance')
def test_deallocate_calculates_quota_auth(self, util_method, reserve, def test_deallocate_calculates_quota_auth(self, util_method, reserve,
get_by_address): get_by_address):
inst = objects.Instance(uuid='fake-uuid') inst = objects.Instance(uuid=uuids.instance)
fip = objects.FixedIP(instance_uuid='fake-uuid', fip = objects.FixedIP(instance_uuid=uuids.instance,
virtual_interface_id=1) virtual_interface_id=1)
get_by_address.return_value = fip get_by_address.return_value = fip
util_method.return_value = ('foo', 'bar') util_method.return_value = ('foo', 'bar')
@ -679,7 +687,7 @@ class FlatNetworkTestCase(test.TestCase):
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
self.network.allocate_fixed_ip, self.network.allocate_fixed_ip,
self.context, instance.uuid, self.context, instance.uuid,
{'cidr': '24', 'id': 1, 'uuid': 'nosuch'}, {'cidr': '24', 'id': 1, 'uuid': uuids.instance},
address=netaddr.IPAddress('1.2.3.4')) address=netaddr.IPAddress('1.2.3.4'))
mock_associate.assert_called_once_with(self.context, mock_associate.assert_called_once_with(self.context,
'1.2.3.4', '1.2.3.4',
@ -701,7 +709,7 @@ class FlatNetworkTestCase(test.TestCase):
mock_instance_get): mock_instance_get):
address = netaddr.IPAddress('1.2.3.4') address = netaddr.IPAddress('1.2.3.4')
fip = objects.FixedIP(instance_uuid='fake-uuid', fip = objects.FixedIP(instance_uuid=uuids.instance,
address=address, address=address,
virtual_interface_id=1) virtual_interface_id=1)
mock_fixedip_associate.return_value = fip mock_fixedip_associate.return_value = fip
@ -711,7 +719,7 @@ class FlatNetworkTestCase(test.TestCase):
mock_instance_get.return_value = instance mock_instance_get.return_value = instance
mock_vif_get.return_value = vif_obj.VirtualInterface( mock_vif_get.return_value = vif_obj.VirtualInterface(
instance_uuid='fake-uuid', id=1) instance_uuid=uuids.instance, id=1)
with test.nested( with test.nested(
mock.patch.object(self.network, '_setup_network_on_host'), mock.patch.object(self.network, '_setup_network_on_host'),
@ -723,7 +731,8 @@ class FlatNetworkTestCase(test.TestCase):
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
self.network.allocate_fixed_ip, self.network.allocate_fixed_ip,
self.context, instance.uuid, self.context, instance.uuid,
{'cidr': '24', 'id': 1, 'uuid': 'nosuch'}, {'cidr': '24', 'id': 1,
'uuid': uuids.instance},
address=address) address=address)
mock_dns_manager.delete_entry.assert_has_calls([ mock_dns_manager.delete_entry.assert_has_calls([
@ -747,10 +756,10 @@ class FlatNetworkTestCase(test.TestCase):
mock_instance_get): mock_instance_get):
address = netaddr.IPAddress('1.2.3.4') address = netaddr.IPAddress('1.2.3.4')
fip = objects.FixedIP(instance_uuid='fake-uuid', fip = objects.FixedIP(instance_uuid=uuids.instance,
address=address, address=address,
virtual_interface_id=1000) virtual_interface_id=1000)
net = {'cidr': '24', 'id': 1, 'uuid': 'nosuch'} net = {'cidr': '24', 'id': 1, 'uuid': uuids.instance}
instance = objects.Instance(context=self.context) instance = objects.Instance(context=self.context)
instance.create() instance.create()
@ -759,7 +768,7 @@ class FlatNetworkTestCase(test.TestCase):
address='00:00:00:00:00:00', address='00:00:00:00:00:00',
instance_uuid=instance.uuid, instance_uuid=instance.uuid,
network_id=net['id'], network_id=net['id'],
uuid='nosuch') uuid=uuids.instance)
mock_fixedip_associate.return_value = fip mock_fixedip_associate.return_value = fip
mock_add.return_value = vif mock_add.return_value = vif
mock_instance_get.return_value = instance mock_instance_get.return_value = instance
@ -811,10 +820,12 @@ class FlatDHCPNetworkTestCase(test.TestCase):
self.flags(use_local=True, group='conductor') self.flags(use_local=True, group='conductor')
self.network = network_manager.FlatDHCPManager(host=HOST) self.network = network_manager.FlatDHCPManager(host=HOST)
self.network.db = db self.network.db = db
self.context = context.RequestContext('testuser', 'testproject', self.context = context.RequestContext('testuser',
fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
self.context_admin = context.RequestContext('testuser', 'testproject', self.context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
@mock.patch('nova.objects.fixed_ip.FixedIP.get_by_id') @mock.patch('nova.objects.fixed_ip.FixedIP.get_by_id')
@mock.patch('nova.objects.floating_ip.FloatingIPList.get_by_host') @mock.patch('nova.objects.floating_ip.FloatingIPList.get_by_host')
@ -836,7 +847,8 @@ class FlatDHCPNetworkTestCase(test.TestCase):
fake_apply.count += 1 fake_apply.count += 1
fake_apply.count = 0 fake_apply.count = 0
ctxt = context.RequestContext('testuser', 'testproject', is_admin=True) ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=True)
float1 = objects.FloatingIP(address='1.2.3.4', fixed_ip_id=1) float1 = objects.FloatingIP(address='1.2.3.4', fixed_ip_id=1)
float2 = objects.FloatingIP(address='1.2.3.5', fixed_ip_id=2) float2 = objects.FloatingIP(address='1.2.3.5', fixed_ip_id=2)
float1._context = ctxt float1._context = ctxt
@ -859,10 +871,12 @@ class VlanNetworkTestCase(test.TestCase):
self.useFixture(test.SampleNetworks()) self.useFixture(test.SampleNetworks())
self.network = network_manager.VlanManager(host=HOST) self.network = network_manager.VlanManager(host=HOST)
self.network.db = db self.network.db = db
self.context = context.RequestContext('testuser', 'testproject', self.context = context.RequestContext('testuser',
fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
self.context_admin = context.RequestContext('testuser', 'testproject', self.context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
def test_quota_driver_type(self): def test_quota_driver_type(self):
self.assertEqual(objects.QuotasNoOp, self.assertEqual(objects.QuotasNoOp,
@ -946,8 +960,8 @@ class VlanNetworkTestCase(test.TestCase):
def test_allocate_fixed_ip_return_none(self, mock_get, def test_allocate_fixed_ip_return_none(self, mock_get,
mock_associate, mock_get_uuid, mock_add, mock_trigger, mock_associate, mock_get_uuid, mock_add, mock_trigger,
mock_validate, mock_setup): mock_validate, mock_setup):
net = {'cidr': '24', 'id': 1, 'uuid': 'nosuch'} net = {'cidr': '24', 'id': 1, 'uuid': uuids.instance}
fip = objects.FixedIP(instance_uuid='fake-uuid', fip = objects.FixedIP(instance_uuid=uuids.instance,
address=netaddr.IPAddress('1.2.3.4'), address=netaddr.IPAddress('1.2.3.4'),
virtual_interface_id=1) virtual_interface_id=1)
@ -959,7 +973,7 @@ class VlanNetworkTestCase(test.TestCase):
address='00:00:00:00:00:00', address='00:00:00:00:00:00',
instance_uuid=instance.uuid, instance_uuid=instance.uuid,
network_id=net['id'], network_id=net['id'],
uuid='nosuch') uuid=uuids.instance)
mock_associate.return_value = fip mock_associate.return_value = fip
mock_add.return_value = vif mock_add.return_value = vif
mock_get.return_value = None mock_get.return_value = None
@ -982,7 +996,7 @@ class VlanNetworkTestCase(test.TestCase):
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
self.network.allocate_fixed_ip, self.network.allocate_fixed_ip,
self.context, instance.uuid, self.context, instance.uuid,
{'cidr': '24', 'id': 1, 'uuid': 'nosuch'}, {'cidr': '24', 'id': 1, 'uuid': uuids.instance},
address=netaddr.IPAddress('1.2.3.4')) address=netaddr.IPAddress('1.2.3.4'))
mock_associate.assert_called_once_with(self.context, mock_associate.assert_called_once_with(self.context,
'1.2.3.4', '1.2.3.4',
@ -1001,7 +1015,7 @@ class VlanNetworkTestCase(test.TestCase):
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
self.network.allocate_fixed_ip, self.network.allocate_fixed_ip,
self.context, instance.uuid, self.context, instance.uuid,
{'cidr': '24', 'id': 1, 'uuid': 'nosuch', {'cidr': '24', 'id': 1, 'uuid': uuids.instance,
'vpn_private_address': netaddr.IPAddress('1.2.3.4') 'vpn_private_address': netaddr.IPAddress('1.2.3.4')
}, vpn=1) }, vpn=1)
mock_associate.assert_called_once_with(self.context, mock_associate.assert_called_once_with(self.context,
@ -1185,7 +1199,7 @@ class VlanNetworkTestCase(test.TestCase):
self.network.validate_networks(self.context, requested_networks) self.network.validate_networks(self.context, requested_networks)
def test_floating_ip_owned_by_project(self): def test_floating_ip_owned_by_project(self):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
# raises because floating_ip project_id is None # raises because floating_ip project_id is None
@ -1198,7 +1212,7 @@ class VlanNetworkTestCase(test.TestCase):
# raises because floating_ip project_id is not equal to ctxt project_id # raises because floating_ip project_id is not equal to ctxt project_id
floating_ip = objects.FloatingIP(address='10.0.0.1', floating_ip = objects.FloatingIP(address='10.0.0.1',
project_id=ctxt.project_id + '1') project_id=uuids.non_existent_uuid)
self.assertRaises(exception.Forbidden, self.assertRaises(exception.Forbidden,
self.network._floating_ip_owned_by_project, self.network._floating_ip_owned_by_project,
ctxt, ctxt,
@ -1219,11 +1233,11 @@ class VlanNetworkTestCase(test.TestCase):
# does not raise (ctxt is admin) # does not raise (ctxt is admin)
floating_ip = objects.FloatingIP(address='10.0.0.1', floating_ip = objects.FloatingIP(address='10.0.0.1',
project_id='testproject') project_id=fakes.FAKE_PROJECT_ID)
self.network._floating_ip_owned_by_project(ctxt, floating_ip) self.network._floating_ip_owned_by_project(ctxt, floating_ip)
def test_allocate_floating_ip(self): def test_allocate_floating_ip(self):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
self.stubs.Set(self.network, '_floating_ip_pool_exists', self.stubs.Set(self.network, '_floating_ip_pool_exists',
@ -1240,7 +1254,7 @@ class VlanNetworkTestCase(test.TestCase):
@mock.patch('nova.quota.QUOTAS.reserve') @mock.patch('nova.quota.QUOTAS.reserve')
@mock.patch('nova.quota.QUOTAS.commit') @mock.patch('nova.quota.QUOTAS.commit')
def test_deallocate_floating_ip(self, mock_commit, mock_reserve): def test_deallocate_floating_ip(self, mock_commit, mock_reserve):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
def fake1(*args, **kwargs): def fake1(*args, **kwargs):
@ -1271,11 +1285,11 @@ class VlanNetworkTestCase(test.TestCase):
self.network.deallocate_floating_ip(ctxt, ctxt.project_id) self.network.deallocate_floating_ip(ctxt, ctxt.project_id)
mock_commit.assert_called_once_with(ctxt, 'reserve', mock_commit.assert_called_once_with(ctxt, 'reserve',
project_id='testproject') project_id=fakes.FAKE_PROJECT_ID)
@mock.patch('nova.db.fixed_ip_get') @mock.patch('nova.db.fixed_ip_get')
def test_associate_floating_ip(self, fixed_get): def test_associate_floating_ip(self, fixed_get):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
def fake1(*args, **kwargs): def fake1(*args, **kwargs):
@ -1360,7 +1374,7 @@ class VlanNetworkTestCase(test.TestCase):
fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip, fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip,
address='1.2.3.4', address='1.2.3.4',
instance_uuid='fake_uuid', instance_uuid=uuids.instance,
network=test_network.fake_network) network=test_network.fake_network)
# doesn't raise because we exit early if the address is the same # doesn't raise because we exit early if the address is the same
@ -1478,7 +1492,7 @@ class VlanNetworkTestCase(test.TestCase):
expected_arg='fooiface') expected_arg='fooiface')
def test_disassociate_floating_ip(self): def test_disassociate_floating_ip(self):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
def fake1(*args, **kwargs): def fake1(*args, **kwargs):
@ -1628,7 +1642,7 @@ class VlanNetworkTestCase(test.TestCase):
net_get.return_value = dict(test_network.fake_network, net_get.return_value = dict(test_network.fake_network,
**networks[1]) **networks[1])
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
context2 = context.RequestContext('user', 'project2') context2 = context.RequestContext('user', 'project2')
float_ip = db.floating_ip_create(context1.elevated(), float_ip = db.floating_ip_create(context1.elevated(),
@ -1638,7 +1652,7 @@ class VlanNetworkTestCase(test.TestCase):
float_addr = float_ip['address'] float_addr = float_ip['address']
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
fix_addr = db.fixed_ip_associate_pool(context1.elevated(), fix_addr = db.fixed_ip_associate_pool(context1.elevated(),
1, instance['uuid']).address 1, instance['uuid']).address
@ -1692,10 +1706,10 @@ class VlanNetworkTestCase(test.TestCase):
return vifs[0] return vifs[0]
self.stub_out('nova.db.virtual_interface_get', vif_get) self.stub_out('nova.db.virtual_interface_get', vif_get)
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
elevated = context1.elevated() elevated = context1.elevated()
fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
@ -1733,10 +1747,10 @@ class VlanNetworkTestCase(test.TestCase):
utils, 'execute', utils, 'execute',
side_effect=processutils.ProcessExecutionError()), side_effect=processutils.ProcessExecutionError()),
) as (_vif_get, _execute): ) as (_vif_get, _execute):
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
elevated = context1.elevated() elevated = context1.elevated()
fix_addr = db.fixed_ip_associate_pool(elevated, 1, fix_addr = db.fixed_ip_associate_pool(elevated, 1,
@ -1780,11 +1794,11 @@ class VlanNetworkTestCase(test.TestCase):
self.stubs.Set(self.network, '_teardown_network_on_host', self.stubs.Set(self.network, '_teardown_network_on_host',
teardown_network_on_host) teardown_network_on_host)
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
elevated = context1.elevated() elevated = context1.elevated()
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
network = db.network_create_safe(elevated, networks[0]) network = db.network_create_safe(elevated, networks[0])
_fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) _fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
@ -1818,10 +1832,10 @@ class VlanNetworkTestCase(test.TestCase):
return None return None
self.stub_out('nova.db.virtual_interface_get', vif_get) self.stub_out('nova.db.virtual_interface_get', vif_get)
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
elevated = context1.elevated() elevated = context1.elevated()
fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid'])
@ -1845,10 +1859,10 @@ class VlanNetworkTestCase(test.TestCase):
# Verify IP is not deallocated if the security group refresh fails. # Verify IP is not deallocated if the security group refresh fails.
net_get.return_value = dict(test_network.fake_network, net_get.return_value = dict(test_network.fake_network,
**networks[1]) **networks[1])
context1 = context.RequestContext('user', 'project1') context1 = context.RequestContext('user', fakes.FAKE_PROJECT_ID)
instance = db.instance_create(context1, instance = db.instance_create(context1,
{'project_id': 'project1'}) {'project_id': fakes.FAKE_PROJECT_ID})
elevated = context1.elevated() elevated = context1.elevated()
fix_addr = objects.FixedIP.associate_pool(elevated, 1, fix_addr = objects.FixedIP.associate_pool(elevated, 1,
@ -1908,7 +1922,9 @@ class VlanNetworkTestCase(test.TestCase):
fake_apply.count += 1 fake_apply.count += 1
fake_apply.count = 0 fake_apply.count = 0
ctxt = context.RequestContext('testuser', 'testproject', is_admin=True) ctxt = context.RequestContext('testuser',
fakes.FAKE_PROJECT_ID,
is_admin=True)
float1 = objects.FloatingIP(address='1.2.3.4', fixed_ip_id=1) float1 = objects.FloatingIP(address='1.2.3.4', fixed_ip_id=1)
float2 = objects.FloatingIP(address='1.2.3.5', fixed_ip_id=2) float2 = objects.FloatingIP(address='1.2.3.5', fixed_ip_id=2)
float1._context = ctxt float1._context = ctxt
@ -1981,7 +1997,7 @@ class CommonNetworkTestCase(test.TestCase):
instance_get): instance_get):
manager = fake_network.FakeNetworkManager() manager = fake_network.FakeNetworkManager()
db = manager.db db = manager.db
instance_get.return_value = fake_inst(uuid='ignoreduuid') instance_get.return_value = fake_inst(uuid=uuids.non_existent_uuid)
db.virtual_interface_delete_by_instance = lambda _x, _y: None db.virtual_interface_delete_by_instance = lambda _x, _y: None
ctx = context.RequestContext('igonre', 'igonre') ctx = context.RequestContext('igonre', 'igonre')
@ -2527,7 +2543,7 @@ class CommonNetworkTestCase(test.TestCase):
# Add an additional network and ensure the rules get configured # Add an additional network and ensure the rules get configured
new_network = {'id': 2, new_network = {'id': 2,
'uuid': 'cccccccc-cccc-cccc-cccc-cccccccc', 'uuid': uuids.network_1,
'label': 'test2', 'label': 'test2',
'injected': False, 'injected': False,
'multi_host': False, 'multi_host': False,
@ -2545,7 +2561,7 @@ class CommonNetworkTestCase(test.TestCase):
'dns2': '192.168.2.2', 'dns2': '192.168.2.2',
'vlan': None, 'vlan': None,
'host': HOST, 'host': HOST,
'project_id': 'fake_project', 'project_id': fakes.FAKE_PROJECT_ID,
'vpn_public_address': '192.168.2.2', 'vpn_public_address': '192.168.2.2',
'vpn_public_port': '22', 'vpn_public_port': '22',
'vpn_private_address': '10.0.0.2'} 'vpn_private_address': '10.0.0.2'}
@ -2618,7 +2634,7 @@ class CommonNetworkTestCase(test.TestCase):
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
manager.deallocate_fixed_ip, manager.deallocate_fixed_ip,
self.context, 'fake', 'fake', self.context, 'fake', 'fake',
instance=fake_inst(uuid='ignoreduuid')) instance=fake_inst(uuid=uuids.non_existent_uuid))
rollback.assert_called_once_with() rollback.assert_called_once_with()
def test_fixed_cidr_out_of_range(self): def test_fixed_cidr_out_of_range(self):
@ -2679,13 +2695,13 @@ class AllocateTestCase(test.TestCase):
self.useFixture(test.SampleNetworks()) self.useFixture(test.SampleNetworks())
self.network = network_manager.VlanManager(host=HOST) self.network = network_manager.VlanManager(host=HOST)
self.user_id = 'fake' self.user_id = fakes.FAKE_USER_ID
self.project_id = 'fake' self.project_id = fakes.FAKE_PROJECT_ID
self.context = context.RequestContext(self.user_id, self.context = context.RequestContext(self.user_id,
self.project_id, self.project_id,
is_admin=True) is_admin=True)
self.user_context = context.RequestContext('testuser', self.user_context = context.RequestContext('testuser',
'testproject') fakes.FAKE_PROJECT_ID)
def test_allocate_for_instance(self): def test_allocate_for_instance(self):
address = "10.10.10.10" address = "10.10.10.10"
@ -2792,7 +2808,7 @@ class FloatingIPTestCase(test.TestCase):
self.flags(log_dir=self.tempdir) self.flags(log_dir=self.tempdir)
self.network = TestFloatingIPManager() self.network = TestFloatingIPManager()
self.network.db = db self.network.db = db
self.project_id = 'testproject' self.project_id = fakes.FAKE_PROJECT_ID
self.context = context.RequestContext('testuser', self.project_id, self.context = context.RequestContext('testuser', self.project_id,
is_admin=False) is_admin=False)
@ -2810,14 +2826,14 @@ class FloatingIPTestCase(test.TestCase):
fixed_ip = dict(test_fixed_ip.fake_fixed_ip, fixed_ip = dict(test_fixed_ip.fake_fixed_ip,
network_id=None, network_id=None,
instance_uuid='instance-uuid') instance_uuid=uuids.instance)
network = dict(test_network.fake_network, network = dict(test_network.fake_network,
multi_host=True) multi_host=True)
instance = dict(fake_instance.fake_db_instance(host='some-other-host')) instance = dict(fake_instance.fake_db_instance(host='some-other-host'))
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
self.stubs.Set(self.network, self.stubs.Set(self.network,
@ -2838,7 +2854,8 @@ class FloatingIPTestCase(test.TestCase):
self.network.network_rpcapi, '_disassociate_floating_ip') self.network.network_rpcapi, '_disassociate_floating_ip')
self.network.network_rpcapi._disassociate_floating_ip( self.network.network_rpcapi._disassociate_floating_ip(
ctxt, 'fl_ip', mox.IgnoreArg(), 'some-other-host', 'instance-uuid') ctxt, 'fl_ip', mox.IgnoreArg(), 'some-other-host',
uuids.instance)
self.mox.ReplayAll() self.mox.ReplayAll()
self.network.disassociate_floating_ip(ctxt, 'fl_ip', True) self.network.disassociate_floating_ip(ctxt, 'fl_ip', True)
@ -2855,14 +2872,14 @@ class FloatingIPTestCase(test.TestCase):
fixed_ip = dict(test_fixed_ip.fake_fixed_ip, fixed_ip = dict(test_fixed_ip.fake_fixed_ip,
network_id=None, network_id=None,
instance_uuid='instance-uuid') instance_uuid=uuids.instance)
network = dict(test_network.fake_network, network = dict(test_network.fake_network,
multi_host=True) multi_host=True)
instance = dict(fake_instance.fake_db_instance(host='some-other-host')) instance = dict(fake_instance.fake_db_instance(host='some-other-host'))
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
self.stubs.Set(self.network, self.stubs.Set(self.network,
@ -2879,7 +2896,7 @@ class FloatingIPTestCase(test.TestCase):
self.network.network_rpcapi._associate_floating_ip( self.network.network_rpcapi._associate_floating_ip(
ctxt, 'fl_ip', 'fix_ip', mox.IgnoreArg(), 'some-other-host', ctxt, 'fl_ip', 'fix_ip', mox.IgnoreArg(), 'some-other-host',
'instance-uuid') uuids.instance)
self.mox.ReplayAll() self.mox.ReplayAll()
self.network.associate_floating_ip(ctxt, 'fl_ip', 'fix_ip', True) self.network.associate_floating_ip(ctxt, 'fl_ip', 'fix_ip', True)
@ -2896,7 +2913,7 @@ class FloatingIPTestCase(test.TestCase):
instance_id=instance_ref['id']) instance_id=instance_ref['id'])
def test_deallocate_floating_ip_quota_rollback(self): def test_deallocate_floating_ip_quota_rollback(self):
ctxt = context.RequestContext('testuser', 'testproject', ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=False) is_admin=False)
def fake(*args, **kwargs): def fake(*args, **kwargs):
@ -2912,13 +2929,14 @@ class FloatingIPTestCase(test.TestCase):
self.mox.StubOutWithMock(quota.QUOTAS, 'rollback') self.mox.StubOutWithMock(quota.QUOTAS, 'rollback')
quota.QUOTAS.reserve(self.context, quota.QUOTAS.reserve(self.context,
floating_ips=-1, floating_ips=-1,
project_id='testproject').AndReturn('fake-rsv') project_id=fakes.FAKE_PROJECT_ID
).AndReturn('fake-rsv')
self.network._floating_ip_owned_by_project(self.context, self.network._floating_ip_owned_by_project(self.context,
mox.IgnoreArg()) mox.IgnoreArg())
db.floating_ip_deallocate(mox.IgnoreArg(), db.floating_ip_deallocate(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(None) mox.IgnoreArg()).AndReturn(None)
quota.QUOTAS.rollback(self.context, 'fake-rsv', quota.QUOTAS.rollback(self.context, 'fake-rsv',
project_id='testproject') project_id=fakes.FAKE_PROJECT_ID)
self.mox.ReplayAll() self.mox.ReplayAll()
self.network.deallocate_floating_ip(self.context, '10.0.0.1') self.network.deallocate_floating_ip(self.context, '10.0.0.1')
@ -2982,7 +3000,7 @@ class FloatingIPTestCase(test.TestCase):
floating_get.side_effect = fake_floating_ip_get_by_address floating_get.side_effect = fake_floating_ip_get_by_address
fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip, fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip,
instance_uuid='fake_uuid', instance_uuid=uuids.instance,
address='10.0.0.2', address='10.0.0.2',
network=test_network.fake_network) network=test_network.fake_network)
floating_update.return_value = fake_floating_ip_get_by_address( floating_update.return_value = fake_floating_ip_get_by_address(
@ -3028,7 +3046,7 @@ class FloatingIPTestCase(test.TestCase):
return str(floating_ip.address) == '172.24.4.23' return str(floating_ip.address) == '172.24.4.23'
fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip, fixed_get.return_value = dict(test_fixed_ip.fake_fixed_ip,
instance_uuid='fake_uuid', instance_uuid=uuids.instance,
address='10.0.0.2', address='10.0.0.2',
network=test_network.fake_network) network=test_network.fake_network)
floating_update.return_value = fake_floating_ip_get_by_address( floating_update.return_value = fake_floating_ip_get_by_address(
@ -3115,7 +3133,7 @@ class FloatingIPTestCase(test.TestCase):
entryname = 'testentry' entryname = 'testentry'
self.network.create_public_dns_domain(self.context, domain1, self.network.create_public_dns_domain(self.context, domain1,
'testproject') fakes.FAKE_PROJECT_ID)
self.network.create_public_dns_domain(self.context, domain2, self.network.create_public_dns_domain(self.context, domain2,
'fakeproject') 'fakeproject')
@ -3123,7 +3141,7 @@ class FloatingIPTestCase(test.TestCase):
self.assertEqual(2, len(domains)) self.assertEqual(2, len(domains))
self.assertEqual(domain1, domains[0]['domain']) self.assertEqual(domain1, domains[0]['domain'])
self.assertEqual(domain2, domains[1]['domain']) self.assertEqual(domain2, domains[1]['domain'])
self.assertEqual('testproject', domains[0]['project']) self.assertEqual(fakes.FAKE_PROJECT_ID, domains[0]['project'])
self.assertEqual('fakeproject', domains[1]['project']) self.assertEqual('fakeproject', domains[1]['project'])
self.network.add_dns_entry(self.context, address1, entryname, self.network.add_dns_entry(self.context, address1, entryname,
@ -3155,11 +3173,12 @@ class FloatingIPTestCase(test.TestCase):
self.stubs.Set(self.network, 'get_dns_domains', fake_domains) self.stubs.Set(self.network, 'get_dns_domains', fake_domains)
context_admin = context.RequestContext('testuser', 'testproject', context_admin = context.RequestContext('testuser',
is_admin=True) fakes.FAKE_PROJECT_ID,
is_admin=True)
self.network.create_public_dns_domain(context_admin, domain1, self.network.create_public_dns_domain(context_admin, domain1,
'testproject') fakes.FAKE_PROJECT_ID)
self.network.create_public_dns_domain(context_admin, domain2, self.network.create_public_dns_domain(context_admin, domain2,
'fakeproject') 'fakeproject')
@ -3188,13 +3207,14 @@ class FloatingIPTestCase(test.TestCase):
def test_mac_conflicts(self): def test_mac_conflicts(self):
# Make sure MAC collisions are retried. # Make sure MAC collisions are retried.
self.flags(create_unique_mac_address_attempts=3) self.flags(create_unique_mac_address_attempts=3)
ctxt = context.RequestContext('testuser', 'testproject', is_admin=True) ctxt = context.RequestContext('testuser', fakes.FAKE_PROJECT_ID,
is_admin=True)
macs = ['bb:bb:bb:bb:bb:bb', 'aa:aa:aa:aa:aa:aa'] macs = ['bb:bb:bb:bb:bb:bb', 'aa:aa:aa:aa:aa:aa']
# Create a VIF with aa:aa:aa:aa:aa:aa # Create a VIF with aa:aa:aa:aa:aa:aa
crash_test_dummy_vif = { crash_test_dummy_vif = {
'address': macs[1], 'address': macs[1],
'instance_uuid': 'fake_uuid', 'instance_uuid': uuids.instance,
'network_id': 123, 'network_id': 123,
'uuid': 'fake_uuid', 'uuid': 'fake_uuid',
} }
@ -3218,7 +3238,7 @@ class FloatingIPTestCase(test.TestCase):
# Attempt to add another and make sure that both MACs are consumed # Attempt to add another and make sure that both MACs are consumed
# by the retry loop # by the retry loop
self.network._add_virtual_interface(ctxt, 'fake_uuid', 123) self.network._add_virtual_interface(ctxt, uuids.instance, 123)
self.assertEqual([], macs) self.assertEqual([], macs)
def test_deallocate_client_exceptions(self): def test_deallocate_client_exceptions(self):
@ -3338,7 +3358,7 @@ class InstanceDNSTestCase(test.TestCase):
self.flags(log_dir=self.tempdir) self.flags(log_dir=self.tempdir)
self.network = TestFloatingIPManager() self.network = TestFloatingIPManager()
self.network.db = db self.network.db = db
self.project_id = 'testproject' self.project_id = fakes.FAKE_PROJECT_ID
self.context = context.RequestContext('testuser', self.project_id, self.context = context.RequestContext('testuser', self.project_id,
is_admin=False) is_admin=False)

149
nova/tests/unit/network/test_neutronv2.py
View File

@ -46,6 +46,7 @@ from nova.pci import whitelist as pci_whitelist
from nova import policy from nova import policy
from nova import test from nova import test
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
from nova.tests import uuidsentinel as uuids
CONF = cfg.CONF CONF = cfg.CONF
@ -60,7 +61,7 @@ fake_info_cache = {
'updated_at': None, 'updated_at': None,
'deleted_at': None, 'deleted_at': None,
'deleted': False, 'deleted': False,
'instance_uuid': 'fake-uuid', 'instance_uuid': uuids.instance,
'network_info': '[]', 'network_info': '[]',
} }
@ -261,14 +262,14 @@ class TestNeutronv2Base(test.TestCase):
'device_id': self.instance2['uuid'], 'device_id': self.instance2['uuid'],
'tenant_id': self.tenant_id, 'tenant_id': self.tenant_id,
'device_owner': 'compute:nova', 'device_owner': 'compute:nova',
'id': 'my_portid1', 'id': uuids.portid_1,
'binding:vnic_type': model.VNIC_TYPE_NORMAL, 'binding:vnic_type': model.VNIC_TYPE_NORMAL,
'status': 'DOWN', 'status': 'DOWN',
'admin_state_up': True, 'admin_state_up': True,
'fixed_ips': [{'ip_address': self.port_address, 'fixed_ips': [{'ip_address': self.port_address,
'subnet_id': 'my_subid1'}], 'subnet_id': 'my_subid1'}],
'mac_address': 'my_mac1', }] 'mac_address': 'my_mac1', }]
self.float_data1 = [{'port_id': 'my_portid1', self.float_data1 = [{'port_id': uuids.portid_1,
'fixed_ip_address': self.port_address, 'fixed_ip_address': self.port_address,
'floating_ip_address': '172.0.1.2'}] 'floating_ip_address': '172.0.1.2'}]
self.dhcp_port_data1 = [{'fixed_ips': [{'ip_address': '10.0.1.9', self.dhcp_port_data1 = [{'fixed_ips': [{'ip_address': '10.0.1.9',
@ -284,7 +285,7 @@ class TestNeutronv2Base(test.TestCase):
'admin_state_up': True, 'admin_state_up': True,
'status': 'ACTIVE', 'status': 'ACTIVE',
'device_owner': 'compute:nova', 'device_owner': 'compute:nova',
'id': 'my_portid2', 'id': uuids.portid_2,
'binding:vnic_type': model.VNIC_TYPE_NORMAL, 'binding:vnic_type': model.VNIC_TYPE_NORMAL,
'fixed_ips': 'fixed_ips':
[{'ip_address': self.port_address2, [{'ip_address': self.port_address2,
@ -292,7 +293,7 @@ class TestNeutronv2Base(test.TestCase):
'mac_address': 'my_mac2', }) 'mac_address': 'my_mac2', })
self.float_data2 = [] self.float_data2 = []
self.float_data2.append(self.float_data1[0]) self.float_data2.append(self.float_data1[0])
self.float_data2.append({'port_id': 'my_portid2', self.float_data2.append({'port_id': uuids.portid_2,
'fixed_ip_address': '10.0.2.2', 'fixed_ip_address': '10.0.2.2',
'floating_ip_address': '172.0.2.2'}) 'floating_ip_address': '172.0.2.2'})
self.port_data3 = [{'network_id': 'my_netid1', self.port_data3 = [{'network_id': 'my_netid1',
@ -301,7 +302,7 @@ class TestNeutronv2Base(test.TestCase):
'status': 'DOWN', 'status': 'DOWN',
'admin_state_up': True, 'admin_state_up': True,
'device_owner': 'compute:nova', 'device_owner': 'compute:nova',
'id': 'my_portid3', 'id': uuids.portid_3,
'binding:vnic_type': model.VNIC_TYPE_NORMAL, 'binding:vnic_type': model.VNIC_TYPE_NORMAL,
'fixed_ips': [], # no fixed ip 'fixed_ips': [], # no fixed ip
'mac_address': 'my_mac3', }] 'mac_address': 'my_mac3', }]
@ -435,10 +436,10 @@ class TestNeutronv2Base(test.TestCase):
if 'requested_networks' in kwargs: if 'requested_networks' in kwargs:
for request in kwargs['requested_networks']: for request in kwargs['requested_networks']:
if request.port_id: if request.port_id:
if request.port_id == 'my_portid3': if request.port_id == uuids.portid_3:
self.moxed_client.show_port(request.port_id self.moxed_client.show_port(request.port_id
).AndReturn( ).AndReturn(
{'port': {'id': 'my_portid3', {'port': {'id': uuids.portid_3,
'network_id': 'my_netid1', 'network_id': 'my_netid1',
'tenant_id': self.tenant_id, 'tenant_id': self.tenant_id,
'mac_address': 'my_mac1', 'mac_address': 'my_mac1',
@ -451,14 +452,14 @@ class TestNeutronv2Base(test.TestCase):
request.network_id = 'my_netid1' request.network_id = 'my_netid1'
if macs is not None: if macs is not None:
macs.discard('my_mac1') macs.discard('my_mac1')
elif request.port_id == 'invalid_id': elif request.port_id == uuids.non_existent_uuid:
PortNotFound = exceptions.PortNotFoundClient( PortNotFound = exceptions.PortNotFoundClient(
status_code=404) status_code=404)
self.moxed_client.show_port(request.port_id self.moxed_client.show_port(request.port_id
).AndRaise(PortNotFound) ).AndRaise(PortNotFound)
else: else:
self.moxed_client.show_port(request.port_id).AndReturn( self.moxed_client.show_port(request.port_id).AndReturn(
{'port': {'id': 'my_portid1', {'port': {'id': uuids.portid_1,
'network_id': 'my_netid1', 'network_id': 'my_netid1',
'tenant_id': self.tenant_id, 'tenant_id': self.tenant_id,
'mac_address': 'my_mac1', 'mac_address': 'my_mac1',
@ -618,7 +619,8 @@ class TestNeutronv2Base(test.TestCase):
nw_inf.fixed_ips()[index].floating_ip_addresses()[0]) nw_inf.fixed_ips()[index].floating_ip_addresses()[0])
self.assertEqual('my_netname%s' % id_suffix, self.assertEqual('my_netname%s' % id_suffix,
nw_inf[index]['network']['label']) nw_inf[index]['network']['label'])
self.assertEqual('my_portid%s' % id_suffix, nw_inf[index]['id']) self.assertEqual(getattr(uuids, 'portid_%s' % id_suffix),
nw_inf[index]['id'])
self.assertEqual('my_mac%s' % id_suffix, nw_inf[index]['address']) self.assertEqual('my_mac%s' % id_suffix, nw_inf[index]['address'])
self.assertEqual('10.0.%s.0/24' % id_suffix, self.assertEqual('10.0.%s.0/24' % id_suffix,
nw_inf[index]['network']['subnets'][0]['cidr']) nw_inf[index]['network']['subnets'][0]['cidr'])
@ -941,7 +943,7 @@ class TestNeutronv2(TestNeutronv2Base):
id_suffix = 3 id_suffix = 3
self.assertEqual(0, len(nw_inf.fixed_ips())) self.assertEqual(0, len(nw_inf.fixed_ips()))
self.assertEqual('my_netname1', nw_inf[0]['network']['label']) self.assertEqual('my_netname1', nw_inf[0]['network']['label'])
self.assertEqual('my_portid%s' % id_suffix, nw_inf[0]['id']) self.assertEqual(uuids.portid_3, nw_inf[0]['id'])
self.assertEqual('my_mac%s' % id_suffix, nw_inf[0]['address']) self.assertEqual('my_mac%s' % id_suffix, nw_inf[0]['address'])
self.assertEqual(0, len(nw_inf[0]['network']['subnets'])) self.assertEqual(0, len(nw_inf[0]['network']['subnets']))
@ -1005,7 +1007,7 @@ class TestNeutronv2(TestNeutronv2Base):
self._returned_nw_info = self.port_data1 self._returned_nw_info = self.port_data1
result = self._allocate_for_instance( result = self._allocate_for_instance(
requested_networks=objects.NetworkRequestList( requested_networks=objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')])) objects=[objects.NetworkRequest(port_id=uuids.portid_1)]))
self.assertEqual(self.port_data1, result) self.assertEqual(self.port_data1, result)
@mock.patch('nova.network.neutronv2.api.API._unbind_ports') @mock.patch('nova.network.neutronv2.api.API._unbind_ports')
@ -1018,7 +1020,7 @@ class TestNeutronv2(TestNeutronv2Base):
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects = [ objects = [
objects.NetworkRequest(network_id=self.nets2[1]['id']), objects.NetworkRequest(network_id=self.nets2[1]['id']),
objects.NetworkRequest(port_id='my_portid1')]) objects.NetworkRequest(port_id=uuids.portid_1)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
net_idx=2, requested_networks=requested_networks, net_idx=2, requested_networks=requested_networks,
macs=set(['my_mac1']), macs=set(['my_mac1']),
@ -1066,7 +1068,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_mac_conflicting_requested_port(self): def test_allocate_for_instance_mac_conflicting_requested_port(self):
# specify only first and last network # specify only first and last network
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
net_idx=1, requested_networks=requested_networks, net_idx=1, requested_networks=requested_networks,
macs=set(['unknown:mac']), macs=set(['unknown:mac']),
@ -1113,7 +1115,8 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_with_invalid_network_id(self): def test_allocate_for_instance_with_invalid_network_id(self):
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(network_id='invalid_id')]) objects=[objects.NetworkRequest(
network_id=uuids.non_existent_uuid)])
api = self._stub_allocate_for_instance(net_idx=9, api = self._stub_allocate_for_instance(net_idx=9,
requested_networks=requested_networks, requested_networks=requested_networks,
_break='post_list_networks') _break='post_list_networks')
@ -1132,7 +1135,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_with_requested_networks_with_port(self): def test_allocate_for_instance_with_requested_networks_with_port(self):
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
self._allocate_for_instance(net_idx=1, self._allocate_for_instance(net_idx=1,
requested_networks=requested_networks) requested_networks=requested_networks)
@ -1294,7 +1297,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_port_in_use(self): def test_allocate_for_instance_port_in_use(self):
# If a port is already in use, an exception should be raised. # If a port is already in use, an exception should be raised.
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
requested_networks=requested_networks, requested_networks=requested_networks,
_break='pre_list_networks', _break='pre_list_networks',
@ -1306,7 +1309,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_port_not_found(self): def test_allocate_for_instance_port_not_found(self):
# If a port is not found, an exception should be raised. # If a port is not found, an exception should be raised.
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='invalid_id')]) objects=[objects.NetworkRequest(port_id=uuids.non_existent_uuid)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
requested_networks=requested_networks, requested_networks=requested_networks,
_break='pre_list_networks') _break='pre_list_networks')
@ -1317,7 +1320,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_allocate_for_instance_port_invalid_tenantid(self): def test_allocate_for_instance_port_invalid_tenantid(self):
self.tenant_id = 'invalid_id' self.tenant_id = 'invalid_id'
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
requested_networks=requested_networks, requested_networks=requested_networks,
_break='pre_list_networks') _break='pre_list_networks')
@ -1433,7 +1436,7 @@ class TestNeutronv2(TestNeutronv2Base):
requested = objects.NetworkRequestList( requested = objects.NetworkRequestList(
objects=[objects.NetworkRequest(network_id='fake-net', objects=[objects.NetworkRequest(network_id='fake-net',
address='1.2.3.4', address='1.2.3.4',
port_id='fake-port')]) port_id=uuids.portid_5)])
# Test to deallocate in one port env. # Test to deallocate in one port env.
self._deallocate_for_instance(1, requested_networks=requested) self._deallocate_for_instance(1, requested_networks=requested)
@ -1443,7 +1446,7 @@ class TestNeutronv2(TestNeutronv2Base):
requested = objects.NetworkRequestList( requested = objects.NetworkRequestList(
objects=[objects.NetworkRequest(network_id='fake-net', objects=[objects.NetworkRequest(network_id='fake-net',
address='1.2.3.4', address='1.2.3.4',
port_id='fake-port')]) port_id=uuids.portid_6)])
# Test to deallocate in one port env. # Test to deallocate in one port env.
self._deallocate_for_instance(2, requested_networks=requested) self._deallocate_for_instance(2, requested_networks=requested)
@ -1683,7 +1686,7 @@ class TestNeutronv2(TestNeutronv2Base):
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest( objects=[objects.NetworkRequest(
network_id='my_netid1', network_id='my_netid1',
port_id='3123-ad34-bc43-32332ca33e')]) port_id=uuids.portid_1)])
PortNotFound = exceptions.PortNotFoundClient() PortNotFound = exceptions.PortNotFoundClient()
self.moxed_client.show_port(requested_networks[0].port_id).AndRaise( self.moxed_client.show_port(requested_networks[0].port_id).AndRaise(
@ -1699,7 +1702,7 @@ class TestNeutronv2(TestNeutronv2Base):
def test_validate_networks_port_show_raises_non404(self): def test_validate_networks_port_show_raises_non404(self):
# Verify that the correct exception is thrown when a non existent # Verify that the correct exception is thrown when a non existent
# port is passed to validate_networks. # port is passed to validate_networks.
fake_port_id = '3123-ad34-bc43-32332ca33e' fake_port_id = uuids.portid_1
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest( objects=[objects.NetworkRequest(
@ -2326,7 +2329,7 @@ class TestNeutronv2(TestNeutronv2Base):
self.moxed_client.list_floatingips(floating_ip_address=address).\ self.moxed_client.list_floatingips(floating_ip_address=address).\
AndReturn({'floatingips': [self.fip_associated]}) AndReturn({'floatingips': [self.fip_associated]})
self.moxed_client.update_floatingip( self.moxed_client.update_floatingip(
fip_id, {'floatingip': {'port_id': 'my_portid1', fip_id, {'floatingip': {'port_id': uuids.portid_1,
'fixed_ip_address': new_fixed_address}}) 'fixed_ip_address': new_fixed_address}})
self.moxed_client.show_port(self.fip_associated['port_id']).\ self.moxed_client.show_port(self.fip_associated['port_id']).\
AndReturn({'port': self.port_data2[1]}) AndReturn({'port': self.port_data2[1]})
@ -2394,7 +2397,7 @@ class TestNeutronv2(TestNeutronv2Base):
} }
port = self.port_data1[0] port = self.port_data1[0]
port['fixed_ips'] = [{'subnet_id': 'my_subid1'}] port['fixed_ips'] = [{'subnet_id': 'my_subid1'}]
self.moxed_client.update_port('my_portid1', self.moxed_client.update_port(uuids.portid_1,
MyComparator(port_req_body)).AndReturn({'port': port}) MyComparator(port_req_body)).AndReturn({'port': port})
self.mox.ReplayAll() self.mox.ReplayAll()
@ -2420,7 +2423,7 @@ class TestNeutronv2(TestNeutronv2Base):
} }
port = self.port_data1[0] port = self.port_data1[0]
port['fixed_ips'] = [] port['fixed_ips'] = []
self.moxed_client.update_port('my_portid1', self.moxed_client.update_port(uuids.portid_1,
MyComparator(port_req_body)).AndReturn({'port': port}) MyComparator(port_req_body)).AndReturn({'port': port})
self.mox.ReplayAll() self.mox.ReplayAll()
@ -2612,7 +2615,7 @@ class TestNeutronv2(TestNeutronv2Base):
fake_inst = objects.Instance() fake_inst = objects.Instance()
fake_inst.project_id = 'fake' fake_inst.project_id = 'fake'
fake_inst.uuid = 'uuid' fake_inst.uuid = uuids.instance
fake_inst.info_cache = objects.InstanceInfoCache() fake_inst.info_cache = objects.InstanceInfoCache()
fake_inst.info_cache.network_info = model.NetworkInfo() fake_inst.info_cache.network_info = model.NetworkInfo()
fake_ports = [ fake_ports = [
@ -2708,7 +2711,7 @@ class TestNeutronv2(TestNeutronv2Base):
neutronapi.get_client(mox.IgnoreArg(), admin=True).MultipleTimes( neutronapi.get_client(mox.IgnoreArg(), admin=True).MultipleTimes(
).AndReturn(self.moxed_client) ).AndReturn(self.moxed_client)
self.moxed_client.list_ports( self.moxed_client.list_ports(
tenant_id='fake', device_id='uuid').AndReturn( tenant_id='fake', device_id=uuids.instance).AndReturn(
{'ports': fake_ports}) {'ports': fake_ports})
self.mox.StubOutWithMock(api, '_get_floating_ips_by_fixed_and_port') self.mox.StubOutWithMock(api, '_get_floating_ips_by_fixed_and_port')
@ -2728,7 +2731,7 @@ class TestNeutronv2(TestNeutronv2Base):
self.mox.ReplayAll() self.mox.ReplayAll()
neutronapi.get_client('fake') neutronapi.get_client('fake')
fake_inst.info_cache = objects.InstanceInfoCache.new( fake_inst.info_cache = objects.InstanceInfoCache.new(
self.context, 'fake-uuid') self.context, uuids.instance)
fake_inst.info_cache.network_info = model.NetworkInfo.hydrate([]) fake_inst.info_cache.network_info = model.NetworkInfo.hydrate([])
nw_infos = api._build_network_info_model( nw_infos = api._build_network_info_model(
self.context, fake_inst, self.context, fake_inst,
@ -2798,7 +2801,7 @@ class TestNeutronv2(TestNeutronv2Base):
fake_inst = objects.Instance() fake_inst = objects.Instance()
fake_inst.project_id = 'fake' fake_inst.project_id = 'fake'
fake_inst.uuid = 'uuid' fake_inst.uuid = uuids.instance
fake_inst.info_cache = objects.InstanceInfoCache() fake_inst.info_cache = objects.InstanceInfoCache()
fake_inst.info_cache.network_info = model.NetworkInfo() fake_inst.info_cache.network_info = model.NetworkInfo()
fake_ports = [ fake_ports = [
@ -2819,7 +2822,7 @@ class TestNeutronv2(TestNeutronv2Base):
neutronapi.get_client(mox.IgnoreArg(), admin=True).MultipleTimes( neutronapi.get_client(mox.IgnoreArg(), admin=True).MultipleTimes(
).AndReturn(self.moxed_client) ).AndReturn(self.moxed_client)
self.moxed_client.list_ports( self.moxed_client.list_ports(
tenant_id='fake', device_id='uuid').AndReturn( tenant_id='fake', device_id=uuids.instance).AndReturn(
{'ports': fake_ports}) {'ports': fake_ports})
mock_gather_port_ids_and_networks.return_value = ([], []) mock_gather_port_ids_and_networks.return_value = ([], [])
@ -2936,12 +2939,12 @@ class TestNeutronv2(TestNeutronv2Base):
self.mox.ResetAll() self.mox.ResetAll()
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects = [ objects = [
objects.NetworkRequest(port_id='my_portid1'), objects.NetworkRequest(port_id=uuids.portid_1),
objects.NetworkRequest(network_id='net1'), objects.NetworkRequest(network_id='net1'),
objects.NetworkRequest(port_id='my_portid2'), objects.NetworkRequest(port_id=uuids.portid_2),
objects.NetworkRequest(port_id='my_portid3'), objects.NetworkRequest(port_id=uuids.portid_3),
objects.NetworkRequest(port_id='my_portid4'), objects.NetworkRequest(port_id=uuids.portid_4),
objects.NetworkRequest(port_id='my_portid5')]) objects.NetworkRequest(port_id=uuids.portid_5)])
pci_requests = objects.InstancePCIRequests(requests=[]) pci_requests = objects.InstancePCIRequests(requests=[])
mock_get_port_vnic_info.side_effect = [ mock_get_port_vnic_info.side_effect = [
(model.VNIC_TYPE_DIRECT, 'phynet1'), (model.VNIC_TYPE_DIRECT, 'phynet1'),
@ -3426,27 +3429,27 @@ class TestNeutronv2WithMock(test.TestCase):
api = neutronapi.API() api = neutronapi.API()
with mock.patch.object(client.Client, 'show_network') as mock_show: with mock.patch.object(client.Client, 'show_network') as mock_show:
mock_show.return_value = { mock_show.return_value = {
'network': {'id': 'fake-uuid', 'name': 'fake-network'} 'network': {'id': uuids.instance, 'name': 'fake-network'}
} }
net_obj = api.get(self.context, 'fake-uuid') net_obj = api.get(self.context, uuids.instance)
self.assertEqual('fake-network', net_obj.label) self.assertEqual('fake-network', net_obj.label)
self.assertEqual('fake-network', net_obj.name) self.assertEqual('fake-network', net_obj.name)
self.assertEqual('fake-uuid', net_obj.uuid) self.assertEqual(uuids.instance, net_obj.uuid)
def test_get_all_networks(self): def test_get_all_networks(self):
api = neutronapi.API() api = neutronapi.API()
with mock.patch.object(client.Client, 'list_networks') as mock_list: with mock.patch.object(client.Client, 'list_networks') as mock_list:
mock_list.return_value = { mock_list.return_value = {
'networks': [ 'networks': [
{'id': 'fake-uuid1', 'name': 'fake-network1'}, {'id': uuids.network_1, 'name': 'fake-network1'},
{'id': 'fake-uuid2', 'name': 'fake-network2'}, {'id': uuids.network_2, 'name': 'fake-network2'},
]} ]}
net_objs = api.get_all(self.context) net_objs = api.get_all(self.context)
self.assertIsInstance(net_objs, objects.NetworkList) self.assertIsInstance(net_objs, objects.NetworkList)
self.assertEqual(2, len(net_objs)) self.assertEqual(2, len(net_objs))
self.assertEqual(('fake-uuid1', 'fake-network1'), self.assertEqual((uuids.network_1, 'fake-network1'),
(net_objs[0].uuid, net_objs[0].name)) (net_objs[0].uuid, net_objs[0].name))
self.assertEqual(('fake-uuid2', 'fake-network2'), self.assertEqual((uuids.network_2, 'fake-network2'),
(net_objs[1].uuid, net_objs[1].name)) (net_objs[1].uuid, net_objs[1].name))
@mock.patch.object(neutronapi.API, "_refresh_neutron_extensions_cache") @mock.patch.object(neutronapi.API, "_refresh_neutron_extensions_cache")
@ -3615,9 +3618,9 @@ class TestNeutronv2WithMock(test.TestCase):
uuid='inst-1') uuid='inst-1')
mock_has_pbe.return_value = False mock_has_pbe.return_value = False
nw_req = objects.NetworkRequestList( nw_req = objects.NetworkRequestList(
objects = [objects.NetworkRequest(port_id='fake-port1'), objects = [objects.NetworkRequest(port_id=uuids.portid_1),
objects.NetworkRequest(port_id='fake-port2'), objects.NetworkRequest(port_id=uuids.portid_2),
objects.NetworkRequest(port_id='fail-port')]) objects.NetworkRequest(port_id=uuids.fail_port_id)])
mock_avail_nets.return_value = [{'id': 'net-1', mock_avail_nets.return_value = [{'id': 'net-1',
'subnets': ['subnet1']}] 'subnets': ['subnet1']}]
@ -3626,7 +3629,7 @@ class TestNeutronv2WithMock(test.TestCase):
requested_networks=nw_req) requested_networks=nw_req)
mock_unbind.assert_called_once_with(mock.sentinel.ctx, mock_unbind.assert_called_once_with(mock.sentinel.ctx,
['fake-port1', 'fake-port2'], [uuids.portid_1, uuids.portid_2],
mock.ANY, mock.ANY,
mock.ANY) mock.ANY)
@ -3675,24 +3678,26 @@ class TestNeutronv2WithMock(test.TestCase):
mock_nc = mock.Mock() mock_nc = mock.Mock()
mock_ntrn.return_value = mock_nc mock_ntrn.return_value = mock_nc
mock_nc.list_ports.return_value = {'ports': [ mock_nc.list_ports.return_value = {'ports': [
{'id': 'port-1'}, {'id': 'port-2'}, {'id': 'port-3'} {'id': uuids.portid_1}, {'id': uuids.portid_2},
{'id': uuids.portid_3}
]} ]}
nw_req = objects.NetworkRequestList( nw_req = objects.NetworkRequestList(
objects = [objects.NetworkRequest(network_id='net-1', objects = [objects.NetworkRequest(network_id='net-1',
address='192.168.0.3', address='192.168.0.3',
port_id='port-1', port_id=uuids.portid_1,
pci_request_id='pci-1')]) pci_request_id=uuids.pci_1)])
mock_gppids.return_value = ['port-3'] mock_gppids.return_value = [uuids.portid_3]
self.api.deallocate_for_instance(mock.sentinel.ctx, mock_inst, self.api.deallocate_for_instance(mock.sentinel.ctx, mock_inst,
requested_networks=nw_req) requested_networks=nw_req)
mock_unbind.assert_called_once_with(mock.sentinel.ctx, mock_unbind.assert_called_once_with(mock.sentinel.ctx,
set(['port-1', 'port-3']), set([uuids.portid_1,
uuids.portid_3]),
mock.ANY) mock.ANY)
mock_deletep.assert_called_once_with(mock_nc, mock_deletep.assert_called_once_with(mock_nc,
mock_inst, mock_inst,
set(['port-2']), set([uuids.portid_2]),
raise_if_fail=True) raise_if_fail=True)
@mock.patch('nova.network.neutronv2.api.API.get_instance_nw_info') @mock.patch('nova.network.neutronv2.api.API.get_instance_nw_info')
@ -3738,7 +3743,7 @@ class TestNeutronv2WithMock(test.TestCase):
uuid='inst-1') uuid='inst-1')
mock_avail_nets.return_value = [{'id': 'net-1', mock_avail_nets.return_value = [{'id': 'net-1',
'subnets': ['subnet1']}] 'subnets': ['subnet1']}]
mock_nc.create_port.return_value = {'port': {'id': 'fake_id', mock_nc.create_port.return_value = {'port': {'id': uuids.portid_1,
'tenant_id': mock_inst.project_id, 'tenant_id': mock_inst.project_id,
'binding:vif_type': 'binding_failed'}} 'binding:vif_type': 'binding_failed'}}
@ -3746,7 +3751,7 @@ class TestNeutronv2WithMock(test.TestCase):
self.api.allocate_for_instance, self.api.allocate_for_instance,
mock.sentinel.ctx, mock.sentinel.ctx,
mock_inst) mock_inst)
mock_nc.delete_port.assert_called_once_with('fake_id') mock_nc.delete_port.assert_called_once_with(uuids.portid_1)
@mock.patch('nova.network.neutronv2.api.API._show_port') @mock.patch('nova.network.neutronv2.api.API._show_port')
@mock.patch('nova.network.neutronv2.api.API._has_port_binding_extension') @mock.patch('nova.network.neutronv2.api.API._has_port_binding_extension')
@ -3764,7 +3769,7 @@ class TestNeutronv2WithMock(test.TestCase):
'tenant_id': mock_inst.project_id, 'tenant_id': mock_inst.project_id,
'binding:vif_type': 'binding_failed'} 'binding:vif_type': 'binding_failed'}
nw_req = objects.NetworkRequestList( nw_req = objects.NetworkRequestList(
objects = [objects.NetworkRequest(port_id='fake_id')]) objects = [objects.NetworkRequest(port_id=uuids.portid_1)])
self.assertRaises(exception.PortBindingFailed, self.assertRaises(exception.PortBindingFailed,
self.api.allocate_for_instance, self.api.allocate_for_instance,
@ -4129,7 +4134,7 @@ class TestNeutronv2NeutronHostnameDNS(TestNeutronv2Base):
# The port's dns_name attribute should be set by the port update # The port's dns_name attribute should be set by the port update
# request in allocate_for_instance # request in allocate_for_instance
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
self._allocate_for_instance(net_idx=1, dns_extension=True, self._allocate_for_instance(net_idx=1, dns_extension=True,
requested_networks=requested_networks) requested_networks=requested_networks)
@ -4138,7 +4143,7 @@ class TestNeutronv2NeutronHostnameDNS(TestNeutronv2Base):
# request in allocate_for_instance. The port's dns_name was preset by # request in allocate_for_instance. The port's dns_name was preset by
# the user with a value equal to the instance's hostname # the user with a value equal to the instance's hostname
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
self._allocate_for_instance(net_idx=1, dns_extension=True, self._allocate_for_instance(net_idx=1, dns_extension=True,
requested_networks=requested_networks, requested_networks=requested_networks,
_dns_name='test-instance') _dns_name='test-instance')
@ -4147,7 +4152,7 @@ class TestNeutronv2NeutronHostnameDNS(TestNeutronv2Base):
# If a pre-existing port has dns_name set, an exception should be # If a pre-existing port has dns_name set, an exception should be
# raised if dns_name is not equal to the instance's hostname # raised if dns_name is not equal to the instance's hostname
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
api = self._stub_allocate_for_instance( api = self._stub_allocate_for_instance(
requested_networks=requested_networks, requested_networks=requested_networks,
dns_extension=True, dns_extension=True,
@ -4170,7 +4175,7 @@ class TestNeutronv2NeutronHostnameDNSPortbinding(TestNeutronv2Base):
# The port's dns_name attribute should be set by the port update # The port's dns_name attribute should be set by the port update
# request in allocate_for_instance # request in allocate_for_instance
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
self._allocate_for_instance(net_idx=1, dns_extension=True, self._allocate_for_instance(net_idx=1, dns_extension=True,
portbinding=True, portbinding=True,
bind_host_id=self.instance.get('host'), bind_host_id=self.instance.get('host'),
@ -4190,7 +4195,7 @@ class TestNeutronv2NeutronHostnameDNSPortbinding(TestNeutronv2Base):
# port binding extension is enabled and the port's network has a # port binding extension is enabled and the port's network has a
# non-blank dns_domain attribute # non-blank dns_domain attribute
requested_networks = objects.NetworkRequestList( requested_networks = objects.NetworkRequestList(
objects=[objects.NetworkRequest(port_id='my_portid1')]) objects=[objects.NetworkRequest(port_id=uuids.portid_1)])
self._allocate_for_instance(net_idx=11, dns_extension=True, self._allocate_for_instance(net_idx=11, dns_extension=True,
portbinding=True, portbinding=True,
bind_host_id=self.instance.get('host'), bind_host_id=self.instance.get('host'),
@ -4321,7 +4326,7 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
objects.NetworkRequest(network_id='net2')]) objects.NetworkRequest(network_id='net2')])
instance = objects.Instance( instance = objects.Instance(
project_id=1, availability_zone='nova', uuid='uuid1') project_id=1, availability_zone='nova', uuid=uuids.instance)
secgroups = ['default'] # Nova API provides the 'default' secgroups = ['default'] # Nova API provides the 'default'
mock_process_requested_networks.return_value = [ mock_process_requested_networks.return_value = [
@ -4341,13 +4346,13 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
mock.ANY, instance, mock.ANY, instance,
u'net1', {'port': u'net1', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, [], None, None), None, [], None, None),
mock.call( mock.call(
mock.ANY, instance, mock.ANY, instance,
u'net2', {'port': u'net2', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, [], None, None)]) None, [], None, None)])
@mock.patch.object(neutronapi.API, 'get_instance_nw_info') @mock.patch.object(neutronapi.API, 'get_instance_nw_info')
@ -4380,7 +4385,7 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
objects.NetworkRequest(network_id='net2')]) objects.NetworkRequest(network_id='net2')])
instance = objects.Instance( instance = objects.Instance(
project_id=1, availability_zone='nova', uuid='uuid1') project_id=1, availability_zone='nova', uuid=uuids.instance)
secgroups = ['default', 'secgrp1', 'secgrp2'] secgroups = ['default', 'secgrp1', 'secgrp2']
mock_process_requested_networks.return_value = [ mock_process_requested_networks.return_value = [
@ -4401,13 +4406,13 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
mock.ANY, instance, mock.ANY, instance,
u'net1', {'port': u'net1', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, ['secgrp-uuid1', 'secgrp-uuid2'], None, None), None, ['secgrp-uuid1', 'secgrp-uuid2'], None, None),
mock.call( mock.call(
mock.ANY, instance, mock.ANY, instance,
u'net2', {'port': u'net2', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, ['secgrp-uuid1', 'secgrp-uuid2'], None, None)]) None, ['secgrp-uuid1', 'secgrp-uuid2'], None, None)])
@mock.patch.object(neutronapi.API, 'get_instance_nw_info') @mock.patch.object(neutronapi.API, 'get_instance_nw_info')
@ -4440,7 +4445,7 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
objects.NetworkRequest(network_id='net2')]) objects.NetworkRequest(network_id='net2')])
instance = objects.Instance( instance = objects.Instance(
project_id=1, availability_zone='nova', uuid='uuid1') project_id=1, availability_zone='nova', uuid=uuids.instance)
secgroups = ['default'] # Nova API provides the 'default' secgroups = ['default'] # Nova API provides the 'default'
mock_process_requested_networks.return_value = [ mock_process_requested_networks.return_value = [
@ -4460,13 +4465,13 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
mock.ANY, instance, mock.ANY, instance,
u'net1', {'port': u'net1', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, [], None, None), None, [], None, None),
mock.call( mock.call(
mock.ANY, instance, mock.ANY, instance,
u'net2', {'port': u'net2', {'port':
{'device_owner': u'compute:nova', {'device_owner': u'compute:nova',
'device_id': 'uuid1'}}, 'device_id': uuids.instance}},
None, [], None, None)]) None, [], None, None)])
@mock.patch.object(neutronapi.API, 'get_instance_nw_info') @mock.patch.object(neutronapi.API, 'get_instance_nw_info')
@ -4499,7 +4504,7 @@ class TestNeutronPortSecurity(test.NoDBTestCase):
objects.NetworkRequest(network_id='net2')]) objects.NetworkRequest(network_id='net2')])
instance = objects.Instance( instance = objects.Instance(
project_id=1, availability_zone='nova', uuid='uuid1') project_id=1, availability_zone='nova', uuid=uuids.instance)
secgroups = ['default', 'secgrp1', 'secgrp2'] secgroups = ['default', 'secgrp1', 'secgrp2']
mock_process_requested_networks.return_value = [ mock_process_requested_networks.return_value = [

14
nova/tests/unit/objects/test_virtual_interface.py
View File

@ -17,7 +17,7 @@ import mock
from nova import db from nova import db
from nova.objects import virtual_interface as vif_obj from nova.objects import virtual_interface as vif_obj
from nova.tests.unit.objects import test_objects from nova.tests.unit.objects import test_objects
from nova.tests import uuidsentinel as uuids
fake_vif = { fake_vif = {
'created_at': None, 'created_at': None,
@ -27,8 +27,8 @@ fake_vif = {
'id': 1, 'id': 1,
'address': '00:00:00:00:00:00', 'address': '00:00:00:00:00:00',
'network_id': 123, 'network_id': 123,
'instance_uuid': 'fake-uuid', 'instance_uuid': uuids.instance,
'uuid': 'fake-uuid-2', 'uuid': uuids.uuid,
'tag': 'fake-tag', 'tag': 'fake-tag',
} }
@ -71,8 +71,8 @@ class _TestVirtualInterface(object):
vif = vif_obj.VirtualInterface(context=self.context) vif = vif_obj.VirtualInterface(context=self.context)
vif.address = '00:00:00:00:00:00' vif.address = '00:00:00:00:00:00'
vif.network_id = 123 vif.network_id = 123
vif.instance_uuid = 'fake-uuid' vif.instance_uuid = uuids.instance
vif.uuid = 'fake-uuid-2' vif.uuid = uuids.uuid
vif.tag = 'fake-tag' vif.tag = 'fake-tag'
with mock.patch.object(db, 'virtual_interface_create') as create: with mock.patch.object(db, 'virtual_interface_create') as create:
@ -94,8 +94,8 @@ class _TestVirtualInterface(object):
vif = vif_obj.VirtualInterface(context=self.context) vif = vif_obj.VirtualInterface(context=self.context)
vif.address = '00:00:00:00:00:00' vif.address = '00:00:00:00:00:00'
vif.network_id = 123 vif.network_id = 123
vif.instance_uuid = 'fake-uuid' vif.instance_uuid = uuids.instance
vif.uuid = 'fake-uuid-2' vif.uuid = uuids.uuid
vif.tag = 'fake-tag' vif.tag = 'fake-tag'
primitive = vif.obj_to_primitive(target_version='1.0') primitive = vif.obj_to_primitive(target_version='1.0')