mirror of
https://github.com/espressif/openthread.git
synced 2026-08-30 22:09:54 +00:00
[tests] simplify border router tests (#6870)
This commit simplifies the border router tests by replacing self.nodes[<NODE_ID>] with shorter names.
This commit is contained in:
kangping
@@ -48,8 +48,6 @@ SERVER = BR1 = 1
|
||||
CLIENT1, CLIENT2 = 2, 3
|
||||
HOST = 4
|
||||
|
||||
DIGGER = HOST
|
||||
|
||||
DOMAIN = 'default.service.arpa.'
|
||||
SERVICE = '_testsrv._udp'
|
||||
SERVICE_FULL_NAME = f'{SERVICE}.{DOMAIN}'
|
||||
@@ -87,42 +85,41 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
}
|
||||
|
||||
def test(self):
|
||||
self.nodes[HOST].start(start_radvd=False)
|
||||
server = br1 = self.nodes[BR1]
|
||||
client1 = self.nodes[CLIENT1]
|
||||
client2 = self.nodes[CLIENT2]
|
||||
digger = host = self.nodes[HOST]
|
||||
|
||||
host.start(start_radvd=False)
|
||||
self.simulator.go(5)
|
||||
|
||||
self.nodes[BR1].start()
|
||||
br1.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('leader', self.nodes[BR1].get_state())
|
||||
self.nodes[SERVER].srp_server_set_enabled(True)
|
||||
self.assertEqual('leader', br1.get_state())
|
||||
server.srp_server_set_enabled(True)
|
||||
|
||||
self.nodes[CLIENT1].start()
|
||||
client1.start()
|
||||
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[CLIENT1].get_state())
|
||||
self.assertEqual('router', client1.get_state())
|
||||
|
||||
self.nodes[CLIENT2].start()
|
||||
client2.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[CLIENT2].get_state())
|
||||
self.assertEqual('router', client2.get_state())
|
||||
|
||||
self.simulator.go(10)
|
||||
|
||||
server_addr = self.nodes[SERVER].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]
|
||||
server_addr = server.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]
|
||||
|
||||
# Router1 can ping to/from the Host on infra link.
|
||||
self.assertTrue(self.nodes[BR1].ping(self.nodes[HOST].get_ip6_address(config.ADDRESS_TYPE.ONLINK_ULA)[0],
|
||||
backbone=True))
|
||||
self.assertTrue(self.nodes[HOST].ping(self.nodes[BR1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0],
|
||||
backbone=True))
|
||||
self.assertTrue(br1.ping(host.get_ip6_address(config.ADDRESS_TYPE.ONLINK_ULA)[0], backbone=True))
|
||||
self.assertTrue(host.ping(br1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0], backbone=True))
|
||||
|
||||
client1_addrs = [
|
||||
self.nodes[CLIENT1].get_mleid(), self.nodes[CLIENT1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]
|
||||
]
|
||||
self._config_srp_client_services(CLIENT1, 'ins1', 'host1', 11111, 1, 1, client1_addrs)
|
||||
client1_addrs = [client1.get_mleid(), client1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]]
|
||||
self._config_srp_client_services(client1, 'ins1', 'host1', 11111, 1, 1, client1_addrs)
|
||||
|
||||
client2_addrs = [
|
||||
self.nodes[CLIENT2].get_mleid(), self.nodes[CLIENT2].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]
|
||||
]
|
||||
self._config_srp_client_services(CLIENT2, 'ins2', 'host2', 22222, 2, 2, client2_addrs)
|
||||
client2_addrs = [client2.get_mleid(), client2.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]]
|
||||
self._config_srp_client_services(client2, 'ins2', 'host2', 22222, 2, 2, client2_addrs)
|
||||
|
||||
ins1_full_name = f'ins1.{SERVICE_FULL_NAME}'
|
||||
ins2_full_name = f'ins2.{SERVICE_FULL_NAME}'
|
||||
@@ -131,7 +128,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
EMPTY_TXT = {}
|
||||
|
||||
# check if PTR query works
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, SERVICE_FULL_NAME, 'PTR')
|
||||
dig_result = digger.dns_dig(server_addr, SERVICE_FULL_NAME, 'PTR')
|
||||
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
@@ -151,7 +148,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
})
|
||||
|
||||
# check if SRV query works
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, ins1_full_name, 'SRV')
|
||||
dig_result = digger.dns_dig(server_addr, ins1_full_name, 'SRV')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(ins1_full_name, 'IN', 'SRV')],
|
||||
@@ -162,7 +159,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
],
|
||||
})
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, ins2_full_name, 'SRV')
|
||||
dig_result = digger.dns_dig(server_addr, ins2_full_name, 'SRV')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(ins2_full_name, 'IN', 'SRV')],
|
||||
@@ -174,20 +171,20 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
})
|
||||
|
||||
# check if TXT query works
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, ins1_full_name, 'TXT')
|
||||
dig_result = digger.dns_dig(server_addr, ins1_full_name, 'TXT')
|
||||
self._assert_dig_result_matches(dig_result, {
|
||||
'QUESTION': [(ins1_full_name, 'IN', 'TXT')],
|
||||
'ANSWER': [(ins1_full_name, 'IN', 'TXT', EMPTY_TXT),],
|
||||
})
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, ins2_full_name, 'TXT')
|
||||
dig_result = digger.dns_dig(server_addr, ins2_full_name, 'TXT')
|
||||
self._assert_dig_result_matches(dig_result, {
|
||||
'QUESTION': [(ins2_full_name, 'IN', 'TXT')],
|
||||
'ANSWER': [(ins2_full_name, 'IN', 'TXT', EMPTY_TXT),],
|
||||
})
|
||||
|
||||
# check if AAAA query works
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, host1_full_name, 'AAAA')
|
||||
dig_result = digger.dns_dig(server_addr, host1_full_name, 'AAAA')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(host1_full_name, 'IN', 'AAAA'),],
|
||||
@@ -197,7 +194,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
],
|
||||
})
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, host2_full_name, 'AAAA')
|
||||
dig_result = digger.dns_dig(server_addr, host2_full_name, 'AAAA')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(host2_full_name, 'IN', 'AAAA'),],
|
||||
@@ -209,30 +206,29 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
|
||||
# check some invalid queries
|
||||
for qtype in ['A', 'CNAME']:
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, host1_full_name, qtype)
|
||||
dig_result = digger.dns_dig(server_addr, host1_full_name, qtype)
|
||||
self._assert_dig_result_matches(dig_result, {
|
||||
'status': 'NOTIMP',
|
||||
})
|
||||
|
||||
for service_name in WRONG_SERVICE_NAMES:
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, service_name, 'PTR')
|
||||
dig_result = digger.dns_dig(server_addr, service_name, 'PTR')
|
||||
self._assert_dig_result_matches(dig_result, {
|
||||
'status': 'NXDOMAIN',
|
||||
})
|
||||
|
||||
# verify Discovery Proxy works for _meshcop._udp
|
||||
self._verify_discovery_proxy_meshcop(server_addr)
|
||||
self._verify_discovery_proxy_meshcop(server_addr, server.get_network_name(), digger)
|
||||
|
||||
def _verify_discovery_proxy_meshcop(self, server_addr):
|
||||
def _verify_discovery_proxy_meshcop(self, server_addr, network_name, digger):
|
||||
dp_service_name = '_meshcop._udp.default.service.arpa.'
|
||||
network_name = self.nodes[SERVER].get_network_name()
|
||||
dp_instance_name = f'{network_name}._meshcop._udp.default.service.arpa.'
|
||||
dp_hostname = lambda x: x.endswith('.default.service.arpa.')
|
||||
|
||||
def check_border_agent_port(port):
|
||||
return 0 < port <= 65535
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, dp_service_name, 'PTR')
|
||||
dig_result = digger.dns_dig(server_addr, dp_service_name, 'PTR')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(dp_service_name, 'IN', 'PTR'),],
|
||||
@@ -254,7 +250,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
|
||||
assert isinstance(dp_hostname, str), dig_result
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, dp_instance_name, 'SRV')
|
||||
dig_result = digger.dns_dig(server_addr, dp_instance_name, 'SRV')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(dp_instance_name, 'IN', 'SRV'),],
|
||||
@@ -263,7 +259,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
'nn') == network_name and 'xp' in txt and 'tv' in txt and 'dd' in txt)),],
|
||||
})
|
||||
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, dp_instance_name, 'TXT')
|
||||
dig_result = digger.dns_dig(server_addr, dp_instance_name, 'TXT')
|
||||
self._assert_dig_result_matches(
|
||||
dig_result, {
|
||||
'QUESTION': [(dp_instance_name, 'IN', 'TXT'),],
|
||||
@@ -273,7 +269,7 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
})
|
||||
|
||||
if dp_ip6_address is not None:
|
||||
dig_result = self.nodes[DIGGER].dns_dig(server_addr, dp_hostname, 'AAAA')
|
||||
dig_result = digger.dns_dig(server_addr, dp_hostname, 'AAAA')
|
||||
|
||||
self._assert_dig_result_matches(dig_result, {
|
||||
'QUESTION': [(dp_hostname, 'IN', 'AAAA'),],
|
||||
@@ -281,16 +277,13 @@ class TestDnssdServerOnBr(thread_cert.TestCase):
|
||||
})
|
||||
|
||||
def _config_srp_client_services(self, client, instancename, hostname, port, priority, weight, addrs):
|
||||
self.nodes[client].netdata_show()
|
||||
srp_server_port = self.nodes[client].get_srp_server_port()
|
||||
|
||||
self.nodes[client].srp_client_start(self.nodes[SERVER].get_mleid(), srp_server_port)
|
||||
self.nodes[client].srp_client_set_host_name(hostname)
|
||||
self.nodes[client].srp_client_set_host_address(*addrs)
|
||||
self.nodes[client].srp_client_add_service(instancename, SERVICE, port, priority, weight)
|
||||
client.srp_client_enable_auto_start_mode()
|
||||
client.srp_client_set_host_name(hostname)
|
||||
client.srp_client_set_host_address(*addrs)
|
||||
client.srp_client_add_service(instancename, SERVICE, port, priority, weight)
|
||||
|
||||
self.simulator.go(5)
|
||||
self.assertEqual(self.nodes[client].srp_client_get_host_state(), 'Registered')
|
||||
self.assertEqual(client.srp_client_get_host_state(), 'Registered')
|
||||
|
||||
def _assert_have_question(self, dig_result, question):
|
||||
for dig_question in dig_result['QUESTION']:
|
||||
|
||||
@@ -51,7 +51,7 @@ BR2 = 3
|
||||
ROUTER2 = 4
|
||||
HOST = 5
|
||||
|
||||
CHANNEL1 = 18
|
||||
CHANNEL = 18
|
||||
|
||||
|
||||
class MultiBorderRouters(thread_cert.TestCase):
|
||||
@@ -63,26 +63,26 @@ class MultiBorderRouters(thread_cert.TestCase):
|
||||
'allowlist': [ROUTER1, BR2],
|
||||
'is_otbr': True,
|
||||
'version': '1.2',
|
||||
'channel': CHANNEL1,
|
||||
'channel': CHANNEL,
|
||||
},
|
||||
ROUTER1: {
|
||||
'name': 'Router_1',
|
||||
'allowlist': [BR1],
|
||||
'version': '1.2',
|
||||
'channel': CHANNEL1,
|
||||
'channel': CHANNEL,
|
||||
},
|
||||
BR2: {
|
||||
'name': 'BR_2',
|
||||
'allowlist': [BR1, ROUTER2],
|
||||
'is_otbr': True,
|
||||
'version': '1.2',
|
||||
'channel': CHANNEL1,
|
||||
'channel': CHANNEL,
|
||||
},
|
||||
ROUTER2: {
|
||||
'name': 'Router_2',
|
||||
'allowlist': [BR2],
|
||||
'version': '1.2',
|
||||
'channel': CHANNEL1,
|
||||
'channel': CHANNEL,
|
||||
},
|
||||
HOST: {
|
||||
'name': 'Host',
|
||||
@@ -91,24 +91,30 @@ class MultiBorderRouters(thread_cert.TestCase):
|
||||
}
|
||||
|
||||
def test(self):
|
||||
self.nodes[HOST].start(start_radvd=False)
|
||||
br1 = self.nodes[BR1]
|
||||
router1 = self.nodes[ROUTER1]
|
||||
br2 = self.nodes[BR2]
|
||||
router2 = self.nodes[ROUTER2]
|
||||
host = self.nodes[HOST]
|
||||
|
||||
host.start(start_radvd=False)
|
||||
self.simulator.go(5)
|
||||
|
||||
self.nodes[BR1].start()
|
||||
br1.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('leader', self.nodes[BR1].get_state())
|
||||
self.assertEqual('leader', br1.get_state())
|
||||
|
||||
self.nodes[ROUTER1].start()
|
||||
router1.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[ROUTER1].get_state())
|
||||
self.assertEqual('router', router1.get_state())
|
||||
|
||||
self.nodes[BR2].start()
|
||||
br2.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[BR2].get_state())
|
||||
self.assertEqual('router', br2.get_state())
|
||||
|
||||
self.nodes[ROUTER2].start()
|
||||
router2.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[ROUTER2].get_state())
|
||||
self.assertEqual('router', router2.get_state())
|
||||
|
||||
#
|
||||
# Case 1. bi-directional connectivity when there are two BRs.
|
||||
@@ -117,96 +123,93 @@ class MultiBorderRouters(thread_cert.TestCase):
|
||||
self.simulator.go(10)
|
||||
self.collect_ipaddrs()
|
||||
|
||||
logging.info("BR1 addrs: %r", self.nodes[BR1].get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", self.nodes[ROUTER1].get_addrs())
|
||||
logging.info("BR2 addrs: %r", self.nodes[BR2].get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", self.nodes[ROUTER2].get_addrs())
|
||||
logging.info("HOST addrs: %r", self.nodes[HOST].get_addrs())
|
||||
logging.info("BR1 addrs: %r", br1.get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", router1.get_addrs())
|
||||
logging.info("BR2 addrs: %r", br2.get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", router2.get_addrs())
|
||||
logging.info("HOST addrs: %r", host.get_addrs())
|
||||
|
||||
self.assertTrue(len(self.nodes[BR1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(br1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(br2.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router2.get_prefixes()) == 1)
|
||||
|
||||
br1_omr_prefix = self.nodes[BR1].get_prefixes()[0]
|
||||
br1_omr_prefix = br1.get_prefixes()[0]
|
||||
|
||||
# Each BR should independently register an external route for the on-link prefix.
|
||||
self.assertTrue(len(self.nodes[BR1].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[BR2].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_routes()) == 2)
|
||||
self.assertTrue(len(br1.get_routes()) == 2)
|
||||
self.assertTrue(len(router1.get_routes()) == 2)
|
||||
self.assertTrue(len(br2.get_routes()) == 2)
|
||||
self.assertTrue(len(router2.get_routes()) == 2)
|
||||
|
||||
external_route = self.nodes[BR1].get_routes()[0]
|
||||
external_route = br1.get_routes()[0]
|
||||
br1_on_link_prefix = external_route.split(' ')[0]
|
||||
|
||||
self.assertTrue(len(self.nodes[BR1].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[HOST].get_matched_ula_addresses(br1_on_link_prefix)) == 1)
|
||||
self.assertTrue(len(br1.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(br2.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(host.get_matched_ula_addresses(br1_on_link_prefix)) == 1)
|
||||
|
||||
# Router1 and Router2 can ping each other inside the Thread network.
|
||||
self.assertTrue(self.nodes[ROUTER1].ping(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(self.nodes[ROUTER2].ping(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router1.ping(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router2.ping(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
|
||||
# Both Router1 and Router2 can ping to/from the Host on infra link.
|
||||
self.assertTrue(self.nodes[ROUTER1].ping(self.nodes[HOST].get_matched_ula_addresses(br1_on_link_prefix)[0]))
|
||||
self.assertTrue(self.nodes[HOST].ping(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0],
|
||||
backbone=True))
|
||||
self.assertTrue(self.nodes[ROUTER2].ping(self.nodes[HOST].get_matched_ula_addresses(br1_on_link_prefix)[0]))
|
||||
self.assertTrue(self.nodes[HOST].ping(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)[0],
|
||||
backbone=True))
|
||||
self.assertTrue(router1.ping(host.get_matched_ula_addresses(br1_on_link_prefix)[0]))
|
||||
self.assertTrue(host.ping(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0], backbone=True))
|
||||
self.assertTrue(router2.ping(host.get_matched_ula_addresses(br1_on_link_prefix)[0]))
|
||||
self.assertTrue(host.ping(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)[0], backbone=True))
|
||||
|
||||
#
|
||||
# Case 2. Another BR continues providing Border Routing when current one is disabled.
|
||||
#
|
||||
|
||||
self.nodes[BR1].disable_br()
|
||||
br1.disable_br()
|
||||
|
||||
self.simulator.go(15)
|
||||
self.collect_ipaddrs()
|
||||
|
||||
logging.info("BR1 addrs: %r", self.nodes[BR1].get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", self.nodes[ROUTER1].get_addrs())
|
||||
logging.info("BR2 addrs: %r", self.nodes[BR2].get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", self.nodes[ROUTER2].get_addrs())
|
||||
logging.info("HOST addrs: %r", self.nodes[HOST].get_addrs())
|
||||
logging.info("BR1 addrs: %r", br1.get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", router1.get_addrs())
|
||||
logging.info("BR2 addrs: %r", br2.get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", router2.get_addrs())
|
||||
logging.info("HOST addrs: %r", host.get_addrs())
|
||||
|
||||
self.assertGreaterEqual(len(self.nodes[HOST].get_addrs()), 2)
|
||||
self.assertGreaterEqual(len(host.get_addrs()), 2)
|
||||
|
||||
self.assertTrue(len(self.nodes[BR1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(br1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(br2.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router2.get_prefixes()) == 1)
|
||||
|
||||
br2_omr_prefix = self.nodes[BR1].get_prefixes()[0]
|
||||
br2_omr_prefix = br1.get_prefixes()[0]
|
||||
self.assertNotEqual(br1_omr_prefix, br2_omr_prefix)
|
||||
|
||||
# Only BR2 will register external route for the on-link prefix.
|
||||
self.assertTrue(len(self.nodes[BR1].get_routes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_routes()) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_routes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_routes()) == 1)
|
||||
self.assertTrue(len(br1.get_routes()) == 1)
|
||||
self.assertTrue(len(router1.get_routes()) == 1)
|
||||
self.assertTrue(len(br2.get_routes()) == 1)
|
||||
self.assertTrue(len(router2.get_routes()) == 1)
|
||||
|
||||
br2_external_route = self.nodes[BR2].get_routes()[0]
|
||||
br2_external_route = br2.get_routes()[0]
|
||||
br2_on_link_prefix = br2_external_route.split(' ')[0]
|
||||
|
||||
self.assertTrue(len(self.nodes[BR1].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(br1.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(br2.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
|
||||
self.assertTrue(len(self.nodes[HOST].get_matched_ula_addresses(br2_on_link_prefix)) == 1)
|
||||
self.assertTrue(len(host.get_matched_ula_addresses(br2_on_link_prefix)) == 1)
|
||||
|
||||
# Router1 and Router2 can ping each other inside the Thread network.
|
||||
self.assertTrue(self.nodes[ROUTER1].ping(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(self.nodes[ROUTER2].ping(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router1.ping(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router2.ping(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
|
||||
# Both Router1 and Router2 can ping to/from the Host on infra link.
|
||||
for router in [ROUTER1, ROUTER2]:
|
||||
self.assertTrue(self.nodes[router].ping(self.nodes[HOST].get_matched_ula_addresses(br2_on_link_prefix)[0]))
|
||||
self.assertTrue(self.nodes[HOST].ping(self.nodes[router].get_ip6_address(config.ADDRESS_TYPE.OMR)[0],
|
||||
backbone=True))
|
||||
for router in [router1, router2]:
|
||||
self.assertTrue(router.ping(host.get_matched_ula_addresses(br2_on_link_prefix)[0]))
|
||||
self.assertTrue(host.ping(router.get_ip6_address(config.ADDRESS_TYPE.OMR)[0], backbone=True))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -87,58 +87,63 @@ class MultiThreadNetworks(thread_cert.TestCase):
|
||||
}
|
||||
|
||||
def test(self):
|
||||
self.nodes[BR1].start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('leader', self.nodes[BR1].get_state())
|
||||
br1 = self.nodes[BR1]
|
||||
router1 = self.nodes[ROUTER1]
|
||||
br2 = self.nodes[BR2]
|
||||
router2 = self.nodes[ROUTER2]
|
||||
|
||||
self.nodes[ROUTER1].start()
|
||||
br1.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[ROUTER1].get_state())
|
||||
self.assertEqual('leader', br1.get_state())
|
||||
|
||||
self.nodes[BR2].start()
|
||||
router1.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('leader', self.nodes[BR2].get_state())
|
||||
self.assertEqual('router', router1.get_state())
|
||||
|
||||
self.nodes[ROUTER2].start()
|
||||
br2.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[ROUTER2].get_state())
|
||||
self.assertEqual('leader', br2.get_state())
|
||||
|
||||
router2.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', router2.get_state())
|
||||
|
||||
self.collect_ipaddrs()
|
||||
|
||||
logging.info("BR1 addrs: %r", self.nodes[BR1].get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", self.nodes[ROUTER1].get_addrs())
|
||||
logging.info("BR2 addrs: %r", self.nodes[BR2].get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", self.nodes[ROUTER2].get_addrs())
|
||||
logging.info("BR1 addrs: %r", br1.get_addrs())
|
||||
logging.info("ROUTER1 addrs: %r", router1.get_addrs())
|
||||
logging.info("BR2 addrs: %r", br2.get_addrs())
|
||||
logging.info("ROUTER2 addrs: %r", router2.get_addrs())
|
||||
|
||||
self.assertTrue(len(self.nodes[BR1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[BR2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_prefixes()) == 1)
|
||||
self.assertTrue(len(br1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router1.get_prefixes()) == 1)
|
||||
self.assertTrue(len(br2.get_prefixes()) == 1)
|
||||
self.assertTrue(len(router2.get_prefixes()) == 1)
|
||||
|
||||
br1_omr_prefix = self.nodes[BR1].get_prefixes()[0]
|
||||
br2_omr_prefix = self.nodes[BR2].get_prefixes()[0]
|
||||
br1_omr_prefix = br1.get_prefixes()[0]
|
||||
br2_omr_prefix = br2.get_prefixes()[0]
|
||||
|
||||
self.assertNotEqual(br1_omr_prefix, br2_omr_prefix)
|
||||
|
||||
# Each BR should independently register an external route for the on-link prefix
|
||||
# and OMR prefix in another Thread Network.
|
||||
self.assertTrue(len(self.nodes[BR1].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[BR2].get_routes()) == 2)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_routes()) == 2)
|
||||
self.assertTrue(len(br1.get_routes()) == 2)
|
||||
self.assertTrue(len(router1.get_routes()) == 2)
|
||||
self.assertTrue(len(br2.get_routes()) == 2)
|
||||
self.assertTrue(len(router2.get_routes()) == 2)
|
||||
|
||||
br1_external_routes = self.nodes[BR1].get_routes()
|
||||
br2_external_routes = self.nodes[BR2].get_routes()
|
||||
br1_external_routes = br1.get_routes()
|
||||
br2_external_routes = br2.get_routes()
|
||||
|
||||
br1_external_routes.sort()
|
||||
br2_external_routes.sort()
|
||||
self.assertNotEqual(br1_external_routes, br2_external_routes)
|
||||
|
||||
self.assertTrue(len(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
self.assertTrue(len(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)) == 1)
|
||||
|
||||
self.assertTrue(self.nodes[ROUTER1].ping(self.nodes[ROUTER2].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(self.nodes[ROUTER2].ping(self.nodes[ROUTER1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router1.ping(router2.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
self.assertTrue(router2.ping(router1.get_ip6_address(config.ADDRESS_TYPE.OMR)[0]))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -38,104 +38,107 @@ import config
|
||||
# Topology:
|
||||
# -----------(eth)------
|
||||
# |
|
||||
# BR1 (Leader)
|
||||
# BR (Leader)
|
||||
# |
|
||||
# ROUTER1
|
||||
# ROUTER
|
||||
#
|
||||
|
||||
BR1 = 1
|
||||
ROUTER1 = 2
|
||||
BR = 1
|
||||
ROUTER = 2
|
||||
|
||||
|
||||
class TestPlatUdpAccessibility(thread_cert.TestCase):
|
||||
USE_MESSAGE_FACTORY = False
|
||||
|
||||
TOPOLOGY = {
|
||||
BR1: {
|
||||
'name': 'BR_1',
|
||||
BR: {
|
||||
'name': 'BR',
|
||||
'is_otbr': True,
|
||||
'version': '1.2',
|
||||
},
|
||||
ROUTER1: {
|
||||
'name': 'Router_1',
|
||||
ROUTER: {
|
||||
'name': 'Router',
|
||||
'version': '1.2',
|
||||
},
|
||||
}
|
||||
|
||||
def test(self):
|
||||
self.nodes[BR1].start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('leader', self.nodes[BR1].get_state())
|
||||
self.nodes[BR1].srp_server_set_enabled(True)
|
||||
br = self.nodes[BR]
|
||||
router = self.nodes[ROUTER]
|
||||
|
||||
self.nodes[ROUTER1].start()
|
||||
br.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', self.nodes[ROUTER1].get_state())
|
||||
self.assertEqual('leader', br.get_state())
|
||||
br.srp_server_set_enabled(True)
|
||||
|
||||
router.start()
|
||||
self.simulator.go(5)
|
||||
self.assertEqual('router', router.get_state())
|
||||
|
||||
# Router1 can ping to/from the Host on infra link.
|
||||
self.assertTrue(self.nodes[ROUTER1].ping(self.nodes[BR1].get_rloc()))
|
||||
self.assertTrue(router.ping(br.get_rloc()))
|
||||
|
||||
server_port = self.nodes[BR1].get_srp_server_port()
|
||||
server_port = br.get_srp_server_port()
|
||||
|
||||
self._test_srp_server(self.nodes[BR1].get_mleid(), server_port)
|
||||
self._test_srp_server(self.nodes[BR1].get_linklocal(), server_port)
|
||||
self._test_srp_server(self.nodes[BR1].get_ip6_address(config.ADDRESS_TYPE.OMR)[0], server_port)
|
||||
self._test_srp_server(self.nodes[BR1].get_rloc(), server_port)
|
||||
for server_aloc in self.nodes[BR1].get_ip6_address(config.ADDRESS_TYPE.ALOC):
|
||||
self._test_srp_server(server_aloc, server_port)
|
||||
self._test_srp_server(router, br.get_mleid(), server_port)
|
||||
self._test_srp_server(router, br.get_linklocal(), server_port)
|
||||
self._test_srp_server(router, br.get_ip6_address(config.ADDRESS_TYPE.OMR)[0], server_port)
|
||||
self._test_srp_server(router, br.get_rloc(), server_port)
|
||||
for server_aloc in br.get_ip6_address(config.ADDRESS_TYPE.ALOC):
|
||||
self._test_srp_server(router, server_aloc, server_port)
|
||||
|
||||
self._testDhcp6ClientAfterReset(BR1, BR1, BR1)
|
||||
self._testDhcp6ClientAfterReset(br, br, br)
|
||||
|
||||
def _testDhcp6ClientAfterReset(self, server, client, reset_device):
|
||||
DHCP6_PREFIX = '2001::/64'
|
||||
|
||||
# Configure DHCP6 server
|
||||
self.nodes[server].add_prefix(DHCP6_PREFIX, 'pdros')
|
||||
server.add_prefix(DHCP6_PREFIX, 'pdros')
|
||||
self.simulator.go(3)
|
||||
self.nodes[server].register_netdata()
|
||||
server.register_netdata()
|
||||
self.simulator.go(10)
|
||||
|
||||
# Verify DHCP6 client works
|
||||
self.assertTrue(self.nodes[client].get_addr(DHCP6_PREFIX))
|
||||
self.assertTrue(client.get_addr(DHCP6_PREFIX))
|
||||
self.simulator.go(3)
|
||||
|
||||
self.nodes[reset_device].reset()
|
||||
self.nodes[reset_device].start()
|
||||
reset_device.reset()
|
||||
reset_device.start()
|
||||
self.simulator.go(5)
|
||||
self.assertIn(self.nodes[reset_device].get_state(), ['leader', 'router'])
|
||||
self.assertIn(reset_device.get_state(), ['leader', 'router'])
|
||||
self.simulator.go(5)
|
||||
|
||||
if reset_device == server:
|
||||
# Reconfigure DHCP6 server if necessary
|
||||
self.nodes[server].add_prefix(DHCP6_PREFIX, 'pdros')
|
||||
server.add_prefix(DHCP6_PREFIX, 'pdros')
|
||||
self.simulator.go(3)
|
||||
self.nodes[server].register_netdata()
|
||||
server.register_netdata()
|
||||
|
||||
self.simulator.go(10)
|
||||
|
||||
# Verify DHCP6 client works after reset
|
||||
self.assertTrue(self.nodes[client].get_addr(DHCP6_PREFIX))
|
||||
self.assertTrue(client.get_addr(DHCP6_PREFIX))
|
||||
self.simulator.go(3)
|
||||
|
||||
def _test_srp_server(self, server_addr, server_port):
|
||||
def _test_srp_server(self, client, server_addr, server_port):
|
||||
print(f'Testing SRP server: {server_addr}:{server_port}')
|
||||
|
||||
# check if the SRP client can register to the SRP server
|
||||
self.nodes[ROUTER1].srp_client_start(server_addr, server_port)
|
||||
self.nodes[ROUTER1].srp_client_set_host_name('host1')
|
||||
self.nodes[ROUTER1].srp_client_set_host_address(self.nodes[ROUTER1].get_rloc())
|
||||
self.nodes[ROUTER1].srp_client_add_service('ins1', '_ipp._tcp', 11111)
|
||||
client.srp_client_start(server_addr, server_port)
|
||||
client.srp_client_set_host_name('host1')
|
||||
client.srp_client_set_host_address(client.get_rloc())
|
||||
client.srp_client_add_service('ins1', '_ipp._tcp', 11111)
|
||||
self.simulator.go(3)
|
||||
self.assertEqual(self.nodes[ROUTER1].srp_client_get_host_state(), 'Registered')
|
||||
self.assertEqual(client.srp_client_get_host_state(), 'Registered')
|
||||
|
||||
# check if the SRP client can remove from the SRP server
|
||||
self.nodes[ROUTER1].srp_client_remove_host('host1')
|
||||
self.nodes[ROUTER1].srp_client_remove_service('ins1', '_ipp._tcp')
|
||||
client.srp_client_remove_host('host1')
|
||||
client.srp_client_remove_service('ins1', '_ipp._tcp')
|
||||
self.simulator.go(3)
|
||||
self.assertEqual(self.nodes[ROUTER1].srp_client_get_host_state(), 'Removed')
|
||||
self.assertEqual(client.srp_client_get_host_state(), 'Removed')
|
||||
|
||||
# stop the SRP client for the next round
|
||||
self.nodes[ROUTER1].srp_client_stop()
|
||||
client.srp_client_stop()
|
||||
self.simulator.go(3)
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user