Add missing tests for db.fixed_ip_*(). functions.

Added new tests for fixed_ip*() functions.
Function fixed_ip_create() should return FixedIp instance rather than
FixedIp.address, because it is used in a tests later.
Fix calls of fixed_ip_create() respectively.

blueprint test-db-api

Change-Id: Id5e9d4486605bde9d9fd1e631d868603a7a7c604

4 files changed, 218 insertions, 19 deletions

diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 1fc273bec..dcc9fb2f8 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1050,7 +1050,7 @@ def fixed_ip_create(context, values):
     fixed_ip_ref = models.FixedIp()
     fixed_ip_ref.update(values)
     fixed_ip_ref.save()
-    return fixed_ip_ref['address']
+    return fixed_ip_ref
 
 
 @require_context
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 5556b6eb5..e64498937 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -187,7 +187,7 @@ def stub_out_db_network_api(stubs):
         ip['id'] = max([i['id'] for i in fixed_ips] or [-1]) + 1
         for key in values:
             ip[key] = values[key]
-        return ip['address']
+        return ip
 
     def fake_fixed_ip_disassociate(context, address):
         ips = filter(lambda i: i['address'] == address,
diff --git a/nova/tests/network/test_manager.py b/nova/tests/network/test_manager.py
index 3fe2d6c74..b8f75233a 100644
--- a/nova/tests/network/test_manager.py
+++ b/nova/tests/network/test_manager.py
@@ -2146,11 +2146,9 @@ class FloatingIPTestCase(test.TestCase):
                 'project_id': self.project_id, 'deleted': True})
         network = db.api.network_create_safe(self.context.elevated(), {
                 'project_id': self.project_id})
-        addr = db.fixed_ip_create(self.context, {'allocated': True,
+        fixed = db.fixed_ip_create(self.context, {'allocated': True,
                 'instance_uuid': instance['uuid'], 'address': '10.1.1.1',
                 'network_id': network['id']})
-        fixed = db.fixed_ip_get_by_address(
-                self.context.elevated(read_deleted='yes'), addr)
         db.api.floating_ip_create(self.context, {
                 'address': '10.10.10.10', 'instance_uuid': instance['uuid'],
                 'fixed_ip_id': fixed['id'],
@@ -2165,11 +2163,9 @@ class FloatingIPTestCase(test.TestCase):
                 'project_id': self.project_id})
         network = db.api.network_create_safe(self.context.elevated(), {
                 'project_id': self.project_id})
-        addr = db.fixed_ip_create(self.context, {'allocated': True,
+        fixed = db.fixed_ip_create(self.context, {'allocated': True,
                 'instance_uuid': instance['uuid'], 'address': '10.1.1.1',
                 'network_id': network['id']})
-        fixed = db.fixed_ip_get_by_address(
-                self.context.elevated(read_deleted='yes'), addr)
         db.api.floating_ip_create(self.context, {
                 'address': '10.10.10.10',
                 'deleted': True})
diff --git a/nova/tests/test_db_api.py b/nova/tests/test_db_api.py
index 13a1dedff..49fee0c64 100644
--- a/nova/tests/test_db_api.py
+++ b/nova/tests/test_db_api.py
@@ -351,11 +351,11 @@ class DbApiTestCase(DbTestCase):
         network = db.network_create_safe(ctxt, values)
         db_network = db.network_get(ctxt, network['id'])
         values = {'network_id': network['id'], 'address': 'fake1'}
-        address1 = db.fixed_ip_create(ctxt, values)
+        address1 = db.fixed_ip_create(ctxt, values)['address']
         values = {'network_id': network['id'],
                   'address': 'fake2',
                   'allocated': True}
-        address2 = db.fixed_ip_create(ctxt, values)
+        address2 = db.fixed_ip_create(ctxt, values)['address']
         self.assertRaises(exception.NetworkInUse,
                           db.network_delete_safe, ctxt, network['id'])
         db.fixed_ip_update(ctxt, address2, {'allocated': False})
@@ -965,7 +965,7 @@ class DbApiTestCase(DbTestCase):
                   'allocated': True,
                   'instance_uuid': instance['uuid'],
                   'virtual_interface_id': vif['id']}
-        fixed_address = db.fixed_ip_create(ctxt, values)
+        fixed_address = db.fixed_ip_create(ctxt, values)['address']
         data = db.network_get_associated_fixed_ips(ctxt, 1)
         self.assertEqual(len(data), 1)
         record = data[0]
@@ -993,7 +993,7 @@ class DbApiTestCase(DbTestCase):
         # network with fixed ip with host set
         net = db.network_create_safe(ctxt, {})
         values = {'host': 'foo', 'network_id': net['id']}
-        fixed_address = db.fixed_ip_create(ctxt, values)
+        db.fixed_ip_create(ctxt, values)
         data = db.network_get_all_by_host(ctxt, 'foo')
         self.assertEqual(len(data), 2)
         # network with instance with host set
@@ -1003,7 +1003,7 @@ class DbApiTestCase(DbTestCase):
         vif = db.virtual_interface_create(ctxt, values)
         values = {'network_id': net['id'],
                   'virtual_interface_id': vif['id']}
-        fixed_address = db.fixed_ip_create(ctxt, values)
+        db.fixed_ip_create(ctxt, values)
         data = db.network_get_all_by_host(ctxt, 'foo')
         self.assertEqual(len(data), 3)
 
@@ -2335,13 +2335,12 @@ class FixedIPTestCase(BaseInstanceTypeTestCase):
         self.assertEqual(result, 0)
 
     def test_fixed_ip_get_by_floating_address(self):
-        fixed = db.fixed_ip_create(self.ctxt, {'address': 'fixed'})
-        fixed_ip_ref = db.fixed_ip_get_by_address(self.ctxt, fixed)
+        fixed_ip = db.fixed_ip_create(self.ctxt, {'address': 'fixed'})
         values = {'address': 'floating',
-                  'fixed_ip_id': fixed_ip_ref['id']}
+                  'fixed_ip_id': fixed_ip['id']}
         floating = db.floating_ip_create(self.ctxt, values)['address']
         fixed_ip_ref = db.fixed_ip_get_by_floating_address(self.ctxt, floating)
-        self.assertEqual(fixed, fixed_ip_ref['address'])
+        self._assertEqualObjects(fixed_ip, fixed_ip_ref)
 
     def test_fixed_ip_get_by_host(self):
         host_ips = {
@@ -2524,7 +2523,7 @@ class FixedIPTestCase(BaseInstanceTypeTestCase):
     def create_fixed_ip(self, **params):
         default_params = {'address': '192.168.0.1'}
         default_params.update(params)
-        return db.fixed_ip_create(self.ctxt, default_params)
+        return db.fixed_ip_create(self.ctxt, default_params)['address']
 
     def test_fixed_ip_associate_fails_if_ip_not_in_network(self):
         instance_uuid = self._create_instance()
@@ -2561,6 +2560,210 @@ class FixedIPTestCase(BaseInstanceTypeTestCase):
         self.assertEqual(fixed_ip['instance_uuid'], instance_uuid)
         self.assertEqual(fixed_ip['network_id'], network['id'])
 
+    def test_fixed_ip_associate_pool_invalid_uuid(self):
+        instance_uuid = '123'
+        self.assertRaises(exception.InvalidUUID, db.fixed_ip_associate_pool,
+                          self.ctxt, None, instance_uuid)
+
+    def test_fixed_ip_associate_pool_no_more_fixed_ips(self):
+        instance_uuid = self._create_instance()
+        self.assertRaises(exception.NoMoreFixedIps, db.fixed_ip_associate_pool,
+                          self.ctxt, None, instance_uuid)
+
+    def test_fixed_ip_associate_pool_succeeds(self):
+        instance_uuid = self._create_instance()
+        network = db.network_create_safe(self.ctxt, {})
+
+        address = self.create_fixed_ip(network_id=network['id'])
+        db.fixed_ip_associate_pool(self.ctxt, network['id'], instance_uuid)
+        fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address)
+        self.assertEqual(fixed_ip['instance_uuid'], instance_uuid)
+
+    def test_fixed_ip_create(self):
+        instance_uuid = self._create_instance()
+        network_id = db.network_create_safe(self.ctxt, {})['id']
+        param = {
+            'reserved': False,
+            'deleted': 0,
+            'leased': False,
+            'host': '127.0.0.1',
+            'address': 'localhost',
+            'allocated': False,
+            'instance_uuid': instance_uuid,
+            'network_id': network_id,
+            'virtual_interface_id': None
+        }
+
+        ignored_keys = ['created_at', 'id', 'deleted_at', 'updated_at']
+        fixed_ip_data = db.fixed_ip_create(self.ctxt, param)
+        self._assertEqualObjects(param, fixed_ip_data, ignored_keys)
+
+    def test_fixed_ip_bulk_create(self):
+        adress = 'fixed_ip_adress'
+        instance_uuid = self._create_instance()
+        network_id_1 = db.network_create_safe(self.ctxt, {})['id']
+        network_id_2 = db.network_create_safe(self.ctxt, {})['id']
+        params = [
+            {'reserved': False, 'deleted': 0, 'leased': False,
+             'host': '127.0.0.1', 'address': adress, 'allocated': False,
+             'instance_uuid': instance_uuid, 'network_id': network_id_1,
+             'virtual_interface_id': None},
+            {'reserved': False, 'deleted': 0, 'leased': False,
+             'host': 'localhost', 'address': adress, 'allocated': True,
+             'instance_uuid': instance_uuid, 'network_id': network_id_2,
+             'virtual_interface_id': None}
+        ]
+
+        db.fixed_ip_bulk_create(self.ctxt, params)
+        ignored_keys = ['created_at', 'id', 'deleted_at', 'updated_at']
+        fixed_ip_data = db.fixed_ip_get_by_instance(self.ctxt, instance_uuid)
+
+        # we have no `id` in incoming data so we can not use
+        # _assertEqualListsOfObjects to compare incoming data and received
+        # objects
+        fixed_ip_data = sorted(fixed_ip_data, key=lambda i: i['network_id'])
+        params = sorted(params, key=lambda i: i['network_id'])
+        for param, ip in zip(params, fixed_ip_data):
+            self._assertEqualObjects(param, ip, ignored_keys)
+
+    def test_fixed_ip_disassociate(self):
+        adress = 'fixed_ip_adress'
+        instance_uuid = self._create_instance()
+        network_id = db.network_create_safe(self.ctxt, {})['id']
+        param = {
+            'reserved': False,
+            'deleted': 0,
+            'leased': False,
+            'host': '127.0.0.1',
+            'address': adress,
+            'allocated': False,
+            'instance_uuid': instance_uuid,
+            'network_id': network_id,
+            'virtual_interface_id': None
+        }
+        db.fixed_ip_create(self.ctxt, param)
+
+        db.fixed_ip_disassociate(self.ctxt, adress)
+        fixed_ip_data = db.fixed_ip_get_by_address(self.ctxt, adress)
+        ignored_keys = ['created_at', 'id', 'deleted_at',
+                        'updated_at', 'instance_uuid']
+        self._assertEqualObjects(param, fixed_ip_data, ignored_keys)
+        self.assertIsNone(fixed_ip_data['instance_uuid'])
+
+    def test_fixed_ip_get_not_found_exception(self):
+        self.assertRaises(exception.FixedIpNotFound,
+                          db.fixed_ip_get, self.ctxt, 0)
+
+    def test_fixed_ip_get_sucsess2(self):
+        adress = 'fixed_ip_adress'
+        instance_uuid = self._create_instance()
+        network_id = db.network_create_safe(self.ctxt, {})['id']
+        param = {
+            'reserved': False,
+            'deleted': 0,
+            'leased': False,
+            'host': '127.0.0.1',
+            'address': adress,
+            'allocated': False,
+            'instance_uuid': instance_uuid,
+            'network_id': network_id,
+            'virtual_interface_id': None
+        }
+        fixed_ip_id = db.fixed_ip_create(self.ctxt, param)
+
+        self.ctxt.is_admin = False
+        self.assertRaises(exception.NotAuthorized, db.fixed_ip_get,
+                          self.ctxt, fixed_ip_id)
+
+    def test_fixed_ip_get_sucsess(self):
+        adress = 'fixed_ip_adress'
+        instance_uuid = self._create_instance()
+        network_id = db.network_create_safe(self.ctxt, {})['id']
+        param = {
+            'reserved': False,
+            'deleted': 0,
+            'leased': False,
+            'host': '127.0.0.1',
+            'address': adress,
+            'allocated': False,
+            'instance_uuid': instance_uuid,
+            'network_id': network_id,
+            'virtual_interface_id': None
+        }
+        db.fixed_ip_create(self.ctxt, param)
+
+        fixed_ip_id = db.fixed_ip_get_by_address(self.ctxt, adress)['id']
+        fixed_ip_data = db.fixed_ip_get(self.ctxt, fixed_ip_id)
+        ignored_keys = ['created_at', 'id', 'deleted_at', 'updated_at']
+        self._assertEqualObjects(param, fixed_ip_data, ignored_keys)
+
+    def test_fixed_ip_get_by_address_detailed_not_found_exception(self):
+        self.assertRaises(exception.FixedIpNotFoundForAddress,
+                          db.fixed_ip_get_by_address_detailed, self.ctxt, 'x')
+
+    def test_fixed_ip_get_by_address_detailed_sucsess(self):
+        adress = 'fixed_ip_adress_123'
+        instance_uuid = self._create_instance()
+        network_id = db.network_create_safe(self.ctxt, {})['id']
+        param = {
+            'reserved': False,
+            'deleted': 0,
+            'leased': False,
+            'host': '127.0.0.1',
+            'address': adress,
+            'allocated': False,
+            'instance_uuid': instance_uuid,
+            'network_id': network_id,
+            'virtual_interface_id': None
+        }
+        db.fixed_ip_create(self.ctxt, param)
+
+        fixed_ip_data = db.fixed_ip_get_by_address_detailed(self.ctxt,
+                                                               adress)
+        # fixed ip check here
+        ignored_keys = ['created_at', 'id', 'deleted_at', 'updated_at']
+        self._assertEqualObjects(param, fixed_ip_data[0], ignored_keys)
+
+        # network model check here
+        network_data = db.network_get(self.ctxt, network_id)
+        self._assertEqualObjects(network_data, fixed_ip_data[1])
+
+        # Instance check here
+        instance_data = db.instance_get_by_uuid(self.ctxt, instance_uuid)
+        ignored_keys = ['info_cache', 'system_metadata',
+                        'security_groups', 'metadata']  # HOW ????
+        self._assertEqualObjects(instance_data, fixed_ip_data[2], ignored_keys)
+
+    def test_fixed_ip_update_not_found_for_adress(self):
+        self.assertRaises(exception.FixedIpNotFoundForAddress,
+                          db.fixed_ip_update, self.ctxt, 'fixed_ip_adress', {})
+
+    def test_fixed_ip_update(self):
+        instance_uuid_1 = self._create_instance()
+        instance_uuid_2 = self._create_instance()
+        network_id_1 = db.network_create_safe(self.ctxt, {})['id']
+        network_id_2 = db.network_create_safe(self.ctxt, {})['id']
+        param_1 = {
+            'reserved': True, 'deleted': 0, 'leased': True,
+            'host': '192.168.133.1', 'address': 'localhost',
+            'allocated': True, 'instance_uuid': instance_uuid_1,
+            'network_id': network_id_1, 'virtual_interface_id': '123',
+        }
+
+        param_2 = {
+            'reserved': False, 'deleted': 0, 'leased': False,
+            'host': '127.0.0.1', 'address': 'localhost', 'allocated': False,
+            'instance_uuid': instance_uuid_2, 'network_id': network_id_2,
+            'virtual_interface_id': None
+        }
+
+        ignored_keys = ['created_at', 'id', 'deleted_at', 'updated_at']
+        fixed_ip_addr = db.fixed_ip_create(self.ctxt, param_1)['address']
+        db.fixed_ip_update(self.ctxt, fixed_ip_addr, param_2)
+        fixed_ip_after_update = db.fixed_ip_get_by_address(self.ctxt,
+                                                           param_2['address'])
+        self._assertEqualObjects(param_2, fixed_ip_after_update, ignored_keys)
+
 
 class FloatingIpTestCase(test.TestCase, ModelsObjectComparatorMixin):
 
@@ -2725,7 +2928,7 @@ class FloatingIpTestCase(test.TestCase, ModelsObjectComparatorMixin):
     def _create_fixed_ip(self, params):
         default_params = {'address': '192.168.0.1'}
         default_params.update(params)
-        return db.fixed_ip_create(self.ctxt, default_params)
+        return db.fixed_ip_create(self.ctxt, default_params)['address']
 
     def test_floating_ip_fixed_ip_associate(self):
         float_addresses = ['1.1.1.1', '1.1.1.2', '1.1.1.3']