Merge lp:~santhoshkumar/network-service/melange_framework into lp:~rajarammallya/network-service/melange_framework

[Santhosh Kumar Muniraj]

* Policy can eager load ip_rules
* Exposed API for index, create and show of Policies.

[lp:~santhoshkumar/network-service/melange_framework]

31. By Rajaram Mallya on 2011-06-03

Vinkesh/Rajaram|cleaned up test_extensions

[Rajaram Mallya (rajarammallya)]

review: Approve

[lp:~santhoshkumar/network-service/melange_framework]

32. By Rajaram Mallya on 2011-06-03

merge from: Santhosh/Vinkesh | Exposed API for ip_block policy resource

33. By Rajaram Mallya on 2011-06-03

Vinkesh/Rajaram|added extensions to app

34. By Rajaram Mallya on 2011-06-06

Rajaram/Deepak| Merge changes from Santosh branch of Iprange rules and nat controller split

=== modified file 'melange/ipam/models.py'
--- melange/ipam/models.py	2011-06-02 13:24:42 +0000
+++ melange/ipam/models.py	2011-06-06 04:56:28 +0000
@@ -127,13 +127,8 @@
     def allowed_by_policy(cls, ip_block, policy, address):
         return policy == None or policy.allows(ip_block.cidr, address)
 
-    def policy(self, eager_load_rules=False):
-        policy = Policy.find_by_id(self.policy_id)
-        if policy == None:
-            return None
-        if eager_load_rules:
-            policy.eager_load()
-        return policy
+    def policy(self):
+        return Policy.find_by_id(self.policy_id)
 
     def allocate_ip(self, port_id=None, address=None):
         candidate_ip = None
@@ -162,7 +157,7 @@
             raise AddressDoesNotBelongError(
                 "Address does not belong to IpBlock")
 
-        policy = self.policy(eager_load_rules=True)
+        policy = self.policy()
         if not IpBlock.allowed_by_policy(self, policy, address):
             raise AddressDisallowedByPolicyError(
                 "Block policy does not allow this address")
@@ -172,7 +167,7 @@
     def _generate_ip(self, allocated_addresses):
         #TODO: very inefficient way to generate ips,
         #will look at better algos for this
-        policy = self.policy(eager_load_rules=True)
+        policy = self.policy()
         for ip in IPNetwork(self.cidr):
             if IpBlock.allowed_by_policy(self, policy, str(ip)) and (str(ip)
                                                    not in allocated_addresses):
@@ -271,24 +266,24 @@
     def find_by_name(cls, name):
         return db_api.find_by(Policy, name=name)
 
-    def ip_rules(self):
-        if hasattr(self, 'ip_range_rules'):
-            return self.ip_range_rules
-        return self._find_ip_range_rules()
+    def create_unusable_range(self, attributes):
+        attributes['policy_id'] = self.id
+        ip_range = IpRange.create(attributes)
+        if hasattr(self, '_unusable_ip_ranges'):
+            self._unusable_ip_ranges.append(ip_range)
+        return ip_range
+
+    def unusable_ip_ranges(self):
+        if not hasattr(self, '_unusable_ip_ranges'):
+            self._load_unusable_ip_ranges()
+        return self._unusable_ip_ranges
 
     def allows(self, cidr, address):
-        return not any(ip_rule.contains(cidr, address)
-                       for ip_rule in self.ip_rules())
-
-    def eager_load(self):
-        self._load_ip_range_rules()
-        return self
-
-    def _load_ip_range_rules(self):
-        self.ip_range_rules = self._find_ip_range_rules()
-
-    def _find_ip_range_rules(self):
-        return IpRange.find_all_by_policy(self.id).all()
+        return not any(ip_range.contains(cidr, address)
+                       for ip_range in self.unusable_ip_ranges())
+
+    def _load_unusable_ip_ranges(self):
+        self._unusable_ip_ranges = IpRange.find_all_by_policy(self.id).all()
 
     def data_fields(self):
         return ['id', 'name']

=== modified file 'melange/ipam/service.py'
--- melange/ipam/service.py	2011-06-03 05:46:27 +0000
+++ melange/ipam/service.py	2011-06-06 04:56:28 +0000
@@ -49,6 +49,15 @@
     def _get_optionals(self, params, *args):
         return [params.get(key, None) for key in args]
 
+    def _parse_ips(self, addresses):
+        return [IpBlock.find_or_allocate_ip(address["ip_block_id"],
+                                                 address["ip_address"])
+                     for address in json.loads(addresses)]
+
+    def _get_addresses(self, ips):
+        return self._json_response(
+            dict(ip_addresses=[ip_address.data() for ip_address in ips]))
+
 
 class IpBlockController(BaseController):
 
@@ -100,46 +109,63 @@
         ip_address.restore()
 
 
-class NatController(BaseController):
-
-    def create_locals(self, request, ip_block_id, address):
-        global_ip = IpBlock.find_or_allocate_ip(ip_block_id, address)
-        local_ips = self._parse_ips(request.params["ip_addresses"])
-        global_ip.add_inside_locals(local_ips)
-
-    def create_globals(self, request, ip_block_id, address):
+class InsideGlobalsController(BaseController):
+
+    def create(self, request, ip_block_id, address):
         local_ip = IpBlock.find_or_allocate_ip(ip_block_id, address)
         global_ips = self._parse_ips(request.params["ip_addresses"])
         local_ip.add_inside_globals(global_ips)
 
-    def show_globals(self, request, ip_block_id, address):
+    def index(self, request, ip_block_id, address):
         ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
         return self._get_addresses(ip.inside_globals(
                                     **self._extract_limits(request.params)))
 
-    def show_locals(self, request, ip_block_id, address):
-        ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
-        return self._get_addresses(ip.inside_locals(
-                                    **self._extract_limits(request.params)))
-
-    def delete_globals(self, request, ip_block_id, address,
-                       inside_global_address=None):
+    def delete(self, request, ip_block_id, address,
+               inside_global_address=None):
         local_ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
         local_ip.remove_inside_globals(inside_global_address)
 
-    def delete_locals(self, request, ip_block_id, address,
-                      inside_local_address=None):
+
+class InsideLocalsController(BaseController):
+
+    def create(self, request, ip_block_id, address):
+        global_ip = IpBlock.find_or_allocate_ip(ip_block_id, address)
+        local_ips = self._parse_ips(request.params["ip_addresses"])
+        global_ip.add_inside_locals(local_ips)
+
+    def index(self, request, ip_block_id, address):
+        ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
+        return self._get_addresses(ip.inside_locals(
+                                    **self._extract_limits(request.params)))
+
+    def delete(self, request, ip_block_id, address,
+               inside_local_address=None):
         global_ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
         global_ip.remove_inside_locals(inside_local_address)
 
-    def _get_addresses(self, ips):
-        return self._json_response(
-            dict(ip_addresses=[ip_address.data() for ip_address in ips]))
-
-    def _parse_ips(self, addresses):
-        return [IpBlock.find_or_allocate_ip(address["ip_block_id"],
-                                                 address["ip_address"])
-                     for address in json.loads(addresses)]
+
+class PoliciesController(BaseController):
+
+    def index(self, request):
+        policies = Policy.find_all()
+        return self._json_response(body=dict(
+                policies=[policy.data() for policy in policies]))
+
+    def show(self, request, id):
+        return self._json_response(Policy.find(id).data())
+
+    def create(self, request):
+        policy = Policy.create(request.params)
+        return self._json_response(policy.data(), status=201)
+
+
+class UnusableIpRangesController(BaseController):
+
+    def create(self, request, policy_id):
+        policy = Policy.find(policy_id)
+        ip_range = policy.create_unusable_range(request.params.copy())
+        return self._json_response(ip_range.data(), status=201)
 
 
 class PoliciesController(BaseController):
@@ -163,32 +189,37 @@
         mapper = routes.Mapper()
         ip_block_controller = IpBlockController()
         ip_address_controller = IpAddressController()
-        nat_controller = NatController()
+        inside_globals_controller = InsideGlobalsController()
+        inside_locals_controller = InsideLocalsController()
         mapper.resource("ip_block", "/ipam/ip_blocks",
                         controller=ip_block_controller)
         mapper.resource("policy", "/ipam/policies",
                         controller=PoliciesController())
 
-        with mapper.submapper(controller=nat_controller,
+        with mapper.submapper(controller=inside_globals_controller,
                         path_prefix="/ipam/ip_blocks/{ip_block_id}/"
                                    "ip_addresses/{address:.+?}/") as submap:
-            submap.connect("inside_locals", action="create_locals",
-                                 conditions=dict(method=["POST"]))
-            submap.connect("inside_globals", action="create_globals",
-                                 conditions=dict(method=["POST"]))
-            submap.connect("inside_globals", action="show_globals",
-                       conditions=dict(method=["GET"]))
-            submap.connect("inside_locals", action="show_locals",
-                       conditions=dict(method=["GET"]))
-            submap.connect("inside_globals", action="delete_globals",
-                        conditions=dict(method=["DELETE"]))
-            submap.connect("inside_locals", action="delete_locals",
+            submap.connect("inside_globals", action="create",
+                                 conditions=dict(method=["POST"]))
+            submap.connect("inside_globals", action="index",
+                       conditions=dict(method=["GET"]))
+            submap.connect("inside_globals", action="delete",
                         conditions=dict(method=["DELETE"]))
             submap.connect("inside_globals/{inside_global_address:.+?}",
-                           action="delete_globals",
+                           action="delete",
                            conditions=dict(method=["DELETE"]))
+
+        with mapper.submapper(controller=inside_locals_controller,
+                              path_prefix="/ipam/ip_blocks/{ip_block_id}/"
+                              "ip_addresses/{address:.+?}/") as submap:
+            submap.connect("inside_locals", action="create",
+                           conditions=dict(method=["POST"]))
+            submap.connect("inside_locals", action="index",
+                           conditions=dict(method=["GET"]))
             submap.connect("inside_locals/{inside_local_address:.+?}",
-                           action="delete_locals",
+                           action="delete",
+                           conditions=dict(method=["DELETE"]))
+            submap.connect("inside_locals", action="delete",
                            conditions=dict(method=["DELETE"]))
 
         mapper.connect("/ipam/ip_blocks/{ip_block_id}/"
@@ -207,6 +238,10 @@
                         controller=ip_address_controller,
                         parent_resource=dict(member_name="ip_block",
                                            collection_name="/ipam/ip_blocks"))
+        mapper.resource("unusable_ip_range", "unusable_ip_ranges",
+                        controller=UnusableIpRangesController(),
+                        parent_resource=dict(member_name="policy",
+                                           collection_name="/ipam/policies"))
         mapper.connect("/", controller=ip_block_controller, action="version")
         super(API, self).__init__(mapper)
 

=== modified file 'tests/unit/test_ipam_models.py'
--- tests/unit/test_ipam_models.py	2011-06-02 13:24:42 +0000
+++ tests/unit/test_ipam_models.py	2011-06-06 04:56:28 +0000
@@ -430,14 +430,14 @@
         self.assertFalse(policy.allows("10.0.0.0/29", "10.0.0.4"))
         self.assertTrue(policy.allows("10.0.0.0/29", "10.0.0.6"))
 
-    def test_ip_rules_for_policy(self):
+    def test_unusable_ip_ranges_for_policy(self):
         policy = Policy.create({'name': "blah"})
         ip_range1 = IpRange.create({'offset': 0, 'length': 2,
                                     'policy_id': policy.id})
         ip_range2 = IpRange.create({'offset': 3, 'length': 2,
                                     'policy_id': policy.id})
 
-        self.assertEqual(policy.ip_rules(), [ip_range1, ip_range2])
+        self.assertEqual(policy.unusable_ip_ranges(), [ip_range1, ip_range2])
 
     def test_data(self):
         policy_data = {'name': 'Infrastructure'}
@@ -454,6 +454,23 @@
 
         self.assertEqual(policies, [policy1, policy2])
 
+    def test_create_unusable_ip_range(self):
+        policy = Policy.create({'name': "BLAH"})
+
+        ip_range = policy.create_unusable_range({'offset': 1, 'length': 2})
+
+        self.assertEqual(ip_range,
+                         IpRange.find_all_by_policy(policy.id).first())
+        self.assertEqual(ip_range.offset, 1)
+        self.assertEqual(ip_range.length, 2)
+
+    def test_unusable_ip_ranges_include_newly_created_ip_ranges(self):
+        policy = Policy.create({'name': "BLAH"})
+        policy.unusable_ip_ranges()
+        ip_range = policy.create_unusable_range({'offset': 1, 'length': 2})
+
+        self.assertTrue(ip_range in policy.unusable_ip_ranges())
+
 
 class TestIpRange(BaseTest):
 
@@ -461,7 +478,7 @@
         policy = Policy.create({'name': 'blah'})
         IpRange.create({'offset': 3, 'length': 10, 'policy_id': policy.id})
 
-        ip_range = policy.ip_rules()[0]
+        ip_range = policy.unusable_ip_ranges()[0]
 
         self.assertEqual(ip_range.offset, 3)
         self.assertEqual(ip_range.length, 10)

=== modified file 'tests/unit/test_service.py'
--- tests/unit/test_service.py	2011-06-03 05:46:27 +0000
+++ tests/unit/test_service.py	2011-06-06 04:56:28 +0000
@@ -21,9 +21,9 @@
 
 from tests.unit import BaseTest
 from melange.common import config
-from melange.ipam.models import IpBlock, IpAddress, Policy
 from melange.ipam import models
 from melange.db import session
+from melange.ipam.models import IpBlock, IpAddress, Policy, IpRange
 
 
 class TestController(BaseTest):
@@ -246,112 +246,9 @@
         self.assertEqual(ip_addresses, [ip.address for ip in ips])
 
 
-class TestIpNatController(TestController):
-
-    def test_create_inside_local_nat(self):
-        global_block, = _create_blocks("169.1.1.1/32")
-        local_block1, = _create_blocks("10.1.1.1/32")
-        local_block2, = _create_blocks("10.0.0.1/32")
-
-        url = "/ipam/ip_blocks/%s/ip_addresses/169.1.1.1/inside_locals"
-        json_data = [
-            {'ip_block_id': local_block1.id, 'ip_address': "10.1.1.1"},
-            {'ip_block_id': local_block2.id, 'ip_address': "10.0.0.1"},
-        ]
-        request_data = {'ip_addresses': json.dumps(json_data)}
-        response = self.app.post(url % global_block.id, request_data)
-
-        self.assertEqual(response.status, "200 OK")
-        ips = global_block.find_allocated_ip("169.1.1.1").inside_locals()
-        inside_locals = [ip.address for ip in ips]
-
-        self.assertEqual(len(inside_locals), 2)
-        self.assertTrue("10.1.1.1" in inside_locals)
-        self.assertTrue("10.0.0.1" in inside_locals)
-        local_ip = IpAddress.find_by_block_and_address(local_block1.id,
-                                                       "10.1.1.1")
-        self.assertEqual(local_ip.inside_globals()[0].address, "169.1.1.1")
-
-    def test_create_inside_global_nat(self):
-        global_block, local_block = _create_blocks('192.1.1.1/32',
-                                                        '10.1.1.1/32')
-        global_ip = global_block.allocate_ip()
-        local_ip = local_block.allocate_ip()
-
-        response = self.app.post("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                 "inside_globals"
-                              % (local_block.id, local_ip.address),
-                              {"ip_addresses": json.dumps(
-                                [{"ip_block_id": global_block.id,
-                                  "ip_address": global_ip.address}])})
-
-        self.assertEqual(response.status, "200 OK")
-
-        self.assertEqual(len(local_ip.inside_globals()), 1)
-        self.assertEqual(global_ip.id, local_ip.inside_globals()[0].id)
-        self.assertEqual(local_ip.id, global_ip.inside_locals()[0].id)
-
-    def test_delete_inside_globals(self):
-        global_block, local_block = _create_blocks('192.1.1.1/32',
-                                                        '10.1.1.1/32')
-        global_ip = global_block.allocate_ip()
-        local_ip = local_block.allocate_ip()
-        local_ip.add_inside_globals([global_ip])
-
-        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                 "inside_globals"
-                              % (local_block.id, local_ip.address))
-
-        self.assertEqual(response.status, "200 OK")
-        self.assertEqual(local_ip.inside_globals(), [])
-
-    def test_delete_inside_global_for_specific_address(self):
-        global_block, local_block = _create_blocks('192.1.1.1/28',
-                                                    '10.1.1.1/28')
-        global_ips, = _allocate_ips((global_block, 3))
-        local_ip = local_block.allocate_ip()
-        local_ip.add_inside_globals(global_ips)
-
-        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                 "inside_globals/%s"
-                                   % (local_block.id, local_ip.address,
-                                      global_ips[1].address))
-
-        globals_left = [ip.address for ip in local_ip.inside_globals()]
-        self.assertEqual(globals_left, [global_ips[0].address,
-                                        global_ips[2].address])
-
-    def test_delete_inside_local_for_specific_address(self):
-        global_block, local_block = _create_blocks('192.1.1.1/28',
-                                                    '10.1.1.1/28')
-        local_ips, = _allocate_ips((local_block, 3))
-        global_ip = global_block.allocate_ip()
-        global_ip.add_inside_locals(local_ips)
-
-        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                 "inside_locals/%s"
-                                   % (global_block.id, global_ip.address,
-                                      local_ips[1].address))
-
-        locals_left = [ip.address for ip in global_ip.inside_locals()]
-        self.assertEqual(locals_left, [local_ips[0].address,
-                                        local_ips[2].address])
-
-    def test_delete_inside_locals(self):
-        global_block, local_block = _create_blocks('192.1.1.1/32',
-                                                        '10.1.1.1/32')
-        global_ip = global_block.allocate_ip()
-        local_ip = local_block.allocate_ip()
-        global_ip.add_inside_locals([local_ip])
-
-        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                 "inside_locals"
-                              % (global_block.id, global_ip.address))
-
-        self.assertEqual(response.status, "200 OK")
-        self.assertEqual(global_ip.inside_locals(), [])
-
-    def test_show_inside_globals(self):
+class TestInsideGlobalsController(TestController):
+
+    def test_index(self):
         local_block, global_block_1, global_block_2 =\
                                     _create_blocks("10.1.1.1/30",
                                                         "192.1.1.1/30",
@@ -370,7 +267,7 @@
                          {'ip_addresses': _data_of(global_ip_1,
                                                    global_ip_2)})
 
-    def test_show_inside_globals_with_pagination(self):
+    def test_index_with_pagination(self):
         local_block, global_block = _create_blocks("10.1.1.1/8",
                                                    "192.1.1.1/8")
         [local_ip], global_ips = _allocate_ips((local_block, 1),
@@ -386,7 +283,110 @@
                         {'ip_addresses': _data_of(global_ips[2],
                                                   global_ips[3])})
 
-    def test_show_inside_locals_with_pagination(self):
+    def test_index_for_nonexistent_block(self):
+        non_existant_block_id = 12122
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_globals"
+        response = self.app.get(url % (non_existant_block_id,
+                                       "10.1.1.2"),
+                                status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpBlock Not Found")
+
+    def test_index_for_nonexistent_address(self):
+        ip_block, = _create_blocks("191.1.1.1/10")
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_globals"
+        response = self.app.get(url % (ip_block.id, '10.1.1.2'),
+                                status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpAddress Not Found")
+
+    def test_create(self):
+        global_block, local_block = _create_blocks('192.1.1.1/32',
+                                                        '10.1.1.1/32')
+        global_ip = global_block.allocate_ip()
+        local_ip = local_block.allocate_ip()
+
+        response = self.app.post("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                 "inside_globals"
+                              % (local_block.id, local_ip.address),
+                              {"ip_addresses": json.dumps(
+                                [{"ip_block_id": global_block.id,
+                                  "ip_address": global_ip.address}])})
+
+        self.assertEqual(response.status, "200 OK")
+
+        self.assertEqual(len(local_ip.inside_globals()), 1)
+        self.assertEqual(global_ip.id, local_ip.inside_globals()[0].id)
+        self.assertEqual(local_ip.id, global_ip.inside_locals()[0].id)
+
+    def test_delete(self):
+        global_block, local_block = _create_blocks('192.1.1.1/32',
+                                                        '10.1.1.1/32')
+        global_ip = global_block.allocate_ip()
+        local_ip = local_block.allocate_ip()
+        local_ip.add_inside_globals([global_ip])
+
+        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                 "inside_globals"
+                              % (local_block.id, local_ip.address))
+
+        self.assertEqual(response.status, "200 OK")
+        self.assertEqual(local_ip.inside_globals(), [])
+
+    def test_delete_for_specific_address(self):
+        global_block, local_block = _create_blocks('192.1.1.1/28',
+                                                    '10.1.1.1/28')
+        global_ips, = _allocate_ips((global_block, 3))
+        local_ip = local_block.allocate_ip()
+        local_ip.add_inside_globals(global_ips)
+
+        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                 "inside_globals/%s"
+                                   % (local_block.id, local_ip.address,
+                                      global_ips[1].address))
+
+        globals_left = [ip.address for ip in local_ip.inside_globals()]
+        self.assertEqual(globals_left, [global_ips[0].address,
+                                        global_ips[2].address])
+
+    def test_delete_for_nonexistent_block(self):
+        non_existant_block_id = 12122
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_globals"
+        response = self.app.delete(url % (non_existant_block_id,
+                                          '10.1.1.2'), status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpBlock Not Found")
+
+    def test_delete_for_nonexistent_address(self):
+        ip_block, = _create_blocks("191.1.1.1/10")
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_globals"
+        response = self.app.delete(url % (ip_block.id, '10.1.1.2'),
+                                    status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpAddress Not Found")
+
+
+class TestInsideLocalsController(TestController):
+
+    def test_index(self):
+        global_block, local_block = _create_blocks("192.1.1.1/8",
+                                                   "10.1.1.1/8")
+        [global_ip], local_ips = _allocate_ips((global_block, 1),
+                                               (local_block, 5))
+        global_ip.add_inside_locals(local_ips)
+
+        response = self.app.get("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                "inside_locals"
+                                % (global_block.id, global_ip.address))
+
+        self.assertEqual(response.json,
+                         {'ip_addresses': _data_of(*local_ips)})
+
+    def test_index_with_pagination(self):
         global_block, local_block = _create_blocks("192.1.1.1/8",
                                                         "10.1.1.1/8")
         [global_ip], local_ips = _allocate_ips((global_block, 1),
@@ -403,60 +403,144 @@
                          {'ip_addresses': _data_of(local_ips[2],
                                                    local_ips[3])})
 
-    def test_show_inside_locals(self):
-        global_block, local_block = _create_blocks("192.1.1.1/8",
-                                                   "10.1.1.1/8")
-        [global_ip], local_ips = _allocate_ips((global_block, 1),
-                                               (local_block, 5))
+    def test_index_for_nonexistent_block(self):
+        non_existant_block_id = 12122
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_locals"
+        response = self.app.get(url % (non_existant_block_id,
+                                       "10.1.1.2"),
+                                status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                 "IpBlock Not Found")
+
+    def test_index_for_nonexistent_address(self):
+        ip_block, = _create_blocks("191.1.1.1/10")
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_locals"
+        response = self.app.get(url % (ip_block.id, '10.1.1.2'),
+                                status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpAddress Not Found")
+
+    def test_create(self):
+        global_block, = _create_blocks("169.1.1.1/32")
+        local_block1, = _create_blocks("10.1.1.1/32")
+        local_block2, = _create_blocks("10.0.0.1/32")
+
+        url = "/ipam/ip_blocks/%s/ip_addresses/169.1.1.1/inside_locals"
+        json_data = [
+            {'ip_block_id': local_block1.id, 'ip_address': "10.1.1.1"},
+            {'ip_block_id': local_block2.id, 'ip_address': "10.0.0.1"},
+        ]
+        request_data = {'ip_addresses': json.dumps(json_data)}
+        response = self.app.post(url % global_block.id, request_data)
+
+        self.assertEqual(response.status, "200 OK")
+        ips = global_block.find_allocated_ip("169.1.1.1").inside_locals()
+        inside_locals = [ip.address for ip in ips]
+
+        self.assertEqual(len(inside_locals), 2)
+        self.assertTrue("10.1.1.1" in inside_locals)
+        self.assertTrue("10.0.0.1" in inside_locals)
+        local_ip = IpAddress.find_by_block_and_address(local_block1.id,
+                                                       "10.1.1.1")
+        self.assertEqual(local_ip.inside_globals()[0].address, "169.1.1.1")
+
+    def test_delete_for_specific_address(self):
+        global_block, local_block = _create_blocks('192.1.1.1/28',
+                                                    '10.1.1.1/28')
+        local_ips, = _allocate_ips((local_block, 3))
+        global_ip = global_block.allocate_ip()
         global_ip.add_inside_locals(local_ips)
 
-        response = self.app.get("/ipam/ip_blocks/%s/ip_addresses/%s/"
-                                "inside_locals"
-                                % (global_block.id, global_ip.address))
-
-        self.assertEqual(response.json,
-                         {'ip_addresses': _data_of(*local_ips)})
-
-    def test_show_nats_for_nonexistent_block(self):
-        for action in ["inside_locals", "inside_globals"]:
-            non_existant_block_id = 12122
-            url = "/ipam/ip_blocks/%s/ip_addresses/%s/%s"
-            response = self.app.get(url % (non_existant_block_id,
-                                           "10.1.1.2", action),
-                                    status='*')
-
-            self.assertErrorResponse(response, "404 Not Found",
-                                     "IpBlock Not Found")
-
-    def test_show_nats_for_nonexistent_address(self):
-        for action in ["inside_locals", "inside_globals"]:
-            ip_block, = _create_blocks("191.1.1.1/10")
-            url = "/ipam/ip_blocks/%s/ip_addresses/%s/%s"
-            response = self.app.get(url % (ip_block.id, '10.1.1.2', action),
-                                    status='*')
-
-            self.assertErrorResponse(response, "404 Not Found",
-                                     "IpAddress Not Found")
-
-    def test_delete_nats_for_nonexistent_block(self):
-        for action in ["inside_locals", "inside_globals"]:
-            non_existant_block_id = 12122
-            url = "/ipam/ip_blocks/%s/ip_addresses/%s/%s"
-            response = self.app.delete(url % (non_existant_block_id,
-                                              '10.1.1.2', action), status='*')
-
-            self.assertErrorResponse(response, "404 Not Found",
-                                     "IpBlock Not Found")
-
-    def test_delete_nats_for_nonexistent_address(self):
-        for action in ["inside_locals", "inside_globals"]:
-            ip_block, = _create_blocks("191.1.1.1/10")
-            url = "/ipam/ip_blocks/%s/ip_addresses/%s/%s"
-            response = self.app.delete(url % (ip_block.id, '10.1.1.2', action),
-                                    status='*')
-
-            self.assertErrorResponse(response, "404 Not Found",
-                                     "IpAddress Not Found")
+        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                 "inside_locals/%s"
+                                   % (global_block.id, global_ip.address,
+                                      local_ips[1].address))
+
+        locals_left = [ip.address for ip in global_ip.inside_locals()]
+        self.assertEqual(locals_left, [local_ips[0].address,
+                                        local_ips[2].address])
+
+    def test_delete(self):
+        global_block, local_block = _create_blocks('192.1.1.1/32',
+                                                        '10.1.1.1/32')
+        global_ip = global_block.allocate_ip()
+        local_ip = local_block.allocate_ip()
+        global_ip.add_inside_locals([local_ip])
+
+        response = self.app.delete("/ipam/ip_blocks/%s/ip_addresses/%s/"
+                                 "inside_locals"
+                              % (global_block.id, global_ip.address))
+
+        self.assertEqual(response.status, "200 OK")
+        self.assertEqual(global_ip.inside_locals(), [])
+
+    def test_delete_for_nonexistent_block(self):
+        non_existant_block_id = 12122
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_locals"
+        response = self.app.delete(url % (non_existant_block_id,
+                                          '10.1.1.2'), status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                     "IpBlock Not Found")
+
+    def test_delete_for_nonexistent_address(self):
+        ip_block, = _create_blocks("191.1.1.1/10")
+        url = "/ipam/ip_blocks/%s/ip_addresses/%s/inside_locals"
+        response = self.app.delete(url % (ip_block.id, '10.1.1.2'),
+                                   status='*')
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                 "IpAddress Not Found")
+
+
+class TestPoliciesController(TestController):
+
+    def test_create(self):
+        response = self.app.post("/ipam/policies", {'name': "ServiceNet"})
+
+        self.assertEqual(response.status, "201 Created")
+        self.assertEqual(response.json['name'], "ServiceNet")
+
+    def test_index(self):
+        _create_policy("PublicNet")
+        _create_policy("DedicatedServiceNet")
+
+        response = self.app.get("/ipam/policies")
+
+        self.assertEqual(response.status, "200 OK")
+        response_policies = response.json['policies']
+        policies = Policy.find_all()
+        self.assertEqual(len(policies), 2)
+        self.assertEqual(response_policies, _data_of(*policies))
+
+    def test_show_when_requested_policy_exists(self):
+        policy = _create_policy("DRAC")
+
+        response = self.app.get("/ipam/policies/%s" % policy.id)
+
+        self.assertEqual(response.status, "200 OK")
+        self.assertEqual(response.json, policy.data())
+
+    def test_show_when_requested_policy_does_not_exist(self):
+        response = self.app.get("/ipam/policies/invalid_id", status="*")
+
+        self.assertErrorResponse(response, "404 Not Found",
+                                 "Policy Not Found")
+
+
+class TestUnusableIpRangesController(TestController):
+
+    def test_create(self):
+        policy = _create_policy("ServiceNet")
+
+        response = self.app.post("/ipam/policies/%s/unusable_ip_ranges"
+                                 % policy.id, {'offset': 1, 'length': 2})
+
+        unusable_range = IpRange.find_all_by_policy(policy.id).first()
+        self.assertEqual(response.status, "201 Created")
+        self.assertEqual(response.json, unusable_range.data())
 
 
 class TestPoliciesController(TestController):
@@ -503,5 +587,9 @@
     return [IpBlock.create({"cidr": cidr}) for cidr in args]
 
 
+def _create_policy(name):
+    return Policy.create({"name": name})
+
+
 def _data_of(*args):
     return [model.data() for model in args]