tests/topotests/multicast_pim6_static_rp_topo1/test_multicast_pim6_static_rp2.py

   1 #!/usr/bin/env python
   2 # SPDX-License-Identifier: ISC
   3
   4 #
   5 # Copyright (c) 2022 by VMware, Inc. ("VMware")
   6 # Used Copyright (c) 2018 by Network Device Education Foundation,
   7 # Inc. ("NetDEF") in this file.
   8 #
   9
  10 """
  11 Following tests are covered to test Multicast basic functionality:
  12
  13 Topology:
  14
  15                  _______r2_____
  16                 |             |
  17       iperf     |             |     iperf
  18         r0-----r1-------------r3-----r5
  19                 |             |
  20                 |_____________|
  21                         r4
  22
  23 Test steps
  24 - Create topology (setup module)
  25 - Bring up topology
  26
  27 1. Configure multiple  groups (10 grps) with same RP address
  28 2. Verify IIF and OIL in updated in mroute when upstream interface
  29    configure as RP
  30 3. Verify RP info and (*,G) mroute after deleting the RP and shut /
  31     no shut the RPF interface.
  32 """
  33
  34 import os
  35 import sys
  36 import json
  37 import time
  38 import pytest
  39
  40 # Save the Current Working Directory to find configuration files.
  41 CWD = os.path.dirname(os.path.realpath(__file__))
  42 sys.path.append(os.path.join(CWD, "../"))
  43 sys.path.append(os.path.join(CWD, "../lib/"))
  44
  45 # Required to instantiate the topology builder class.
  46
  47 # pylint: disable=C0413
  48 # Import topogen and topotest helpers
  49 from lib.topogen import Topogen, get_topogen
  50
  51 from lib.common_config import (
  52     start_topology,
  53     write_test_header,
  54     write_test_footer,
  55     reset_config_on_routers,
  56     step,
  57     shutdown_bringup_interface,
  58     kill_router_daemons,
  59     start_router_daemons,
  60     create_static_routes,
  61     check_router_status,
  62     socat_send_mld_join,
  63     socat_send_pim6_traffic,
  64     kill_socat,
  65     create_debug_log_config,
  66 )
  67 from lib.pim import (
  68     create_pim_config,
  69     verify_upstream_iif,
  70     verify_join_state_and_timer,
  71     verify_mroutes,
  72     verify_pim_neighbors,
  73     verify_pim_interface_traffic,
  74     verify_pim_rp_info,
  75     verify_pim_state,
  76     clear_pim6_interface_traffic,
  77     clear_pim6_mroute,
  78     verify_pim6_neighbors,
  79     get_pim6_interface_traffic,
  80     clear_pim6_interfaces,
  81     verify_mld_groups,
  82 )
  83 from lib.topolog import logger
  84 from lib.topojson import build_topo_from_json, build_config_from_json
  85
  86 # Global variables
  87 GROUP_RANGE_1 = "ff08::/64"
  88 GROUP_ADDRESS_1 = "ff08::1"
  89 GROUP_RANGE_3 = "ffaa::/64"
  90 GROUP_ADDRESS_3 = "ffaa::1"
  91 GROUP_RANGE_LIST_1 = [
  92     "ffaa::1/128",
  93     "ffaa::2/128",
  94     "ffaa::3/128",
  95     "ffaa::4/128",
  96     "ffaa::5/128",
  97 ]
  98 GROUP_RANGE_LIST_2 = [
  99     "ffaa::6/128",
 100     "ffaa::7/128",
 101     "ffaa::8/128",
 102     "ffaa::9/128",
 103     "ffaa::10/128",
 104 ]
 105 GROUP_ADDRESS_LIST_1 = ["ffaa::1", "ffaa::2", "ffaa::3", "ffaa::4", "ffaa::5"]
 106 GROUP_ADDRESS_LIST_2 = ["ffaa::6", "ffaa::7", "ffaa::8", "ffaa::9", "ffaa::10"]
 107 STAR = "*"
 108 SOURCE = "Static"
 109 ASSERT_MSG = "Testcase {} : Failed Error: {}"
 110
 111 pytestmark = [pytest.mark.pim6d]
 112
 113
 114 def build_topo(tgen):
 115     """Build function"""
 116
 117     # Building topology from json file
 118     build_topo_from_json(tgen, TOPO)
 119
 120
 121 def setup_module(mod):
 122     """
 123     Sets up the pytest environment
 124
 125     * `mod`: module name
 126     """
 127
 128     testsuite_run_time = time.asctime(time.localtime(time.time()))
 129     logger.info("Testsuite start time: %s", testsuite_run_time)
 130     logger.info("=" * 40)
 131
 132     topology = """
 133
 134                  _______r2_____
 135                 |             |
 136       iperf     |             |     iperf
 137         r0-----r1-------------r3-----r5
 138                 |             |
 139                 |_____________|
 140                         r4
 141
 142     """
 143     logger.info("Master Topology: \n %s", topology)
 144
 145     logger.info("Running setup_module to create topology")
 146
 147     # This function initiates the topology build with Topogen...
 148     json_file = "{}/multicast_pim6_static_rp.json".format(CWD)
 149     tgen = Topogen(json_file, mod.__name__)
 150     global TOPO
 151     TOPO = tgen.json_topo
 152
 153     # ... and here it calls Mininet initialization functions.
 154
 155     # Starting topology, create tmp files which are loaded to routers
 156     #  to start daemons and then start routers
 157     start_topology(tgen)
 158
 159     # Don"t run this test if we have any failure.
 160     if tgen.routers_have_failure():
 161         pytest.skip(tgen.errors)
 162
 163     # Creating configuration from JSON
 164     build_config_from_json(tgen, TOPO)
 165
 166     # Verify PIM6 neighbors
 167     result = verify_pim6_neighbors(tgen, TOPO)
 168     assert result is True, "setup_module :Failed \n Error:" " {}".format(result)
 169
 170     logger.info("Running setup_module() done")
 171
 172
 173 def teardown_module():
 174     """Teardown the pytest environment"""
 175
 176     logger.info("Running teardown_module to delete topology")
 177     tgen = get_topogen()
 178
 179     # Clean up socat
 180     kill_socat(tgen)
 181
 182     # Stop toplogy and Remove tmp files
 183     tgen.stop_topology()
 184
 185     logger.info("Testsuite end time: %s", time.asctime(time.localtime(time.time())))
 186     logger.info("=" * 40)
 187
 188
 189 #####################################################
 190 #
 191 #   Local API
 192 #
 193 #####################################################
 194
 195
 196 def verify_state_incremented(state_before, state_after):
 197     """
 198     API to compare interface traffic state incrementing
 199
 200     Parameters
 201     ----------
 202     * `state_before` : State dictionary for any particular instance
 203     * `state_after` : State dictionary for any particular instance
 204     """
 205
 206     for router, state_data in state_before.items():
 207         for state, value in state_data.items():
 208             if state_before[router][state] >= state_after[router][state]:
 209                 errormsg = (
 210                     "[DUT: %s]: state %s value has not"
 211                     " incremented, Initial value: %s, "
 212                     "Current value: %s [FAILED!!]"
 213                     % (
 214                         router,
 215                         state,
 216                         state_before[router][state],
 217                         state_after[router][state],
 218                     )
 219                 )
 220                 return errormsg
 221
 222             logger.info(
 223                 "[DUT: %s]: State %s value is "
 224                 "incremented, Initial value: %s, Current value: %s"
 225                 " [PASSED!!]",
 226                 router,
 227                 state,
 228                 state_before[router][state],
 229                 state_after[router][state],
 230             )
 231
 232     return True
 233
 234
 235 #####################################################
 236 #
 237 #   Testcases
 238 #
 239 #####################################################
 240
 241
 242 def test_pim6_multiple_groups_same_RP_address_p2(request):
 243     """
 244     Configure multiple  groups (10 grps) with same RP address
 245
 246     Topology used:
 247                 ________r2_____
 248                 |             |
 249       iperf     |             |     iperf
 250         r0-----r1-------------r3-----r5
 251
 252     r1 : LHR
 253     r2 : RP
 254     r3 : FHR
 255     """
 256
 257     tgen = get_topogen()
 258     tc_name = request.node.name
 259     write_test_header(tc_name)
 260
 261     # Don"t run this test if we have any failure.
 262     if tgen.routers_have_failure():
 263         pytest.skip(tgen.errors)
 264
 265     step("Creating configuration from JSON")
 266     reset_config_on_routers(tgen)
 267
 268     input_dict = {
 269         "r1": {"debug": {"log_file": "r1_debug.log", "enable": ["pim6d"]}},
 270         "r2": {"debug": {"log_file": "r2_debug.log", "enable": ["pim6d"]}},
 271         "r3": {"debug": {"log_file": "r3_debug.log", "enable": ["pim6d"]}},
 272         "r4": {"debug": {"log_file": "r4_debug.log", "enable": ["pim6d"]}},
 273     }
 274
 275     result = create_debug_log_config(tgen, input_dict)
 276
 277     step("Enable MLD on r1 interface")
 278     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
 279     step("r2: Configure r2 as RP")
 280     input_dict = {
 281         "r2": {
 282             "pim6": {
 283                 "rp": [
 284                     {
 285                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 286                             "/"
 287                         )[0],
 288                         "group_addr_range": GROUP_RANGE_3,
 289                     }
 290                 ]
 291             }
 292         }
 293     }
 294
 295     result = create_pim_config(tgen, TOPO, input_dict)
 296     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 297
 298     step("r2: verify rp-info")
 299     dut = "r2"
 300     oif = "lo"
 301     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
 302     result = verify_pim_rp_info(tgen, TOPO, dut, GROUP_RANGE_3, oif, rp_address, SOURCE)
 303     assert result is True, ASSERT_MSG.format(tc_name, result)
 304
 305     group_address_list = GROUP_ADDRESS_LIST_1 + GROUP_ADDRESS_LIST_2
 306     step("r0: Send MLD join for 10 groups")
 307     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
 308     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
 309     result = socat_send_mld_join(
 310         tgen, "r0", "UDP6-RECV", group_address_list, intf, intf_ip
 311     )
 312     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 313
 314     step("r1: Verify MLD groups")
 315     dut = "r1"
 316     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 317     result = verify_mld_groups(tgen, dut, intf_r1_r0, group_address_list)
 318     assert result is True, ASSERT_MSG.format(tc_name, result)
 319
 320     step("r5: Send multicast traffic for group {}".format(group_address_list))
 321     intf = TOPO["routers"]["r5"]["links"]["r3"]["interface"]
 322     SOURCE_ADDRESS = TOPO["routers"]["r5"]["links"]["r3"]["ipv6"].split("/")[0]
 323     result = socat_send_pim6_traffic(tgen, "r5", "UDP6-SEND", group_address_list, intf)
 324     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 325
 326     step("r1: Verify (*, G) upstream IIF interface")
 327     dut = "r1"
 328     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 329     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 330     assert result is True, ASSERT_MSG.format(tc_name, result)
 331
 332     step("r1: Verify (*, G) upstream join state and join timer")
 333     result = verify_join_state_and_timer(
 334         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 335     )
 336     assert result is True, ASSERT_MSG.format(tc_name, result)
 337
 338     step("r1: Verify (*, G) ip mroutes")
 339     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 340     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 341     assert result is True, ASSERT_MSG.format(tc_name, result)
 342
 343     step("r1: Verify (S, G) ip mroutes")
 344     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 345     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 346     assert result is True, ASSERT_MSG.format(tc_name, result)
 347
 348     step("r1: Verify (S, G) upstream IIF interface")
 349     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 350     assert result is True, ASSERT_MSG.format(tc_name, result)
 351
 352     step("r1: Verify (S, G) upstream join state and join timer")
 353     result = verify_join_state_and_timer(
 354         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, addr_type="ipv6"
 355     )
 356     assert result is True, ASSERT_MSG.format(tc_name, result)
 357
 358     step("r2: Verify (*, G) upstream IIF interface")
 359     dut = "r2"
 360     iif = "lo"
 361     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 362     assert result is True, ASSERT_MSG.format(tc_name, result)
 363
 364     step("r2: Verify (*, G) upstream join state and join timer")
 365     result = verify_join_state_and_timer(
 366         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 367     )
 368     assert result is True, ASSERT_MSG.format(tc_name, result)
 369
 370     step("r2: Verify (*, G) ip mroutes")
 371     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 372     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 373     assert result is True, ASSERT_MSG.format(tc_name, result)
 374
 375     step("r3: Verify (S, G) upstream IIF interface")
 376     dut = "r3"
 377     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 378     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 379     assert result is True, ASSERT_MSG.format(tc_name, result)
 380
 381     step("r3: Verify (S, G) upstream join state and join timer")
 382     result = verify_join_state_and_timer(
 383         tgen,
 384         dut,
 385         iif,
 386         SOURCE_ADDRESS,
 387         group_address_list,
 388         addr_type="ipv6",
 389         expected=False,
 390     )
 391     assert result is not True, (
 392         "Testcase {} : Failed \n "
 393         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 394             tc_name, result
 395         )
 396     )
 397
 398     step("r3: Verify (S, G) ip mroutes")
 399     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 400     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 401     assert result is True, ASSERT_MSG.format(tc_name, result)
 402
 403     step("r2: Verify (S, G) upstream IIF interface")
 404     dut = "r2"
 405     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
 406     result = verify_upstream_iif(
 407         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, joinState="NotJoined"
 408     )
 409     assert result is True, ASSERT_MSG.format(tc_name, result)
 410
 411     step("r2: Verify (S, G) upstream join state and join timer")
 412     result = verify_join_state_and_timer(
 413         tgen,
 414         dut,
 415         iif,
 416         SOURCE_ADDRESS,
 417         group_address_list,
 418         addr_type="ipv6",
 419         expected=False,
 420     )
 421     assert result is not True, (
 422         "Testcase {} : Failed \n "
 423         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 424             tc_name, result
 425         )
 426     )
 427
 428     step("r2: Verify (S, G) ip mroutes")
 429     oif = "none"
 430     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 431     assert result is True, ASSERT_MSG.format(tc_name, result)
 432
 433     step("r1: Delete RP configuration")
 434     input_dict = {
 435         "r1": {
 436             "pim6": {
 437                 "rp": [
 438                     {
 439                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 440                             "/"
 441                         )[0],
 442                         "group_addr_range": GROUP_RANGE_3,
 443                         "delete": True,
 444                     }
 445                 ]
 446             }
 447         }
 448     }
 449
 450     result = create_pim_config(tgen, TOPO, input_dict)
 451     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 452
 453     step("r1: Shut the interface r1-r2-eth1 from R1 to R2")
 454     dut = "r1"
 455     intf = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 456     shutdown_bringup_interface(tgen, dut, intf, False)
 457
 458     step("r1: No Shut the interface r1-r2-eth1 from R1 to R2")
 459     shutdown_bringup_interface(tgen, dut, intf, True)
 460
 461     step("r1: Configure RP")
 462     input_dict = {
 463         "r1": {
 464             "pim6": {
 465                 "rp": [
 466                     {
 467                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 468                             "/"
 469                         )[0],
 470                         "group_addr_range": GROUP_RANGE_3,
 471                     }
 472                 ]
 473             }
 474         }
 475     }
 476
 477     result = create_pim_config(tgen, TOPO, input_dict)
 478     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 479
 480     step("r1: Shut the interface r1-r0-eth0 from R1 to R2")
 481     intf = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 482     shutdown_bringup_interface(tgen, dut, intf, False)
 483
 484     step("r1: No Shut the interface r1-r0-eth0 from R1 to R2")
 485     shutdown_bringup_interface(tgen, dut, intf, True)
 486
 487     step("r1: Verify (*, G) upstream IIF interface")
 488     dut = "r1"
 489     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 490     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 491     assert result is True, ASSERT_MSG.format(tc_name, result)
 492
 493     step("r1: Verify (*, G) upstream join state and join timer")
 494     result = verify_join_state_and_timer(
 495         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 496     )
 497     assert result is True, ASSERT_MSG.format(tc_name, result)
 498
 499     step("r1: Verify (*, G) ip mroutes")
 500     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 501     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 502     assert result is True, ASSERT_MSG.format(tc_name, result)
 503
 504     step("r1: Verify (S, G) upstream IIF interface")
 505     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 506     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 507     assert result is True, ASSERT_MSG.format(tc_name, result)
 508
 509     step("r1: Verify (S, G) upstream join state and join timer")
 510     result = verify_join_state_and_timer(
 511         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, addr_type="ipv6"
 512     )
 513     assert result is True, ASSERT_MSG.format(tc_name, result)
 514
 515     step("r1: Verify (S, G) ip mroutes")
 516     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 517     assert result is True, ASSERT_MSG.format(tc_name, result)
 518
 519     step("r2: Verify (*, G) upstream IIF interface")
 520     dut = "r2"
 521     iif = "lo"
 522     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 523     assert result is True, ASSERT_MSG.format(tc_name, result)
 524
 525     step("r2: Verify (*, G) upstream join state and join timer")
 526     result = verify_join_state_and_timer(
 527         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 528     )
 529     assert result is True, ASSERT_MSG.format(tc_name, result)
 530
 531     step("r2: Verify (*, G) ip mroutes")
 532     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 533     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 534     assert result is True, ASSERT_MSG.format(tc_name, result)
 535
 536     step("r3: Verify (S, G) upstream IIF interface")
 537     dut = "r3"
 538     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 539     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 540     assert result is True, ASSERT_MSG.format(tc_name, result)
 541
 542     step("r3: Verify (S, G) upstream join state and join timer")
 543     result = verify_join_state_and_timer(
 544         tgen,
 545         dut,
 546         iif,
 547         SOURCE_ADDRESS,
 548         group_address_list,
 549         addr_type="ipv6",
 550         expected=False,
 551     )
 552     assert result is not True, (
 553         "Testcase {} : Failed \n "
 554         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 555             tc_name, result
 556         )
 557     )
 558
 559     step("r3: Verify (S, G) ip mroutes")
 560     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 561     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 562     assert result is True, ASSERT_MSG.format(tc_name, result)
 563
 564     write_test_footer(tc_name)
 565
 566
 567 def test_pim6_multiple_groups_different_RP_address_p2(request):
 568     """
 569     Verify IIF and OIL in updated in mroute when upstream interface
 570     configure as RP
 571
 572     Topology used:
 573                 ________r2_____
 574                 |             |
 575       iperf     |             |     iperf
 576         r0-----r1-------------r3-----r5
 577                 |             |
 578                 |_____________|
 579                         r4
 580     r1 : LHR
 581     r2 & r4 : RP
 582     r3 : FHR
 583     """
 584
 585     tgen = get_topogen()
 586     tc_name = request.node.name
 587     write_test_header(tc_name)
 588
 589     # Don"t run this test if we have any failure.
 590     if tgen.routers_have_failure():
 591         pytest.skip(tgen.errors)
 592
 593     step("Creating configuration from JSON")
 594     reset_config_on_routers(tgen)
 595
 596     step("Enable MLD on r1 interface")
 597     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
 598     step("r2: Configure r2 as RP")
 599     step("r4: Configure r4 as RP")
 600     input_dict = {
 601         "r2": {
 602             "pim6": {
 603                 "rp": [
 604                     {
 605                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 606                             "/"
 607                         )[0],
 608                         "group_addr_range": GROUP_RANGE_LIST_1,
 609                     }
 610                 ]
 611             }
 612         },
 613         "r4": {
 614             "pim6": {
 615                 "rp": [
 616                     {
 617                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 618                             "/"
 619                         )[0],
 620                         "group_addr_range": GROUP_RANGE_LIST_2,
 621                     }
 622                 ]
 623             }
 624         },
 625     }
 626
 627     result = create_pim_config(tgen, TOPO, input_dict)
 628     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 629
 630     step("r2: Verify RP info")
 631     dut = "r2"
 632     oif = "lo"
 633     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
 634     result = verify_pim_rp_info(
 635         tgen, TOPO, dut, GROUP_RANGE_LIST_1, oif, rp_address, SOURCE
 636     )
 637     assert result is True, ASSERT_MSG.format(tc_name, result)
 638
 639     step("r4: Verify RP info")
 640     dut = "r4"
 641     rp_address = TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split("/")[0]
 642     result = verify_pim_rp_info(
 643         tgen, TOPO, dut, GROUP_RANGE_LIST_2, oif, rp_address, SOURCE
 644     )
 645     assert result is True, ASSERT_MSG.format(tc_name, result)
 646
 647     group_address_list = GROUP_ADDRESS_LIST_1 + GROUP_ADDRESS_LIST_2
 648     step("r0: Send MLD join for 10 groups")
 649     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
 650     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
 651     result = socat_send_mld_join(
 652         tgen, "r0", "UDP6-RECV", group_address_list, intf, intf_ip
 653     )
 654     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 655
 656     step("r1: Verify MLD groups")
 657     dut = "r1"
 658     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 659     result = verify_mld_groups(tgen, dut, intf_r1_r0, group_address_list)
 660     assert result is True, ASSERT_MSG.format(tc_name, result)
 661
 662     step("r5: Send multicast traffic for group {}".format(group_address_list))
 663     intf = TOPO["routers"]["r5"]["links"]["r3"]["interface"]
 664     SOURCE_ADDRESS = TOPO["routers"]["r5"]["links"]["r3"]["ipv6"].split("/")[0]
 665     result = socat_send_pim6_traffic(tgen, "r5", "UDP6-SEND", group_address_list, intf)
 666     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 667
 668     step("r1: Verify (*, G) upstream IIF interface")
 669     dut = "r1"
 670     iif1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 671     iif2 = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 672
 673     for _iif, _group in zip([iif1, iif2], [GROUP_ADDRESS_LIST_1, GROUP_ADDRESS_LIST_2]):
 674         result = verify_upstream_iif(tgen, dut, _iif, STAR, _group)
 675         assert result is True, ASSERT_MSG.format(tc_name, result)
 676
 677         step("r1: Verify (*, G) upstream join state and join timer")
 678         result = verify_join_state_and_timer(
 679             tgen, dut, _iif, STAR, _group, addr_type="ipv6"
 680         )
 681         assert result is True, ASSERT_MSG.format(tc_name, result)
 682
 683     step("r1: Verify (*, G) ip mroutes")
 684     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 685     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 686     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 687     assert result is True, ASSERT_MSG.format(tc_name, result)
 688
 689     step("r1: Verify (S, G) upstream IIF interface")
 690     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 691     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 692     assert result is True, ASSERT_MSG.format(tc_name, result)
 693
 694     step("r1: Verify (S, G) upstream join state and join timer")
 695     result = verify_join_state_and_timer(
 696         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 697     )
 698     assert result is True, ASSERT_MSG.format(tc_name, result)
 699
 700     step("r1: Verify (S, G) ip mroutes")
 701     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 702     assert result is True, ASSERT_MSG.format(tc_name, result)
 703
 704     step("r2: Verify (*, G) upstream IIF interface")
 705     dut = "r2"
 706     iif = "lo"
 707     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 708     assert result is True, ASSERT_MSG.format(tc_name, result)
 709
 710     step("r2: Verify (*, G) upstream join state and join timer")
 711     result = verify_join_state_and_timer(
 712         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 713     )
 714     assert result is True, ASSERT_MSG.format(tc_name, result)
 715
 716     step("r2: Verify (*, G) ip mroutes")
 717     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 718     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 719     assert result is True, ASSERT_MSG.format(tc_name, result)
 720
 721     step("r2: Verify (S, G) upstream IIF interface")
 722     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
 723     result = verify_upstream_iif(
 724         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, joinState="NotJoined"
 725     )
 726     assert result is True, ASSERT_MSG.format(tc_name, result)
 727
 728     step("r2: Verify (S, G) upstream join state and join timer")
 729     result = verify_join_state_and_timer(
 730         tgen,
 731         dut,
 732         iif,
 733         SOURCE_ADDRESS,
 734         GROUP_ADDRESS_LIST_1,
 735         addr_type="ipv6",
 736         expected=False,
 737     )
 738     assert result is not True, (
 739         "Testcase {} : Failed \n "
 740         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 741             tc_name, result
 742         )
 743     )
 744
 745     step("r2: Verify (S, G) ip mroutes")
 746     oif = "none"
 747     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 748     assert result is True, ASSERT_MSG.format(tc_name, result)
 749
 750     step("r3: Verify (S, G) upstream IIF interface")
 751     dut = "r3"
 752     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 753     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 754     assert result is True, ASSERT_MSG.format(tc_name, result)
 755
 756     step("r3: Verify (S, G) upstream join state and join timer")
 757     result = verify_join_state_and_timer(
 758         tgen,
 759         dut,
 760         iif,
 761         SOURCE_ADDRESS,
 762         GROUP_ADDRESS_LIST_1,
 763         addr_type="ipv6",
 764         expected=False,
 765     )
 766     assert result is not True, (
 767         "Testcase {} : Failed \n "
 768         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 769             tc_name, result
 770         )
 771     )
 772
 773     step("r3: Verify (S, G) ip mroutes")
 774     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 775     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 776     assert result is True, ASSERT_MSG.format(tc_name, result)
 777
 778     step("r1: Verify (*, G) upstream IIF interface")
 779     dut = "r1"
 780     iif = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 781     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
 782     assert result is True, ASSERT_MSG.format(tc_name, result)
 783
 784     step("r1: Verify (*, G) upstream join state and join timer")
 785     result = verify_join_state_and_timer(
 786         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 787     )
 788     assert result is True, ASSERT_MSG.format(tc_name, result)
 789
 790     step("r1: Verify (*, G) ip mroutes")
 791     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 792     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
 793     assert result is True, ASSERT_MSG.format(tc_name, result)
 794
 795     step("r1: Verify (S, G) upstream IIF interface")
 796     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 797     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
 798     assert result is True, ASSERT_MSG.format(tc_name, result)
 799
 800     step("r1: Verify (S, G) upstream join state and join timer")
 801     result = verify_join_state_and_timer(
 802         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 803     )
 804     assert result is True, ASSERT_MSG.format(tc_name, result)
 805
 806     step("r1: Verify (S, G) ip mroutes")
 807     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 808     assert result is True, ASSERT_MSG.format(tc_name, result)
 809
 810     step("r4: Verify (*, G) upstream IIF interface")
 811     dut = "r4"
 812     iif = "lo"
 813     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
 814     assert result is True, ASSERT_MSG.format(tc_name, result)
 815
 816     step("r4: Verify (*, G) upstream join state and join timer")
 817     result = verify_join_state_and_timer(
 818         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 819     )
 820     assert result is True, ASSERT_MSG.format(tc_name, result)
 821
 822     step("r4: Verify (*, G) ip mroutes")
 823     oif = TOPO["routers"]["r4"]["links"]["r1"]["interface"]
 824     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
 825     assert result is True, ASSERT_MSG.format(tc_name, result)
 826
 827     step("r4: Verify (S, G) upstream IIF interface")
 828     iif = TOPO["routers"]["r4"]["links"]["r3"]["interface"]
 829     result = verify_upstream_iif(
 830         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, joinState="NotJoined"
 831     )
 832     assert result is True, ASSERT_MSG.format(tc_name, result)
 833
 834     step("r4: Verify (S, G) upstream join state and join timer")
 835     result = verify_join_state_and_timer(
 836         tgen,
 837         dut,
 838         iif,
 839         SOURCE_ADDRESS,
 840         GROUP_ADDRESS_LIST_2,
 841         addr_type="ipv6",
 842         expected=False,
 843     )
 844     assert result is not True, (
 845         "Testcase {} : Failed \n "
 846         "r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 847             tc_name, result
 848         )
 849     )
 850
 851     step("r4: Verify (S, G) ip mroutes")
 852     oif = "none"
 853     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 854     assert result is True, ASSERT_MSG.format(tc_name, result)
 855
 856     step("r3: Verify (S, G) upstream IIF interface")
 857     dut = "r3"
 858     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 859     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
 860     assert result is True, ASSERT_MSG.format(tc_name, result)
 861
 862     step("r3: Verify (S, G) upstream join state and join timer")
 863     result = verify_join_state_and_timer(
 864         tgen,
 865         dut,
 866         iif,
 867         SOURCE_ADDRESS,
 868         GROUP_ADDRESS_LIST_2,
 869         addr_type="ipv6",
 870         expected=False,
 871     )
 872     assert result is not True, "Testcase {} :Failed \n Error: {}".format(
 873         tc_name, result
 874     )
 875
 876     step("r3: Verify (S, G) ip mroutes")
 877     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 878     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 879     assert result is True, ASSERT_MSG.format(tc_name, result)
 880
 881     step("Delete RP configuration")
 882     input_dict = {
 883         "r2": {
 884             "pim6": {
 885                 "rp": [
 886                     {
 887                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 888                             "/"
 889                         )[0],
 890                         "group_addr_range": GROUP_RANGE_LIST_1,
 891                         "delete": True,
 892                     }
 893                 ]
 894             }
 895         },
 896         "r4": {
 897             "pim6": {
 898                 "rp": [
 899                     {
 900                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 901                             "/"
 902                         )[0],
 903                         "group_addr_range": GROUP_RANGE_LIST_2,
 904                         "delete": True,
 905                     }
 906                 ]
 907             }
 908         },
 909     }
 910
 911     result = create_pim_config(tgen, TOPO, input_dict)
 912     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 913
 914     step("r1, r2, r3, r4: Re-configure RP")
 915     input_dict = {
 916         "r2": {
 917             "pim6": {
 918                 "rp": [
 919                     {
 920                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 921                             "/"
 922                         )[0],
 923                         "group_addr_range": GROUP_RANGE_LIST_1,
 924                     }
 925                 ]
 926             }
 927         },
 928         "r4": {
 929             "pim6": {
 930                 "rp": [
 931                     {
 932                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 933                             "/"
 934                         )[0],
 935                         "group_addr_range": GROUP_RANGE_LIST_2,
 936                     }
 937                 ]
 938             }
 939         },
 940     }
 941
 942     result = create_pim_config(tgen, TOPO, input_dict)
 943     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 944
 945     step("r1: Shut/No Shut the interfacesfrom R1 to R2, R4 and R0")
 946     dut = "r1"
 947     intf1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 948     intf2 = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 949     intf3 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 950     for intf in [intf1, intf2, intf3]:
 951         shutdown_bringup_interface(tgen, dut, intf, False)
 952         shutdown_bringup_interface(tgen, dut, intf, True)
 953
 954     step("r1: Verify (*, G) upstream IIF interface")
 955     dut = "r1"
 956     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 957     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 958     assert result is True, ASSERT_MSG.format(tc_name, result)
 959
 960     step("r1: Verify (*, G) upstream join state and join timer")
 961     result = verify_join_state_and_timer(
 962         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 963     )
 964     assert result is True, ASSERT_MSG.format(tc_name, result)
 965
 966     step("r1: Verify (*, G) ip mroutes")
 967     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 968     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 969     assert result is True, ASSERT_MSG.format(tc_name, result)
 970
 971     step("r1: Verify (S, G) upstream IIF interface")
 972     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 973     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 974     assert result is True, ASSERT_MSG.format(tc_name, result)
 975
 976     step("r1: Verify (S, G) upstream join state and join timer")
 977     result = verify_join_state_and_timer(
 978         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 979     )
 980     assert result is True, ASSERT_MSG.format(tc_name, result)
 981
 982     step("r1: Verify (S, G) ip mroutes")
 983     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 984     assert result is True, ASSERT_MSG.format(tc_name, result)
 985
 986     step("r2: Verify (*, G) upstream IIF interface")
 987     dut = "r2"
 988     iif = "lo"
 989     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 990     assert result is True, ASSERT_MSG.format(tc_name, result)
 991
 992     step("r2: Verify (*, G) upstream join state and join timer")
 993     result = verify_join_state_and_timer(
 994         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 995     )
 996     assert result is True, ASSERT_MSG.format(tc_name, result)
 997
 998     step("r2: Verify (*, G) ip mroutes")
 999     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
1000     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
1001     assert result is True, ASSERT_MSG.format(tc_name, result)
1002
1003     step("r2: Verify (S, G) upstream IIF interface")
1004     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
1005     result = verify_upstream_iif(
1006         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, joinState="NotJoined"
1007     )
1008     assert result is True, ASSERT_MSG.format(tc_name, result)
1009
1010     step("r2: Verify (S, G) upstream join state and join timer")
1011     result = verify_join_state_and_timer(
1012         tgen,
1013         dut,
1014         iif,
1015         SOURCE_ADDRESS,
1016         GROUP_ADDRESS_LIST_1,
1017         addr_type="ipv6",
1018         expected=False,
1019     )
1020     assert result is not True, (
1021         "Testcase {} : Failed \n "
1022         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1023             tc_name, result
1024         )
1025     )
1026
1027     step("r2: Verify (S, G) ip mroutes")
1028     oif = "none"
1029     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
1030     assert result is True, ASSERT_MSG.format(tc_name, result)
1031
1032     step("r3: Verify (S, G) upstream IIF interface")
1033     dut = "r3"
1034     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
1035     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
1036     assert result is True, ASSERT_MSG.format(tc_name, result)
1037
1038     step("r3: Verify (S, G) upstream join state and join timer")
1039     result = verify_join_state_and_timer(
1040         tgen,
1041         dut,
1042         iif,
1043         SOURCE_ADDRESS,
1044         GROUP_ADDRESS_LIST_1,
1045         addr_type="ipv6",
1046         expected=False,
1047     )
1048     assert result is not True, (
1049         "Testcase {} : Failed \n "
1050         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1051             tc_name, result
1052         )
1053     )
1054
1055     step("r3: Verify (S, G) ip mroutes")
1056     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
1057     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
1058     assert result is True, ASSERT_MSG.format(tc_name, result)
1059
1060     step("r1: Verify (*, G) upstream IIF interface")
1061     dut = "r1"
1062     iif = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
1063     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
1064     assert result is True, ASSERT_MSG.format(tc_name, result)
1065
1066     step("r1: Verify (*, G) upstream join state and join timer")
1067     result = verify_join_state_and_timer(
1068         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1069     )
1070     assert result is True, ASSERT_MSG.format(tc_name, result)
1071
1072     step("r1: Verify (*, G) ip mroutes")
1073     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1074     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
1075     assert result is True, ASSERT_MSG.format(tc_name, result)
1076
1077     step("r1: Verify (S, G) upstream IIF interface")
1078     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
1079     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
1080     assert result is True, ASSERT_MSG.format(tc_name, result)
1081
1082     step("r1: Verify (S, G) upstream join state and join timer")
1083     result = verify_join_state_and_timer(
1084         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1085     )
1086     assert result is True, ASSERT_MSG.format(tc_name, result)
1087
1088     step("r1: Verify (S, G) ip mroutes")
1089     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1090     assert result is True, ASSERT_MSG.format(tc_name, result)
1091
1092     step("r4: Verify (*, G) upstream IIF interface")
1093     dut = "r4"
1094     iif = "lo"
1095     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
1096     assert result is True, ASSERT_MSG.format(tc_name, result)
1097
1098     step("r4: Verify (*, G) upstream join state and join timer")
1099     result = verify_join_state_and_timer(
1100         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1101     )
1102     assert result is True, ASSERT_MSG.format(tc_name, result)
1103
1104     step("r4: Verify (*, G) ip mroutes")
1105     oif = TOPO["routers"]["r4"]["links"]["r1"]["interface"]
1106     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
1107     assert result is True, ASSERT_MSG.format(tc_name, result)
1108
1109     step("r4: Verify (S, G) upstream IIF interface")
1110     iif = TOPO["routers"]["r4"]["links"]["r3"]["interface"]
1111     result = verify_upstream_iif(
1112         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, joinState="NotJoined"
1113     )
1114     assert result is True, ASSERT_MSG.format(tc_name, result)
1115
1116     step("r4: Verify (S, G) upstream join state and join timer")
1117     result = verify_join_state_and_timer(
1118         tgen,
1119         dut,
1120         iif,
1121         SOURCE_ADDRESS,
1122         GROUP_ADDRESS_LIST_2,
1123         addr_type="ipv6",
1124         expected=False,
1125     )
1126     assert result is not True, (
1127         "Testcase {} : Failed \n "
1128         "r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1129             tc_name, result
1130         )
1131     )
1132
1133     step("r4: Verify (S, G) ip mroutes")
1134     oif = "none"
1135     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1136     assert result is True, ASSERT_MSG.format(tc_name, result)
1137
1138     step("r3: Verify (S, G) upstream IIF interface")
1139     dut = "r3"
1140     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
1141     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
1142     assert result is True, ASSERT_MSG.format(tc_name, result)
1143
1144     step("r3: Verify (S, G) upstream join state and join timer")
1145     result = verify_join_state_and_timer(
1146         tgen,
1147         dut,
1148         iif,
1149         SOURCE_ADDRESS,
1150         GROUP_ADDRESS_LIST_2,
1151         addr_type="ipv6",
1152         expected=False,
1153     )
1154     assert result is not True, (
1155         "Testcase {} : Failed \n "
1156         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1157             tc_name, result
1158         )
1159     )
1160
1161     step("r3: Verify (S, G) ip mroutes")
1162     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
1163     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1164     assert result is True, ASSERT_MSG.format(tc_name, result)
1165
1166     write_test_footer(tc_name)
1167
1168
1169 def test_pim6_delete_RP_shut_noshut_upstream_interface_p1(request):
1170     """
1171     Verify RP info and (*,G) mroute after deleting the RP and shut /
1172     no shut the RPF interface.
1173
1174     Topology used:
1175                 ________r2_____
1176                 |             |
1177       iperf     |             |
1178         r0-----r1-------------r3
1179     """
1180
1181     tgen = get_topogen()
1182     tc_name = request.node.name
1183     write_test_header(tc_name)
1184
1185     # Don"t run this test if we have any failure.
1186     if tgen.routers_have_failure():
1187         pytest.skip(tgen.errors)
1188
1189     step("Creating configuration from JSON")
1190     reset_config_on_routers(tgen)
1191
1192     step("Enable MLD on r1 interface")
1193     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
1194     step("r2: Configure r2 as RP")
1195     input_dict = {
1196         "r2": {
1197             "pim6": {
1198                 "rp": [
1199                     {
1200                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
1201                             "/"
1202                         )[0],
1203                         "group_addr_range": GROUP_RANGE_1,
1204                     }
1205                 ]
1206             }
1207         }
1208     }
1209
1210     result = create_pim_config(tgen, TOPO, input_dict)
1211     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1212
1213     step("r2: verify rp-info")
1214     dut = "r2"
1215     oif = "lo"
1216     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
1217     result = verify_pim_rp_info(
1218         tgen, TOPO, dut, GROUP_ADDRESS_1, oif, rp_address, SOURCE
1219     )
1220     assert result is True, ASSERT_MSG.format(tc_name, result)
1221
1222     step("r0: Send MLD join")
1223     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
1224     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
1225     result = socat_send_mld_join(
1226         tgen, "r0", "UDP6-RECV", GROUP_ADDRESS_1, intf, intf_ip
1227     )
1228     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
1229
1230     step("r1: Verify MLD groups")
1231     dut = "r1"
1232     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1233     result = verify_mld_groups(tgen, dut, intf_r1_r0, GROUP_ADDRESS_1)
1234     assert result is True, ASSERT_MSG.format(tc_name, result)
1235
1236     step("r1: Verify (*, G) ip mroutes created")
1237     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1238     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1239     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif)
1240     assert result is True, ASSERT_MSG.format(tc_name, result)
1241
1242     step("r2: Verify (*, G) ip mroutes created")
1243     dut = "r2"
1244     iif = "lo"
1245     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
1246     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif)
1247     assert result is True, ASSERT_MSG.format(tc_name, result)
1248
1249     step("r1: Delete RP configuration")
1250     input_dict = {
1251         "r1": {
1252             "pim6": {
1253                 "rp": [
1254                     {
1255                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
1256                             "/"
1257                         )[0],
1258                         "group_addr_range": GROUP_RANGE_1,
1259                         "delete": True,
1260                     }
1261                 ]
1262             }
1263         }
1264     }
1265
1266     result = create_pim_config(tgen, TOPO, input_dict)
1267     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1268
1269     step("r1: Shut/No Shut the interface r1-r2-eth1/r1-r0-eth0 from R1 to R2")
1270     dut = "r1"
1271     intf1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1272     intf2 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1273     for intf in [intf1, intf2]:
1274         shutdown_bringup_interface(tgen, dut, intf, False)
1275         shutdown_bringup_interface(tgen, dut, intf, True)
1276
1277     step("r2: Shut the RP interface lo")
1278     dut = "r2"
1279     intf = "lo"
1280     shutdown_bringup_interface(tgen, dut, intf, False)
1281
1282     step("r1: Shut the interface r1-r2-eth1/r1-r3-eth2 towards RP")
1283     intf3 = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
1284     for intf in [intf1, intf3]:
1285         shutdown_bringup_interface(tgen, dut, intf, False)
1286
1287     step("r1: Verify (*, G) ip mroutes cleared")
1288     dut = "r1"
1289     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1290     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1291     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif, expected=False)
1292     assert result is not True, (
1293         "Testcase {} : Failed \n "
1294         "r1: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
1295             tc_name, result
1296         )
1297     )
1298
1299     step("r2: Verify (*, G) ip mroutes cleared")
1300     dut = "r2"
1301     iif = "lo"
1302     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
1303     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif, expected=False)
1304     assert result is not True, (
1305         "Testcase {} : Failed \n "
1306         "r2: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
1307             tc_name, result
1308         )
1309     )
1310
1311     write_test_footer(tc_name)
1312
1313
1314 if __name__ == "__main__":
1315     args = ["-s"] + sys.argv[1:]
1316     sys.exit(pytest.main(args))