Пример #1
0
 def test_unschedule_deleted_speaker(self):
     self.bgp_peer_args[0]['peer_ip'] = self.r_as_ip[0].split('/')[0]
     num, subnet = six.next(self.tnet_gen)
     mask = '/' + str(self.TPool.prefixlen)
     TNet = s_base.Net(name='',
                       net=subnet,
                       mask=self.TPool.prefixlen,
                       cidr=subnet + mask,
                       router=None)
     TSubNet = s_base.SubNet(name='', cidr=TNet.cidr, mask=TNet.mask)
     MyRouter = s_base.Router(name='my-router' + str(num), gw='')
     ext_net_id = self.create_bgp_network(4, self.MyScope, self.PNet,
                                          self.PPool, self.PSubNet,
                                          self.TPool,
                                          [[TNet, TSubNet, MyRouter]])
     speaker_id, peers_ids = self.create_and_add_peers_to_speaker(
         ext_net_id,
         self.bgp_speaker_args, [self.bgp_peer_args[0]],
         auto_delete=False)
     self.check_remote_as_state(self.dr, self.r_ass[0],
                                ctn_base.BGP_FSM_ESTABLISHED)
     self.delete_bgp_speaker(speaker_id)
     self.delete_bgp_peer(peers_ids[0])
     self.check_remote_as_state(self.dr,
                                self.r_ass[0],
                                ctn_base.BGP_FSM_ACTIVE,
                                init_state=ctn_base.BGP_FSM_ESTABLISHED)
Пример #2
0
 def _test_check_advertised_multiple_tenant_network(self, ip_version):
     self.bgp_peer_args[0]['peer_ip'] = self.r_as_ip[0].split('/')[0]
     tnets = []
     tnets_cidr = []
     for i in range(0, 3):
         num, subnet = six.next(self.tnet_gen)
         mask = '/' + str(self.TPool.prefixlen)
         TNet = base.Net(name='',
                         net=subnet,
                         mask=self.TPool.prefixlen,
                         cidr=subnet + mask,
                         router=None)
         TSubNet = base.SubNet(name='', cidr=TNet.cidr, mask=TNet.mask)
         MyRouter = base.Router(name='my-router' + str(num), gw='')
         tnets.append([TNet, TSubNet, MyRouter])
         tnets_cidr.append(TNet.cidr)
     ext_net_id = self.create_bgp_network(ip_version, self.MyScope,
                                          self.PNet, self.PPool,
                                          self.PSubNet, self.TPool, tnets)
     speaker_id, peers_ids = self.create_and_add_peers_to_speaker(
         ext_net_id, self.bgp_speaker_args, [self.bgp_peer_args[0]])
     self.check_remote_as_state(self.dr, self.r_ass[0],
                                ctn_base.BGP_FSM_ESTABLISHED)
     rf = 'ipv' + str(ip_version)
     for cidr in tnets_cidr:
         self.check_remote_as_rib(self.r_ass[0], cidr, rf, 'nexthop',
                                  self.get_next_hop(speaker_id, cidr))
Пример #3
0
 def _test_check_advertised_tenant_network_with_multiple_peers(
         self, ip_version):
     for (bgp_peer_args, r_as_ip) in zip(self.bgp_peer_args, self.r_as_ip):
         bgp_peer_args['peer_ip'] = r_as_ip.split('/')[0]
     num, subnet = six.next(self.tnet_gen)
     mask = '/' + str(self.TPool.prefixlen)
     TNet = base.Net(name='',
                     net=subnet,
                     mask=self.TPool.prefixlen,
                     cidr=subnet + mask,
                     router=None)
     TSubNet = base.SubNet(name='', cidr=TNet.cidr, mask=TNet.mask)
     MyRouter = base.Router(name='my-router' + str(num), gw='')
     ext_net_id = self.create_bgp_network(ip_version, self.MyScope,
                                          self.PNet, self.PPool,
                                          self.PSubNet, self.TPool,
                                          [[TNet, TSubNet, MyRouter]])
     speaker_id, peers_ids = self.create_and_add_peers_to_speaker(
         ext_net_id, self.bgp_speaker_args, self.bgp_peer_args)
     self.check_multi_remote_as_state(self.dr, self.r_ass,
                                      ctn_base.BGP_FSM_ESTABLISHED)
     rf = 'ipv' + str(ip_version)
     next_hop = self.get_next_hop(speaker_id, TNet.cidr)
     self.check_multi_remote_as_rib(self.r_ass, TNet.cidr, rf, 'nexthop',
                                    next_hop)
Пример #4
0
 def _test_check_neighbor_established(self, ip_version):
     self.bgp_peer_args[0]['peer_ip'] = self.r_as_ip[0].split('/')[0]
     num, subnet = six.next(self.tnet_gen)
     mask = '/' + str(self.TPool.prefixlen)
     TNet = base.Net(name='',
                     net=subnet,
                     mask=self.TPool.prefixlen,
                     cidr=subnet + mask,
                     router=None)
     TSubNet = base.SubNet(name='', cidr=TNet.cidr, mask=TNet.mask)
     MyRouter = base.Router(name='my-router' + str(num), gw='')
     ext_net_id = self.create_bgp_network(ip_version, self.MyScope,
                                          self.PNet, self.PPool,
                                          self.PSubNet, self.TPool,
                                          [[TNet, TSubNet, MyRouter]])
     speaker_id, peers_ids = self.create_and_add_peers_to_speaker(
         ext_net_id, self.bgp_speaker_args, [self.bgp_peer_args[0]])
     self.check_remote_as_state(self.dr, self.r_ass[0],
                                ctn_base.BGP_FSM_ESTABLISHED)
Пример #5
0
    def test_remove_add_speaker_agent(self):
        self.bgp_peer_args[0]['peer_ip'] = self.r_as_ip[0].split('/')[0]
        num, subnet = six.next(self.tnet_gen)
        mask = '/' + str(self.TPool.prefixlen)
        TNet = s_base.Net(name='',
                          net=subnet,
                          mask=self.TPool.prefixlen,
                          cidr=subnet + mask,
                          router=None)
        TSubNet = s_base.SubNet(name='', cidr=TNet.cidr, mask=TNet.mask)
        MyRouter = s_base.Router(name='my-router' + str(num), gw='')
        ext_net_id = self.create_bgp_network(4, self.MyScope, self.PNet,
                                             self.PPool, self.PSubNet,
                                             self.TPool,
                                             [[TNet, TSubNet, MyRouter]])
        speaker_id, peers_ids = self.create_and_add_peers_to_speaker(
            ext_net_id, self.bgp_speaker_args, [self.bgp_peer_args[0]])
        self.check_remote_as_state(self.dr, self.r_ass[0],
                                   ctn_base.BGP_FSM_ESTABLISHED)
        agent_list = self.bgp_client.list_dragents_for_bgp_speaker(
            speaker_id)['agents']
        self.assertEqual(1, len(agent_list))
        agent_id = agent_list[0]['id']
        self.bgp_client.remove_bgp_speaker_from_dragent(agent_id, speaker_id)
        # NOTE(tidwellr) This assertion can fail due to the fact that BGP
        # speakers are auto-scheduled. The BGP process can quickly return to
        # ACTIVE status before this gets asserted. Let's see how it goes with
        # this commented out.
        # self.check_remote_as_state(self.dr, self.r_ass[0],
        #                           ctn_base.BGP_FSM_ACTIVE,
        #                           init_state=ctn_base.BGP_FSM_ESTABLISHED)

        # Ignore errors re-associating the BGP speaker, auto-scheduling may
        # have already added it to an agent. The next assertion is what
        # matters.
        self.bgp_client.add_bgp_speaker_to_dragent(agent_id,
                                                   speaker_id,
                                                   ignore_errors=True)
        self.check_remote_as_state(self.dr, self.r_ass[0],
                                   ctn_base.BGP_FSM_ESTABLISHED)
Пример #6
0
class BgpSpeakerBasicTestJSONBase(base.BgpSpeakerScenarioTestJSONBase):

    RAS_MAX = 3
    public_gw = '192.168.20.1'
    MyScope = base.Scope(name='my-scope')
    PNet = base.Net(name='',
                    net='172.24.6.0',
                    mask=24,
                    cidr='172.24.6.0/24',
                    router=None)
    PPool = base.Pool(name='test-pool-ext',
                      prefixlen=PNet.mask,
                      prefixes=[PNet.net + '/8'])
    PSubNet = base.SubNet(name='', cidr=PNet.cidr, mask=PNet.mask)
    TPool = base.Pool(name='tenant-test-pool',
                      prefixlen=28,
                      prefixes=['10.10.0.0/16'])
    L_AS = base.AS(asn='64512', router_id='192.168.0.2', adv_net='')
    ras_l = [
        base.AS(asn='64522',
                router_id='192.168.0.12',
                adv_net='192.168.162.0/24'),
        base.AS(asn='64523',
                router_id='192.168.0.13',
                adv_net='192.168.163.0/24'),
        base.AS(asn='64524',
                router_id='192.168.0.14',
                adv_net='192.168.164.0/24')
    ]

    bgp_speaker_args = {
        'local_as': L_AS.asn,
        'ip_version': 4,
        'name': 'my-bgp-speaker1',
        'advertise_floating_ip_host_routes': True,
        'advertise_tenant_networks': True
    }
    bgp_peer_args = [{
        'remote_as': ras_l[0].asn,
        'name': 'my-bgp-peer1',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[1].asn,
        'name': 'my-bgp-peer2',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[2].asn,
        'name': 'my-bgp-peer3',
        'peer_ip': None,
        'auth_type': 'none'
    }]

    def setUp(self):
        super(BgpSpeakerBasicTestJSONBase, self).setUp()

    @classmethod
    def resource_setup_container(cls):
        cls.brdc = ctn_base.Bridge(name='br-docker-basic',
                                   subnet='192.168.20.0/24',
                                   start_ip='192.168.20.128',
                                   end_ip='192.168.20.254',
                                   self_ip=True,
                                   fixed_ip=cls.public_gw + '/24',
                                   br_type=base.BRIDGE_TYPE)
        cls.bridges.append(cls.brdc)
        # This is dummy container object for a dr service.
        # This keeps data which passes to a quagga container.
        cls.dr = ctn_base.BGPContainer(name='dummy-dr-basic',
                                       asn=int(cls.L_AS.asn),
                                       router_id=cls.L_AS.router_id)
        cls.dr.set_addr_info(bridge='br-docker-basic', ipv4=cls.public_gw)
        # quagga container
        cls.dockerimg = ctn_base.DockerImage()
        cls.q_img = cls.dockerimg.create_quagga(check_exist=True)
        cls.images.append(cls.q_img)
        for i in range(cls.RAS_MAX):
            qg = quagga.QuaggaBGPContainer(name='q-basic-' + str(i + 1),
                                           asn=int(cls.ras_l[i].asn),
                                           router_id=cls.ras_l[i].router_id,
                                           ctn_image_name=cls.q_img)
            cls.containers.append(qg)
            cls.r_ass.append(qg)
            qg.add_route(cls.ras_l[i].adv_net)
            qg.run(wait=True)
            cls.r_as_ip.append(cls.brdc.addif(qg))
            qg.add_peer(cls.dr,
                        bridge=cls.brdc.name,
                        peer_info={'passive': True})

        cls.tnet_gen = cls.get_subnet(start='10.10.1.0',
                                      end='10.10.255.0',
                                      step=256)
class BgpSpeaker4byteASNTest(test_base.BgpSpeakerProtoTestBase):

    RAS_MAX = 3
    ip_version = 4
    public_gw = '192.168.10.1'
    MyScope = base.Scope(name='my-scope')
    PNet = base.Net(name='', net='172.24.6.0', mask=24,
                    cidr='172.24.6.0/24', router=None)
    PPool = base.Pool(name='test-pool-ext', prefixlen=PNet.mask,
                      prefixes=[PNet.net + '/8'])
    PSubNet = base.SubNet(name='', cidr=PNet.cidr, mask=PNet.mask)
    TPool = base.Pool(name='tenant-test-pool', prefixlen=28,
                      prefixes=['10.10.0.0/16'])
    L_AS = base.AS(asn='4200000000', router_id='192.168.0.3', adv_net='')
    ras_l = [
        base.AS(asn='4210000000', router_id='192.168.0.12',
                adv_net='192.168.162.0/24'),
        base.AS(asn='64522', router_id='192.168.0.13',
                adv_net='192.168.163.0/24'),
        base.AS(asn='4230000000', router_id='192.168.0.14',
                adv_net='192.168.164.0/24')
    ]

    bgp_speaker_args = {
        'local_as': L_AS.asn,
        'ip_version': ip_version,
        'name': 'my-bgp-speaker1',
        'advertise_floating_ip_host_routes': True,
        'advertise_tenant_networks': True
    }
    bgp_peer_args = [
        {'remote_as': ras_l[0].asn,
         'name': 'my-bgp-peer1',
         'peer_ip': None,
         'auth_type': 'none'},
        {'remote_as': ras_l[1].asn,
         'name': 'my-bgp-peer2',
         'peer_ip': None,
         'auth_type': 'none'},
        {'remote_as': ras_l[2].asn,
         'name': 'my-bgp-peer3',
         'peer_ip': None,
         'auth_type': 'none'}
    ]

    @classmethod
    @utils.requires_ext(extension="bgp_4byte_asn", service="network")
    def resource_setup(cls):
        super(BgpSpeaker4byteASNTest, cls).resource_setup()

    @classmethod
    def resource_setup_container(cls):
        cls.brdc = ctn_base.Bridge(name='br-docker-4byte-asn',
                                   subnet='192.168.10.0/24',
                                   start_ip='192.168.10.128',
                                   end_ip='192.168.10.254',
                                   self_ip=True,
                                   fixed_ip=cls.public_gw + '/24',
                                   br_type=base.BRIDGE_TYPE)
        cls.bridges.append(cls.brdc)
        # This is dummy container object for a dr service.
        # This keeps data which passes to a quagga container.
        cls.dr = ctn_base.BGPContainer(name='dummy-dr-4byte-asn',
                                       asn=int(cls.L_AS.asn),
                                       router_id=cls.L_AS.router_id)
        cls.dr.set_addr_info(bridge='br-docker-4byte-asn', ipv4=cls.public_gw)
        # quagga container
        cls.dockerimg = ctn_base.DockerImage()
        cls.q_img = cls.dockerimg.create_quagga(check_exist=True)
        cls.images.append(cls.q_img)
        for i in range(cls.RAS_MAX):
            qg = quagga.QuaggaBGPContainer(name='q-4byte-asn-' + str(i + 1),
                                           asn=int(cls.ras_l[i].asn),
                                           router_id=cls.ras_l[i].router_id,
                                           ctn_image_name=cls.q_img)
            cls.containers.append(qg)
            cls.r_ass.append(qg)
            qg.add_route(cls.ras_l[i].adv_net)
            qg.run(wait=True)
            cls.r_as_ip.append(cls.brdc.addif(qg))
            qg.add_peer(cls.dr, bridge=cls.brdc.name,
                        peer_info={'passive': True})
        cls.tnet_gen = cls.get_subnet(start='10.10.1.0', end='10.10.255.0',
                                      step=256)

    @decorators.idempotent_id('9f18c931-a59e-4a27-939b-21124995ffe2')
    def test_check_neighbor_established(self):
        self._test_check_neighbor_established(self.ip_version)

    @decorators.idempotent_id('73466aa5-7d1d-4f9f-8fb4-4100fad2dffe')
    def test_check_advertised_tenant_network(self):
        self._test_check_advertised_tenant_network(self.ip_version)

    @decorators.idempotent_id('c3158328-2f69-4aa2-b1b7-5a06ab58afaf')
    def test_check_advertised_multiple_tenant_network(self):
        self._test_check_advertised_multiple_tenant_network(self.ip_version)

    @decorators.idempotent_id('212a3d82-ac50-43dc-b657-030b1133643e')
    def test_check_neighbor_established_with_multiple_peers(self):
        self._test_check_neighbor_established_with_multiple_peers(
            self.ip_version)

    @decorators.idempotent_id('c72411c8-ea79-495d-bdbd-a10159642676')
    def test_check_advertised_tenant_network_with_multiple_peers(self):
        self._test_check_advertised_tenant_network_with_multiple_peers(
            self.ip_version)
Пример #8
0
class BgpSpeakerIpv4Test(test_base.BgpSpeakerProtoTestBase):

    RAS_MAX = 3
    ip_version = 4
    public_gw = '192.168.11.1'
    MyScope = base.Scope(name='my-scope')
    PNet = base.Net(name='',
                    net='172.24.6.0',
                    mask=24,
                    cidr='172.24.6.0/24',
                    router=None)
    PPool = base.Pool(name='test-pool-ext',
                      prefixlen=PNet.mask,
                      prefixes=[PNet.net + '/8'])
    PSubNet = base.SubNet(name='', cidr=PNet.cidr, mask=PNet.mask)
    TPool = base.Pool(name='tenant-test-pool',
                      prefixlen=28,
                      prefixes=['10.10.0.0/16'])
    L_AS = base.AS(asn='64512', router_id='192.168.0.2', adv_net='')
    ras_l = [
        base.AS(asn='64522',
                router_id='192.168.0.12',
                adv_net='192.168.162.0/24'),
        base.AS(asn='64523',
                router_id='192.168.0.13',
                adv_net='192.168.163.0/24'),
        base.AS(asn='64524',
                router_id='192.168.0.14',
                adv_net='192.168.164.0/24')
    ]

    bgp_speaker_args = {
        'local_as': L_AS.asn,
        'ip_version': ip_version,
        'name': 'my-bgp-speaker1',
        'advertise_floating_ip_host_routes': True,
        'advertise_tenant_networks': True
    }
    bgp_peer_args = [{
        'remote_as': ras_l[0].asn,
        'name': 'my-bgp-peer1',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[1].asn,
        'name': 'my-bgp-peer2',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[2].asn,
        'name': 'my-bgp-peer3',
        'peer_ip': None,
        'auth_type': 'none'
    }]

    def setUp(self):
        super(BgpSpeakerIpv4Test, self).setUp()

    @classmethod
    def resource_setup_container(cls):
        cls.brdc = ctn_base.Bridge(name='br-docker-ipv4',
                                   subnet='192.168.11.0/24',
                                   start_ip='192.168.11.128',
                                   end_ip='192.168.11.254',
                                   self_ip=True,
                                   fixed_ip=cls.public_gw + '/24',
                                   br_type=base.BRIDGE_TYPE)
        cls.bridges.append(cls.brdc)
        # This is dummy container object for a dr service.
        # This keeps data which passes to a quagga container.
        cls.dr = ctn_base.BGPContainer(name='dr',
                                       asn=int(cls.L_AS.asn),
                                       router_id=cls.L_AS.router_id)
        cls.dr.set_addr_info(bridge='br-docker-ipv4', ipv4=cls.public_gw)
        # quagga container
        cls.dockerimg = ctn_base.DockerImage()
        cls.q_img = cls.dockerimg.create_quagga(check_exist=True)
        cls.images.append(cls.q_img)
        for i in range(cls.RAS_MAX):
            qg = quagga.QuaggaBGPContainer(name='q' + str(i + 1),
                                           asn=int(cls.ras_l[i].asn),
                                           router_id=cls.ras_l[i].router_id,
                                           ctn_image_name=cls.q_img)
            cls.containers.append(qg)
            cls.r_ass.append(qg)
            qg.add_route(cls.ras_l[i].adv_net)
            qg.run(wait=True)
            cls.r_as_ip.append(cls.brdc.addif(qg))
            qg.add_peer(cls.dr,
                        bridge=cls.brdc.name,
                        peer_info={'passive': True})
        cls.tnet_gen = cls.get_subnet(start='10.10.1.0',
                                      end='10.10.255.0',
                                      step=256)

    @decorators.idempotent_id('7f2acbc2-ff88-4a63-aa02-a2f9feb3f5b0')
    def test_check_neighbor_established(self):
        self._test_check_neighbor_established(self.ip_version)

    @decorators.idempotent_id('f32245fc-aeab-4244-acfa-3af9dd662e8d')
    def test_check_advertised_tenant_network(self):
        self._test_check_advertised_tenant_network(self.ip_version)

    @decorators.idempotent_id('a5c238de-b750-499c-aaa2-b44a057e9ed3')
    def test_check_advertised_multiple_tenant_network(self):
        self._test_check_advertised_multiple_tenant_network(self.ip_version)

    @decorators.idempotent_id('e4961cc1-0c47-4081-a896-caaa9342ca75')
    def test_check_neighbor_established_with_multiple_peers(self):
        self._test_check_neighbor_established_with_multiple_peers(
            self.ip_version)

    @decorators.idempotent_id('91971dfb-c129-4744-9fbb-ac4f9e8d56c0')
    def test_check_advertised_tenant_network_with_multiple_peers(self):
        self._test_check_advertised_tenant_network_with_multiple_peers(
            self.ip_version)
Пример #9
0
class BgpSpeakerIpv6Test(test_base.BgpSpeakerProtoTestBase):

    RAS_MAX = 3
    ip_version = 6
    public_gw = '2001:db8:a000::1'
    MyScope = base.Scope(name='my-scope')
    PNet = base.Net(name='',
                    net='2001:db8::',
                    mask=64,
                    cidr='2001:db8::/64',
                    router=None)
    PPool = base.Pool(name='test-pool-ext',
                      prefixlen=PNet.mask,
                      prefixes=[PNet.net + '/8'])
    PSubNet = base.SubNet(name='', cidr=PNet.cidr, mask=PNet.mask)
    TPool = base.Pool(name='tenant-test-pool',
                      prefixlen=64,
                      prefixes=['2001:db8:8000::/48'])
    L_AS = base.AS(asn='64512', router_id='192.168.0.2', adv_net='')
    ras_l = [
        base.AS(asn='64522',
                router_id='192.168.0.12',
                adv_net='2001:db8:9002::/48'),
        base.AS(asn='64523',
                router_id='192.168.0.13',
                adv_net='2001:db8:9003::/48'),
        base.AS(asn='64524',
                router_id='192.168.0.14',
                adv_net='2001:db8:9004::/48')
    ]

    bgp_speaker_args = {
        'local_as': L_AS.asn,
        'ip_version': ip_version,
        'name': 'my-bgp-speaker1',
        'advertise_floating_ip_host_routes': True,
        'advertise_tenant_networks': True
    }
    bgp_peer_args = [{
        'remote_as': ras_l[0].asn,
        'name': 'my-bgp-peer1',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[1].asn,
        'name': 'my-bgp-peer2',
        'peer_ip': None,
        'auth_type': 'none'
    }, {
        'remote_as': ras_l[2].asn,
        'name': 'my-bgp-peer3',
        'peer_ip': None,
        'auth_type': 'none'
    }]

    def setUp(self):
        super(BgpSpeakerIpv6Test, self).setUp()

    @classmethod
    def resource_setup_container(cls):
        cls.brdc = ctn_base.Bridge(name='br-docker-ipv6',
                                   subnet='2001:db8:a000::/64',
                                   start_ip='2001:db8:a000::8000',
                                   end_ip='2001:db8:a000::fffe',
                                   self_ip=True,
                                   fixed_ip=cls.public_gw + '/64',
                                   br_type=base.BRIDGE_TYPE)
        cls.bridges.append(cls.brdc)
        # This is dummy container object for a dr service.
        # This keeps data which passes to a quagga container.
        cls.dr = ctn_base.BGPContainer(name='dr',
                                       asn=int(cls.L_AS.asn),
                                       router_id=cls.L_AS.router_id)
        cls.dr.set_addr_info(bridge='br-docker-ipv6', ipv6=cls.public_gw)
        # quagga container
        cls.dockerimg = ctn_base.DockerImage()
        cls.q_img = cls.dockerimg.create_quagga(check_exist=True)
        cls.images.append(cls.q_img)
        for i in range(cls.RAS_MAX):
            qg = quagga.QuaggaBGPContainer(name='q' + str(i + 1),
                                           asn=int(cls.ras_l[i].asn),
                                           router_id=cls.ras_l[i].router_id,
                                           ctn_image_name=cls.q_img)
            cls.containers.append(qg)
            cls.r_ass.append(qg)
            qg.add_route(cls.ras_l[i].adv_net, route_info={'rf': 'ipv6'})
            qg.run(wait=True)
            cls.r_as_ip.append(cls.brdc.addif(qg))
            qg.add_peer(cls.dr,
                        bridge=cls.brdc.name,
                        v6=True,
                        peer_info={'passive': True})
        cls.tnet_gen = cls.get_subnet(start='2001:db8:8000:1::',
                                      end='2001:db8:8000:ffff::',
                                      step=65536 * 65536 * 65536 * 65536)

    @decorators.idempotent_id('5194a8e2-95bd-49f0-872d-1e3e875ede32')
    def test_check_neighbor_established(self):
        self._test_check_neighbor_established(self.ip_version)

    @decorators.idempotent_id('6a3483fc-8c8a-4387-bda6-c7061410e04b')
    def test_check_advertised_tenant_network(self):
        self._test_check_advertised_tenant_network(self.ip_version)

    @decorators.idempotent_id('aca5d678-c249-4de5-921b-6b6ba621e4f7')
    def test_check_advertised_multiple_tenant_network(self):
        self._test_check_advertised_multiple_tenant_network(self.ip_version)

    @decorators.idempotent_id('f81012f3-2f7e-4b3c-8c1d-b1778146d712')
    def test_check_neighbor_established_with_multiple_peers(self):
        self._test_check_neighbor_established_with_multiple_peers(
            self.ip_version)

    @decorators.idempotent_id('be710ec1-a338-44c9-8b89-31c3532aae65')
    def test_check_advertised_tenant_network_with_multiple_peers(self):
        self._test_check_advertised_tenant_network_with_multiple_peers(
            self.ip_version)