tests all pass

4 files changed, 80 insertions, 36 deletions

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 41b4b8681..87c8e063f 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -209,7 +209,6 @@ class FloatingIP(object):
 
         rpc.called by network_api
         """
-        LOG.debug("#"*80)
         instance_id = kwargs.get('instance_id')
         LOG.debug(_("floating IP deallocation for instance |%s|"), instance_id,
                                                                context=context)
@@ -230,6 +229,8 @@ class FloatingIP(object):
         # call the next inherited class's deallocate_for_instance()
         # which is currently the NetworkManager version
         # call this after so floating IPs are handled first
+        LOG.debug('*'*20)
+        LOG.debug('%s' % super(FloatingIP, self).deallocate_for_instance)
         super(FloatingIP, self).deallocate_for_instance(context, **kwargs)
 
     def allocate_floating_ip(self, context, project_id):
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 0178e9d57..1c03317f9 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -38,6 +38,8 @@ class FakeModel(object):
             return self.values[key]
         else:
             raise NotImplementedError()
+    def __repr__(self):
+        return '<FakeModel: %s>' % self.values
 
 
 def stub_out(stubs, funcs):
@@ -49,7 +51,7 @@ def stub_out(stubs, funcs):
         stubs.Set(db, func_name, func)
 
 
-def stub_out_db_network_api(stubs, host='localhost'):
+def stub_out_db_network_api(stubs):
     network_fields = {'id': 0,
                       'cidr': '192.168.0.0/24',
                       'netmask': '255.255.255.0',
@@ -64,7 +66,8 @@ def stub_out_db_network_api(stubs, host='localhost'):
                       'gateway_v6': 'dead:beef::1',
                       'dns': '192.168.0.1',
                       'vlan': None,
-                      'host': host}
+                      'host': None,
+                      'vpn_public_address': '192.168.0.2'}
 
     fixed_ip_fields = {'id': 0,
                        'network_id': 0,
@@ -73,7 +76,8 @@ def stub_out_db_network_api(stubs, host='localhost'):
                        'instance_id': 0,
                        'allocated': False,
                        'mac_address_id': 0,
-                       'mac_addres': None}
+                       'mac_address': None,
+                       'floating_ips': []}
 
     flavor_fields = {'id': 0,
                      'rxtx_cap': 3}
@@ -152,47 +156,69 @@ def stub_out_db_network_api(stubs, host='localhost'):
             ips[0]['auto_assigned'] = True
 
     def fake_fixed_ip_associate(context, address, instance_id):
-        if fixed_ip_fields['address'] == address and \
-           not fixed_ip_fields['instance']:
-            fixed_ip_fields['instance'] = True
-            fixed_ip_fields['instance_id'] = instance_id
+        ips = filter(lambda i: i['address'] == address,
+                     fixed_ips)
+        if not ips:
+            raise db.NoMoreAddresses()
+        ips[0]['instance'] = True
+        ips[0]['instance_id'] = instance_id
 
     def fake_fixed_ip_associate_pool(context, network_id, instance_id):
-        if fixed_ip_fields['network_id'] == network_id and \
-           not fixed_ip_fields['instance']:
-            fixed_ip_fields['instance'] = True
-            fixed_ip_fields['instance_id'] = instance_id
-            return fixed_ip_fields['address']
+        ips = filter(lambda i: (i['network_id'] == network_id \
+                             or i['network_id'] is None) \
+                            and not i['instance'],
+                     fixed_ips)
+        if not ips:
+            raise db.NoMoreAddresses()
+        ips[0]['instance'] = True
+        ips[0]['instance_id'] = instance_id
+        return ips[0]['address']
 
     def fake_fixed_ip_create(context, values):
-        if values['address'] == fixed_ip_fields['address']:
-            return fixed_ip_fields['address']
+        ip = dict(fixed_ip_fields)
+        ip['id'] = max([i['id'] for i in fixed_ips] or [-1]) + 1
+        for key in values:
+            ip[key] = values[key]
+        return ip['address']
 
     def fake_fixed_ip_disassociate(context, address):
-        if fixed_ip_fields['address'] == address:
-            fixed_ip_fields['instance'] = None
-            fixed_ip_fields['instance_id'] = None
+        ips = filter(lambda i: i['address'] == address,
+                     fixed_ips)
+        if ips:
+            ips[0]['instance_id'] = None
+            ips[0]['instance'] = None
+            ips[0]['mac_address'] = None
+            ips[0]['mac_address_id'] = None
 
     def fake_fixed_ip_disassociate_all_by_timeout(context, host, time):
         return 0
 
     def fake_fixed_ip_get_all_by_instance(context, instance_id):
-        if fixed_ip_fields['instance_id'] == instance_id:
-            return [FakeModel(fixed_ip_fields)]
+        ips = filter(lambda i: i['instance_id'] == instance_id,
+                     fixed_ips)
+        return [FakeModel(i) for i in ips]
 
     def fake_fixed_ip_get_by_address(context, address):
-        if fixed_ip_fields['address'] == address:
-            return FakeModel(fixed_ip_fields)
+        ips = filter(lambda i: i['address'] == address,
+                     fixed_ips)
+        if ips:
+            return FakeModel(ips[0])
 
     def fake_fixed_ip_get_network(context, address):
-        if fixed_ip_fields['address'] == address and \
-           fixed_ip_fields['network_id'] == network_fields['id']:
-            return FakeModel(network_fields)
+        ips = filter(lambda i: i['address'] == address,
+                     fixed_ips)
+        if ips:
+            nets = filter(lambda n: n['id'] == ips[0]['network_id'],
+                          networks)
+            if nets:
+                return FakeModel(nets[0])
 
     def fake_fixed_ip_update(context, address, values):
-        if fixed_ip_fields['address'] == address:
+        ips = filter(lambda i: i['address'] == address,
+                     fixed_ips)
+        if ips:
             for key in values:
-                fixed_ip_fields[key] = values[key]
+                ips[0][key] = values[key]
                 if key == 'mac_address_id':
                     mac = filter(lambda x: x['id'] == values[key],
                                  mac_addresses)
diff --git a/nova/tests/network/base.py b/nova/tests/network/base.py
index 320f8aa6f..79b99fcae 100644
--- a/nova/tests/network/base.py
+++ b/nova/tests/network/base.py
@@ -48,11 +48,14 @@ class NetworkTestCase(test.TestCase):
     def tearDown(self):
         super(NetworkTestCase, self).tearDown()
         reload(db)
-
+        
 
 class TestFuncs(object):
+    def _compare_fields(self, dict1, dict2, fields):
+        for field in fields:
+            self.assertEqual(dict1[field], dict2[field])
+
     def test_set_network_hosts(self):
-        db_fakes.stub_out_db_network_api(self.stubs, host=None)
         self.network.set_network_hosts(self.context)
 
     def test_set_network_host(self):
@@ -64,6 +67,7 @@ class TestFuncs(object):
         instance_id = 0
         project_id = 0
         type_id = 0
+        self.network.set_network_hosts(self.context)
         nw = self.network.allocate_for_instance(self.context,
                                                 instance_id=instance_id,
                                                 project_id=project_id,
@@ -82,25 +86,34 @@ class TestFuncs(object):
                          'label': 'fake',
                          'mac': 'DE:AD:BE:EF:00:00',
                          'rxtx_cap': 3})]
-        self.assertEqual(static_info, nw)
+
+        self._compare_fields(nw[0][0], static_info[0][0], ('bridge',))
+        self._compare_fields(nw[0][1], static_info[0][1], ('ips',
+                                                           'broadcast',
+                                                           'gateway',
+                                                           'ip6s'))
 
     def test_deallocate_for_instance(self):
         instance_id = 0
         network_id = 0
+        self.network.set_network_hosts(self.context)
         self.network.add_fixed_ip_to_instance(self.context,
                                               instance_id=instance_id,
                                               network_id=network_id)
-        self.assertTrue(db.fixed_ip_get_all_by_instance(self.context,
-                                                        instance_id))
+        ips = db.fixed_ip_get_all_by_instance(self.context, instance_id)
+        for ip in ips:
+            self.assertTrue(ip['allocated'])
         self.network.deallocate_for_instance(self.context,
                                              instance_id=instance_id)
-        self.assertFalse(db.fixed_ip_get_all_by_instance(self.context,
-                                                         instance_id))
+        ips = db.fixed_ip_get_all_by_instance(self.context, instance_id)
+        for ip in ips:
+            self.assertFalse(ip['allocated'])
 
     def test_lease_release_fixed_ip(self):
         instance_id = 0
         project_id = 0
         type_id = 0
+        self.network.set_network_hosts(self.context)
         nw = self.network.allocate_for_instance(self.context,
                                                 instance_id=instance_id,
                                                 project_id=project_id,
@@ -116,6 +129,10 @@ class TestFuncs(object):
         self.assertTrue(ips)
         address = ips[0]['address']
 
+        db.fixed_ip_associate(self.context, address, instance_id)
+        db.fixed_ip_update(self.context, address,
+                           {'mac_address_id': mac['id']})
+
         self.network.lease_fixed_ip(self.context, mac['address'], address)
         ip = db.fixed_ip_get_by_address(self.context, address)
         self.assertTrue(ip['leased'])
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 562703b5f..370dd3526 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -28,8 +28,8 @@ class FlatNetworkTestCase(base.NetworkTestCase, base.TestFuncs):
     network_manager = 'nova.network.manager.FlatManager'
 
 
-#class FlatDHCPNetworkTestCase(base.NetworkTestCase, base.TestFuncs):
-#    network_manager = 'nova.network.manager.FlatDHCPManager'
+class FlatDHCPNetworkTestCase(base.NetworkTestCase, base.TestFuncs):
+    network_manager = 'nova.network.manager.FlatDHCPManager'
 
 
 class VlanNetworkTestCase(base.NetworkTestCase, base.TestFuncs):