tests/topotests/bgp_default_originate/test_bgp_default_originate_2links.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2022 by VMware, Inc. ("VMware")
   4 # Used Copyright (c) 2018 by Network Device Education Foundation, Inc. ("NetDEF")
   5 # in this file.
   6 #
   7 # Permission to use, copy, modify, and/or distribute this software
   8 # for any purpose with or without fee is hereby granted, provided
   9 # that the above copyright notice and this permission notice appear
  10 # in all copies.
  11 # Shreenidhi A R <rshreenidhi@vmware.com>
  12 # THE SOFTWARE IS PROVIDED "AS IS" AND VMWARE DISCLAIMS ALL WARRANTIES
  13 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  14 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL VMWARE BE LIABLE FOR
  15 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
  16 # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  17 # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  18 # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  19 # OF THIS SOFTWARE.
  20 #
  21 """
  22 Following tests are covered.
  23 1. Verify default-originate route with default static and network command
  24 2. Verify default-originate route with aggregate summary command
  25 """
  26 import os
  27 import sys
  28 import time
  29 import pytest
  30 import datetime
  31 from copy import deepcopy
  32 from lib.topolog import logger
  33
  34 # pylint: disable=C0413
  35 # Import topogen and topotest helpers
  36 from lib.topogen import Topogen, get_topogen
  37 from lib.topojson import build_config_from_json
  38 from lib.topolog import logger
  39
  40 from lib.bgp import (
  41     verify_bgp_convergence,
  42     create_router_bgp,
  43     verify_bgp_rib,
  44     get_dut_as_number,
  45     verify_rib_default_route,
  46     verify_fib_default_route,
  47 )
  48 from lib.common_config import (
  49     verify_fib_routes,
  50     step,
  51     run_frr_cmd,
  52     get_frr_ipv6_linklocal,
  53     start_topology,
  54     apply_raw_config,
  55     write_test_header,
  56     check_address_types,
  57     write_test_footer,
  58     reset_config_on_routers,
  59     create_static_routes,
  60     check_router_status,
  61 )
  62
  63 # Save the Current Working Directory to find configuration files.
  64 CWD = os.path.dirname(os.path.realpath(__file__))
  65 sys.path.append(os.path.join(CWD, "../"))
  66 sys.path.append(os.path.join(CWD, "../lib/"))
  67
  68 # Required to instantiate the topology builder class.
  69
  70 # pylint: disable=C0413
  71 # Import topogen and topotest helpers
  72
  73 # Global variables
  74 topo = None
  75 NETWORK1_1 = {"ipv4": "198.51.1.1/32", "ipv6": "2001:DB8::1:1/128"}
  76 NETWORK1_2 = {"ipv4": "198.51.1.2/32", "ipv6": "2001:DB8::1:2/128"}
  77 NETWORK1_3 = {"ipv4": "198.51.1.3/32", "ipv6": "2001:DB8::1:3/128"}
  78 NETWORK1_4 = {"ipv4": "198.51.1.4/32", "ipv6": "2001:DB8::1:4/128"}
  79 NETWORK1_5 = {"ipv4": "198.51.1.5/32", "ipv6": "2001:DB8::1:5/128"}
  80
  81 ipv4_uptime_dict = {
  82     "r2": {
  83         "static_routes": [
  84             {"network": "0.0.0.0/0"},
  85         ]
  86     }
  87 }
  88
  89 ipv6_uptime_dict = {
  90     "r2": {
  91         "static_routes": [
  92             {"network": "::/0"},
  93         ]
  94     }
  95 }
  96
  97 DEFAULT_ROUTES = {"ipv4": "0.0.0.0/0", "ipv6": "0::0/0"}
  98 NEXT_HOP_IP = {"ipv4": "Null0", "ipv6": "Null0"}
  99
 100 pytestmark = [pytest.mark.bgpd]
 101
 102
 103 def setup_module(mod):
 104     """
 105     Sets up the pytest environment
 106
 107     * `mod`: module name
 108     """
 109     testsuite_run_time = time.asctime(time.localtime(time.time()))
 110     logger.info("Testsuite start time: {}".format(testsuite_run_time))
 111     logger.info("=" * 40)
 112
 113     logger.info("Running setup_module to create topology")
 114
 115     # This function initiates the topology build with Topogen...
 116     json_file = "{}/bgp_default_originate_2links.json".format(CWD)
 117     tgen = Topogen(json_file, mod.__name__)
 118     global topo
 119     topo = tgen.json_topo
 120     # ... and here it calls Mininet initialization functions.
 121
 122     # Starting topology, create tmp files which are loaded to routers
 123     #  to start daemons and then start routers
 124     start_topology(tgen)
 125
 126     # Creating configuration from JSON
 127     build_config_from_json(tgen, topo)
 128
 129     global ADDR_TYPES
 130     global BGP_CONVERGENCE
 131     global DEFAULT_ROUTES
 132     global DEFAULT_ROUTE_NXT_HOP_LINK1, DEFAULT_ROUTE_NXT_HOP_LINK2
 133     ADDR_TYPES = check_address_types()
 134     BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
 135     assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}".format(
 136         BGP_CONVERGENCE
 137     )
 138
 139     DEFAULT_ROUTES = {"ipv4": "0.0.0.0/0", "ipv6": "0::0/0"}
 140
 141     interface = topo["routers"]["r1"]["links"]["r2-link1"]["interface"]
 142     ipv6_link_local = get_frr_ipv6_linklocal(tgen, "r1", intf=interface)
 143     ipv4_nxt_hop = topo["routers"]["r1"]["links"]["r2-link1"]["ipv4"].split("/")[0]
 144     ipv6_nxt_hop = topo["routers"]["r1"]["links"]["r2-link1"]["ipv6"].split("/")[0]
 145     DEFAULT_ROUTE_NXT_HOP_LINK1 = {"ipv4": ipv4_nxt_hop, "ipv6": ipv6_link_local}
 146
 147     interface = topo["routers"]["r1"]["links"]["r2-link2"]["interface"]
 148     ipv6_link_local = get_frr_ipv6_linklocal(tgen, "r1", intf=interface)
 149     ipv4_nxt_hop = topo["routers"]["r1"]["links"]["r2-link2"]["ipv4"].split("/")[0]
 150     ipv6_nxt_hop = topo["routers"]["r1"]["links"]["r2-link2"]["ipv6"].split("/")[0]
 151     DEFAULT_ROUTE_NXT_HOP_LINK2 = {"ipv4": ipv4_nxt_hop, "ipv6": ipv6_link_local}
 152     logger.info("Running setup_module() done")
 153
 154
 155 def teardown_module():
 156     """Teardown the pytest environment"""
 157
 158     logger.info("Running teardown_module to delete topology")
 159
 160     tgen = get_topogen()
 161
 162     # Stop toplogy and Remove tmp files
 163     tgen.stop_topology()
 164
 165     logger.info(
 166         "Testsuite end time: {}".format(time.asctime(time.localtime(time.time())))
 167     )
 168     logger.info("=" * 40)
 169
 170
 171 #####################################################
 172 #
 173 #                      Local API's
 174 #
 175 #####################################################
 176
 177
 178 def get_rib_route_uptime(tgen, addr_type, dut, input_dict):
 179     """
 180     Verify route uptime in RIB using "show ip route"
 181
 182     Parameters
 183     ----------
 184     * `tgen` : topogen object
 185     * `addr_type` : ip type, ipv4/ipv6
 186     * `dut`: Device Under Test, for which user wants to test the data
 187     * `input_dict` : input dict, has details of static routes
 188     * `route_uptime`: uptime of the routes
 189
 190     Usage
 191     -----
 192     # Creating static routes for r1
 193      input_dict_r1 = {
 194             "r1": {
 195                 "static_routes": [
 196                     {
 197                         "network": "147.10.13.4/32"
 198                     },
 199                    {
 200                        "network": "147.10.12.0/24"
 201                    },
 202                     {
 203                         "network": "147.10.13.4/32"
 204                     },
 205                    {
 206                        "network": "147.10.13.4/32"
 207                    },
 208                    {
 209                        "network": "147.10.13.4/32"
 210                    }
 211                 ]
 212             }
 213     }
 214
 215
 216     Returns
 217     -------
 218     errormsg(str) or True
 219     """
 220
 221     logger.info("Entering lib API: get_rib_route_uptime()")
 222     route_time = []
 223     out_route_dict = {}
 224     router_list = tgen.routers()
 225     for routerInput in input_dict.keys():
 226         for router, rnode in router_list.items():
 227             if router != dut:
 228                 continue
 229
 230             logger.info("Checking router %s RIB:", router)
 231
 232             # Verifying RIB routes
 233             if addr_type == "ipv4":
 234                 command = "show ip route"
 235             else:
 236                 command = "show ipv6 route"
 237
 238             if "static_routes" in input_dict[routerInput]:
 239                 static_routes = input_dict[routerInput]["static_routes"]
 240
 241                 for static_route in static_routes:
 242                     if "vrf" in static_route and static_route["vrf"] is not None:
 243
 244                         logger.info(
 245                             "[DUT: {}]: Verifying routes for VRF:"
 246                             " {}".format(router, static_route["vrf"])
 247                         )
 248                         cmd = "{} vrf {}".format(command, static_route["vrf"])
 249
 250                     else:
 251                         cmd = "{}".format(command)
 252
 253                     cmd = "{} json".format(cmd)
 254
 255                     rib_routes_json = run_frr_cmd(rnode, cmd, isjson=True)
 256
 257                     if bool(rib_routes_json) is False:
 258                         errormsg = "No route found in rib of router {}..".format(router)
 259                         return errormsg
 260                     network = static_route["network"]
 261                     route_time.append(rib_routes_json[network][0]["uptime"])
 262
 263     logger.info("Exiting lib API: get_rib_route_uptime()")
 264     return route_time
 265
 266
 267 def verify_the_uptime(time_stamp_before, time_stamp_after, incremented=None):
 268     """
 269     time_stamp_before : string the time stamp captured
 270     time_stamp_after : string the time stamp captured
 271     """
 272     uptime_before = datetime.datetime.strptime(time_stamp_before[0], "%H:%M:%S")
 273     uptime_after = datetime.datetime.strptime(time_stamp_after[0], "%H:%M:%S")
 274
 275     if incremented == True:
 276         if uptime_before < uptime_after:
 277             logger.info(
 278                 "  The Uptime [{}] is incremented than [{}].......PASSED ".format(
 279                     time_stamp_before, time_stamp_after
 280                 )
 281             )
 282             return True
 283         else:
 284             logger.error(
 285                 "  The Uptime [{}] is expected to be incremented than [{}].......FAILED ".format(
 286                     time_stamp_before, time_stamp_after
 287                 )
 288             )
 289             return False
 290     else:
 291         logger.info(
 292             "  The Uptime [{}] is not incremented than [{}] ".format(
 293                 time_stamp_before, time_stamp_after
 294             )
 295         )
 296         return True
 297
 298
 299 #####################################################
 300 #
 301 #                      Testcases
 302 #
 303 #####################################################
 304
 305
 306 def test_verify_bgp_default_originate_with_default_static_route_p1(request):
 307     """
 308     Summary: "Verify default-originate route with default static and network command  "
 309
 310     """
 311     tgen = get_topogen()
 312     global BGP_CONVERGENCE, DEFAULT_ROUTE_NXT_HOP_LINK1, DEFAULT_ROUTE_NXT_HOP_LINK2, DEFAULT_ROUTES
 313
 314     if BGP_CONVERGENCE != True:
 315         pytest.skip("skipped because of BGP Convergence failure")
 316     # test case name
 317     tc_name = request.node.name
 318     write_test_header(tc_name)
 319     if tgen.routers_have_failure():
 320         check_router_status(tgen)
 321     reset_config_on_routers(tgen)
 322
 323     step("Configure 2 link between R1 and R2")
 324     step("Configure IPV4 and IPV6 EBGP between R1 and R2  both the links")
 325     step("Configure default-originate on R1 IPv4 and IPv6 BGP session link-1 only ")
 326     local_as = get_dut_as_number(tgen, dut="r1")
 327     default_originate_config = {
 328         "r1": {
 329             "bgp": {
 330                 "local_as": local_as,
 331                 "address_family": {
 332                     "ipv4": {
 333                         "unicast": {
 334                             "default_originate": {"r2": {"dest-link": "r1-link1"}}
 335                         }
 336                     },
 337                     "ipv6": {
 338                         "unicast": {
 339                             "default_originate": {"r2": {"dest-link": "r1-link1"}}
 340                         }
 341                     },
 342                 },
 343             }
 344         }
 345     }
 346     result = create_router_bgp(tgen, topo, default_originate_config)
 347     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 348
 349     step("Verify IPv4/IPv6 default originate routes present on R2 nexthop as link-1")
 350     for addr_type in ADDR_TYPES:
 351         static_routes_input = {
 352             "r2": {
 353                 "static_routes": [
 354                     {
 355                         "network": [DEFAULT_ROUTES[addr_type]],
 356                         "next_hop": DEFAULT_ROUTE_NXT_HOP_LINK1[addr_type],
 357                     }
 358                 ]
 359             }
 360         }
 361
 362         result = verify_fib_routes(
 363             tgen,
 364             addr_type,
 365             "r2",
 366             static_routes_input,
 367             next_hop=DEFAULT_ROUTE_NXT_HOP_LINK1[addr_type],
 368         )
 369         assert result is True, "Testcase {} : Failed \n Error: {}".format(
 370             tc_name, result
 371         )
 372
 373         result = verify_bgp_rib(
 374             tgen,
 375             addr_type,
 376             "r2",
 377             static_routes_input,
 378             next_hop=DEFAULT_ROUTE_NXT_HOP_LINK1[addr_type],
 379         )
 380         assert result is True, "Testcase {} : Failed \n Error: {}".format(
 381             tc_name, result
 382         )
 383
 384     step(
 385         "Configure  network command on R1 (0.0.0.0/0 and 0::0/0) for IPv4 and IPv6 address family "
 386     )
 387     DEFAULT_ROUTES = {"ipv4": "0.0.0.0/0", "ipv6": "0::0/0"}
 388     for addr_type in ADDR_TYPES:
 389         input_advertise = {
 390             "r1": {
 391                 "bgp": {
 392                     "address_family": {
 393                         addr_type: {
 394                             "unicast": {
 395                                 "advertise_networks": [
 396                                     {"network": [DEFAULT_ROUTES[addr_type]]}
 397                                 ]
 398                             }
 399                         }
 400                     }
 401                 }
 402             }
 403         }
 404
 405         result = create_router_bgp(tgen, topo, input_advertise)
 406         assert result is True, "Testcase {} :Failed \n Error: {}".format(
 407             tc_name, result
 408         )
 409
 410     step("No change on IPv4/IPv6  default-originate route advertised from link1")
 411     result = verify_rib_default_route(
 412         tgen,
 413         topo,
 414         dut="r2",
 415         routes=DEFAULT_ROUTES,
 416         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 417     )
 418     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 419     result = verify_fib_default_route(
 420         tgen,
 421         topo,
 422         dut="r2",
 423         routes=DEFAULT_ROUTES,
 424         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 425     )
 426     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 427
 428     step("verify 0.0.0.0/0 and 0::0/0 route also get advertised from link-2  ")
 429     result = verify_rib_default_route(
 430         tgen,
 431         topo,
 432         dut="r2",
 433         routes=DEFAULT_ROUTES,
 434         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 435     )
 436     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 437     result = verify_fib_default_route(
 438         tgen,
 439         topo,
 440         dut="r2",
 441         routes=DEFAULT_ROUTES,
 442         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 443     )
 444     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 445
 446     step(
 447         "Before removing default originate from R1 link -1 IPv4 and IPv6 address family taking the uptime snapshot"
 448     )
 449     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 450     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 451
 452     step("Remove default originate from R1 link -1 IPv4 and IPv6 address family ")
 453     local_as = get_dut_as_number(tgen, dut="r1")
 454     default_originate_config = {
 455         "r1": {
 456             "bgp": {
 457                 "local_as": local_as,
 458                 "address_family": {
 459                     "ipv4": {
 460                         "unicast": {
 461                             "default_originate": {
 462                                 "r2": {"dest-link": "r1-link1", "delete": True}
 463                             }
 464                         }
 465                     },
 466                     "ipv6": {
 467                         "unicast": {
 468                             "default_originate": {
 469                                 "r2": {"dest-link": "r1-link1", "delete": True}
 470                             }
 471                         }
 472                     },
 473                 },
 474             }
 475         }
 476     }
 477     result = create_router_bgp(tgen, topo, default_originate_config)
 478     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 479
 480     step("Routes must be learned from network command")
 481     result = verify_rib_default_route(
 482         tgen,
 483         topo,
 484         dut="r2",
 485         routes=DEFAULT_ROUTES,
 486         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 487     )
 488     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 489     result = verify_fib_default_route(
 490         tgen,
 491         topo,
 492         dut="r2",
 493         routes=DEFAULT_ROUTES,
 494         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 495     )
 496     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 497
 498     result = verify_rib_default_route(
 499         tgen,
 500         topo,
 501         dut="r2",
 502         routes=DEFAULT_ROUTES,
 503         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 504     )
 505     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 506     result = verify_fib_default_route(
 507         tgen,
 508         topo,
 509         dut="r2",
 510         routes=DEFAULT_ROUTES,
 511         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 512     )
 513     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 514
 515     step("After removing the default originate  on R1 taking the uptime snapshot")
 516     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 517     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 518
 519     step(
 520         "After removing the default-originate uptime should get reset for link-1 learn route"
 521     )
 522     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
 523     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 524
 525     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
 526     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 527
 528     step("Taking uptime snapshot before configuring default - originate")
 529     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 530     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 531
 532     step(
 533         "Configure default-originate on R1 link-1 again for IPv4 and IPv6 address family"
 534     )
 535     local_as = get_dut_as_number(tgen, dut="r1")
 536     default_originate_config = {
 537         "r1": {
 538             "bgp": {
 539                 "local_as": local_as,
 540                 "address_family": {
 541                     "ipv4": {
 542                         "unicast": {
 543                             "default_originate": {
 544                                 "r2": {
 545                                     "dest-link": "r1-link1",
 546                                 }
 547                             }
 548                         }
 549                     },
 550                     "ipv6": {
 551                         "unicast": {
 552                             "default_originate": {
 553                                 "r2": {
 554                                     "dest-link": "r1-link1",
 555                                 }
 556                             }
 557                         }
 558                     },
 559                 },
 560             }
 561         }
 562     }
 563     result = create_router_bgp(tgen, topo, default_originate_config)
 564     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 565
 566     step("Verify No change on R2 routing and BGP table for both the links ")
 567     result = verify_rib_default_route(
 568         tgen,
 569         topo,
 570         dut="r2",
 571         routes=DEFAULT_ROUTES,
 572         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 573     )
 574     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 575     result = verify_fib_default_route(
 576         tgen,
 577         topo,
 578         dut="r2",
 579         routes=DEFAULT_ROUTES,
 580         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 581     )
 582     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 583
 584     result = verify_rib_default_route(
 585         tgen,
 586         topo,
 587         dut="r2",
 588         routes=DEFAULT_ROUTES,
 589         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 590     )
 591     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 592     result = verify_fib_default_route(
 593         tgen,
 594         topo,
 595         dut="r2",
 596         routes=DEFAULT_ROUTES,
 597         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 598     )
 599     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 600
 601     step("Taking snapshot after configuring default - originate")
 602     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 603     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 604
 605     step(
 606         "After configuring the default-originate uptime should not get reset for link-1 learn route"
 607     )
 608     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=True)
 609     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 610
 611     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=True)
 612     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 613
 614     step("Taking uptime snapshot before  removing  network 0.0.0.0  ")
 615     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 616     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 617
 618     step("Remove network command from R1 IPv4/IPv6 address family ")
 619     DEFAULT_ROUTES = {"ipv4": "0.0.0.0/0", "ipv6": "0::0/0"}
 620     for addr_type in ADDR_TYPES:
 621         input_advertise = {
 622             "r1": {
 623                 "bgp": {
 624                     "address_family": {
 625                         addr_type: {
 626                             "unicast": {
 627                                 "advertise_networks": [
 628                                     {
 629                                         "network": [DEFAULT_ROUTES[addr_type]],
 630                                         "delete": True,
 631                                     }
 632                                 ]
 633                             }
 634                         }
 635                     }
 636                 }
 637             }
 638         }
 639
 640         result = create_router_bgp(tgen, topo, input_advertise)
 641         assert result is True, "Testcase {} :Failed \n Error: {}".format(
 642             tc_name, result
 643         )
 644
 645     step(
 646         "Verify 0.0.0.0/0 and 0::0/0 route get removed from link-2  and default-originate IPv4/IPv6 route learn on link-1"
 647     )
 648     result = verify_rib_default_route(
 649         tgen,
 650         topo,
 651         dut="r2",
 652         routes=DEFAULT_ROUTES,
 653         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 654     )
 655     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 656     result = verify_fib_default_route(
 657         tgen,
 658         topo,
 659         dut="r2",
 660         routes=DEFAULT_ROUTES,
 661         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 662     )
 663     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 664
 665     result = verify_rib_default_route(
 666         tgen,
 667         topo,
 668         dut="r2",
 669         routes=DEFAULT_ROUTES,
 670         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 671         expected=False,
 672     )
 673     assert (
 674         result is not True
 675     ), "Testcase {} : Failed \n Route from link2 is not expected \n Error: {}".format(
 676         tc_name, result
 677     )
 678     result = verify_fib_default_route(
 679         tgen,
 680         topo,
 681         dut="r2",
 682         routes=DEFAULT_ROUTES,
 683         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 684         expected=False,
 685     )
 686     assert (
 687         result is not True
 688     ), "Testcase {} : Failed\n Route from link2 is not expected \n  Error: {}".format(
 689         tc_name, result
 690     )
 691
 692     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 693     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 694
 695     step(
 696         "After removing default originate command on R1 verify that the uptime got reset on R2"
 697     )
 698
 699     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
 700     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 701
 702     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
 703     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 704
 705     step("Taking uptime snapshot before  configuring static route  network")
 706     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 707     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 708
 709     step(
 710         "Configure static default route for IPv4 and IPv6 (0.0.0.0/0 next-hop Null0 and 0::0/0 next-hop Null0) on R1"
 711     )
 712     static_routes_input = {
 713         "r1": {
 714             "static_routes": [
 715                 {
 716                     "network": "0.0.0.0/0",
 717                     "next_hop": NEXT_HOP_IP["ipv4"],
 718                 },
 719                 {
 720                     "network": "0::0/0",
 721                     "next_hop": NEXT_HOP_IP["ipv6"],
 722                 },
 723             ]
 724         }
 725     }
 726     result = create_static_routes(tgen, static_routes_input)
 727     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 728
 729     step("verifyIPv4 and IPv6 static routes are configure and up on R1 ")
 730     for addr_type in ADDR_TYPES:
 731         static_routes_input = {
 732             "r1": {
 733                 "static_routes": [
 734                     {
 735                         "network": "0.0.0.0/0",
 736                         "next_hop": NEXT_HOP_IP["ipv4"],
 737                     },
 738                     {
 739                         "network": "0::0/0",
 740                         "next_hop": NEXT_HOP_IP["ipv6"],
 741                     },
 742                 ]
 743             }
 744         }
 745         result = verify_fib_routes(tgen, addr_type, "r1", static_routes_input)
 746         assert result is True, "Testcase {} : Failed \n Error: {}".format(
 747             tc_name, result
 748         )
 749
 750     step("Configure redistribute static on IPv4 and IPv6 address family")
 751     redistribute_static = {
 752         "r1": {
 753             "bgp": {
 754                 "address_family": {
 755                     "ipv4": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
 756                     "ipv6": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
 757                 }
 758             }
 759         }
 760     }
 761     result = create_router_bgp(tgen, topo, redistribute_static)
 762     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 763
 764     step("Verify No change on IPv4/IPv6  default-originate route advertised from link1")
 765     result = verify_rib_default_route(
 766         tgen,
 767         topo,
 768         dut="r2",
 769         routes=DEFAULT_ROUTES,
 770         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 771     )
 772     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 773     result = verify_fib_default_route(
 774         tgen,
 775         topo,
 776         dut="r2",
 777         routes=DEFAULT_ROUTES,
 778         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 779     )
 780     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 781
 782     step("verify 0.0.0.0/0 and 0::0/0 route also get advertised from link-2 ")
 783     result = verify_rib_default_route(
 784         tgen,
 785         topo,
 786         dut="r2",
 787         routes=DEFAULT_ROUTES,
 788         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 789     )
 790     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 791     result = verify_fib_default_route(
 792         tgen,
 793         topo,
 794         dut="r2",
 795         routes=DEFAULT_ROUTES,
 796         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 797         expected=False,
 798     )
 799     assert (
 800         result is not True
 801     ), "Testcase {} : Failed\n Best Path sould be advertised in routes\n Error: {}".format(
 802         tc_name, result
 803     )
 804
 805     step("Taking uptime snapshot before  removing  default originate")
 806     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 807     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 808
 809     step("Remove default-originate from link-1 from IPv4 and IPv6 neighbor ")
 810     local_as = get_dut_as_number(tgen, dut="r1")
 811     default_originate_config = {
 812         "r1": {
 813             "bgp": {
 814                 "local_as": local_as,
 815                 "address_family": {
 816                     "ipv4": {
 817                         "unicast": {
 818                             "default_originate": {
 819                                 "r2": {"dest-link": "r1-link1", "delete": True}
 820                             }
 821                         }
 822                     },
 823                     "ipv6": {
 824                         "unicast": {
 825                             "default_originate": {
 826                                 "r2": {"dest-link": "r1-link1", "delete": True}
 827                             }
 828                         }
 829                     },
 830                 },
 831             }
 832         }
 833     }
 834     result = create_router_bgp(tgen, topo, default_originate_config)
 835     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 836
 837     step("Taking uptime snapshot after  removing  default originate")
 838     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 839     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 840
 841     step("verify the up time , up time should get reset ")
 842     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
 843     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 844
 845     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
 846     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 847
 848     step("Verify No change on IPv4/IPv6  default-originate route advertised from link1")
 849     result = verify_rib_default_route(
 850         tgen,
 851         topo,
 852         dut="r2",
 853         routes=DEFAULT_ROUTES,
 854         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 855     )
 856     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 857     result = verify_fib_default_route(
 858         tgen,
 859         topo,
 860         dut="r2",
 861         routes=DEFAULT_ROUTES,
 862         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 863     )
 864     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 865
 866     result = verify_rib_default_route(
 867         tgen,
 868         topo,
 869         dut="r2",
 870         routes=DEFAULT_ROUTES,
 871         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 872     )
 873     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 874     result = verify_fib_default_route(
 875         tgen,
 876         topo,
 877         dut="r2",
 878         routes=DEFAULT_ROUTES,
 879         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 880     )
 881     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 882
 883     step("Taking uptime snapshot before  configuring  default originate")
 884     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 885     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 886
 887     step(
 888         " Configure default-originate on link-1 again for IPv4 and IPv6 address family"
 889     )
 890     local_as = get_dut_as_number(tgen, dut="r1")
 891     default_originate_config = {
 892         "r1": {
 893             "bgp": {
 894                 "local_as": local_as,
 895                 "address_family": {
 896                     "ipv4": {
 897                         "unicast": {
 898                             "default_originate": {
 899                                 "r2": {
 900                                     "dest-link": "r1-link1",
 901                                 }
 902                             }
 903                         }
 904                     },
 905                     "ipv6": {
 906                         "unicast": {
 907                             "default_originate": {
 908                                 "r2": {
 909                                     "dest-link": "r1-link1",
 910                                 }
 911                             }
 912                         }
 913                     },
 914                 },
 915             }
 916         }
 917     }
 918     result = create_router_bgp(tgen, topo, default_originate_config)
 919     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
 920
 921     step("Verify No change on IPv4/IPv6  default-originate route advertised from link1")
 922     result = verify_rib_default_route(
 923         tgen,
 924         topo,
 925         dut="r2",
 926         routes=DEFAULT_ROUTES,
 927         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 928     )
 929     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 930     result = verify_fib_default_route(
 931         tgen,
 932         topo,
 933         dut="r2",
 934         routes=DEFAULT_ROUTES,
 935         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
 936     )
 937     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 938
 939     result = verify_rib_default_route(
 940         tgen,
 941         topo,
 942         dut="r2",
 943         routes=DEFAULT_ROUTES,
 944         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 945     )
 946     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 947     result = verify_fib_default_route(
 948         tgen,
 949         topo,
 950         dut="r2",
 951         routes=DEFAULT_ROUTES,
 952         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
 953         expected=False,
 954     )
 955     assert result is not True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 956
 957     step("Taking uptime snapshot after  configuring  default originate")
 958     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 959     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 960
 961     step("After configuring the default originate the uptime should not get reset ")
 962     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
 963     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 964     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
 965     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 966
 967     step("Taking uptime snapshot before  removing   redisctribute static ")
 968     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
 969     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
 970
 971     step("Remove redistribute static from IPv4 and IPv6 address family ")
 972     input_dict_1 = {
 973         "r1": {
 974             "bgp": {
 975                 "local_as": get_dut_as_number(tgen, dut="r1"),
 976                 "address_family": {
 977                     "ipv4": {
 978                         "unicast": {
 979                             "redistribute": [{"redist_type": "static", "delete": True}]
 980                         }
 981                     },
 982                     "ipv6": {
 983                         "unicast": {
 984                             "redistribute": [{"redist_type": "static", "delete": True}]
 985                         }
 986                     },
 987                 },
 988             }
 989         }
 990     }
 991
 992     result = create_router_bgp(tgen, topo, input_dict_1)
 993     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 994
 995     step("Verify No change on IPv4/IPv6  default-originate route advertised from link1")
 996     result = verify_rib_default_route(
 997         tgen,
 998         topo,
 999         dut="r2",
1000         routes=DEFAULT_ROUTES,
1001         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1002     )
1003     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1004     result = verify_fib_default_route(
1005         tgen,
1006         topo,
1007         dut="r2",
1008         routes=DEFAULT_ROUTES,
1009         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1010     )
1011     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1012
1013     result = verify_rib_default_route(
1014         tgen,
1015         topo,
1016         dut="r2",
1017         routes=DEFAULT_ROUTES,
1018         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1019         expected=False,
1020     )
1021     assert result is not True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1022     result = verify_fib_default_route(
1023         tgen,
1024         topo,
1025         dut="r2",
1026         routes=DEFAULT_ROUTES,
1027         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1028         expected=False,
1029     )
1030     assert result is not True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1031
1032     step("Taking uptime snapshot before  removing   redisctribute static ")
1033     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1034     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1035
1036     step("After removing default originate the route uptime should get reset ")
1037     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=True)
1038     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1039
1040     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=True)
1041     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1042     write_test_footer(tc_name)
1043
1044
1045 def test_verify_bgp_default_originate_with_aggregate_summary_p1(request):
1046     """
1047     Summary: "Verify default-originate route with aggregate summary command"
1048     """
1049     tgen = get_topogen()
1050     global BGP_CONVERGENCE
1051     tc_name = request.node.name
1052     write_test_header(tc_name)
1053     if tgen.routers_have_failure():
1054         check_router_status(tgen)
1055     reset_config_on_routers(tgen)
1056     if BGP_CONVERGENCE != True:
1057         pytest.skip("skipped because of BGP Convergence failure")
1058
1059     step("After changing the BGP AS Path Verify the BGP Convergence")
1060     BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
1061     assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}".format(
1062         BGP_CONVERGENCE
1063     )
1064
1065     step("Configure default-originate on R1 IPv4 and IPv6 BGP session link-1 only")
1066     local_as = get_dut_as_number(tgen, dut="r1")
1067     default_originate_config = {
1068         "r1": {
1069             "bgp": {
1070                 "local_as": local_as,
1071                 "address_family": {
1072                     "ipv4": {
1073                         "unicast": {
1074                             "default_originate": {"r2": {"dest-link": "r1-link1"}}
1075                         }
1076                     },
1077                     "ipv6": {
1078                         "unicast": {
1079                             "default_originate": {"r2": {"dest-link": "r1-link1"}}
1080                         }
1081                     },
1082                 },
1083             }
1084         }
1085     }
1086     result = create_router_bgp(tgen, topo, default_originate_config)
1087     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
1088
1089     step(
1090         "Verify IPv4/IPv6 default originate routes present on R2 nexthop as link-1,on R2"
1091     )
1092     result = verify_rib_default_route(
1093         tgen,
1094         topo,
1095         dut="r2",
1096         routes=DEFAULT_ROUTES,
1097         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1098     )
1099     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1100     result = verify_fib_default_route(
1101         tgen,
1102         topo,
1103         dut="r2",
1104         routes=DEFAULT_ROUTES,
1105         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1106     )
1107     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1108
1109     step("Configure 5 static  route for IPv4 and IPv6  on R0")
1110     for addr_type in ADDR_TYPES:
1111         input_advertise = {
1112             "r1": {
1113                 "bgp": {
1114                     "address_family": {
1115                         addr_type: {
1116                             "unicast": {
1117                                 "advertise_networks": [
1118                                     {
1119                                         "network": [NETWORK1_1[addr_type]],
1120                                         "next_hop": NEXT_HOP_IP[addr_type],
1121                                     },
1122                                     {
1123                                         "network": [NETWORK1_2[addr_type]],
1124                                         "next_hop": NEXT_HOP_IP[addr_type],
1125                                     },
1126                                     {
1127                                         "network": [NETWORK1_3[addr_type]],
1128                                         "next_hop": NEXT_HOP_IP[addr_type],
1129                                     },
1130                                     {
1131                                         "network": [NETWORK1_4[addr_type]],
1132                                         "next_hop": NEXT_HOP_IP[addr_type],
1133                                     },
1134                                     {
1135                                         "network": [NETWORK1_5[addr_type]],
1136                                         "next_hop": NEXT_HOP_IP[addr_type],
1137                                     },
1138                                 ]
1139                             }
1140                         }
1141                     }
1142                 }
1143             }
1144         }
1145
1146         result = create_router_bgp(tgen, topo, input_advertise)
1147         assert result is True, "Testcase {} :Failed \n Error: {}".format(
1148             tc_name, result
1149         )
1150
1151     step("Before configuring the aggregate route taking uptime snapshot  ")
1152     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1153     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1154
1155     step("Configure aggregate summary command  for IPv4 and IPv6 address family ")
1156     local_as = get_dut_as_number(tgen, dut="r1")
1157     raw_config = {
1158         "r1": {
1159             "raw_config": [
1160                 "router bgp {}".format(local_as),
1161                 "address-family ipv4 unicast",
1162                 "aggregate-address {} summary-only".format("0.0.0.0/0 "),
1163                 "exit-address-family",
1164                 "address-family ipv6 unicast",
1165                 "aggregate-address {} summary-only".format("0::0/0"),
1166                 "exit-address-family",
1167             ]
1168         }
1169     }
1170     result = apply_raw_config(tgen, raw_config)
1171     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1172
1173     step(
1174         "verify that no change on IPv4/IPv6  default-originate route advertised from link1  0.0.0.0/0 and 0::0/0 route also get advertised from link-2    on R2"
1175     )
1176     result = verify_rib_default_route(
1177         tgen,
1178         topo,
1179         dut="r2",
1180         routes=DEFAULT_ROUTES,
1181         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1182     )
1183     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1184     result = verify_fib_default_route(
1185         tgen,
1186         topo,
1187         dut="r2",
1188         routes=DEFAULT_ROUTES,
1189         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1190     )
1191     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1192
1193     result = verify_rib_default_route(
1194         tgen,
1195         topo,
1196         dut="r2",
1197         routes=DEFAULT_ROUTES,
1198         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1199     )
1200     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1201     result = verify_fib_default_route(
1202         tgen,
1203         topo,
1204         dut="r2",
1205         routes=DEFAULT_ROUTES,
1206         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1207     )
1208     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1209
1210     step("After configuring the aggregate route taking uptime snapshot  ")
1211     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1212     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1213
1214     step(
1215         "After Configuring  the aggregate route uptime should get reset for link-1 learn route"
1216     )
1217     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
1218     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1219
1220     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
1221     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1222
1223     step("Before removing default originate  taking uptime snapshot ")
1224     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1225     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1226
1227     step("Remove default originate from R1 link -1 IPv4 and IPv6 address family")
1228     local_as = get_dut_as_number(tgen, dut="r1")
1229     default_originate_config = {
1230         "r1": {
1231             "bgp": {
1232                 "local_as": local_as,
1233                 "address_family": {
1234                     "ipv4": {
1235                         "unicast": {
1236                             "default_originate": {
1237                                 "r2": {"dest-link": "r1-link1", "delete": True}
1238                             }
1239                         }
1240                     },
1241                     "ipv6": {
1242                         "unicast": {
1243                             "default_originate": {
1244                                 "r2": {"dest-link": "r1-link1", "delete": True}
1245                             }
1246                         }
1247                     },
1248                 },
1249             }
1250         }
1251     }
1252     result = create_router_bgp(tgen, topo, default_originate_config)
1253     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
1254
1255     step(
1256         "verify that no change on IPv4/IPv6  default-originate route advertised from link1  0.0.0.0/0 and 0::0/0 route also get advertised from link-2    on R2"
1257     )
1258     result = verify_rib_default_route(
1259         tgen,
1260         topo,
1261         dut="r2",
1262         routes=DEFAULT_ROUTES,
1263         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1264     )
1265     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1266     result = verify_fib_default_route(
1267         tgen,
1268         topo,
1269         dut="r2",
1270         routes=DEFAULT_ROUTES,
1271         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1272     )
1273     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1274
1275     step("After removing default origin taking uptime snapshot  ")
1276     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1277     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1278
1279     step(
1280         "After removing the default-originate uptime should get reset for link-1 learn route"
1281     )
1282     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
1283     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1284
1285     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
1286     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1287
1288     step("Before Configuring default origin taking uptime snapshot ")
1289     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1290     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1291
1292     step(
1293         "Configure default-originate on R1 link-1 again for IPv4 and IPv6 address family"
1294     )
1295     local_as = get_dut_as_number(tgen, dut="r1")
1296     default_originate_config = {
1297         "r1": {
1298             "bgp": {
1299                 "local_as": local_as,
1300                 "address_family": {
1301                     "ipv4": {
1302                         "unicast": {
1303                             "default_originate": {
1304                                 "r2": {
1305                                     "dest-link": "r1-link1",
1306                                 }
1307                             }
1308                         }
1309                     },
1310                     "ipv6": {
1311                         "unicast": {
1312                             "default_originate": {
1313                                 "r2": {
1314                                     "dest-link": "r1-link1",
1315                                 }
1316                             }
1317                         }
1318                     },
1319                 },
1320             }
1321         }
1322     }
1323     result = create_router_bgp(tgen, topo, default_originate_config)
1324     assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
1325
1326     step("After Configuring  default originate  taking uptime snapshot")
1327     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1328     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1329
1330     step(
1331         "After Configuring  the default-originate uptime should get reset for link-1 learn route"
1332     )
1333     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
1334     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1335
1336     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
1337     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1338
1339     step("Before removing aggregate -summary command taking the uptime snapshot ")
1340     uptime_before_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1341     uptime_before_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1342
1343     step("remove aggregate summary command  for IPv4 and IPv6 address family ")
1344     local_as = get_dut_as_number(tgen, dut="r1")
1345     raw_config = {
1346         "r1": {
1347             "raw_config": [
1348                 "router bgp {}".format(local_as),
1349                 "address-family ipv4 unicast",
1350                 "no aggregate-address {} summary-only".format("0.0.0.0/0"),
1351                 "exit-address-family",
1352                 "address-family ipv6 unicast",
1353                 "no aggregate-address {} summary-only".format("0::0/0"),
1354                 "exit-address-family",
1355             ]
1356         }
1357     }
1358     result = apply_raw_config(tgen, raw_config)
1359     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1360
1361     step("Verify Default-originate IPv4/IPv6 route learn on link-1 ")
1362     result = verify_rib_default_route(
1363         tgen,
1364         topo,
1365         dut="r2",
1366         routes=DEFAULT_ROUTES,
1367         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1368     )
1369     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1370     result = verify_fib_default_route(
1371         tgen,
1372         topo,
1373         dut="r2",
1374         routes=DEFAULT_ROUTES,
1375         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK1,
1376     )
1377     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1378
1379     step("Verify 0.0.0.0/0 and 0::0/0 route get removed from link-2 ")
1380     result = verify_rib_default_route(
1381         tgen,
1382         topo,
1383         dut="r2",
1384         routes=DEFAULT_ROUTES,
1385         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1386         expected=False,
1387     )
1388     assert result is not True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1389     result = verify_fib_default_route(
1390         tgen,
1391         topo,
1392         dut="r2",
1393         routes=DEFAULT_ROUTES,
1394         expected_nexthop=DEFAULT_ROUTE_NXT_HOP_LINK2,
1395         expected=False,
1396     )
1397     assert result is not True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1398
1399     step("After removing aggregate -summary command taking the uptime snapshot ")
1400     uptime_after_ipv4 = get_rib_route_uptime(tgen, "ipv4", "r2", ipv4_uptime_dict)
1401     uptime_after_ipv6 = get_rib_route_uptime(tgen, "ipv6", "r2", ipv6_uptime_dict)
1402
1403     step("After removing aggregate command uptime should get reset ")
1404     result = verify_the_uptime(uptime_before_ipv4, uptime_after_ipv4, incremented=False)
1405     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1406
1407     result = verify_the_uptime(uptime_before_ipv6, uptime_after_ipv6, incremented=False)
1408     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1409     write_test_footer(tc_name)
1410
1411
1412 if __name__ == "__main__":
1413     args = ["-s"] + sys.argv[1:]
1414     sys.exit(pytest.main(args))