pull-up from trunk

9 files changed, 144 insertions, 217 deletions

diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index 2297d2f0e..073216495 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -42,3 +42,4 @@ FLAGS['iscsi_num_targets'].SetDefault(8)
 FLAGS['verbose'].SetDefault(True)
 FLAGS['sqlite_db'].SetDefault("tests.sqlite")
 FLAGS['use_ipv6'].SetDefault(True)
+FLAGS['flat_network_bridge'].SetDefault('br100')
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index f87edc407..e419e7a50 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -121,7 +121,6 @@ class CloudTestCase(test.TestCase):
                                   public_ip=address)
         db.floating_ip_destroy(self.context, address)
 
-    @test.skip_test("Skipping this pending future merge")
     def test_allocate_address(self):
         address = "10.10.10.10"
         allocate = self.cloud.allocate_address
@@ -161,13 +160,10 @@ class CloudTestCase(test.TestCase):
         # ApiError: Floating ip is in use.  Disassociate it before releasing.
         self.assertRaises(exception.ApiError, release, self.context, address)
 
-    @test.skip_test("Skipping this pending future merge")
     def test_associate_disassociate_address(self):
         """Verifies associate runs cleanly without raising an exception"""
         address = "10.10.10.10"
-        db.floating_ip_create(self.context,
-                              {'address': address,
-                               'host': self.network.host})
+        db.floating_ip_create(self.context, {'address': address})
         self.cloud.allocate_address(self.context)
         # TODO(jkoelker) Probably need to query for instance_type_id and
         #                make sure we get a valid one
@@ -175,11 +171,14 @@ class CloudTestCase(test.TestCase):
                                                  'instance_type_id': 1})
         networks = db.network_get_all(self.context)
         for network in networks:
-            self.network.set_network_host(self.context, network['id'])
+            db.network_update(self.context, network['id'],
+                              {'host': self.network.host})
         project_id = self.context.project_id
         type_id = inst['instance_type_id']
         ips = self.network.allocate_for_instance(self.context,
                                                  instance_id=inst['id'],
+                                                 host=inst['host'],
+                                                 vpn=None,
                                                  instance_type_id=type_id,
                                                  project_id=project_id)
         # TODO(jkoelker) Make this mas bueno
@@ -422,8 +421,6 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, service1['id'])
         db.service_destroy(self.context, service2['id'])
 
-    # NOTE(jkoelker): this test relies on fixed_ip being in instances
-    @test.skip_test("EC2 stuff needs fixed_ip in instance_ref")
     def test_describe_snapshots(self):
         """Makes sure describe_snapshots works and filters results."""
         vol = db.volume_create(self.context, {})
@@ -1058,12 +1055,6 @@ class CloudTestCase(test.TestCase):
         self.cloud.delete_key_pair(self.context, 'test')
 
     def test_run_instances(self):
-        # stub out the rpc call
-        def stub_cast(*args, **kwargs):
-            pass
-
-        self.stubs.Set(rpc, 'cast', stub_cast)
-
         kwargs = {'image_id': FLAGS.default_image,
                   'instance_type': FLAGS.default_instance_type,
                   'max_count': 1}
@@ -1073,7 +1064,7 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(instance['imageId'], 'ami-00000001')
         self.assertEqual(instance['displayName'], 'Server 1')
         self.assertEqual(instance['instanceId'], 'i-00000001')
-        self.assertEqual(instance['instanceState']['name'], 'scheduling')
+        self.assertEqual(instance['instanceState']['name'], 'running')
         self.assertEqual(instance['instanceType'], 'm1.small')
 
     def test_run_instances_image_state_none(self):
@@ -1145,16 +1136,15 @@ class CloudTestCase(test.TestCase):
         self.assertEqual('c00l 1m4g3', inst['display_name'])
         db.instance_destroy(self.context, inst['id'])
 
-    # NOTE(jkoelker): This test relies on mac_address in instance
-    @test.skip_test("EC2 stuff needs mac_address in instance_ref")
     def test_update_of_instance_wont_update_private_fields(self):
         inst = db.instance_create(self.context, {})
+        host = inst['host']
         ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3',
-                                   mac_address='DE:AD:BE:EF')
+                                   host='otherhost')
         inst = db.instance_get(self.context, inst['id'])
-        self.assertEqual(None, inst['mac_address'])
+        self.assertEqual(host, inst['host'])
         db.instance_destroy(self.context, inst['id'])
 
     def test_update_of_volume_display_fields(self):
@@ -1210,7 +1200,6 @@ class CloudTestCase(test.TestCase):
         elevated = self.context.elevated(read_deleted=True)
         self._wait_for_state(elevated, instance_id, is_deleted)
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_start_instance(self):
         """Makes sure stop/start instance works"""
         # enforce periodic tasks run in short time to avoid wait for 60s.
@@ -1268,7 +1257,6 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(vol['status'], "available")
         self.assertEqual(vol['attach_status'], "detached")
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_start_with_volume(self):
         """Make sure run instance with block device mapping works"""
 
@@ -1337,7 +1325,6 @@ class CloudTestCase(test.TestCase):
 
         self._restart_compute_service()
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_stop_with_attached_volume(self):
         """Make sure attach info is reflected to block device mapping"""
         # enforce periodic tasks run in short time to avoid wait for 60s.
@@ -1413,7 +1400,6 @@ class CloudTestCase(test.TestCase):
         greenthread.sleep(0.3)
         return result['snapshotId']
 
-    @test.skip_test("skipping, test is hanging with multinic for rpc reasons")
     def test_run_with_snapshot(self):
         """Makes sure run/stop/start instance with snapshot works."""
         vol = self._volume_create()
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 2a8f33dd3..0ede4f469 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -583,8 +583,9 @@ class ComputeTestCase(test.TestCase):
         the same host"""
         instance_id = self._create_instance()
         self.compute.run_instance(self.context, instance_id)
+        inst_ref = db.instance_get(self.context, instance_id)
         self.assertRaises(exception.Error, self.compute.prep_resize,
-                self.context, instance_id, 1)
+                self.context, inst_ref['uuid'], 1)
         self.compute.terminate_instance(self.context, instance_id)
 
     def test_migrate(self):
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index d4f8f00d8..d8462eb25 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -88,7 +88,7 @@ def _setup_networking(instance_id, ip='1.2.3.4'):
                 'virtual_interface_id': vif_ref['id']}
     db.fixed_ip_create(ctxt, fixed_ip)
     db.fixed_ip_update(ctxt, ip, {'allocated': True,
-                                        'instance_id': instance_id})
+                                  'instance_id': instance_id})
 
 
 class CacheConcurrencyTestCase(test.TestCase):
@@ -177,13 +177,13 @@ class LibvirtConnTestCase(test.TestCase):
         self.context = context.get_admin_context()
         FLAGS.instances_path = ''
         self.call_libvirt_dependant_setup = False
+        self.test_ip = '10.11.12.13'
 
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
         super(LibvirtConnTestCase, self).tearDown()
 
-    test_ip = '10.11.12.13'
     test_instance = {'memory_kb':     '1024000',
                      'basepath':      '/some/path',
                      'bridge_name':   'br100',
@@ -232,6 +232,16 @@ class LibvirtConnTestCase(test.TestCase):
             def setattr(self, key, val):
                 self.__setattr__(key, val)
 
+            def plug(self, instance, network, mapping):
+                return {
+                    'id': 'fake',
+                    'bridge_name': 'fake',
+                    'mac_address': 'fake',
+                    'ip_address': 'fake',
+                    'dhcp_server': 'fake',
+                    'extra_params': 'fake'
+                }
+
         # Creating mocks
         fake = FakeLibvirtConnection()
         fakeip = FakeIptablesFirewallDriver
@@ -280,7 +290,6 @@ class LibvirtConnTestCase(test.TestCase):
 
         return db.service_create(context.get_admin_context(), service_ref)
 
-    @test.skip_test("Please review this test to ensure intent")
     def test_preparing_xml_info(self):
         conn = connection.LibvirtConnection(True)
         instance_ref = db.instance_create(self.context, self.test_instance)
@@ -296,27 +305,23 @@ class LibvirtConnTestCase(test.TestCase):
                                         _create_network_info(2))
         self.assertTrue(len(result['nics']) == 2)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_ramdisk_no_kernel(self):
         instance_data = dict(self.test_instance)
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=False, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_ramdisk(self):
         instance_data = dict(self.test_instance)
         instance_data['kernel_id'] = 'aki-deadbeef'
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=True, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_no_kernel(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=False, expect_ramdisk=False)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
@@ -324,7 +329,6 @@ class LibvirtConnTestCase(test.TestCase):
         self._check_xml_and_uri(instance_data,
                                 expect_kernel=True, expect_ramdisk=True)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_xml_and_uri_rescue(self):
         instance_data = dict(self.test_instance)
         instance_data['ramdisk_id'] = 'ari-deadbeef'
@@ -332,7 +336,6 @@ class LibvirtConnTestCase(test.TestCase):
         self._check_xml_and_uri(instance_data, expect_kernel=True,
                                 expect_ramdisk=True, rescue=True)
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_lxc_container_and_uri(self):
         instance_data = dict(self.test_instance)
         self._check_xml_and_container(instance_data)
@@ -412,6 +415,15 @@ class LibvirtConnTestCase(test.TestCase):
         self.assertEquals(snapshot['status'], 'active')
         self.assertEquals(snapshot['name'], snapshot_name)
 
+    def test_attach_invalid_device(self):
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InvalidDevicePath,
+                          conn.attach_volume,
+                          "fake", "bad/device/path", "/dev/fake")
+
     def test_multi_nic(self):
         instance_data = dict(self.test_instance)
         network_info = _create_network_info(2)
@@ -432,24 +444,7 @@ class LibvirtConnTestCase(test.TestCase):
         user_context = context.RequestContext(project=self.project,
                                               user=self.user)
         instance_ref = db.instance_create(user_context, instance)
-        # Re-get the instance so it's bound to an actual session
-        instance_ref = db.instance_get(user_context, instance_ref['id'])
-        network_ref = db.project_get_networks(context.get_admin_context(),
-                                             self.project.id)[0]
-
-        vif = {'address': '56:12:12:12:12:12',
-               'network_id': network_ref['id'],
-               'instance_id': instance_ref['id']}
-        vif_ref = db.virtual_interface_create(self.context, vif)
-        fixed_ip = {'address': self.test_ip,
-                    'network_id': network_ref['id'],
-                    'virtual_interface_id': vif_ref['id']}
-
-        ctxt = context.get_admin_context()
-        fixed_ip_ref = db.fixed_ip_create(ctxt, fixed_ip)
-        db.fixed_ip_update(ctxt, self.test_ip,
-                                 {'allocated': True,
-                                  'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         self.flags(libvirt_type='lxc')
         conn = connection.LibvirtConnection(True)
@@ -481,7 +476,7 @@ class LibvirtConnTestCase(test.TestCase):
         network_ref = db.project_get_networks(context.get_admin_context(),
                                              self.project.id)[0]
 
-        _setup_networking(instance_ref['id'], ip=self.test_ip)
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         type_uri_map = {'qemu': ('qemu:///system',
                              [(lambda t: t.find('.').get('type'), 'qemu'),
@@ -743,7 +738,6 @@ class LibvirtConnTestCase(test.TestCase):
         db.volume_destroy(self.context, volume_ref['id'])
         db.instance_destroy(self.context, instance_ref['id'])
 
-    @test.skip_test("test needs rewrite: instance no longer has mac_address")
     def test_spawn_with_network_info(self):
         # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
@@ -762,17 +756,7 @@ class LibvirtConnTestCase(test.TestCase):
         conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
         conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
 
-        network = db.project_get_networks(context.get_admin_context(),
-                                          self.project.id)[0]
-        ip_dict = {'ip': self.test_ip,
-                   'netmask': network['netmask'],
-                   'enabled': '1'}
-        mapping = {'label': network['label'],
-                   'gateway': network['gateway'],
-                   'mac': instance['mac_address'],
-                   'dns': [network['dns']],
-                   'ips': [ip_dict]}
-        network_info = [(network, mapping)]
+        network_info = _create_network_info()
 
         try:
             conn.spawn(self.context, instance, network_info)
@@ -830,6 +814,7 @@ class IptablesFirewallTestCase(test.TestCase):
                 """setup_basic_rules in nwfilter calls this."""
                 pass
         self.fake_libvirt_connection = FakeLibvirtConnection()
+        self.test_ip = '10.11.12.13'
         self.fw = firewall.IptablesFirewallDriver(
                       get_connection=lambda: self.fake_libvirt_connection)
 
@@ -895,27 +880,11 @@ class IptablesFirewallTestCase(test.TestCase):
                                    'project_id': 'fake',
                                    'instance_type_id': 1})
 
-    @test.skip_test("skipping libvirt tests depends on get_network_info shim")
     def test_static_filters(self):
         instance_ref = self._create_instance_ref()
-        ip = '10.11.12.13'
-
-        network_ref = db.project_get_networks(self.context,
-                                               'fake',
-                                               associate=True)[0]
-        vif = {'address': '56:12:12:12:12:12',
-               'network_id': network_ref['id'],
-               'instance_id': instance_ref['id']}
-        vif_ref = db.virtual_interface_create(self.context, vif)
-
-        fixed_ip = {'address': ip,
-                    'network_id': network_ref['id'],
-                    'virtual_interface_id': vif_ref['id']}
-        admin_ctxt = context.get_admin_context()
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
 
+        admin_ctxt = context.get_admin_context()
         secgroup = db.security_group_create(admin_ctxt,
                                             {'user_id': 'fake',
                                              'project_id': 'fake',
@@ -1047,7 +1016,6 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertEquals(ipv6_network_rules,
                           ipv6_rules_per_network * networks_count)
 
-    @test.skip_test("skipping libvirt tests")
     def test_do_refresh_security_group_rules(self):
         instance_ref = self._create_instance_ref()
         self.mox.StubOutWithMock(self.fw,
@@ -1058,7 +1026,6 @@ class IptablesFirewallTestCase(test.TestCase):
         self.mox.ReplayAll()
         self.fw.do_refresh_security_group_rules("fake")
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_unfilter_instance_undefines_nwfilter(self):
         # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
@@ -1072,38 +1039,24 @@ class IptablesFirewallTestCase(test.TestCase):
         self.fw.nwfilter._conn.nwfilterLookupByName =\
                                fakefilter.nwfilterLookupByName
         instance_ref = self._create_instance_ref()
-        inst_id = instance_ref['id']
-        instance = db.instance_get(self.context, inst_id)
 
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': inst_id})
-        self.fw.setup_basic_filtering(instance)
-        self.fw.prepare_instance_filter(instance)
-        self.fw.apply_instance_filter(instance)
+        _setup_networking(instance_ref['id'], self.test_ip)
+        self.fw.setup_basic_filtering(instance_ref)
+        self.fw.prepare_instance_filter(instance_ref)
+        self.fw.apply_instance_filter(instance_ref)
         original_filter_count = len(fakefilter.filters)
-        self.fw.unfilter_instance(instance)
+        self.fw.unfilter_instance(instance_ref)
 
         # should undefine just the instance filter
         self.assertEqual(original_filter_count - len(fakefilter.filters), 1)
 
         db.instance_destroy(admin_ctxt, instance_ref['id'])
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_provider_firewall_rules(self):
         # setup basic instance data
         instance_ref = self._create_instance_ref()
         nw_info = _create_network_info(1)
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        admin_ctxt = context.get_admin_context()
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': instance_ref['id']})
+        _setup_networking(instance_ref['id'], self.test_ip)
         # FRAGILE: peeks at how the firewall names chains
         chain_name = 'inst-%s' % instance_ref['id']
 
@@ -1115,6 +1068,7 @@ class IptablesFirewallTestCase(test.TestCase):
                       if rule.chain == 'provider']
         self.assertEqual(0, len(rules))
 
+        admin_ctxt = context.get_admin_context()
         # add a rule and send the update message, check for 1 rule
         provider_fw0 = db.provider_fw_rule_create(admin_ctxt,
                                                   {'protocol': 'tcp',
@@ -1173,6 +1127,7 @@ class NWFilterTestCase(test.TestCase):
 
         self.fake_libvirt_connection = Mock()
 
+        self.test_ip = '10.11.12.13'
         self.fw = firewall.NWFilterFirewall(
                                          lambda: self.fake_libvirt_connection)
 
@@ -1259,7 +1214,6 @@ class NWFilterTestCase(test.TestCase):
         inst.update(params)
         return db.instance_type_create(context, inst)['id']
 
-    @test.skip_test('Skipping this test')
     def test_creates_base_rule_first(self):
         # These come pre-defined by libvirt
         self.defined_filters = ['no-mac-spoofing',
@@ -1291,21 +1245,11 @@ class NWFilterTestCase(test.TestCase):
         instance_ref = self._create_instance()
         inst_id = instance_ref['id']
 
-        ip = '10.11.12.13'
-
-        #network_ref = db.project_get_networks(self.context, 'fake')[0]
-        #fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-
-        #admin_ctxt = context.get_admin_context()
-        #db.fixed_ip_create(admin_ctxt, fixed_ip)
-        #db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-        #                                    'instance_id': inst_id})
-
-        self._setup_networking(instance_ref['id'], ip=ip)
+        _setup_networking(instance_ref['id'], self.test_ip)
 
         def _ensure_all_called():
             instance_filter = 'nova-instance-%s-%s' % (instance_ref['name'],
-                                                       '00A0C914C829')
+                                                       '561212121212')
             secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
             for required in [secgroup_filter, 'allow-dhcp-server',
                              'no-arp-spoofing', 'no-ip-spoofing',
@@ -1326,7 +1270,7 @@ class NWFilterTestCase(test.TestCase):
         self.fw.apply_instance_filter(instance)
         _ensure_all_called()
         self.teardown_security_group()
-        db.instance_destroy(admin_ctxt, instance_ref['id'])
+        db.instance_destroy(context.get_admin_context(), instance_ref['id'])
 
     def test_create_network_filters(self):
         instance_ref = self._create_instance()
@@ -1336,7 +1280,6 @@ class NWFilterTestCase(test.TestCase):
                                                  "fake")
         self.assertEquals(len(result), 3)
 
-    @test.skip_test("skip libvirt test project_get_network no longer exists")
     def test_unfilter_instance_undefines_nwfilters(self):
         admin_ctxt = context.get_admin_context()
 
@@ -1354,12 +1297,7 @@ class NWFilterTestCase(test.TestCase):
 
         instance = db.instance_get(self.context, inst_id)
 
-        ip = '10.11.12.13'
-        network_ref = db.project_get_network(self.context, 'fake')
-        fixed_ip = {'address': ip, 'network_id': network_ref['id']}
-        db.fixed_ip_create(admin_ctxt, fixed_ip)
-        db.fixed_ip_update(admin_ctxt, ip, {'allocated': True,
-                                            'instance_id': inst_id})
+        _setup_networking(instance_ref['id'], self.test_ip)
         self.fw.setup_basic_filtering(instance)
         self.fw.prepare_instance_filter(instance)
         self.fw.apply_instance_filter(instance)
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 69d2deafe..a35caadf8 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -269,11 +269,10 @@ class QuotaTestCase(test.TestCase):
         for volume_id in volume_ids:
             db.volume_destroy(self.context, volume_id)
 
-    @test.skip_test
     def test_too_many_addresses(self):
         address = '192.168.0.100'
         db.floating_ip_create(context.get_admin_context(),
-                              {'address': address, 'host': FLAGS.host,
+                              {'address': address,
                                'project_id': self.project.id})
         self.assertRaises(quota.QuotaError,
                           self.network.allocate_floating_ip,
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index cbf7801cf..7313508a6 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -19,9 +19,6 @@
 Test suite for VMWareAPI.
 """
 
-import stubout
-
-from nova import context
 from nova import db
 from nova import flags
 from nova import test
@@ -41,51 +38,66 @@ FLAGS = flags.FLAGS
 class VMWareAPIVMTestCase(test.TestCase):
     """Unit tests for Vmware API connection calls."""
 
-    # NOTE(jkoelker): This is leaking stubs into the db module.
-    #                 Commenting out until updated for multi-nic.
-    #def setUp(self):
-    #    super(VMWareAPIVMTestCase, self).setUp()
-    #    self.flags(vmwareapi_host_ip='test_url',
-    #               vmwareapi_host_username='test_username',
-    #               vmwareapi_host_password='test_pass')
-    #    self.manager = manager.AuthManager()
-    #    self.user = self.manager.create_user('fake', 'fake', 'fake',
-    #                                         admin=True)
-    #    self.project = self.manager.create_project('fake', 'fake', 'fake')
-    #    self.network = utils.import_object(FLAGS.network_manager)
-    #    self.stubs = stubout.StubOutForTesting()
-    #    vmwareapi_fake.reset()
-    #    db_fakes.stub_out_db_instance_api(self.stubs)
-    #    stubs.set_stubs(self.stubs)
-    #    glance_stubs.stubout_glance_client(self.stubs,
-    #                                       glance_stubs.FakeGlance)
-    #    self.conn = vmwareapi_conn.get_connection(False)
-
-    #def tearDown(self):
-    #    super(VMWareAPIVMTestCase, self).tearDown()
-    #    vmwareapi_fake.cleanup()
-    #    self.manager.delete_project(self.project)
-    #    self.manager.delete_user(self.user)
-    #    self.stubs.UnsetAll()
+    def setUp(self):
+        super(VMWareAPIVMTestCase, self).setUp()
+        self.flags(vmwareapi_host_ip='test_url',
+                   vmwareapi_host_username='test_username',
+                   vmwareapi_host_password='test_pass')
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('fake', 'fake', 'fake',
+                                             admin=True)
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
+        self.network = utils.import_object(FLAGS.network_manager)
+        vmwareapi_fake.reset()
+        db_fakes.stub_out_db_instance_api(self.stubs)
+        stubs.set_stubs(self.stubs)
+        glance_stubs.stubout_glance_client(self.stubs)
+        self.conn = vmwareapi_conn.get_connection(False)
+        # NOTE(vish): none of the network plugging code is actually
+        #             being tested
+        self.network_info = [({'bridge': 'fa0',
+                               'id': 0,
+                               'vlan': None,
+                               'bridge_interface': None,
+                               'injected': True},
+                          {'broadcast': '192.168.0.255',
+                           'dns': ['192.168.0.1'],
+                           'gateway': '192.168.0.1',
+                           'gateway6': 'dead:beef::1',
+                           'ip6s': [{'enabled': '1',
+                                     'ip': 'dead:beef::dcad:beff:feef:0',
+                                           'netmask': '64'}],
+                           'ips': [{'enabled': '1',
+                                    'ip': '192.168.0.100',
+                                    'netmask': '255.255.255.0'}],
+                           'label': 'fake',
+                           'mac': 'DE:AD:BE:EF:00:00',
+                           'rxtx_cap': 3})]
+
+    def tearDown(self):
+        super(VMWareAPIVMTestCase, self).tearDown()
+        vmwareapi_fake.cleanup()
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
 
     def _create_instance_in_the_db(self):
         values = {'name': 1,
                   'id': 1,
                   'project_id': self.project.id,
                   'user_id': self.user.id,
-                  'image_id': "1",
+                  'image_ref': "1",
                   'kernel_id': "1",
                   'ramdisk_id': "1",
+                  'mac_address': "de:ad:be:ef:be:ef",
                   'instance_type': 'm1.large',
-                  'mac_address': 'aa:bb:cc:dd:ee:ff',
                   }
-        self.instance = db.instance_create(values)
+        self.instance = db.instance_create(None, values)
 
     def _create_vm(self):
         """Create and spawn the VM."""
         self._create_instance_in_the_db()
         self.type_data = db.instance_type_get_by_name(None, 'm1.large')
-        self.conn.spawn(self.instance)
+        self.conn.spawn(self.instance, self.network_info)
         self._check_vm_record()
 
     def _check_vm_record(self):
@@ -129,24 +141,20 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.assertEquals(info["mem"], mem_kib)
         self.assertEquals(info["num_cpu"], self.type_data['vcpus'])
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_list_instances(self):
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 0)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_list_instances_1(self):
         self._create_vm()
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_spawn(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_snapshot(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -155,27 +163,23 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_snapshot_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.snapshot, self.instance,
                           "Test-Snapshot")
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
-        self.conn.reboot(self.instance)
+        self.conn.reboot(self.instance, self.network_info)
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.reboot, self.instance)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_reboot_not_poweredon(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -185,7 +189,6 @@ class VMWareAPIVMTestCase(test.TestCase):
         self._check_vm_info(info, power_state.PAUSED)
         self.assertRaises(Exception, self.conn.reboot, self.instance)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_suspend(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -194,13 +197,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.PAUSED)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_suspend_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.suspend, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -212,13 +213,11 @@ class VMWareAPIVMTestCase(test.TestCase):
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume_non_existent(self):
         self._create_instance_in_the_db()
         self.assertRaises(Exception, self.conn.resume, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_resume_not_suspended(self):
         self._create_vm()
         info = self.conn.get_info(1)
@@ -226,49 +225,41 @@ class VMWareAPIVMTestCase(test.TestCase):
         self.assertRaises(Exception, self.conn.resume, self.instance,
                           self.dummy_callback_handler)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_info(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_destroy(self):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 1)
-        self.conn.destroy(self.instance)
+        self.conn.destroy(self.instance, self.network_info)
         instances = self.conn.list_instances()
         self.assertEquals(len(instances), 0)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_destroy_non_existent(self):
         self._create_instance_in_the_db()
-        self.assertEquals(self.conn.destroy(self.instance), None)
+        self.assertEquals(self.conn.destroy(self.instance, self.network_info),
+                          None)
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_pause(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_unpause(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_diagnostics(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_console_output(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def test_get_ajax_console(self):
         pass
 
-    @test.skip_test("DB stubbing not removed, needs updating for multi-nic")
     def dummy_callback_handler(self, ret):
         """
         Dummy callback function to be passed to suspend, resume, etc., calls.
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index fd8416424..bb1b88421 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -397,18 +397,22 @@ class XenAPIVMTestCase(test.TestCase):
     def _test_spawn(self, image_ref, kernel_id, ramdisk_id,
                     instance_type_id="3", os_type="linux",
                     architecture="x86-64", instance_id=1,
-                    check_injection=False):
+                    check_injection=False,
+                    create_record=True):
         stubs.stubout_loopingcall_start(self.stubs)
-        values = {'id': instance_id,
-                  'project_id': self.project.id,
-                  'user_id': self.user.id,
-                  'image_ref': image_ref,
-                  'kernel_id': kernel_id,
-                  'ramdisk_id': ramdisk_id,
-                  'instance_type_id': instance_type_id,
-                  'os_type': os_type,
-                  'architecture': architecture}
-        instance = db.instance_create(self.context, values)
+        if create_record:
+            values = {'id': instance_id,
+                      'project_id': self.project.id,
+                      'user_id': self.user.id,
+                      'image_ref': image_ref,
+                      'kernel_id': kernel_id,
+                      'ramdisk_id': ramdisk_id,
+                      'instance_type_id': instance_type_id,
+                      'os_type': os_type,
+                      'architecture': architecture}
+            instance = db.instance_create(self.context, values)
+        else:
+            instance = db.instance_get(self.context, instance_id)
         network_info = [({'bridge': 'fa0', 'id': 0, 'injected': True},
                           {'broadcast': '192.168.0.255',
                            'dns': ['192.168.0.1'],
@@ -600,41 +604,38 @@ class XenAPIVMTestCase(test.TestCase):
         # guest agent is detected
         self.assertFalse(self._tee_executed)
 
-    @test.skip_test("Never gets an address, not sure why")
     def test_spawn_vlanmanager(self):
         self.flags(xenapi_image_service='glance',
                    network_manager='nova.network.manager.VlanManager',
-                   network_driver='nova.network.xenapi_net',
                    vlan_interface='fake0')
 
         def dummy(*args, **kwargs):
             pass
 
-        self.stubs.Set(VMOps, 'create_vifs', dummy)
+        self.stubs.Set(vmops.VMOps, 'create_vifs', dummy)
         # Reset network table
         xenapi_fake.reset_table('network')
         # Instance id = 2 will use vlan network (see db/fakes.py)
         ctxt = self.context.elevated()
-        instance_ref = self._create_instance(2)
-        network_bk = self.network
-        # Ensure we use xenapi_net driver
-        self.network = utils.import_object(FLAGS.network_manager)
+        instance = self._create_instance(2, False)
         networks = self.network.db.network_get_all(ctxt)
         for network in networks:
-            self.network.set_network_host(ctxt, network['id'])
-
-        self.network.allocate_for_instance(ctxt, instance_id=instance_ref.id,
-                instance_type_id=1, project_id=self.project.id)
-        self.network.setup_compute_network(ctxt, instance_ref.id)
+            self.network.set_network_host(ctxt, network)
+
+        self.network.allocate_for_instance(ctxt,
+                                           instance_id=2,
+                                           host=FLAGS.host,
+                                           vpn=None,
+                                           instance_type_id=1,
+                                           project_id=self.project.id)
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK,
-                         instance_id=instance_ref.id,
+                         instance_id=2,
                          create_record=False)
         # TODO(salvatore-orlando): a complete test here would require
         # a check for making sure the bridge for the VM's VIF is
         # consistent with bridge specified in nova db
-        self.network = network_bk
 
     def test_spawn_with_network_qos(self):
         self._create_instance()
@@ -645,7 +646,7 @@ class XenAPIVMTestCase(test.TestCase):
                               str(3 * 1024))
 
     def test_rescue(self):
-        self.flags(xenapi_inject_image=False)
+        self.flags(flat_injected=False)
         instance = self._create_instance()
         conn = xenapi_conn.get_connection(False)
         conn.rescue(instance, None, [])
@@ -664,7 +665,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.vm = None
         self.stubs.UnsetAll()
 
-    def _create_instance(self, instance_id=1):
+    def _create_instance(self, instance_id=1, spawn=True):
         """Creates and spawns a test instance."""
         stubs.stubout_loopingcall_start(self.stubs)
         values = {
@@ -692,7 +693,8 @@ class XenAPIVMTestCase(test.TestCase):
                            'label': 'fake',
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
-        self.conn.spawn(self.context, instance, network_info)
+        if spawn:
+            self.conn.spawn(self.context, instance, network_info)
         return instance
 
 
diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
index d4eb87daf..afd672c7a 100644
--- a/nova/tests/vmwareapi/db_fakes.py
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -70,8 +70,8 @@ def stub_out_db_instance_api(stubs):
             'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),

             'instance_type': values['instance_type'],

             'memory_mb': type_data['memory_mb'],

-            'mac_address': values['mac_address'],

             'vcpus': type_data['vcpus'],

+            'mac_addresses': [{'address': values['mac_address']}],

             'local_gb': type_data['local_gb'],

             }

         return FakeModel(base_options)

@@ -83,6 +83,8 @@ def stub_out_db_instance_api(stubs):
             'bridge': 'vmnet0',

             'netmask': '255.255.255.0',

             'gateway': '10.10.10.1',

+            'broadcast': '10.10.10.255',

+            'dns1': 'fake',

             'vlan': 100}

         return FakeModel(fields)

 

@@ -90,7 +92,7 @@ def stub_out_db_instance_api(stubs):
         """Stubs out the db.instance_action_create method."""

         pass

 

-    def fake_instance_get_fixed_address(context, instance_id):

+    def fake_instance_get_fixed_addresses(context, instance_id):

         """Stubs out the db.instance_get_fixed_address method."""

         return '10.10.10.10'

 

@@ -103,7 +105,7 @@ def stub_out_db_instance_api(stubs):
     stubs.Set(db, 'instance_create', fake_instance_create)

     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)

     stubs.Set(db, 'instance_action_create', fake_instance_action_create)

-    stubs.Set(db, 'instance_get_fixed_address',

-                fake_instance_get_fixed_address)

+    stubs.Set(db, 'instance_get_fixed_addresses',

+                fake_instance_get_fixed_addresses)

     stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)

     stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)

diff --git a/nova/tests/vmwareapi/stubs.py b/nova/tests/vmwareapi/stubs.py
index a648efb16..0ed5e9b68 100644
--- a/nova/tests/vmwareapi/stubs.py
+++ b/nova/tests/vmwareapi/stubs.py
@@ -22,6 +22,8 @@ Stubouts for the test suite
 from nova.virt import vmwareapi_conn

 from nova.virt.vmwareapi import fake

 from nova.virt.vmwareapi import vmware_images

+from nova.virt.vmwareapi import vmops

+from nova.virt.vmwareapi import network_utils

 

 

 def fake_get_vim_object(arg):

@@ -36,11 +38,16 @@ def fake_is_vim_object(arg, module):
 

 def set_stubs(stubs):

     """Set the stubs."""

+    stubs.Set(vmops.VMWareVMOps, 'plug_vifs', fake.fake_plug_vifs)

+    stubs.Set(network_utils, 'get_network_with_the_name',

+              fake.fake_get_network)

     stubs.Set(vmware_images, 'fetch_image', fake.fake_fetch_image)

     stubs.Set(vmware_images, 'get_vmdk_size_and_properties',

               fake.fake_get_vmdk_size_and_properties)

     stubs.Set(vmware_images, 'upload_image', fake.fake_upload_image)

     stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",

               fake_get_vim_object)

+    stubs.Set(vmwareapi_conn.VMWareAPISession, "_get_vim_object",

+              fake_get_vim_object)

     stubs.Set(vmwareapi_conn.VMWareAPISession, "_is_vim_object",

               fake_is_vim_object)