Exemplo n.º 1
0
    def test_update_shared_ip_with_garbage_will_error(self):

        with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]["id"], ports[1]["id"]]
            shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip["type"])
            port_ids = [ports[0]["id"], ports[3]["id"]]
            shared_ip = {"delasdfkj": dict(port_ids=port_ids)}

            with self.assertRaises(n_exc.BadRequest):
                ip_api.update_ip_address(self.context, ip["id"], shared_ip)
Exemplo n.º 2
0
    def test_reserve_ip_admin_port_assoc_raises_not_authorized(self):
        # This value prevents the testing of the exception thrown if an admin
        # attempts to deallocate/allocate an IP associated with a port since
        # an exception is thrown beforehand.
        old_override = cfg.CONF.QUARK.ipaddr_allow_fixed_ip
        cfg.CONF.set_override('ipaddr_allow_fixed_ip', True, 'QUARK')
        with self._stubs() as ip:
            with self.assertRaises(q_exc.ActionNotAuthorized):
                self.context.is_admin = True
                ip_addr.update_ip_address(self.context, ip["id"],
                                          self.ip_address_dealloc)

        cfg.CONF.set_override('ipaddr_allow_fixed_ip', old_override, 'QUARK')
Exemplo n.º 3
0
    def test_reserve_ip_admin_port_assoc_raises_not_authorized(self):
        # This value prevents the testing of the exception thrown if an admin
        # attempts to deallocate/allocate an IP associated with a port since
        # an exception is thrown beforehand.
        old_override = cfg.CONF.QUARK.ipaddr_allow_fixed_ip
        cfg.CONF.set_override('ipaddr_allow_fixed_ip', True, 'QUARK')
        with self._stubs() as ip:
            with self.assertRaises(q_exc.ActionNotAuthorized):
                self.context.is_admin = True
                ip_addr.update_ip_address(self.context, ip["id"],
                                          self.ip_address_dealloc)

        cfg.CONF.set_override('ipaddr_allow_fixed_ip', old_override, 'QUARK')
Exemplo n.º 4
0
 def test_reserve_ip_non_admin(self):
     with self._stubs() as ip:
         deallocated_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                    self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(self.context,
                                             id=deallocated_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                    self.ip_address_reserve)
         ip_address = db_api.ip_address_find(self.context,
                                             id=deallocated_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
Exemplo n.º 5
0
    def test_get_deallocated_ips_admin_both(self):
        self.context.is_admin = True
        with self._stubs() as (ip1, ip2):
            reserved_ip = ip_addr.update_ip_address(self.context, ip2["id"],
                                                    self.ip_address_dealloc)
            self.assertEqual(reserved_ip["_deallocated"], True)

            deallocated_ips = ip_addr.get_ip_addresses(self.context)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], False)

            filters = {'deallocated': 'True'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(reserved_ip['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], True)

            filters = {'deallocated': 'False'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], False)

            filters = {'deallocated': 'both'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 2)
            for ip in deallocated_ips:
                if ip["id"] == ip1["id"]:
                    self.assertEqual(ip["_deallocated"], False)
                elif ip["id"] == ip2["id"]:
                    self.assertEqual(ip["_deallocated"], True)
Exemplo n.º 6
0
 def test_reserve_ip_non_admin(self):
     with self._stubs() as ip:
         deallocated_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                    self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(
             self.context,
             id=deallocated_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                    self.ip_address_reserve)
         ip_address = db_api.ip_address_find(
             self.context,
             id=deallocated_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
Exemplo n.º 7
0
    def test_get_deallocated_ips_admin_both(self):
        self.context.is_admin = True
        with self._stubs() as (ip1, ip2):
            reserved_ip = ip_addr.update_ip_address(self.context, ip2["id"],
                                                    self.ip_address_dealloc)
            self.assertEqual(reserved_ip["_deallocated"], True)

            deallocated_ips = ip_addr.get_ip_addresses(self.context)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], False)

            filters = {'deallocated': 'True'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(reserved_ip['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], True)

            filters = {'deallocated': 'False'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertEqual(deallocated_ips[0]['_deallocated'], False)

            filters = {'deallocated': 'both'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 2)
            for ip in deallocated_ips:
                if ip["id"] == ip1["id"]:
                    self.assertEqual(ip["_deallocated"], False)
                elif ip["id"] == ip2["id"]:
                    self.assertEqual(ip["_deallocated"], True)
Exemplo n.º 8
0
    def test_update_shared_ip_with_empty_port_id_list_will_error(self):

        with self._stubs(self.network, self.subnet, self.ports_info4) as (
                net, sub, ports):

            port_ids = [ports[0]['id'], ports[1]['id']]
            shared_ip = {'ip_address': dict(port_ids=port_ids,
                                            network_id=net['id'],
                                            version=4)}
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip['type'])
            port_ids = []
            shared_ip = {'ip_addresses': dict(port_ids=port_ids)}

            with self.assertRaises(exceptions.BadRequest):
                ip_api.update_ip_address(self.context, ip['id'], shared_ip)
Exemplo n.º 9
0
    def test_get_deallocated_ips_non_admin_both(self):
        with self._stubs() as (ip1, ip2):
            reserved_ip = ip_addr.update_ip_address(self.context, ip2["id"],
                                                    self.ip_address_dealloc)
            self.assertNotIn('_deallocated', reserved_ip)

            ip_addresses = db_api.ip_address_find(self.context,
                                                  scope=db_api.ALL)
            self.assertEqual(len(ip_addresses), 2)
            for ip in ip_addresses:
                if ip["id"] == ip1["id"]:
                    self.assertEqual(ip["_deallocated"], False)
                elif ip["id"] == ip2["id"]:
                    self.assertEqual(ip["_deallocated"], True)

            deallocated_ips = ip_addr.get_ip_addresses(self.context)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertNotIn('_deallocated', deallocated_ips[0])

            filters = {'deallocated': 'True'}
            deallocated_ips1 = ip_addr.get_ip_addresses(
                self.context, **filters)
            self.assertEqual(len(deallocated_ips1), 1)

            filters = {'deallocated': 'False'}
            deallocated_ips1 = ip_addr.get_ip_addresses(
                self.context, **filters)
            self.assertEqual(len(deallocated_ips1), 1)

            filters = {'deallocated': 'both'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertNotIn('_deallocated', deallocated_ips[0])
Exemplo n.º 10
0
    def test_update_shared_ip_with_owned_port_no_error_if_same_list(self):

        with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]["id"], ports[1]["id"]]
            p_id = ports[0]["id"]

            shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip["type"])

            port_ip_update = ip_api.update_port_for_ip_address
            port_ip_update(self.context, ip["id"], p_id, self._make_port_body("derp"))

            shared_ip = {"ip_address": dict(port_ids=port_ids)}

            ip_api.update_ip_address(self.context, ip["id"], shared_ip)
Exemplo n.º 11
0
    def test_update_shared_ip_with_garbage_will_error(self):

        with self._stubs(self.network, self.subnet,
                         self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]['id'], ports[1]['id']]
            shared_ip = {
                'ip_address':
                dict(port_ids=port_ids, network_id=net['id'], version=4)
            }
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip['type'])
            port_ids = [ports[0]['id'], ports[3]['id']]
            shared_ip = {'delasdfkj': dict(port_ids=port_ids)}

            with self.assertRaises(n_exc.BadRequest):
                ip_api.update_ip_address(self.context, ip['id'], shared_ip)
Exemplo n.º 12
0
 def test_get_deallocated_ips_non_admin_empty(self):
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(self.context,
                                             id=reserved_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ips = ip_addr.get_ip_addresses(self.context)
         self.assertEqual(len(deallocated_ips), 0)
Exemplo n.º 13
0
 def test_get_single_deallocated_ip_non_admin_raises(self):
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(self.context,
                                             id=reserved_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         with self.assertRaises(q_exc.IpAddressNotFound):
             ip_addr.get_ip_address(self.context, ip_address['id'])
Exemplo n.º 14
0
 def test_get_deallocated_ips_non_admin_empty(self):
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(
             self.context,
             id=reserved_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ips = ip_addr.get_ip_addresses(self.context)
         self.assertEqual(len(deallocated_ips), 0)
Exemplo n.º 15
0
 def test_get_single_deallocated_ip_non_admin_raises(self):
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(
             self.context,
             id=reserved_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         with self.assertRaises(q_exc.IpAddressNotFound):
             ip_addr.get_ip_address(self.context,
                                    ip_address['id'])
Exemplo n.º 16
0
    def test_update_shared_ip_with_owned_port_no_error_if_same_list(self):

        with self._stubs(self.network, self.subnet,
                         self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]['id'], ports[1]['id']]
            p_id = ports[0]['id']

            shared_ip = {
                'ip_address':
                dict(port_ids=port_ids, network_id=net['id'], version=4)
            }
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip['type'])

            port_ip_update = ip_api.update_port_for_ip_address
            port_ip_update(self.context, ip['id'], p_id,
                           self._make_port_body('derp'))

            shared_ip = {'ip_address': dict(port_ids=port_ids)}

            ip_api.update_ip_address(self.context, ip['id'], shared_ip)
Exemplo n.º 17
0
    def test_update_shared_ip_with_owned_port_no_error_if_adding(self):

        with self._stubs(self.network, self.subnet, self.ports_info4) as (
                net, sub, ports):

            port_ids = [ports[0]['id'], ports[1]['id']]
            p_id = ports[0]['id']

            shared_ip = {'ip_address': dict(port_ids=port_ids,
                                            network_id=net['id'],
                                            version=4)}
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip['type'])

            port_ip_update = ip_api.update_port_for_ip_address
            port_ip_update(self.context, ip['id'], p_id,
                           self._make_port_body('derp'))
            port_ids = [ports[0]['id'], ports[1]['id'], ports[2]['id']]

            shared_ip = {'ip_address': dict(port_ids=port_ids)}

            ip_api.update_ip_address(self.context, ip['id'], shared_ip)
Exemplo n.º 18
0
 def test_get_single_deallocated_ip_admin(self):
     self.context.is_admin = True
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(self.context,
                                             id=reserved_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ip = ip_addr.get_ip_address(self.context,
                                                 ip_address['id'])
         self.assertEqual(reserved_ip['id'], deallocated_ip['id'])
         self.assertEqual(deallocated_ip['_deallocated'], True)
Exemplo n.º 19
0
 def test_get_deallocated_ips_admin(self):
     self.context.is_admin = True
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(self.context,
                                             id=reserved_ip["id"],
                                             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         filters = {'deallocated': 'True'}
         deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
         self.assertEqual(len(deallocated_ips), 1)
         self.assertEqual(reserved_ip['id'], deallocated_ips[0]['id'])
         self.assertEqual(deallocated_ips[0]['_deallocated'], True)
Exemplo n.º 20
0
 def test_get_single_deallocated_ip_admin(self):
     self.context.is_admin = True
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(
             self.context,
             id=reserved_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         deallocated_ip = ip_addr.get_ip_address(self.context,
                                                 ip_address['id'])
         self.assertEqual(reserved_ip['id'], deallocated_ip['id'])
         self.assertEqual(deallocated_ip['_deallocated'], True)
Exemplo n.º 21
0
 def test_get_deallocated_ips_admin(self):
     self.context.is_admin = True
     with self._stubs() as ip:
         reserved_ip = ip_addr.update_ip_address(self.context, ip["id"],
                                                 self.ip_address_dealloc)
         ip_address = db_api.ip_address_find(
             self.context,
             id=reserved_ip["id"],
             scope=db_api.ONE)
         self.assertEqual(ip_address["deallocated"], True)
         filters = {'deallocated': 'True'}
         deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
         self.assertEqual(len(deallocated_ips), 1)
         self.assertEqual(reserved_ip['id'], deallocated_ips[0]['id'])
         self.assertEqual(deallocated_ips[0]['_deallocated'], True)
Exemplo n.º 22
0
    def test_update_shared_ip_with_unowned_ports_is_okay(self):

        with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]["id"], ports[1]["id"]]
            shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip["type"])
            port_ids = [ports[0]["id"], ports[3]["id"]]
            shared_ip = {"ip_address": dict(port_ids=port_ids)}

            ip = ip_api.update_ip_address(self.context, ip["id"], shared_ip)

            ports_ip = ip_api.get_ports_for_ip_address(self.context, ip["id"])
            self.assertEqual(2, len(ports_ip))
            for port in ports_ip:
                self.assertTrue(port["id"] in port_ids)
Exemplo n.º 23
0
    def test_update_shared_ip_with_unowned_ports_is_okay(self):

        with self._stubs(self.network, self.subnet,
                         self.ports_info4) as (net, sub, ports):

            port_ids = [ports[0]['id'], ports[1]['id']]
            shared_ip = {
                'ip_address':
                dict(port_ids=port_ids, network_id=net['id'], version=4)
            }
            ip = ip_api.create_ip_address(self.context, shared_ip)
            self.assertEqual(ip_types.SHARED, ip['type'])
            port_ids = [ports[0]['id'], ports[3]['id']]
            shared_ip = {'ip_address': dict(port_ids=port_ids)}

            ip = ip_api.update_ip_address(self.context, ip['id'], shared_ip)

            ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
            self.assertEqual(2, len(ports_ip))
            for port in ports_ip:
                self.assertTrue(port['id'] in port_ids)
Exemplo n.º 24
0
    def test_get_deallocated_ips_non_admin_both(self):
        with self._stubs() as (ip1, ip2):
            reserved_ip = ip_addr.update_ip_address(self.context, ip2["id"],
                                                    self.ip_address_dealloc)
            self.assertNotIn('_deallocated', reserved_ip)

            ip_addresses = db_api.ip_address_find(
                self.context,
                scope=db_api.ALL)
            self.assertEqual(len(ip_addresses), 2)
            for ip in ip_addresses:
                if ip["id"] == ip1["id"]:
                    self.assertEqual(ip["_deallocated"], False)
                elif ip["id"] == ip2["id"]:
                    self.assertEqual(ip["_deallocated"], True)

            deallocated_ips = ip_addr.get_ip_addresses(self.context)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertNotIn('_deallocated', deallocated_ips[0])

            filters = {'deallocated': 'True'}
            deallocated_ips1 = ip_addr.get_ip_addresses(self.context,
                                                        **filters)
            self.assertEqual(len(deallocated_ips1), 1)

            filters = {'deallocated': 'False'}
            deallocated_ips1 = ip_addr.get_ip_addresses(self.context,
                                                        **filters)
            self.assertEqual(len(deallocated_ips1), 1)

            filters = {'deallocated': 'both'}
            deallocated_ips = ip_addr.get_ip_addresses(self.context, **filters)
            self.assertEqual(len(deallocated_ips), 1)
            self.assertEqual(ip1['id'], deallocated_ips[0]['id'])
            self.assertNotIn('_deallocated', deallocated_ips[0])
Exemplo n.º 25
0
 def update_ip_address(self, context, id, ip_address):
     return ip_addresses.update_ip_address(context, id, ip_address)
Exemplo n.º 26
0
 def test_reserve_ip_non_admin_port_assoc_raises_bad_request(self):
     with self._stubs() as ip:
         with self.assertRaises(n_exc.BadRequest):
             ip_addr.update_ip_address(self.context, ip["id"],
                                       self.ip_address_dealloc)
Exemplo n.º 27
0
 def update_ip_address(self, context, id, ip_address):
     return ip_addresses.update_ip_address(context, id, ip_address)
Exemplo n.º 28
0
 def test_reserve_ip_non_admin_port_assoc_raises_bad_request(self):
     with self._stubs() as ip:
         with self.assertRaises(n_exc.BadRequest):
             ip_addr.update_ip_address(self.context, ip["id"],
                                       self.ip_address_dealloc)