Merge from trunk

12 files changed, 897 insertions, 156 deletions

diff --git a/nova/tests/api/openstack/contrib/test_floating_ips.py b/nova/tests/api/openstack/contrib/test_floating_ips.py
index 642f2b841..0744f0a11 100644
--- a/nova/tests/api/openstack/contrib/test_floating_ips.py
+++ b/nova/tests/api/openstack/contrib/test_floating_ips.py
@@ -212,11 +212,45 @@ class FloatingIpTest(test.TestCase):
             "fixed_ip": None}
         self.assertEqual(ip, expected)
 
-    def test_floating_ip_release(self):
+    def test_floating_ip_release_associated(self):
+        self.disassociated = False
+
+        def get_floating_ip(ignore, context, id):
+            return {'id': 1, 'address': '10.10.10.10',
+                    'fixed_ip': {'id': 1}}
+
+        def disassociate(ignore, context, floating_address):
+            self.disassociated = True
+
+        self.stubs.Set(network.api.API, "get_floating_ip",
+                       get_floating_ip)
+        self.stubs.Set(network.api.API, "disassociate_floating_ip",
+                       disassociate)
+        req = webob.Request.blank('/v1.1/123/os-floating-ips/1')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+        self.assertTrue(self.disassociated)
+
+    def test_floating_ip_release_disassociated(self):
+        self.disassociated = False
+
+        def fake_get_floating_ip(ignore, context, id):
+            return {'id': 1, 'address': '10.10.10.10',
+                    'fixed_ip': None}
+
+        def fake_disassociate(ignore, context, floating_address):
+            self.disassociated = True
+
+        self.stubs.Set(network.api.API, "get_floating_ip",
+                       fake_get_floating_ip)
+        self.stubs.Set(network.api.API, "disassociate_floating_ip",
+                       fake_disassociate)
         req = webob.Request.blank('/v1.1/123/os-floating-ips/1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
+        self.assertFalse(self.disassociated)
 
     def test_add_floating_ip_to_instance(self):
         self.stubs.Set(network.api.API, "associate_floating_ip",
@@ -289,8 +323,45 @@ class FloatingIpTest(test.TestCase):
         self.assertEqual(resp.status_int, 202)
         self.assertTrue(self.disassociated)
 
-    def test_remove_floating_ip_from_instance(self):
-        body = dict(removeFloatingIp=dict(address='11.0.0.1'))
+    def test_remove_associated_floating_ip_from_instance(self):
+        self.disassociated = False
+
+        def fake_get_floating_ip_by_ip(ignore, context, ip):
+            return {'id': 1, 'address': '10.10.10.10',
+                    'fixed_ip': {'id': 1}}
+
+        def fake_disassociate(ignore, context, floating_address):
+            self.disassociated = True
+
+        self.stubs.Set(network.api.API, "get_floating_ip_by_ip",
+                       fake_get_floating_ip_by_ip)
+        self.stubs.Set(network.api.API, "disassociate_floating_ip",
+                       fake_disassociate)
+        body = dict(removeFloatingIp=dict(address='10.10.10.10'))
+        req = webob.Request.blank('/v1.1/123/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 202)
+        self.assertTrue(self.disassociated)
+
+    def test_remove_disassociated_floating_ip_from_instance(self):
+        self.disassociated = False
+
+        def fake_get_floating_ip_by_ip(ignore, context, ip):
+            return {'id': 1, 'address': '10.10.10.10',
+                    'fixed_ip': None}
+
+        def fake_disassociate(ignore, context, floating_address):
+            self.disassociated = True
+
+        self.stubs.Set(network.api.API, "get_floating_ip_by_ip",
+                       fake_get_floating_ip_by_ip)
+        self.stubs.Set(network.api.API, "disassociate_floating_ip",
+                       fake_disassociate)
+        body = dict(removeFloatingIp=dict(address='10.10.10.10'))
         req = webob.Request.blank('/v1.1/123/servers/test_inst/action')
         req.method = "POST"
         req.body = json.dumps(body)
@@ -298,6 +369,7 @@ class FloatingIpTest(test.TestCase):
 
         resp = req.get_response(fakes.wsgi_app())
         self.assertEqual(resp.status_int, 202)
+        self.assertFalse(self.disassociated)
 
     def test_bad_address_param_in_remove_floating_ip(self):
         body = dict(removeFloatingIp=dict(badparam='11.0.0.1'))
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 9d0f9c4f7..ee7927c64 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -3764,7 +3764,6 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "id": 1,
                 "uuid": self.instance['uuid'],
                 "name": "test_server",
-                "key_name": '',
                 "links": [
                     {
                         "rel": "self",
@@ -3775,7 +3774,6 @@ class ServersViewBuilderV11Test(test.TestCase):
                         "href": "http://localhost/servers/1",
                     },
                 ],
-                "config_drive": None,
             }
         }
 
@@ -3788,8 +3786,6 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "id": 1,
                 "uuid": self.instance['uuid'],
                 "name": "test_server",
-                "key_name": '',
-                "config_drive": None,
                 "links": [
                     {
                         "rel": "self",
diff --git a/nova/tests/fake_network.py b/nova/tests/fake_network.py
new file mode 100644
index 000000000..1ecb99b31
--- /dev/null
+++ b/nova/tests/fake_network.py
@@ -0,0 +1,164 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Rackspace
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from nova import db
+from nova import flags
+from nova import test
+from nova.network import manager as network_manager
+
+
+HOST = "testhost"
+FLAGS = flags.FLAGS
+
+
+class FakeModel(dict):
+    """Represent a model from the db"""
+    def __init__(self, *args, **kwargs):
+        self.update(kwargs)
+
+        def __getattr__(self, name):
+            return self[name]
+
+
+flavor = {'id': 0,
+          'name': 'fake_flavor',
+          'memory_mb': 2048,
+          'vcpus': 2,
+          'local_gb': 10,
+          'flavor_id': 0,
+          'swap': 0,
+          'rxtx_quota': 0,
+          'rxtx_cap': 3}
+
+
+def fake_network(network_id, ipv6=None):
+    if ipv6 is None:
+        ipv6 = FLAGS.use_ipv6
+    fake_network = {'id': network_id,
+                    'label': 'test%d' % network_id,
+                    'injected': False,
+                    'multi_host': False,
+                    'cidr': '192.168.%d.0/24' % network_id,
+                    'cidr_v6': None,
+                    'netmask': '255.255.255.0',
+                    'netmask_v6': None,
+                    'bridge': 'fake_br%d' % network_id,
+                    'bridge_interface': 'fake_eth%d' % network_id,
+                    'gateway': '192.168.%d.1' % network_id,
+                    'gateway_v6': None,
+                    'broadcast': '192.168.%d.255' % network_id,
+                    'dns1': '192.168.%d.3' % network_id,
+                    'dns2': '192.168.%d.4' % network_id,
+                    'vlan': None,
+                    'host': None,
+                    'project_id': 'fake_project',
+                    'vpn_public_address': '192.168.%d.2' % network_id}
+    if ipv6:
+        fake_network['cidr_v6'] = '2001:db8:0:%x::/64' % network_id
+        fake_network['gateway_v6'] = '2001:db8:0:%x::1' % network_id
+        fake_network['netmask_v6'] = '64'
+
+    return fake_network
+
+
+def vifs(n):
+    for x in xrange(n):
+        yield {'id': x,
+               'address': 'DE:AD:BE:EF:00:%02x' % x,
+               'uuid': '00000000-0000-0000-0000-00000000000000%02d' % x,
+               'network_id': x,
+               'network': FakeModel(**fake_network(x)),
+               'instance_id': 0}
+
+
+def floating_ip_ids():
+    for i in xrange(99):
+        yield i
+
+
+def fixed_ip_ids():
+    for i in xrange(99):
+        yield i
+
+
+floating_ip_id = floating_ip_ids()
+fixed_ip_id = fixed_ip_ids()
+
+
+def next_fixed_ip(network_id, num_floating_ips=0):
+    next_id = fixed_ip_id.next()
+    f_ips = [FakeModel(**next_floating_ip(next_id))
+             for i in xrange(num_floating_ips)]
+    return {'id': next_id,
+            'network_id': network_id,
+            'address': '192.168.%d.1%02d' % (network_id, next_id),
+            'instance_id': 0,
+            'allocated': False,
+            # and since network_id and vif_id happen to be equivalent
+            'virtual_interface_id': network_id,
+            'floating_ips': f_ips}
+
+
+def next_floating_ip(fixed_ip_id):
+    next_id = floating_ip_id.next()
+    return {'id': next_id,
+            'address': '10.10.10.1%02d' % next_id,
+            'fixed_ip_id': fixed_ip_id,
+            'project_id': None,
+            'auto_assigned': False}
+
+
+def ipv4_like(ip, match_string):
+    ip = ip.split('.')
+    match_octets = match_string.split('.')
+
+    for i, octet in enumerate(match_octets):
+        if octet == '*':
+            continue
+        if octet != ip[i]:
+            return False
+    return True
+
+
+def fake_get_instance_nw_info(stubs, num_networks=1, ips_per_vif=2,
+                              floating_ips_per_fixed_ip=0):
+    # stubs is the self.stubs from the test
+    # ips_per_vif is the number of ips each vif will have
+    # num_floating_ips is number of float ips for each fixed ip
+    network = network_manager.FlatManager(host=HOST)
+    network.db = db
+
+    # reset the fixed and floating ip generators
+    global floating_ip_id, fixed_ip_id
+    floating_ip_id = floating_ip_ids()
+    fixed_ip_id = fixed_ip_ids()
+
+    def fixed_ips_fake(*args, **kwargs):
+        return [next_fixed_ip(i, floating_ips_per_fixed_ip)
+                for i in xrange(num_networks) for j in xrange(ips_per_vif)]
+
+    def virtual_interfaces_fake(*args, **kwargs):
+        return [vif for vif in vifs(num_networks)]
+
+    def instance_type_fake(*args, **kwargs):
+        return flavor
+
+    stubs.Set(db, 'fixed_ip_get_by_instance', fixed_ips_fake)
+    stubs.Set(db, 'virtual_interface_get_by_instance', virtual_interfaces_fake)
+    stubs.Set(db, 'instance_type_get', instance_type_fake)
+
+    return network.get_instance_nw_info(None, 0, 0, None)
diff --git a/nova/tests/scheduler/test_abstract_scheduler.py b/nova/tests/scheduler/test_abstract_scheduler.py
index aa97e2344..5549ea453 100644
--- a/nova/tests/scheduler/test_abstract_scheduler.py
+++ b/nova/tests/scheduler/test_abstract_scheduler.py
@@ -26,6 +26,7 @@ from nova import test
 from nova.compute import api as compute_api
 from nova.scheduler import driver
 from nova.scheduler import abstract_scheduler
+from nova.scheduler import base_scheduler
 from nova.scheduler import zone_manager
 
 
@@ -65,6 +66,11 @@ class FakeAbstractScheduler(abstract_scheduler.AbstractScheduler):
     pass
 
 
+class FakeBaseScheduler(base_scheduler.BaseScheduler):
+    # No need to stub anything at the moment
+    pass
+
+
 class FakeZoneManager(zone_manager.ZoneManager):
     def __init__(self):
         self.service_states = {
@@ -365,3 +371,52 @@ class AbstractSchedulerTestCase(test.TestCase):
 
         self.assertEqual(fixture._decrypt_blob(test_data),
                          json.dumps(test_data))
+
+    def test_empty_local_hosts(self):
+        """
+        Create a nested set of FakeZones, try to build multiple instances
+        and ensure that a select call returns the appropriate build plan.
+        """
+        sched = FakeAbstractScheduler()
+        self.stubs.Set(sched, '_call_zone_method', fake_call_zone_method)
+        self.stubs.Set(nova.db, 'zone_get_all', fake_zone_get_all)
+
+        zm = FakeZoneManager()
+        # patch this to have no local hosts
+        zm.service_states = {}
+        sched.set_zone_manager(zm)
+
+        fake_context = {}
+        build_plan = sched.select(fake_context,
+                {'instance_type': {'memory_mb': 512},
+                    'num_instances': 4})
+
+        # 0 from local zones, 12 from remotes
+        self.assertEqual(12, len(build_plan))
+
+
+class BaseSchedulerTestCase(test.TestCase):
+    """Test case for Base Scheduler."""
+
+    def test_weigh_hosts(self):
+        """
+        Try to weigh a short list of hosts and make sure enough
+        entries for a larger number instances are returned.
+        """
+
+        sched = FakeBaseScheduler()
+
+        # Fake out a list of hosts
+        zm = FakeZoneManager()
+        hostlist = [(host, services['compute'])
+                    for host, services in zm.service_states.items()
+                    if 'compute' in services]
+
+        # Call weigh_hosts()
+        num_instances = len(hostlist) * 2 + len(hostlist) / 2
+        instlist = sched.weigh_hosts('compute',
+                                     dict(num_instances=num_instances),
+                                     hostlist)
+
+        # Should be enough entries to cover all instances
+        self.assertEqual(len(instlist), num_instances)
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index a52dd041a..890348192 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -963,9 +963,14 @@ class FakeZone(object):
         self.password = password
 
 
+ZONE_API_URL1 = "http://1.example.com"
+ZONE_API_URL2 = "http://2.example.com"
+
+
 def zone_get_all(context):
     return [
-                FakeZone(1, 'http://example.com', 'bob', 'xxx'),
+                FakeZone(1, ZONE_API_URL1, 'bob', 'xxx'),
+                FakeZone(2, ZONE_API_URL2, 'bob', 'xxx'),
            ]
 
 
@@ -1065,7 +1070,9 @@ class ZoneRedirectTest(test.TestCase):
 
     def test_unmarshal_single_server(self):
         decorator = api.reroute_compute("foo")
-        self.assertEquals(decorator.unmarshall_result([]), {})
+        decorator.item_uuid = 'fake_uuid'
+        self.assertRaises(exception.InstanceNotFound,
+                decorator.unmarshall_result, [])
         self.assertEquals(decorator.unmarshall_result(
                 [FakeResource(dict(a=1, b=2)), ]),
                 dict(server=dict(a=1, b=2)))
@@ -1079,6 +1086,90 @@ class ZoneRedirectTest(test.TestCase):
                 [FakeResource(dict(_a=1, manager=2)), ]),
                 dict(server={}))
 
+    def test_one_zone_down_no_instances(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            return None
+
+        class FakeNovaClientWithFailure(object):
+            def __init__(self, username, password, method, api_url):
+                self.api_url = api_url
+
+            def authenticate(self):
+                if self.api_url == ZONE_API_URL2:
+                    raise novaclient_exceptions.BadRequest('foo')
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientWithFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        self.assertRaises(exception.ZoneRequestError,
+                do_get, None, {}, FAKE_UUID)
+
+    def test_one_zone_down_got_instance(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            class FakeServer(object):
+                def __init__(self):
+                    self.id = FAKE_UUID
+                    self.test = '1234'
+            return FakeServer()
+
+        class FakeNovaClientWithFailure(object):
+            def __init__(self, username, password, method, api_url):
+                self.api_url = api_url
+
+            def authenticate(self):
+                if self.api_url == ZONE_API_URL2:
+                    raise novaclient_exceptions.BadRequest('foo')
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientWithFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        try:
+            do_get(None, {}, FAKE_UUID)
+        except api.RedirectResult, e:
+            results = e.results
+            self.assertIn('server', results)
+            self.assertEqual(results['server']['id'], FAKE_UUID)
+            self.assertEqual(results['server']['test'], '1234')
+        except Exception, e:
+            self.fail(_("RedirectResult should have been raised"))
+        else:
+            self.fail(_("RedirectResult should have been raised"))
+
+    def test_zones_up_no_instances(self):
+
+        def _fake_issue_novaclient_command(nova, zone, *args, **kwargs):
+            return None
+
+        class FakeNovaClientNoFailure(object):
+            def __init__(self, username, password, method, api_url):
+                pass
+
+            def authenticate(self):
+                return
+
+        self.stubs.Set(api, '_issue_novaclient_command',
+                _fake_issue_novaclient_command)
+        self.stubs.Set(api.novaclient, 'Client', FakeNovaClientNoFailure)
+
+        @api.reroute_compute("get")
+        def do_get(self, context, uuid):
+            pass
+
+        self.assertRaises(exception.InstanceNotFound,
+                do_get, None, {}, FAKE_UUID)
+
 
 class FakeServerCollection(object):
     def get(self, instance_id):
@@ -1097,7 +1188,7 @@ class FakeEmptyServerCollection(object):
 
 
 class FakeNovaClient(object):
-    def __init__(self, collection):
+    def __init__(self, collection, *args, **kwargs):
         self.servers = collection
 
 
@@ -1162,8 +1253,9 @@ class CallZoneMethodTest(test.TestCase):
         context = {}
         method = 'do_something'
         results = api.call_zone_method(context, method)
-        expected = [(1, 42)]
-        self.assertEqual(expected, results)
+        self.assertEqual(len(results), 2)
+        self.assertIn((1, 42), results)
+        self.assertIn((2, 42), results)
 
     def test_call_zone_method_not_present(self):
         context = {}
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 3fe6a9b42..7fe353b3d 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -486,11 +486,9 @@ class CloudTestCase(test.TestCase):
         inst2 = db.instance_create(self.context, args2)
         db.instance_destroy(self.context, inst1.id)
         result = self.cloud.describe_instances(self.context)
+        self.assertEqual(len(result['reservationSet']), 1)
         result1 = result['reservationSet'][0]['instancesSet']
         self.assertEqual(result1[0]['instanceId'],
-                         ec2utils.id_to_ec2_id(inst1.id))
-        result2 = result['reservationSet'][1]['instancesSet']
-        self.assertEqual(result2[0]['instanceId'],
                          ec2utils.id_to_ec2_id(inst2.id))
 
     def _block_device_mapping_create(self, instance_id, mappings):
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 65fdffbd6..4d463572b 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -300,11 +300,20 @@ class ComputeTestCase(test.TestCase):
         self.compute.resume_instance(self.context, instance_id)
         self.compute.terminate_instance(self.context, instance_id)
 
-    def test_reboot(self):
-        """Ensure instance can be rebooted"""
+    def test_soft_reboot(self):
+        """Ensure instance can be soft rebooted"""
         instance_id = self._create_instance()
+        reboot_type = "SOFT"
         self.compute.run_instance(self.context, instance_id)
-        self.compute.reboot_instance(self.context, instance_id)
+        self.compute.reboot_instance(self.context, instance_id, reboot_type)
+        self.compute.terminate_instance(self.context, instance_id)
+
+    def test_hard_reboot(self):
+        """Ensure instance can be hard rebooted"""
+        instance_id = self._create_instance()
+        reboot_type = "HARD"
+        self.compute.run_instance(self.context, instance_id)
+        self.compute.reboot_instance(self.context, instance_id, reboot_type)
         self.compute.terminate_instance(self.context, instance_id)
 
     def test_set_admin_password(self):
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index 8c6775b29..93967ceec 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -37,61 +37,20 @@ from nova.compute import power_state
 from nova.compute import vm_states
 from nova.virt.libvirt import connection
 from nova.virt.libvirt import firewall
+from nova.tests import fake_network
 
 libvirt = None
 FLAGS = flags.FLAGS
 
+_fake_network_info = fake_network.fake_get_instance_nw_info
+_ipv4_like = fake_network.ipv4_like
+
 
 def _concurrency(wait, done, target):
     wait.wait()
     done.send()
 
 
-def _create_network_info(count=1, ipv6=None):
-    if ipv6 is None:
-        ipv6 = FLAGS.use_ipv6
-    fake = 'fake'
-    fake_ip = '10.11.12.13'
-    fake_ip_2 = '0.0.0.1'
-    fake_ip_3 = '0.0.0.1'
-    fake_vlan = 100
-    fake_bridge_interface = 'eth0'
-    network = {'bridge': fake,
-               'cidr': fake_ip,
-               'cidr_v6': fake_ip,
-               'gateway_v6': fake,
-               'vlan': fake_vlan,
-               'bridge_interface': fake_bridge_interface}
-    mapping = {'mac': fake,
-               'dhcp_server': '10.0.0.1',
-               'gateway': fake,
-               'gateway6': fake,
-               'ips': [{'ip': fake_ip}, {'ip': fake_ip}]}
-    if ipv6:
-        mapping['ip6s'] = [{'ip': fake_ip},
-                           {'ip': fake_ip_2},
-                           {'ip': fake_ip_3}]
-    return [(network, mapping) for x in xrange(0, count)]
-
-
-def _setup_networking(instance_id, ip='1.2.3.4', mac='56:12:12:12:12:12'):
-    ctxt = context.get_admin_context()
-    network_ref = db.project_get_networks(ctxt,
-                                           'fake',
-                                           associate=True)[0]
-    vif = {'address': mac,
-           'network_id': network_ref['id'],
-           'instance_id': instance_id}
-    vif_ref = db.virtual_interface_create(ctxt, vif)
-
-    fixed_ip = {'address': ip,
-                'network_id': network_ref['id'],
-                '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})
-
-
 class CacheConcurrencyTestCase(test.TestCase):
     def setUp(self):
         super(CacheConcurrencyTestCase, self).setUp()
@@ -163,7 +122,6 @@ class LibvirtConnTestCase(test.TestCase):
         self.context = context.get_admin_context()
         self.flags(instances_path='')
         self.call_libvirt_dependant_setup = False
-        self.test_ip = '10.11.12.13'
 
     test_instance = {'memory_kb':     '1024000',
                      'basepath':      '/some/path',
@@ -277,12 +235,12 @@ class LibvirtConnTestCase(test.TestCase):
         instance_ref = db.instance_create(self.context, self.test_instance)
 
         result = conn._prepare_xml_info(instance_ref,
-                                        _create_network_info(),
+                                        _fake_network_info(self.stubs, 1),
                                         False)
         self.assertTrue(len(result['nics']) == 1)
 
         result = conn._prepare_xml_info(instance_ref,
-                                        _create_network_info(2),
+                                        _fake_network_info(self.stubs, 2),
                                         False)
         self.assertTrue(len(result['nics']) == 2)
 
@@ -407,7 +365,7 @@ class LibvirtConnTestCase(test.TestCase):
 
     def test_multi_nic(self):
         instance_data = dict(self.test_instance)
-        network_info = _create_network_info(2)
+        network_info = _fake_network_info(self.stubs, 2)
         conn = connection.LibvirtConnection(True)
         instance_ref = db.instance_create(self.context, instance_data)
         xml = conn.to_xml(instance_ref, network_info, False)
@@ -417,15 +375,14 @@ class LibvirtConnTestCase(test.TestCase):
         parameters = interfaces[0].findall('./filterref/parameter')
         self.assertEquals(interfaces[0].get('type'), 'bridge')
         self.assertEquals(parameters[0].get('name'), 'IP')
-        self.assertEquals(parameters[0].get('value'), '10.11.12.13')
+        self.assertTrue(_ipv4_like(parameters[0].get('value'), '192.168'))
         self.assertEquals(parameters[1].get('name'), 'DHCPSERVER')
-        self.assertEquals(parameters[1].get('value'), '10.0.0.1')
+        self.assertTrue(_ipv4_like(parameters[1].get('value'), '192.168.*.1'))
 
     def _check_xml_and_container(self, instance):
         user_context = context.RequestContext(self.user_id,
                                               self.project_id)
         instance_ref = db.instance_create(user_context, instance)
-        _setup_networking(instance_ref['id'], self.test_ip)
 
         self.flags(libvirt_type='lxc')
         conn = connection.LibvirtConnection(True)
@@ -433,7 +390,7 @@ class LibvirtConnTestCase(test.TestCase):
         uri = conn.get_uri()
         self.assertEquals(uri, 'lxc:///')
 
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
         xml = conn.to_xml(instance_ref, network_info)
         tree = xml_to_tree(xml)
 
@@ -457,8 +414,6 @@ class LibvirtConnTestCase(test.TestCase):
         network_ref = db.project_get_networks(context.get_admin_context(),
                                              self.project_id)[0]
 
-        _setup_networking(instance_ref['id'], self.test_ip)
-
         type_uri_map = {'qemu': ('qemu:///system',
                              [(lambda t: t.find('.').get('type'), 'qemu'),
                               (lambda t: t.find('./os/type').text, 'hvm'),
@@ -504,9 +459,11 @@ class LibvirtConnTestCase(test.TestCase):
         common_checks = [
             (lambda t: t.find('.').tag, 'domain'),
             (lambda t: t.find(parameter).get('name'), 'IP'),
-            (lambda t: t.find(parameter).get('value'), '10.11.12.13'),
+            (lambda t: _ipv4_like(t.find(parameter).get('value'), '192.168'),
+             True),
             (lambda t: t.findall(parameter)[1].get('name'), 'DHCPSERVER'),
-            (lambda t: t.findall(parameter)[1].get('value'), '10.0.0.1'),
+            (lambda t: _ipv4_like(t.findall(parameter)[1].get('value'),
+                                  '192.168.*.1'), True),
             (lambda t: t.find('./devices/serial/source').get(
                 'path').split('/')[1], 'console.log'),
             (lambda t: t.find('./memory').text, '2097152')]
@@ -531,7 +488,7 @@ class LibvirtConnTestCase(test.TestCase):
             uri = conn.get_uri()
             self.assertEquals(uri, expected_uri)
 
-            network_info = _create_network_info()
+            network_info = _fake_network_info(self.stubs, 1)
             xml = conn.to_xml(instance_ref, network_info, rescue)
             tree = xml_to_tree(xml)
             for i, (check, expected_result) in enumerate(checks):
@@ -646,7 +603,7 @@ class LibvirtConnTestCase(test.TestCase):
 
         self.create_fake_libvirt_mock()
         instance_ref = db.instance_create(self.context, self.test_instance)
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
 
         # Start test
         self.mox.ReplayAll()
@@ -830,7 +787,7 @@ class LibvirtConnTestCase(test.TestCase):
         conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
         conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
 
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
 
         try:
             conn.spawn(self.context, instance, network_info)
@@ -923,7 +880,6 @@ 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)
 
@@ -987,10 +943,6 @@ class IptablesFirewallTestCase(test.TestCase):
     def test_static_filters(self):
         instance_ref = self._create_instance_ref()
         src_instance_ref = self._create_instance_ref()
-        src_ip = '10.11.12.14'
-        src_mac = '56:12:12:12:12:13'
-        _setup_networking(instance_ref['id'], self.test_ip, src_mac)
-        _setup_networking(src_instance_ref['id'], src_ip)
 
         admin_ctxt = context.get_admin_context()
         secgroup = db.security_group_create(admin_ctxt,
@@ -1061,10 +1013,17 @@ class IptablesFirewallTestCase(test.TestCase):
                 return '', ''
             print cmd, kwargs
 
+        def get_fixed_ips(*args, **kwargs):
+            ips = []
+            for network, info in network_info:
+                ips.extend(info['ips'])
+            return [ip['ip'] for ip in ips]
+
         from nova.network import linux_net
         linux_net.iptables_manager.execute = fake_iptables_execute
 
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
+        self.stubs.Set(db, 'instance_get_fixed_addresses', get_fixed_ips)
         self.fw.prepare_instance_filter(instance_ref, network_info)
         self.fw.apply_instance_filter(instance_ref, network_info)
 
@@ -1078,7 +1037,8 @@ class IptablesFirewallTestCase(test.TestCase):
         instance_chain = None
         for rule in self.out_rules:
             # This is pretty crude, but it'll do for now
-            if '-d 10.11.12.13 -j' in rule:
+            # last two octets change
+            if re.search('-d 192.168.[0-9]{1,3}.[0-9]{1,3} -j', rule):
                 instance_chain = rule.split(' ')[-1]
                 break
         self.assertTrue(instance_chain, "The instance chain wasn't added")
@@ -1101,10 +1061,11 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "ICMP Echo Request acceptance rule wasn't added")
 
-        regex = re.compile('-A .* -j ACCEPT -p tcp -m multiport '
-                           '--dports 80:81 -s %s' % (src_ip,))
-        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
-                        "TCP port 80/81 acceptance rule wasn't added")
+        for ip in get_fixed_ips():
+            regex = re.compile('-A .* -j ACCEPT -p tcp -m multiport '
+                               '--dports 80:81 -s %s' % ip)
+            self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
+                            "TCP port 80/81 acceptance rule wasn't added")
 
         regex = re.compile('-A .* -j ACCEPT -p tcp '
                            '-m multiport --dports 80:81 -s 192.168.10.0/24')
@@ -1114,24 +1075,27 @@ class IptablesFirewallTestCase(test.TestCase):
 
     def test_filters_for_instance_with_ip_v6(self):
         self.flags(use_ipv6=True)
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
         rulesv4, rulesv6 = self.fw._filters_for_instance("fake", network_info)
         self.assertEquals(len(rulesv4), 2)
-        self.assertEquals(len(rulesv6), 3)
+        self.assertEquals(len(rulesv6), 1)
 
     def test_filters_for_instance_without_ip_v6(self):
         self.flags(use_ipv6=False)
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
         rulesv4, rulesv6 = self.fw._filters_for_instance("fake", network_info)
         self.assertEquals(len(rulesv4), 2)
         self.assertEquals(len(rulesv6), 0)
 
     def test_multinic_iptables(self):
-        ipv4_rules_per_network = 2
-        ipv6_rules_per_network = 3
+        ipv4_rules_per_addr = 1
+        ipv4_addr_per_network = 2
+        ipv6_rules_per_addr = 1
+        ipv6_addr_per_network = 1
         networks_count = 5
         instance_ref = self._create_instance_ref()
-        network_info = _create_network_info(networks_count)
+        network_info = _fake_network_info(self.stubs, networks_count,
+                                                      ipv4_addr_per_network)
         ipv4_len = len(self.fw.iptables.ipv4['filter'].rules)
         ipv6_len = len(self.fw.iptables.ipv6['filter'].rules)
         inst_ipv4, inst_ipv6 = self.fw.instance_rules(instance_ref,
@@ -1142,9 +1106,9 @@ class IptablesFirewallTestCase(test.TestCase):
         ipv4_network_rules = len(ipv4) - len(inst_ipv4) - ipv4_len
         ipv6_network_rules = len(ipv6) - len(inst_ipv6) - ipv6_len
         self.assertEquals(ipv4_network_rules,
-                          ipv4_rules_per_network * networks_count)
+                  ipv4_rules_per_addr * ipv4_addr_per_network * networks_count)
         self.assertEquals(ipv6_network_rules,
-                          ipv6_rules_per_network * networks_count)
+                  ipv6_rules_per_addr * ipv6_addr_per_network * networks_count)
 
     def test_do_refresh_security_group_rules(self):
         instance_ref = self._create_instance_ref()
@@ -1170,8 +1134,7 @@ class IptablesFirewallTestCase(test.TestCase):
                                fakefilter.nwfilterLookupByName
         instance_ref = self._create_instance_ref()
 
-        _setup_networking(instance_ref['id'], self.test_ip)
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
         self.fw.setup_basic_filtering(instance_ref, network_info)
         self.fw.prepare_instance_filter(instance_ref, network_info)
         self.fw.apply_instance_filter(instance_ref, network_info)
@@ -1186,13 +1149,12 @@ class IptablesFirewallTestCase(test.TestCase):
     def test_provider_firewall_rules(self):
         # setup basic instance data
         instance_ref = self._create_instance_ref()
-        _setup_networking(instance_ref['id'], self.test_ip)
         # FRAGILE: peeks at how the firewall names chains
         chain_name = 'inst-%s' % instance_ref['id']
 
         # create a firewall via setup_basic_filtering like libvirt_conn.spawn
         # should have a chain with 0 rules
-        network_info = _create_network_info(1)
+        network_info = _fake_network_info(self.stubs, 1)
         self.fw.setup_basic_filtering(instance_ref, network_info)
         self.assertTrue('provider' in self.fw.iptables.ipv4['filter'].chains)
         rules = [rule for rule in self.fw.iptables.ipv4['filter'].rules
@@ -1256,7 +1218,6 @@ 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)
 
@@ -1372,11 +1333,9 @@ class NWFilterTestCase(test.TestCase):
         instance_ref = self._create_instance()
         inst_id = instance_ref['id']
 
-        _setup_networking(instance_ref['id'], self.test_ip)
-
-        def _ensure_all_called():
+        def _ensure_all_called(mac):
             instance_filter = 'nova-instance-%s-%s' % (instance_ref['name'],
-                                                       'fake')
+                                                   mac.translate(None, ':'))
             secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
             for required in [secgroup_filter, 'allow-dhcp-server',
                              'no-arp-spoofing', 'no-ip-spoofing',
@@ -1392,17 +1351,22 @@ class NWFilterTestCase(test.TestCase):
                                        self.security_group.id)
         instance = db.instance_get(self.context, inst_id)
 
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
+        # since there is one (network_info) there is one vif
+        # pass this vif's mac to _ensure_all_called()
+        # to set the instance_filter properly
+        mac = network_info[0][1]['mac']
+
         self.fw.setup_basic_filtering(instance, network_info)
         self.fw.prepare_instance_filter(instance, network_info)
         self.fw.apply_instance_filter(instance, network_info)
-        _ensure_all_called()
+        _ensure_all_called(mac)
         self.teardown_security_group()
         db.instance_destroy(context.get_admin_context(), instance_ref['id'])
 
     def test_create_network_filters(self):
         instance_ref = self._create_instance()
-        network_info = _create_network_info(3)
+        network_info = _fake_network_info(self.stubs, 3)
         result = self.fw._create_network_filters(instance_ref,
                                                  network_info,
                                                  "fake")
@@ -1425,8 +1389,7 @@ class NWFilterTestCase(test.TestCase):
 
         instance = db.instance_get(self.context, inst_id)
 
-        _setup_networking(instance_ref['id'], self.test_ip)
-        network_info = _create_network_info()
+        network_info = _fake_network_info(self.stubs, 1)
         self.fw.setup_basic_filtering(instance, network_info)
         self.fw.prepare_instance_filter(instance, network_info)
         self.fw.apply_instance_filter(instance, network_info)
diff --git a/nova/tests/test_linux_net.py b/nova/tests/test_linux_net.py
new file mode 100755
index 000000000..99577b88e
--- /dev/null
+++ b/nova/tests/test_linux_net.py
@@ -0,0 +1,347 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright 2011 NTT

+# All Rights Reserved.

+#

+# Licensed under the Apache License, Version 2.0 (the "License"); you may

+# not use this file except in compliance with the License. You may obtain

+# a copy of the License at

+#

+#      http://www.apache.org/licenses/LICENSE-2.0

+#

+# Unless required by applicable law or agreed to in writing, software

+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

+# License for the specific language governing permissions and limitations

+# under the License.

+

+from nova import context

+from nova import db

+from nova import exception

+from nova import flags

+from nova import log as logging

+from nova import test

+from nova import utils

+from nova.network import manager as network_manager

+from nova.network import linux_net

+

+import mox

+

+FLAGS = flags.FLAGS

+

+LOG = logging.getLogger('nova.tests.network')

+

+

+HOST = "testhost"

+

+instances = [{'id': 0,

+              'host': 'fake_instance00',

+              'hostname': 'fake_instance00'},

+             {'id': 1,

+              'host': 'fake_instance01',

+              'hostname': 'fake_instance01'}]

+

+

+addresses = [{"address": "10.0.0.1"},

+             {"address": "10.0.0.2"},

+             {"address": "10.0.0.3"},

+             {"address": "10.0.0.4"},

+             {"address": "10.0.0.5"},

+             {"address": "10.0.0.6"}]

+

+

+networks = [{'id': 0,

+             'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",

+             'label': 'test0',

+             'injected': False,

+             'multi_host': False,

+             'cidr': '192.168.0.0/24',

+             'cidr_v6': '2001:db8::/64',

+             'gateway_v6': '2001:db8::1',

+             'netmask_v6': '64',

+             'netmask': '255.255.255.0',

+             'bridge': 'fa0',

+             'bridge_interface': 'fake_fa0',

+             'gateway': '192.168.0.1',

+             'broadcast': '192.168.0.255',

+             'dns1': '192.168.0.1',

+             'dns2': '192.168.0.2',

+             'dhcp_server': '0.0.0.0',

+             'dhcp_start': '192.168.100.1',

+             'vlan': None,

+             'host': None,

+             'project_id': 'fake_project',

+             'vpn_public_address': '192.168.0.2'},

+            {'id': 1,

+             'uuid': "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",

+             'label': 'test1',

+             'injected': False,

+             'multi_host': False,

+             'cidr': '192.168.1.0/24',

+             'cidr_v6': '2001:db9::/64',

+             'gateway_v6': '2001:db9::1',

+             'netmask_v6': '64',

+             'netmask': '255.255.255.0',

+             'bridge': 'fa1',

+             'bridge_interface': 'fake_fa1',

+             'gateway': '192.168.1.1',

+             'broadcast': '192.168.1.255',

+             'dns1': '192.168.0.1',

+             'dns2': '192.168.0.2',

+             'dhcp_server': '0.0.0.0',

+             'dhcp_start': '192.168.100.1',

+             'vlan': None,

+             'host': None,

+             'project_id': 'fake_project',

+             'vpn_public_address': '192.168.1.2'}]

+

+

+fixed_ips = [{'id': 0,

+              'network_id': 0,

+              'address': '192.168.0.100',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 0,

+              'virtual_interface': addresses[0],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 1,

+              'network_id': 1,

+              'address': '192.168.1.100',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 1,

+              'virtual_interface': addresses[1],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 2,

+              'network_id': 1,

+              'address': '192.168.0.101',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 2,

+              'virtual_interface': addresses[2],

+              'instance': instances[1],

+              'floating_ips': []},

+             {'id': 3,

+              'network_id': 0,

+              'address': '192.168.1.101',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 3,

+              'virtual_interface': addresses[3],

+              'instance': instances[1],

+              'floating_ips': []},

+             {'id': 4,

+              'network_id': 0,

+              'address': '192.168.0.102',

+              'instance_id': 0,

+              'allocated': True,

+              'virtual_interface_id': 4,

+              'virtual_interface': addresses[4],

+              'instance': instances[0],

+              'floating_ips': []},

+             {'id': 5,

+              'network_id': 1,

+              'address': '192.168.1.102',

+              'instance_id': 1,

+              'allocated': True,

+              'virtual_interface_id': 5,

+              'virtual_interface': addresses[5],

+              'instance': instances[1],

+              'floating_ips': []}]

+

+

+vifs = [{'id': 0,

+         'address': 'DE:AD:BE:EF:00:00',

+         'uuid': '00000000-0000-0000-0000-0000000000000000',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 0},

+        {'id': 1,

+         'address': 'DE:AD:BE:EF:00:01',

+         'uuid': '00000000-0000-0000-0000-0000000000000001',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 0},

+        {'id': 2,

+         'address': 'DE:AD:BE:EF:00:02',

+         'uuid': '00000000-0000-0000-0000-0000000000000002',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 1},

+        {'id': 3,

+         'address': 'DE:AD:BE:EF:00:03',

+         'uuid': '00000000-0000-0000-0000-0000000000000003',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 1},

+        {'id': 4,

+         'address': 'DE:AD:BE:EF:00:04',

+         'uuid': '00000000-0000-0000-0000-0000000000000004',

+         'network_id': 0,

+         'network': networks[0],

+         'instance_id': 0},

+        {'id': 5,

+         'address': 'DE:AD:BE:EF:00:05',

+         'uuid': '00000000-0000-0000-0000-0000000000000005',

+         'network_id': 1,

+         'network': networks[1],

+         'instance_id': 1}]

+

+

+class LinuxNetworkTestCase(test.TestCase):

+

+    def setUp(self):

+        super(LinuxNetworkTestCase, self).setUp()

+        network_driver = FLAGS.network_driver

+        self.driver = utils.import_object(network_driver)

+        self.driver.db = db

+

+    def test_update_dhcp_for_nw00(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0], vifs[1]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2], vifs[3]])

+        self.mox.ReplayAll()

+

+        self.driver.update_dhcp(None, "eth0", networks[0])

+

+    def test_update_dhcp_for_nw01(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0], vifs[1]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2], vifs[3]])

+        self.mox.ReplayAll()

+

+        self.driver.update_dhcp(None, "eth0", networks[0])

+

+    def test_get_dhcp_hosts_for_nw00(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3]])

+        self.mox.ReplayAll()

+

+        expected = \

+        "10.0.0.1,fake_instance00.novalocal,"\

+            "192.168.0.100,net:NW-i00000000-0\n"\

+        "10.0.0.4,fake_instance01.novalocal,"\

+            "192.168.1.101,net:NW-i00000001-0"

+        actual_hosts = self.driver.get_dhcp_hosts(None, networks[1])

+

+        self.assertEquals(actual_hosts, expected)

+

+    def test_get_dhcp_hosts_for_nw01(self):

+        self.flags(use_single_default_gateway=True)

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2]])

+        self.mox.ReplayAll()

+

+        expected = \

+        "10.0.0.2,fake_instance00.novalocal,"\

+            "192.168.1.100,net:NW-i00000000-1\n"\

+        "10.0.0.3,fake_instance01.novalocal,"\

+            "192.168.0.101,net:NW-i00000001-1"

+        actual_hosts = self.driver.get_dhcp_hosts(None, networks[0])

+

+        self.assertEquals(actual_hosts, expected)

+

+    def test_get_dhcp_opts_for_nw00(self):

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[0],

+                                                        fixed_ips[3],

+                                                        fixed_ips[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0],

+                                                         vifs[1],

+                                                         vifs[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2],

+                                                         vifs[3],

+                                                         vifs[5]])

+        self.mox.ReplayAll()

+

+        expected_opts = 'NW-i00000001-0,3'

+        actual_opts = self.driver.get_dhcp_opts(None, networks[0])

+

+        self.assertEquals(actual_opts, expected_opts)

+

+    def test_get_dhcp_opts_for_nw01(self):

+        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')

+        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

+

+        db.network_get_associated_fixed_ips(mox.IgnoreArg(),

+                                            mox.IgnoreArg())\

+                                            .AndReturn([fixed_ips[1],

+                                                        fixed_ips[2],

+                                                        fixed_ips[5]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[0],

+                                                         vifs[1],

+                                                         vifs[4]])

+        db.virtual_interface_get_by_instance(mox.IgnoreArg(),

+                                             mox.IgnoreArg())\

+                                             .AndReturn([vifs[2],

+                                                         vifs[3],

+                                                         vifs[5]])

+        self.mox.ReplayAll()

+

+        expected_opts = "NW-i00000000-1,3"

+        actual_opts = self.driver.get_dhcp_opts(None, networks[1])

+

+        self.assertEquals(actual_opts, expected_opts)

+

+    def test_dhcp_opts_not_default_gateway_network(self):

+        expected = "NW-i00000000-0,3"

+        actual = self.driver._host_dhcp_opts(fixed_ips[0])

+        self.assertEquals(actual, expected)

+

+    def test_host_dhcp_without_default_gateway_network(self):

+        expected = ("10.0.0.1,fake_instance00.novalocal,192.168.0.100")

+        actual = self.driver._host_dhcp(fixed_ips[0])

+        self.assertEquals(actual, expected)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 2ae5a35e3..c947bbc58 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -14,6 +14,7 @@
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations
 # under the License.
+import mox
 
 from nova import context
 from nova import db
@@ -21,9 +22,7 @@ from nova import exception
 from nova import log as logging
 from nova import test
 from nova.network import manager as network_manager
-
-
-import mox
+from nova.tests import fake_network
 
 
 LOG = logging.getLogger('nova.tests.network')
@@ -58,7 +57,7 @@ networks = [{'id': 0,
              'dns1': '192.168.0.1',
              'dns2': '192.168.0.2',
              'vlan': None,
-             'host': None,
+             'host': HOST,
              'project_id': 'fake_project',
              'vpn_public_address': '192.168.0.2'},
             {'id': 1,
@@ -78,7 +77,7 @@ networks = [{'id': 0,
              'dns1': '192.168.0.1',
              'dns2': '192.168.0.2',
              'vlan': None,
-             'host': None,
+             'host': HOST,
              'project_id': 'fake_project',
              'vpn_public_address': '192.168.1.2'}]
 
@@ -138,60 +137,50 @@ class FlatNetworkTestCase(test.TestCase):
                                               is_admin=False)
 
     def test_get_instance_nw_info(self):
-        self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
-        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
-        self.mox.StubOutWithMock(db, 'instance_type_get')
-
-        db.fixed_ip_get_by_instance(mox.IgnoreArg(),
-                                    mox.IgnoreArg()).AndReturn(fixed_ips)
-        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
-                                             mox.IgnoreArg()).AndReturn(vifs)
-        db.instance_type_get(mox.IgnoreArg(),
-                                   mox.IgnoreArg()).AndReturn(flavor)
-        self.mox.ReplayAll()
-
-        nw_info = self.network.get_instance_nw_info(None, 0, 0, None)
+        fake_get_instance_nw_info = fake_network.fake_get_instance_nw_info
 
-        self.assertTrue(nw_info)
+        nw_info = fake_get_instance_nw_info(self.stubs, 0, 2)
+        self.assertFalse(nw_info)
 
-        for i, nw in enumerate(nw_info):
-            i8 = i + 8
-            check = {'bridge': 'fa%s' % i,
+        for i, (nw, info) in enumerate(nw_info):
+            check = {'bridge': 'fake_br%d' % i,
                      'cidr': '192.168.%s.0/24' % i,
-                     'cidr_v6': '2001:db%s::/64' % i8,
+                     'cidr_v6': '2001:db8:0:%x::/64' % i,
                      'id': i,
                      'multi_host': False,
-                     'injected': 'DONTCARE',
-                     'bridge_interface': 'fake_fa%s' % i,
+                     'injected': False,
+                     'bridge_interface': 'fake_eth%d' % i,
                      'vlan': None}
 
-            self.assertDictMatch(nw[0], check)
+            self.assertDictMatch(nw, check)
 
-            check = {'broadcast': '192.168.%s.255' % i,
-                     'dhcp_server': '192.168.%s.1' % i,
-                     'dns': 'DONTCARE',
-                     'gateway': '192.168.%s.1' % i,
-                     'gateway6': '2001:db%s::1' % i8,
+            check = {'broadcast': '192.168.%d.255' % i,
+                     'dhcp_server': '192.168.%d.1' % i,
+                     'dns': ['192.168.%d.3' % n, '192.168.%d.4' % n],
+                     'gateway': '192.168.%d.1' % i,
+                     'gateway6': '2001:db8:0:%x::1' % i,
                      'ip6s': 'DONTCARE',
                      'ips': 'DONTCARE',
-                     'label': 'test%s' % i,
-                     'mac': 'DE:AD:BE:EF:00:0%s' % i,
-                     'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
-                                  i),
-                     'rxtx_cap': 'DONTCARE',
+                     'label': 'test%d' % i,
+                     'mac': 'DE:AD:BE:EF:00:%02x' % i,
+                     'vif_uuid':
+                        '00000000-0000-0000-0000-00000000000000%02d' % i,
+                     'rxtx_cap': 3,
                      'should_create_vlan': False,
                      'should_create_bridge': False}
-            self.assertDictMatch(nw[1], check)
+            self.assertDictMatch(info, check)
 
             check = [{'enabled': 'DONTCARE',
-                      'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i),
+                      'ip': '2001:db8::dcad:beff:feef:%s' % i,
                       'netmask': '64'}]
-            self.assertDictListMatch(nw[1]['ip6s'], check)
+            self.assertDictListMatch(info['ip6s'], check)
 
-            check = [{'enabled': '1',
-                      'ip': '192.168.%s.100' % i,
-                      'netmask': '255.255.255.0'}]
-            self.assertDictListMatch(nw[1]['ips'], check)
+            num_fixed_ips = len(info['ips'])
+            check = [{'enabled': 'DONTCARE',
+                      'ip': '192.168.%d.1%02d' % (i, ip_num),
+                      'netmask': '255.255.255.0'}
+                      for ip_num in xrange(num_fixed_ips)]
+            self.assertDictListMatch(info['ips'], check)
 
     def test_validate_networks(self):
         self.mox.StubOutWithMock(db, 'network_get_all_by_uuids')
@@ -252,6 +241,34 @@ class FlatNetworkTestCase(test.TestCase):
 
         self.network.validate_networks(None, requested_networks)
 
+    def test_add_fixed_ip_instance_without_vpn_requested_networks(self):
+        self.mox.StubOutWithMock(db, 'network_get')
+        self.mox.StubOutWithMock(db, 'network_update')
+        self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool')
+        self.mox.StubOutWithMock(db, 'instance_get')
+        self.mox.StubOutWithMock(db,
+                              'virtual_interface_get_by_instance_and_network')
+        self.mox.StubOutWithMock(db, 'fixed_ip_update')
+
+        db.fixed_ip_update(mox.IgnoreArg(),
+                           mox.IgnoreArg(),
+                           mox.IgnoreArg())
+        db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(),
+                mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0})
+
+        db.instance_get(mox.IgnoreArg(),
+                        mox.IgnoreArg()).AndReturn({'security_groups':
+                                                             [{'id': 0}]})
+        db.fixed_ip_associate_pool(mox.IgnoreArg(),
+                                   mox.IgnoreArg(),
+                                   mox.IgnoreArg()).AndReturn('192.168.0.101')
+        db.network_get(mox.IgnoreArg(),
+                       mox.IgnoreArg()).AndReturn(networks[0])
+        db.network_update(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg())
+        self.mox.ReplayAll()
+        self.network.add_fixed_ip_to_instance(self.context, 1, HOST,
+                                              networks[0]['id'])
+
 
 class VlanNetworkTestCase(test.TestCase):
     def setUp(self):
@@ -392,6 +409,32 @@ class VlanNetworkTestCase(test.TestCase):
                           mox.IgnoreArg(),
                           mox.IgnoreArg())
 
+    def test_add_fixed_ip_instance_without_vpn_requested_networks(self):
+        self.mox.StubOutWithMock(db, 'network_get')
+        self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool')
+        self.mox.StubOutWithMock(db, 'instance_get')
+        self.mox.StubOutWithMock(db,
+                              'virtual_interface_get_by_instance_and_network')
+        self.mox.StubOutWithMock(db, 'fixed_ip_update')
+
+        db.fixed_ip_update(mox.IgnoreArg(),
+                           mox.IgnoreArg(),
+                           mox.IgnoreArg())
+        db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(),
+                mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0})
+
+        db.instance_get(mox.IgnoreArg(),
+                        mox.IgnoreArg()).AndReturn({'security_groups':
+                                                             [{'id': 0}]})
+        db.fixed_ip_associate_pool(mox.IgnoreArg(),
+                                   mox.IgnoreArg(),
+                                   mox.IgnoreArg()).AndReturn('192.168.0.101')
+        db.network_get(mox.IgnoreArg(),
+                       mox.IgnoreArg()).AndReturn(networks[0])
+        self.mox.ReplayAll()
+        self.network.add_fixed_ip_to_instance(self.context, 1, HOST,
+                                              networks[0]['id'])
+
 
 class CommonNetworkTestCase(test.TestCase):
 
diff --git a/nova/tests/test_virt_drivers.py b/nova/tests/test_virt_drivers.py
index 480247c91..440d3401b 100644
--- a/nova/tests/test_virt_drivers.py
+++ b/nova/tests/test_virt_drivers.py
@@ -103,8 +103,9 @@ class _VirtDriverTestCase(test.TestCase):
     def test_reboot(self):
         instance_ref = test_utils.get_test_instance()
         network_info = test_utils.get_test_network_info()
+        reboot_type = "SOFT"
         self.connection.spawn(self.ctxt, instance_ref, network_info)
-        self.connection.reboot(instance_ref, network_info)
+        self.connection.reboot(instance_ref, network_info, reboot_type)
 
     @catch_notimplementederror
     def test_get_host_ip_addr(self):
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index 06daf46e8..e6da1690f 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -170,7 +170,8 @@ class VMWareAPIVMTestCase(test.TestCase):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
-        self.conn.reboot(self.instance, self.network_info)
+        reboot_type = "SOFT"
+        self.conn.reboot(self.instance, self.network_info, reboot_type)
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)