# Copyright (c) 2015 Red Hat, Inc.
#
#    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.

import contextlib
from unittest import mock

import netaddr
from neutron_lib.api.definitions import address_scope as apidef
from neutron_lib.callbacks import events
from neutron_lib.callbacks import registry
from neutron_lib.callbacks import resources
from neutron_lib import constants
from neutron_lib import context
from neutron_lib.plugins import directory
import webob.exc

from neutron.db import address_scope_db
from neutron.db import db_base_plugin_v2
from neutron.extensions import address_scope as ext_address_scope
from neutron.tests.unit.db import test_db_base_plugin_v2

DB_PLUGIN_KLASS = ('neutron.tests.unit.extensions.test_address_scope.'
                   'AddressScopeTestPlugin')


class AddressScopeTestExtensionManager(object):

    def get_resources(self):
        return ext_address_scope.Address_scope.get_resources()

    def get_actions(self):
        return []

    def get_request_extensions(self):
        return []


class AddressScopeTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase):

    def _create_address_scope(self, fmt, ip_version=constants.IP_VERSION_4,
                              expected_res_status=None, admin=False, **kwargs):
        address_scope = {'address_scope': {}}
        address_scope['address_scope']['ip_version'] = ip_version
        for k, v in kwargs.items():
            address_scope['address_scope'][k] = str(v)

        address_scope_req = self.new_create_request('address-scopes',
                                                    address_scope, fmt)

        if not admin:
            neutron_context = context.Context('', kwargs.get('tenant_id',
                                                             self._tenant_id))
            address_scope_req.environ['neutron.context'] = neutron_context

        address_scope_res = address_scope_req.get_response(self.ext_api)
        if expected_res_status:
            self.assertEqual(expected_res_status, address_scope_res.status_int)
        return address_scope_res

    def _make_address_scope(self, fmt, ip_version, admin=False, **kwargs):
        res = self._create_address_scope(fmt, ip_version,
                                         admin=admin, **kwargs)
        if res.status_int >= webob.exc.HTTPClientError.code:
            raise webob.exc.HTTPClientError(code=res.status_int)
        return self.deserialize(fmt, res)

    @contextlib.contextmanager
    def address_scope(self, ip_version=constants.IP_VERSION_4,
                      admin=False, **kwargs):
        addr_scope = self._make_address_scope(self.fmt, ip_version,
                                              admin, **kwargs)
        yield addr_scope

    def _test_create_address_scope(self, ip_version=constants.IP_VERSION_4,
                                   admin=False, expected=None, **kwargs):
        keys = kwargs.copy()
        keys.setdefault('tenant_id', self._tenant_id)
        with self.address_scope(ip_version,
                                admin=admin, **keys) as addr_scope:
            keys['ip_version'] = ip_version
            self._validate_resource(addr_scope, keys, 'address_scope')
            if expected:
                self._compare_resource(addr_scope, expected, 'address_scope')
        return addr_scope

    def _test_update_address_scope(self, addr_scope_id, data, admin=False,
                                   expected=None, tenant_id=None):
        update_req = self.new_update_request(
            'address-scopes', data, addr_scope_id)
        update_req.environ['neutron.context'] = context.Context(
            '', tenant_id or self._tenant_id, is_admin=admin)

        update_res = update_req.get_response(self.ext_api)
        if expected:
            addr_scope = self.deserialize(self.fmt, update_res)
            self._compare_resource(addr_scope, expected, 'address_scope')
            return addr_scope

        return update_res


class AddressScopeTestPlugin(db_base_plugin_v2.NeutronDbPluginV2,
                             address_scope_db.AddressScopeDbMixin):
    __native_pagination_support = True
    __native_sorting_support = True

    supported_extension_aliases = [apidef.ALIAS]


class TestAddressScope(AddressScopeTestCase):

    def setUp(self):
        plugin = DB_PLUGIN_KLASS
        ext_mgr = AddressScopeTestExtensionManager()
        super(TestAddressScope, self).setUp(plugin=plugin, ext_mgr=ext_mgr)

    def test_create_address_scope_ipv4(self):
        expected_addr_scope = {'name': 'foo-address-scope',
                               'tenant_id': self._tenant_id,
                               'shared': False,
                               'ip_version': constants.IP_VERSION_4}
        self._test_create_address_scope(name='foo-address-scope',
                                        expected=expected_addr_scope)

    def test_create_address_scope_ipv6(self):
        expected_addr_scope = {'name': 'foo-address-scope',
                               'tenant_id': self._tenant_id,
                               'shared': False,
                               'ip_version': constants.IP_VERSION_6}
        self._test_create_address_scope(constants.IP_VERSION_6,
                                        name='foo-address-scope',
                                        expected=expected_addr_scope)

    def test_create_address_scope_empty_name(self):
        expected_addr_scope = {'name': '',
                               'tenant_id': self._tenant_id,
                               'shared': False}
        self._test_create_address_scope(name='', expected=expected_addr_scope)

        # no name specified
        self._test_create_address_scope(expected=expected_addr_scope)

    def test_create_address_scope_shared_admin(self):
        expected_addr_scope = {'name': 'foo-address-scope', 'shared': True}
        self._test_create_address_scope(name='foo-address-scope', admin=True,
                                        shared=True,
                                        expected=expected_addr_scope)

    def test_created_address_scope_shared_non_admin(self):
        res = self._create_address_scope(self.fmt, name='foo-address-scope',
                                         tenant_id=self._tenant_id,
                                         admin=False, shared=True)
        self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)

    def test_created_address_scope_specify_id(self):
        res = self._create_address_scope(self.fmt, name='foo-address-scope',
                                         id='foo-id')
        self.assertEqual(webob.exc.HTTPClientError.code, res.status_int)

    def test_delete_address_scope(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            self._delete('address-scopes', addr_scope['address_scope']['id'])
            self._show('address-scopes', addr_scope['address_scope']['id'],
                       expected_code=webob.exc.HTTPNotFound.code)

    def test_update_address_scope(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope')
        data = {'address_scope': {'name': 'bar-address-scope'}}
        self._test_update_address_scope(addr_scope['address_scope']['id'],
                                        data, expected=data['address_scope'])

    def test_update_address_scope_shared_true_admin(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope')
        data = {'address_scope': {'shared': True}}
        self._test_update_address_scope(addr_scope['address_scope']['id'],
                                        data, admin=True,
                                        expected=data['address_scope'])

    def test_update_address_scope_shared_true_non_admin(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope')
        data = {'address_scope': {'shared': True}}
        res = self._test_update_address_scope(
            addr_scope['address_scope']['id'], data, admin=False)
        self.assertEqual(webob.exc.HTTPForbidden.code, res.status_int)

    def test_update_address_scope_shared_false_admin(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope',
                                                     admin=True, shared=True)
        data = {'address_scope': {'shared': False}}
        res = self._test_update_address_scope(
            addr_scope['address_scope']['id'], data, admin=True)
        self.assertEqual(webob.exc.HTTPClientError.code, res.status_int)

    def test_get_address_scope(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope')
        req = self.new_show_request('address-scopes',
                                    addr_scope['address_scope']['id'])
        res = self.deserialize(self.fmt, req.get_response(self.ext_api))
        self.assertEqual(addr_scope['address_scope']['id'],
                         res['address_scope']['id'])

    def test_get_address_scope_different_tenants_not_shared(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope')
        req = self.new_show_request('address-scopes',
                                    addr_scope['address_scope']['id'])
        neutron_context = context.Context('', 'not-the-owner')
        req.environ['neutron.context'] = neutron_context
        res = req.get_response(self.ext_api)
        self.assertEqual(webob.exc.HTTPNotFound.code, res.status_int)

    def test_get_address_scope_different_tenants_shared(self):
        addr_scope = self._test_create_address_scope(name='foo-address-scope',
                                                     shared=True, admin=True)
        req = self.new_show_request('address-scopes',
                                    addr_scope['address_scope']['id'])
        neutron_context = context.Context('', 'test-tenant-2')
        req.environ['neutron.context'] = neutron_context
        res = self.deserialize(self.fmt, req.get_response(self.ext_api))
        self.assertEqual(addr_scope['address_scope']['id'],
                         res['address_scope']['id'])

    def test_list_address_scopes(self):
        self._test_create_address_scope(name='foo-address-scope')
        self._test_create_address_scope(constants.IP_VERSION_6,
                                        name='bar-address-scope')
        res = self._list('address-scopes')
        self.assertEqual(2, len(res['address_scopes']))

    def test_list_address_scopes_different_tenants_shared(self):
        self._test_create_address_scope(name='foo-address-scope', shared=True,
                                        admin=True)
        admin_res = self._list('address-scopes')
        mortal_res = self._list(
            'address-scopes',
            neutron_context=context.Context('', 'not-the-owner'))
        self.assertEqual(1, len(admin_res['address_scopes']))
        self.assertEqual(1, len(mortal_res['address_scopes']))

    def test_list_address_scopes_different_tenants_not_shared(self):
        self._test_create_address_scope(constants.IP_VERSION_6,
                                        name='foo-address-scope')
        admin_res = self._list('address-scopes')
        mortal_res = self._list(
            'address-scopes',
            neutron_context=context.Context('', 'not-the-owner'))
        self.assertEqual(1, len(admin_res['address_scopes']))
        self.assertEqual(0, len(mortal_res['address_scopes']))


class TestSubnetPoolsWithAddressScopes(AddressScopeTestCase):
    def setUp(self):
        plugin = DB_PLUGIN_KLASS
        ext_mgr = AddressScopeTestExtensionManager()
        super(TestSubnetPoolsWithAddressScopes, self).setUp(plugin=plugin,
                                                            ext_mgr=ext_mgr)

    def _test_create_subnetpool(self, prefixes, expected=None,
                                admin=False, **kwargs):
        keys = kwargs.copy()
        keys.setdefault('tenant_id', self._tenant_id)
        with self.subnetpool(prefixes, admin, **keys) as subnetpool:
            self._validate_resource(subnetpool, keys, 'subnetpool')
            if expected:
                self._compare_resource(subnetpool, expected, 'subnetpool')
        return subnetpool

    def test_create_subnetpool_associate_address_scope(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            expected = {'address_scope_id': address_scope_id}
            self._test_create_subnetpool([subnet.cidr], expected=expected,
                                         name='foo-subnetpool',
                                         min_prefixlen='21',
                                         address_scope_id=address_scope_id)

    def test_create_subnetpool_associate_invalid_address_scope(self):
        self.assertRaises(
            webob.exc.HTTPClientError, self._test_create_subnetpool, [],
            min_prefixlen='21', address_scope_id='foo-addr-scope-id')

    def test_create_subnetpool_assoc_address_scope_with_prefix_intersect(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            expected = {'address_scope_id': address_scope_id}
            self._test_create_subnetpool([subnet.cidr], expected=expected,
                                         name='foo-subnetpool',
                                         min_prefixlen='21',
                                         address_scope_id=address_scope_id)
            overlap_subnet = netaddr.IPNetwork('10.10.10.10/24')
            self.assertRaises(
                webob.exc.HTTPClientError, self._test_create_subnetpool,
                [overlap_subnet.cidr], min_prefixlen='21',
                address_scope_id=address_scope_id)

    def test_update_subnetpool_associate_address_scope(self):
        subnet = netaddr.IPNetwork('10.10.10.0/24')
        initial_subnetpool = self._test_create_subnetpool([subnet.cidr],
                                                          name='foo-sp',
                                                          min_prefixlen='21')
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            data = {'subnetpool': {'address_scope_id': address_scope_id}}
            req = self.new_update_request(
                'subnetpools', data, initial_subnetpool['subnetpool']['id'])
            api = self._api_for_resource('subnetpools')
            res = self.deserialize(self.fmt, req.get_response(api))
            self._compare_resource(res, data['subnetpool'], 'subnetpool')

    def test_update_subnetpool_associate_invalid_address_scope(self):
        subnet = netaddr.IPNetwork('10.10.10.0/24')
        initial_subnetpool = self._test_create_subnetpool([subnet.cidr],
                                                          name='foo-sp',
                                                          min_prefixlen='21')
        data = {'subnetpool': {'address_scope_id': 'foo-addr-scope-id'}}
        req = self.new_update_request(
            'subnetpools', data, initial_subnetpool['subnetpool']['id'])
        api = self._api_for_resource('subnetpools')
        res = req.get_response(api)
        self.assertEqual(webob.exc.HTTPClientError.code, res.status_int)

    def test_update_subnetpool_disassociate_address_scope(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            expected = {'address_scope_id': address_scope_id}
            initial_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], expected=expected, name='foo-sp',
                min_prefixlen='21', address_scope_id=address_scope_id)

            data = {'subnetpool': {'address_scope_id': None}}
            req = self.new_update_request(
                'subnetpools', data, initial_subnetpool['subnetpool']['id'])
            api = self._api_for_resource('subnetpools')
            res = self.deserialize(self.fmt, req.get_response(api))
            self._compare_resource(res, data['subnetpool'], 'subnetpool')

    def test_update_subnetpool_associate_another_address_scope(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            expected = {'address_scope_id': address_scope_id}
            initial_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], expected=expected, name='foo-sp',
                min_prefixlen='21', address_scope_id=address_scope_id)

            with self.address_scope(name='foo-address-scope') as other_a_s:
                other_a_s_id = other_a_s['address_scope']['id']
                update_data = {'subnetpool': {'address_scope_id':
                                              other_a_s_id}}
                req = self.new_update_request(
                    'subnetpools', update_data,
                    initial_subnetpool['subnetpool']['id'])
                api = self._api_for_resource('subnetpools')
                res = self.deserialize(self.fmt, req.get_response(api))
                self._compare_resource(res, update_data['subnetpool'],
                                       'subnetpool')

    def _test_update_subnetpool_address_scope_notify(self, as_change=True):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            foo_as_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            initial_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], name='foo-sp',
                min_prefixlen='21', address_scope_id=foo_as_id)
            subnetpool_id = initial_subnetpool['subnetpool']['id']
            with self.address_scope(name='bar-address-scope') as other_as, \
                    self.network() as network:
                data = {'subnet': {
                        'network_id': network['network']['id'],
                        'subnetpool_id': subnetpool_id,
                        'prefixlen': 24,
                        'ip_version': constants.IP_VERSION_4,
                        'tenant_id': network['network']['tenant_id']}}
                req = self.new_create_request('subnets', data)
                subnet = self.deserialize(self.fmt,
                                          req.get_response(self.api))

                with mock.patch.object(registry, 'publish') as publish:
                    plugin = db_base_plugin_v2.NeutronDbPluginV2()
                    plugin.is_address_scope_owned_by_tenant = mock.Mock(
                        return_value=True)
                    plugin._validate_address_scope_id = mock.Mock()
                    ctx = context.get_admin_context()

                    bar_as_id = other_as['address_scope']['id']
                    data = {'subnetpool': {
                            'name': 'bar-sp'}}
                    if as_change:
                        data['subnetpool']['address_scope_id'] = bar_as_id

                    updated_sp = plugin.update_subnetpool(
                        ctx, subnetpool_id, data)

                    self.assertEqual('bar-sp', updated_sp['name'])
                    if as_change:
                        self.assertEqual(bar_as_id,
                                         updated_sp['address_scope_id'])
                        publish.assert_called_once_with(
                            resources.SUBNETPOOL_ADDRESS_SCOPE,
                            events.AFTER_UPDATE,
                            plugin.update_subnetpool, payload=mock.ANY)
                        payload = publish.mock_calls[0][2]['payload']
                        self.assertEqual(ctx, payload.context)
                        self.assertEqual(subnetpool_id, payload.resource_id)
                    else:
                        self.assertEqual(foo_as_id,
                                         updated_sp['address_scope_id'])
                        self.assertFalse(publish.called)

    def test_update_subnetpool_address_scope_notify(self):
        self._test_update_subnetpool_address_scope_notify()

    def test_not_update_subnetpool_address_scope_not_notify(self):
        self._test_update_subnetpool_address_scope_notify(False)

    def test_network_create_contain_address_scope_attr(self):
        with self.network() as network:
            result = self._show('networks', network['network']['id'])
            keys = [apidef.IPV4_ADDRESS_SCOPE,
                    apidef.IPV6_ADDRESS_SCOPE]
            for k in keys:
                # Correlated address scopes should initially be None
                self.assertIsNone(result['network'][k])

    def test_correlate_network_with_address_scope(self):
        with self.address_scope(name='v4-as') as v4_addr_scope, \
                self.address_scope(
                    name='v6-as',
                    ip_version=constants.IP_VERSION_6) as v6_addr_scope, \
                self.network() as network:
            v4_as_id = v4_addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            v4_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], name='v4-sp',
                min_prefixlen='24', address_scope_id=v4_as_id)
            v4_subnetpool_id = v4_subnetpool['subnetpool']['id']
            v6_as_id = v6_addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('fd5c:6ee1:c7ae::/64')
            v6_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], name='v6-sp',
                min_prefixlen='64', address_scope_id=v6_as_id)
            v6_subnetpool_id = v6_subnetpool['subnetpool']['id']
            data = {'subnet': {
                    'network_id': network['network']['id'],
                    'subnetpool_id': v4_subnetpool_id,
                    'ip_version': constants.IP_VERSION_4,
                    'tenant_id': network['network']['tenant_id']}}
            req = self.new_create_request('subnets', data)
            self.deserialize(self.fmt, req.get_response(self.api))
            data['subnet']['subnetpool_id'] = v6_subnetpool_id
            data['subnet']['ip_version'] = constants.IP_VERSION_6
            req = self.new_create_request('subnets', data)
            self.deserialize(self.fmt, req.get_response(self.api))
            result = self._show('networks', network['network']['id'])
            self.assertEqual(
                v4_as_id,
                result['network'][apidef.IPV4_ADDRESS_SCOPE])
            self.assertEqual(
                v6_as_id,
                result['network'][apidef.IPV6_ADDRESS_SCOPE])

    def test_delete_address_scope_in_use(self):
        with self.address_scope(name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            expected = {'address_scope_id': address_scope_id}
            self._test_create_subnetpool([subnet.cidr], expected=expected,
                                         name='foo-subnetpool',
                                         min_prefixlen='21',
                                         address_scope_id=address_scope_id)
            self._delete('address-scopes', address_scope_id,
                         expected_code=webob.exc.HTTPConflict.code)

    def test_add_subnetpool_address_scope_wrong_address_family(self):
        with self.address_scope(constants.IP_VERSION_6,
                                name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('10.10.10.0/24')
            self.assertRaises(webob.exc.HTTPClientError,
                              self._test_create_subnetpool,
                              [subnet.cidr], name='foo-subnetpool',
                              min_prefixlen='21',
                              address_scope_id=address_scope_id)

    def test_update_subnetpool_associate_address_scope_wrong_family(self):
        with self.address_scope(constants.IP_VERSION_6,
                                name='foo-address-scope') as addr_scope:
            address_scope_id = addr_scope['address_scope']['id']
            subnet = netaddr.IPNetwork('2001:db8::/64')
            expected = {'address_scope_id': address_scope_id}
            initial_subnetpool = self._test_create_subnetpool(
                [subnet.cidr], expected=expected, name='foo-sp',
                min_prefixlen='64', address_scope_id=address_scope_id)

            with self.address_scope(name='foo-address-scope') as other_a_s:
                other_a_s_id = other_a_s['address_scope']['id']
                update_data = {'subnetpool': {'address_scope_id':
                                              other_a_s_id}}
                req = self.new_update_request(
                    'subnetpools', update_data,
                    initial_subnetpool['subnetpool']['id'])
                api = self._api_for_resource('subnetpools')
                res = req.get_response(api)
                self.assertEqual(webob.exc.HTTPBadRequest.code,
                                 res.status_int)

    def test_create_two_subnets_different_subnetpools_same_network(self):
        with self.address_scope(constants.IP_VERSION_4,
                                name='foo-address-scope') as addr_scope:
            addr_scope = addr_scope['address_scope']
            with self.subnetpool(
                        ['10.10.0.0/16'],
                        name='subnetpool_a',
                        tenant_id=addr_scope['tenant_id'],
                        default_prefixlen=24,
                        address_scope_id=addr_scope['id']) as subnetpool_a,\
                self.subnetpool(
                         ['10.20.0.0/16'],
                         name='subnetpool_b',
                         tenant_id=addr_scope['tenant_id'],
                         default_prefixlen=24,
                         address_scope_id=addr_scope['id']) as subnetpool_b:
                subnetpool_a = subnetpool_a['subnetpool']
                subnetpool_b = subnetpool_b['subnetpool']

                with self.network(
                        tenant_id=addr_scope['tenant_id']) as network:
                    subnet_a = self._make_subnet(
                        self.fmt,
                        network,
                        constants.ATTR_NOT_SPECIFIED,
                        None,
                        subnetpool_id=subnetpool_a['id'],
                        ip_version=constants.IP_VERSION_4,
                        tenant_id=addr_scope['tenant_id'])
                    subnet_b = self._make_subnet(
                        self.fmt,
                        network,
                        constants.ATTR_NOT_SPECIFIED,
                        None,
                        subnetpool_id=subnetpool_b['id'],
                        ip_version=constants.IP_VERSION_4,
                        tenant_id=addr_scope['tenant_id'])

                    # Look up subnet counts and perform assertions
                    ctx = context.Context('', addr_scope['tenant_id'])
                    pl = directory.get_plugin()
                    total_count = pl.get_subnets_count(
                        ctx,
                        filters={'network_id':
                                 [network['network']['id']]})
                    subnets_pool_a_count = pl.get_subnets_count(
                        ctx,
                        filters={'id': [subnet_a['subnet']['id']],
                                 'subnetpool_id': [subnetpool_a['id']],
                                 'network_id': [network['network']['id']]})
                    subnets_pool_b_count = pl.get_subnets_count(
                        ctx,
                        filters={'id': [subnet_b['subnet']['id']],
                                 'subnetpool_id': [subnetpool_b['id']],
                                 'network_id': [network['network']['id']]})
                    self.assertEqual(2, total_count)
                    self.assertEqual(1, subnets_pool_a_count)
                    self.assertEqual(1, subnets_pool_b_count)

    def test_block_update_subnetpool_network_affinity(self):
        with self.address_scope(constants.IP_VERSION_4,
                                name='scope-a') as scope_a,\
            self.address_scope(constants.IP_VERSION_4,
                               name='scope-b') as scope_b:
            scope_a = scope_a['address_scope']
            scope_b = scope_b['address_scope']

            with self.subnetpool(
                        ['10.10.0.0/16'],
                        name='subnetpool_a',
                        tenant_id=scope_a['tenant_id'],
                        default_prefixlen=24,
                        address_scope_id=scope_a['id']) as subnetpool_a,\
                self.subnetpool(
                         ['10.20.0.0/16'],
                         name='subnetpool_b',
                         tenant_id=scope_a['tenant_id'],
                         default_prefixlen=24,
                         address_scope_id=scope_a['id']) as subnetpool_b:
                subnetpool_a = subnetpool_a['subnetpool']
                subnetpool_b = subnetpool_b['subnetpool']

                with self.network(
                        tenant_id=scope_a['tenant_id']) as network:
                    self._make_subnet(
                        self.fmt,
                        network,
                        constants.ATTR_NOT_SPECIFIED,
                        None,
                        subnetpool_id=subnetpool_a['id'],
                        ip_version=constants.IP_VERSION_4,
                        tenant_id=scope_a['tenant_id'])
                    self._make_subnet(
                        self.fmt,
                        network,
                        constants.ATTR_NOT_SPECIFIED,
                        None,
                        subnetpool_id=subnetpool_b['id'],
                        ip_version=constants.IP_VERSION_4,
                        tenant_id=scope_a['tenant_id'])

                    # Attempt to update subnetpool_b's address scope and
                    # assert failure.
                    data = {'subnetpool': {'address_scope_id':
                                           scope_b['id']}}
                    req = self.new_update_request('subnetpools', data,
                                                  subnetpool_b['id'])
                    api = self._api_for_resource('subnetpools')
                    res = req.get_response(api)
                    self.assertEqual(webob.exc.HTTPBadRequest.code,
                                     res.status_int)

    def test_ipv6_pd_add_non_pd_subnet_to_same_network(self):
        with self.address_scope(constants.IP_VERSION_6,
                                name='foo-address-scope') as addr_scope:
            addr_scope = addr_scope['address_scope']
            with self.subnetpool(
                        ['2001:db8:1234::/48'],
                        name='non_pd_pool',
                        tenant_id=addr_scope['tenant_id'],
                        default_prefixlen=64,
                        address_scope_id=addr_scope['id']) as non_pd_pool:
                non_pd_pool = non_pd_pool['subnetpool']

                with self.network(
                        tenant_id=addr_scope['tenant_id']) as network:
                    with self.subnet(cidr=None,
                                     network=network,
                                     ip_version=constants.IP_VERSION_6,
                                     subnetpool_id=constants.IPV6_PD_POOL_ID,
                                     ipv6_ra_mode=constants.IPV6_SLAAC,
                                     ipv6_address_mode=constants.IPV6_SLAAC):
                        res = self._create_subnet(
                            self.fmt,
                            cidr=None,
                            net_id=network['network']['id'],
                            subnetpool_id=non_pd_pool['id'],
                            tenant_id=addr_scope['tenant_id'],
                            ip_version=constants.IP_VERSION_6)
                        self.assertEqual(webob.exc.HTTPBadRequest.code,
                                         res.status_int)

    def test_ipv6_non_pd_add_pd_subnet_to_same_network(self):
        with self.address_scope(constants.IP_VERSION_6,
                                name='foo-address-scope') as addr_scope:
            addr_scope = addr_scope['address_scope']
            with self.subnetpool(
                        ['2001:db8:1234::/48'],
                        name='non_pd_pool',
                        tenant_id=addr_scope['tenant_id'],
                        default_prefixlen=64,
                        address_scope_id=addr_scope['id']) as non_pd_pool:
                non_pd_pool = non_pd_pool['subnetpool']

                with self.network(
                        tenant_id=addr_scope['tenant_id']) as network:
                    with self.subnet(cidr=None,
                                     network=network,
                                     ip_version=constants.IP_VERSION_6,
                                     subnetpool_id=non_pd_pool['id']):
                        res = self._create_subnet(
                            self.fmt,
                            cidr=None,
                            net_id=network['network']['id'],
                            tenant_id=addr_scope['tenant_id'],
                            subnetpool_id=constants.IPV6_PD_POOL_ID,
                            ip_version=constants.IP_VERSION_6,
                            ipv6_ra_mode=constants.IPV6_SLAAC,
                            ipv6_address_mode=constants.IPV6_SLAAC)
                        self.assertEqual(webob.exc.HTTPBadRequest.code,
                                         res.status_int)
