def test_large_community_aggregate_network(request): """ Restart router and check if large community and community attributes are getting re-populated. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) config_for_as_path(tgen, topo, tc_name) input_dict = { "community": STANDARD_COMM["agg_1"], "largeCommunity": LARGE_COMM["agg_1"], } input_dict_1 = { "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "aggregate_address": [ { "network": "%s/%s" % (NETWORK["ipv4"][2], NET_MASK["ipv4"]), "as_set": True, } ] } }, "ipv6": { "unicast": { "aggregate_address": [ { "network": "%s/%s" % (NETWORK["ipv6"][2], NET_MASK["ipv6"]), "as_set": True, } ] } }, } } } } step("Configuring aggregate address as-set on r2") result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Test case {} : Failed \n Error: {}".format(tc_name, result) for adt in ADDR_TYPES: result = verify_bgp_community( tgen, adt, "r4", ["%s/%s" % (NETWORK[adt][2], NET_MASK[adt])], input_dict ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) input_dict_2 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "advertise_networks": [ { "network": "%s/%s" % (NETWORK["ipv4"][0], MASK["ipv4"]), "no_of_network": 1, "delete": True, } ] } }, "ipv6": { "unicast": { "advertise_networks": [ { "network": "%s/%s" % (NETWORK["ipv6"][0], MASK["ipv6"]), "no_of_network": 1, "delete": True, } ] } }, } } } } step("Stop advertising one of the networks") result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Test case {} : Failed \n Error: {}".format(tc_name, result) input_dict_3 = { "community": STANDARD_COMM["agg_2"], "largeCommunity": LARGE_COMM["agg_2"], } for adt in ADDR_TYPES: step("Verifying bgp community values on r5 is also modified") result = verify_bgp_community( tgen, adt, "r4", ["%s/%s" % (NETWORK[adt][2], NET_MASK[adt])], input_dict_3 ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_ospf_lan_tc2_p0(request): """ OSPF IFSM -Verify state change events on DR / BDR / DR Other """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") reset_config_on_routers(tgen) step("Verify that OSPF is subscribed to multi cast services " "(All SPF, all DR Routers).") step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "priority": 98, "timerDeadSecs": 4, "area": "0.0.0.3", "mcastMemberOspfDesignatedRouters": True, "mcastMemberOspfAllRouters": True, "ospfEnabled": True, } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Delete the ip address") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["s1"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Change the ip on the R0 interface") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3) + "/{}".format( intf_ip.split("/")[1]) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "ipAddress": topo_modify_change_ip["routers"]["r0"]["links"]["s1"] ["ipv4"].split("/")[0], "ipAddressPrefixlen": int(topo_modify_change_ip["routers"]["r0"]["links"] ["s1"]["ipv4"].split("/")[1]), } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Modify the mask on the R0 interface") ip_addr = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] mask = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] step("Delete the ip address") topo1 = { "r0": { "links": { "r3": { "ipv4": ip_addr, "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Change the ip on the R0 interface") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3) + "/{}".format(int(intf_ip.split("/")[1]) + 1) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "ipAddress": topo_modify_change_ip["routers"]["r0"]["links"]["s1"] ["ipv4"].split("/")[0], "ipAddressPrefixlen": int(topo_modify_change_ip["routers"]["r0"]["links"] ["s1"]["ipv4"].split("/")[1]), } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Change the area id on the interface") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "area": "0.0.0.3" }, "delete": True, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "area": "0.0.0.2" }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "area": "0.0.0.2", "ospfEnabled": True } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_ecmp_tc17_p0(request): """ Verify OSPF ECMP. Verify OSPF ECMP with max path configured as 2 (Edge having 2 uplink ports) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step("Configure 2 interfaces between R1 and R2 & enable ospf in area 0.") reset_config_on_routers(tgen) step("Verify that OSPF is up with 2 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Configure a static route in R0 and redistribute in OSPF.") input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) dut = "r0" red_static(dut) step("Verify that route in R2 in stalled with 2 next hops.") nh1 = topo["routers"]["r0"]["links"]["r1-link1"]["ipv4"].split("/")[0] nh2 = topo["routers"]["r0"]["links"]["r1"]["ipv4"].split("/")[0] nh = [nh1, nh2] dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" Un configure static route on R0") dut = "r0" red_static(dut, config=False) # sleep till the route gets withdrawn sleep(10) step("Verify that route is withdrawn from R2.") dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, attempts=5, expected=False, ) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Reconfigure the static route in R0.Change ECMP value to 2.") dut = "r0" red_static(dut) step("Configure cost on R0 as 100") r0_ospf_cost = {"r0": {"links": {"r1": {"ospf": {"cost": 100}}}}} result = config_ospf_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_chaos_tc34_p1(request): """ verify ospf functionality when staticd is restarted. Verify ospf functionalitywhen staticroutes are redistributed & Staticd is restarted. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config as per the topology") reset_config_on_routers(tgen) step("Create static routes(10.0.20.1/32) in R1 and redistribute " "to OSPF using route map.") # Create Static routes input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_red_r0 = { "r0": { "ospf": { "redistribute": [{ "redist_type": "static" }] } } } result = create_router_ospf(tgen, topo, ospf_red_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify OSPF neighbors after base config is done.") # Api call verify whether OSPF is converged ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Verify that route is advertised to R1.") dut = "r1" protocol = "ospf" nh = topo["routers"]["r0"]["links"]["r1"]["ipv4"].split("/")[0] result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Kill staticd daemon on R0.") kill_router_daemons(tgen, "r0", ["staticd"]) step("Verify that route advertised to R1 are deleted from RIB and FIB.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed \n " "r1: OSPF routes are present \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False) assert ( result is not True ), "Testcase {} : Failed \n " "r1: routes are still present \n Error: {}".format( tc_name, result) step("Bring up staticd daemon on R0.") start_router_daemons(tgen, "r0", ["staticd"]) step("Verify OSPF neighbors are up after bringing back ospfd in R0") # Api call verify whether OSPF is converged ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("All the neighbours are up and routes are installed before the" " restart. Verify OSPF route table and ip route table.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Kill staticd daemon on R1.") kill_router_daemons(tgen, "r1", ["staticd"]) step("Bring up staticd daemon on R1.") start_router_daemons(tgen, "r1", ["staticd"]) step("Verify OSPF neighbors are up after bringing back ospfd in R1") # Api call verify whether OSPF is converged ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("All the neighbours are up and routes are installed before the" " restart. Verify OSPF route table and ip route table.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_bgp_with_loopback_interface(request): """ Test BGP with loopback interface Adding keys:value pair "dest_link": "lo" and "source_link": "lo" peer dict of input json file for all router's creating config using loopback interface. Once BGP neighboship is up then verifying BGP convergence """ tgen = get_topogen() if BGP_CONVERGENCE is not True: pytest.skip("skipped because of BGP Convergence failure") # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) for routerN in sorted(topo["routers"].keys()): for bgp_neighbor in topo["routers"][routerN]["bgp"]["address_family"]["ipv4"][ "unicast" ]["neighbor"].keys(): # Adding ['source_link'] = 'lo' key:value pair topo["routers"][routerN]["bgp"]["address_family"]["ipv4"]["unicast"][ "neighbor" ][bgp_neighbor]["dest_link"] = {"lo": {"source_link": "lo",}} # Creating configuration from JSON build_config_from_json(tgen, topo) input_dict = { "r1": { "static_routes": [ {"network": "1.0.2.17/32", "next_hop": "10.0.0.2"}, {"network": "1.0.3.17/32", "next_hop": "10.0.0.6"}, ] }, "r2": { "static_routes": [ {"network": "1.0.1.17/32", "next_hop": "10.0.0.1"}, {"network": "1.0.3.17/32", "next_hop": "10.0.0.10"}, ] }, "r3": { "static_routes": [ {"network": "1.0.1.17/32", "next_hop": "10.0.0.5"}, {"network": "1.0.2.17/32", "next_hop": "10.0.0.9"}, {"network": "1.0.4.17/32", "next_hop": "10.0.0.14"}, ] }, "r4": {"static_routes": [{"network": "1.0.3.17/32", "next_hop": "10.0.0.13"}]}, } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) # Api call verify whether BGP is converged result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ecmp_after_clear_bgp(request, test_type): """ Verify BGP table and RIB in DUT after clear BGP routes and neighbors""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() reset_config_on_routers(tgen) # Verifying RIB routes dut = "r3" protocol = "bgp" static_or_nw(tgen, topo, tc_name, test_type, "r2") for addr_type in ADDR_TYPES: input_dict_1 = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict_1, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Clear BGP for addr_type in ADDR_TYPES: clear_bgp(tgen, addr_type, dut) # Verify BGP convergence result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for addr_type in ADDR_TYPES: input_dict_1 = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict_1, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ecmp_remove_static_route(request): """ Delete static routes and verify routers are cleared from BGP table, and RIB of DUT. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Verifying RIB routes dut = "r3" protocol = "bgp" reset_config_on_routers(tgen) static_or_nw(tgen, topo, tc_name, "redist_static", "r2") for addr_type in ADDR_TYPES: input_dict_1 = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict_1, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for addr_type in ADDR_TYPES: input_dict_2 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP[addr_type], "delete": True, }] } } logger.info("Remove static routes") result = create_static_routes(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) logger.info("Verifying %s routes on r3 are removed", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict_2, next_hop=[], protocol=protocol, expected=False, ) assert ( result is not True ), "Testcase {} : Failed \n Routes still" " present in RIB".format( tc_name) for addr_type in ADDR_TYPES: # Enable static routes input_dict_4 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP[addr_type] }] } } logger.info("Enable static route") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict_4, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result)
def test_ospfv3_cost_tc52_p0(request): """OSPF Cost - verifying ospf interface cost functionality""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") reset_config_on_routers(tgen) step( "Configure ospf cost as 20 on interface between R0 and R1. " "Configure ospf cost as 30 between interface between R0 and R2." ) r0_ospf_cost = { "r0": {"links": {"r1": {"ospf6": {"cost": 20}}, "r2": {"ospf6": {"cost": 30}}}} } result = config_ospf6_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that cost is updated in the ospf interface between" " r0 and r1 as 30 and r0 and r2 as 20" ) dut = "r0" result = verify_ospf6_interface(tgen, topo, dut=dut, input_dict=r0_ospf_cost) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Swap the costs between interfaces on r0, between r0 and r1 to 30" ", r0 and r2 to 20" ) r0_ospf_cost = { "r0": {"links": {"r1": {"ospf6": {"cost": 30}}, "r2": {"ospf6": {"cost": 20}}}} } result = config_ospf6_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that cost is updated in the ospf interface between r0 " "and r1 as 30 and r0 and r2 as 20." ) result = verify_ospf6_interface(tgen, topo, dut=dut, input_dict=r0_ospf_cost) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step(" Un configure cost from the interface r0 - r1.") r0_ospf_cost = { "r0": {"links": {"r1": {"ospf6": {"cost": 30, "del_action": True}}}} } result = config_ospf6_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": {"links": {"r1": {"ospf6": {"cost": 10}}, "r2": {"ospf6": {"cost": 20}}}} } step( "Verify that cost is updated in the ospf interface between r0" " and r1 as 10 and r0 and r2 as 20." ) result = verify_ospf6_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step(" Un configure cost from the interface r0 - r2.") r0_ospf_cost = { "r0": {"links": {"r2": {"ospf6": {"cost": 20, "del_action": True}}}} } result = config_ospf6_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that cost is updated in the ospf interface between r0" "and r1 as 10 and r0 and r2 as 10" ) input_dict = { "r0": {"links": {"r1": {"ospf6": {"cost": 10}}, "r2": {"ospf6": {"cost": 10}}}} } result = verify_ospf6_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_learning_tc15_p0(request): """Verify OSPF can learn different types of LSA and processes them. OSPF Learning : Edge learning different types of LSAs. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step("Configure area 1 as NSSA Area") reset_config_on_routers(tgen) step("Verify that Type 3 summary LSA is originated for the same Area 0") ip = topo["routers"]["r1"]["links"]["r3-link0"]["ipv4"] ip_net = str(ipaddress.ip_interface(u"{}".format(ip)).network) dut = "r0" input_dict = { "r1": { "static_routes": [{ "network": ip_net, "no_of_ip": 1, "routeType": "N IA" }] } } dut = "r0" result = verify_ospf_rib(tgen, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = { "r2": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0" }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Redistribute static route in R2 ospf.") dut = "r2" redistribute_ospf(tgen, topo, dut, "static") step("Verify that Type 5 LSA is originated by R2.") dut = "r0" protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that R0 receives Type 4 summary LSA.") dut = "r0" input_dict = { "r1": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 1, "routeType": "N E2" }] } } dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Change area 1 as non nssa area (on the fly changing area" " type on DUT).") for rtr in ["r1", "r2", "r3"]: input_dict = { rtr: { "ospf": { "area": [{ "id": "0.0.0.2", "type": "nssa", "delete": True }] } } } result = create_router_ospf(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that OSPF neighbours are reset after changing area type.") step("Verify that ABR R2 originates type 5 LSA in area 1.") step("Verify that route is calculated and installed in R1.") input_dict = { "r1": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 1, "routeType": "N E2" }] } } dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_redistribution_tc6_p0(request): """Test OSPF inter area route calculations.""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config.") reset_config_on_routers(tgen) step("Verify that OSPF neighbors are FULL.") ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("verify intra area route is calculated for r0-r3 interface ip in R1") ip = topo["routers"]["r0"]["links"]["r3"]["ipv4"] ip_net = str(ipaddress.ip_interface(u"{}".format(ip)).network) nh = topo["routers"]["r0"]["links"]["r1"]["ipv4"].split("/")[0] input_dict = { "r1": { "static_routes": [{ "network": ip_net, "no_of_ip": 1, "routeType": "N" }] } } dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Delete the ip address on newly configured loopback of R0") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["r3"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["r3"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) dut = "r1" for num in range(0, nretry): result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False) if result is not True: break assert result is not True, ( "Testcase {} : Failed \n " "r1: OSPF routes are present after deleting ip address of newly " "configured loopback of R0 \n Error: {}".format(tc_name, result)) protocol = "ospf" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, expected=False, ) assert result is not True, ( "Testcase {} : Failed \n " "r1: OSPF routes are present in fib after deleting ip address of newly " "configured loopback of R0 \n Error: {}".format(tc_name, result)) step("Add back the deleted ip address on newly configured interface of R0") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["r3"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["r3"]["interface"], } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Shut no shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["r3"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step("un shut the OSPF interface on R0") dut = "r0" shutdown_bringup_interface(tgen, dut, intf, True) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_redistribution_tc8_p1(request): """ Test OSPF redistribution of connected routes. Verify OSPF redistribution of connected routes when bgp multi hop neighbor is configured using ospf routes """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") step("Configure loopback interface on all routers, and redistribut" "e connected routes into ospf") reset_config_on_routers(tgen) step("verify that connected routes -loopback is found in all routers" "advertised/exchaged via ospf") for rtr in topo["routers"]: redistribute_ospf(tgen, topo, rtr, "static") redistribute_ospf(tgen, topo, rtr, "connected") for node in topo["routers"]: input_dict = { "r0": { "static_routes": [{ "network": topo["routers"][node]["links"]["lo"]["ipv4"], "no_of_ip": 1, }] } } for rtr in topo["routers"]: result = verify_rib(tgen, "ipv4", rtr, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure E BGP multi hop using the loopback addresses.") as_num = 100 for node in topo["routers"]: as_num += 1 topo["routers"][node].update({ "bgp": { "local_as": as_num, "address_family": { "ipv4": { "unicast": { "neighbor": {} } } }, } }) for node in topo["routers"]: for rtr in topo["routers"]: if node is not rtr: topo["routers"][node]["bgp"]["address_family"]["ipv4"][ "unicast"]["neighbor"].update({ rtr: { "dest_link": { "lo": { "source_link": "lo", "ebgp_multihop": 2 } } } }) result = create_router_bgp(tgen, topo, topo["routers"]) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that BGP neighbor is ESTABLISHED") result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Configure couple of static routes in R0 and " "Redistribute static routes in R1 bgp.") for rtr in topo["routers"]: redistribute_ospf(tgen, topo, rtr, "static", delete=True) input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) configure_bgp_on_r0 = { "r0": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [{ "redist_type": "static" }] } } } } } } result = create_router_bgp(tgen, topo, configure_bgp_on_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "bgp" for rtr in ["r1", "r2", "r3"]: result = verify_rib(tgen, "ipv4", rtr, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in R0") for rtr in topo["routers"]: clear_ospf(tgen, rtr) step("Verify that OSPF neighbours are reset and forms new adjacencies.") # Api call verify whether OSPF is converged ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Verify that BGP neighbours are reset and forms new adjacencies.") result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) protocol = "bgp" for rtr in ["r1", "r2", "r3"]: result = verify_rib(tgen, "ipv4", rtr, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_static_route_2nh_admin_dist_p0_tc_2_ibgp(request): """ Verify static route functionality with 2 next hop & different AD value """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) NEXT_HOP_IP = populate_nh() step( "Configure IPv4 static route (10.1.1.1) in R2 with next hop N1" "(28.1.1.2 ) AD 10 and N2 (29.1.1.2) AD 20 , Static route next-hop" "present on R1 \n ex :- ip route 10.1.1.1/24 28.1.1.2 10 & " "ip route 10.1.1.1/24 29.1.1.2 20" ) reset_config_on_routers(tgen) NEXT_HOP_IP = populate_nh() for addr_type in ADDR_TYPES: input_dict_4 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }, { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step( "On R2, static route installed in RIB using " "show ip route with 2 next hop , lowest AD nexthop is active " ) rte1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, } ] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, } ] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) step("Configure IBGP IPv4 peering between R2 and R3 router.") step("Explicit route is added in R3 for R2 nexthop rechability") rt3_rtes = { "r3": { "static_routes": [ { "network": NEXT_HOP_IP["nh1"][addr_type] + "/32", "next_hop": topo["routers"]["r2"]["links"]["r3"][addr_type], }, { "network": NEXT_HOP_IP["nh2"][addr_type] + "/32", "next_hop": topo["routers"]["r2"]["links"]["r3"][addr_type], }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rt3_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Configure redistribute static in BGP on R2 router") input_dict_2 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "static"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Remove the static route configured with nexthop N1 from running config") rt1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, "delete": True, } ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rt1_nh1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step( "On R2, after removing the static route with N1 , " "route become active with nexthop N2 and vice versa." ) rte1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, } ] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, } ] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) step("Configure the static route with nexthop N1") rte1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, } ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte1_nh1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Remove the static route configured with nexthop N2 from running config") rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, "delete": True, } ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte2_nh2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step( "On R2, after removing the static route with N2 , " "route become active with nexthop N1 and vice versa." ) nh = NEXT_HOP_IP["nh2"][addr_type] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol ) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("Configure the static route with nexthop N2") rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, } ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte2_nh2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Shut nexthop interface N1") intf = topo["routers"]["r2"]["links"]["r1-link0"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step("after shut of nexthop N1 , route become active with nexthop N2") nh = NEXT_HOP_IP["nh1"][addr_type] result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh2"][addr_type]] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("No shut the nexthop interface N1") shutdown_bringup_interface(tgen, dut, intf, True) step( "after shut of nexthop N1 , route become active " "with nexthop N2 and vice versa." ) nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("Shut nexthop interface N2") intf = topo["routers"]["r2"]["links"]["r1-link1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step( " after shut of nexthop N1 , route become active with " "nexthop N2 and vice versa." ) nh = NEXT_HOP_IP["nh2"][addr_type] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol ) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("No shut nexthop interface N2") shutdown_bringup_interface(tgen, dut, intf, True) step( "after shut of nexthop N1 , route become active " "with nexthop N2 and vice versa." ) rte1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, } ] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, } ] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r2" step("Reload the FRR router") # stop/start -> restart FRR router and verify stop_router(tgen, "r2") start_router(tgen, "r2") step( "After reload of FRR router , static route installed" " in RIB and FIB properly ." ) rte1_nh1 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, } ] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True ) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_bgp_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, } ] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_bgp_rib(tgen, addr_type, dut, rte2_nh2, next_hop=nh) assert result is True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) write_test_footer(tc_name)
def test_ospf_type5_summary_tc44_p0(request): """OSPF summarisation with type7 LSAs""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) step("Bring up the base config as per the topology") step("Configure area 1 as NSSA Area") reset_config_on_routers(tgen) dut = "r0" protocol = "ospf" red_static(dut) input_dict_static_rtes = { "r0": { "static_routes": [ {"network": NETWORK["ipv4"], "next_hop": "blackhole"}, {"network": NETWORK2["ipv4"], "next_hop": "blackhole"}, ] } } result = create_static_routes(tgen, input_dict_static_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that routes are learnt on R1.") dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict_static_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict_static_rtes, protocol=protocol) assert ( result is True ), "Testcase {} : Failed" "Error: Routes is missing in RIB".format(tc_name) step( "Configure External Route summary in R0 to summarise 5" " routes to one route." ) ospf_summ_r0 = { "r0": { "ospf": { "summary-address": [ {"prefix": SUMMARY["ipv4"][0].split("/")[0], "mask": "8"} ] } } } result = create_router_ospf(tgen, topo, ospf_summ_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Verify that external routes are summarised to configured summary " "address on R0 after 5 secs of delay timer expiry and only one " "route is sent to R1." ) step( "Configure summary & redistribute static/connected route with " "metric type 2" ) input_dict_summary = {"r0": {"static_routes": [{"network": SUMMARY["ipv4"][3]}]}} dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict_summary) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict_summary, protocol=protocol) assert ( result is True ), "Testcase {} : Failed" "Error: Routes is missing in RIB".format(tc_name) step("Verify that show ip ospf summary should show the summaries.") input_dict = { SUMMARY["ipv4"][3]: { "Summary address": SUMMARY["ipv4"][3], "Metric-type": "E2", "Metric": 20, "Tag": 0, "External route count": 5, } } dut = "r0" result = verify_ospf_summary(tgen, topo, dut, input_dict) assert ( result is True ), "Testcase {} : Failed" "Error: Summary missing in OSPF DB".format(tc_name) step("Learn type 7 lsa from neighbours") dut = "r1" protocol = "ospf" red_static(dut) input_dict_static_rtes = { "r1": { "static_routes": [{"network": NETWORK3["ipv4"], "next_hop": "blackhole"}] } } result = create_static_routes(tgen, input_dict_static_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that routes are learnt on R0.") dut = "r0" result = verify_ospf_rib(tgen, dut, input_dict_static_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict_static_rtes, protocol=protocol) assert ( result is True ), "Testcase {} : Failed" "Error: Routes is missing in RIB".format(tc_name) ospf_summ_r0 = { "r0": { "ospf": { "summary-address": [ {"prefix": SUMMARY["ipv4"][2].split("/")[0], "mask": "8"} ] } } } result = create_router_ospf(tgen, topo, ospf_summ_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that type7 LSAs received from neighbor are not summarised.") input_dict = { "13.0.0.0/8": { "Summary address": "13.0.0.0/8", "Metric-type": "E2", "Metric": 20, "Tag": 0, "External route count": 0, } } dut = "r0" result = verify_ospf_summary(tgen, topo, dut, input_dict) assert ( result is True ), "Testcase {} : Failed" "Error: Summary missing in OSPF DB".format(tc_name) step("Verify that already originated summary is intact.") input_dict = { SUMMARY["ipv4"][3]: { "Summary address": SUMMARY["ipv4"][3], "Metric-type": "E2", "Metric": 20, "Tag": 0, "External route count": 5, } } dut = "r0" result = verify_ospf_summary(tgen, topo, dut, input_dict) assert ( result is True ), "Testcase {} : Failed" "Error: Summary missing in OSPF DB".format(tc_name) dut = "r1" aggr_timer = {"r1": {"ospf": {"aggr_timer": 6}}} result = create_router_ospf(tgen, topo, aggr_timer) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) ospf_summ_r0 = { "r0": { "ospf": { "summary-address": [ {"prefix": SUMMARY["ipv4"][2].split("/")[0], "mask": "8"} ] } } } result = create_router_ospf(tgen, topo, ospf_summ_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "wait for 6+1 seconds as ospf aggregation start after 6 secs as " "per the above aggr_timer command" ) sleep(7) dut = "r1" aggr_timer = {"r1": {"ospf": {"del_aggr_timer": 6}}} result = create_router_ospf(tgen, topo, aggr_timer) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_static_routes_rmap_pfxlist_p0_tc7_ibgp(request): """ Verify static route are blocked from route-map & prefix-list applied in BGP nbrs """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) step("Configure holddown timer = 1 keep alive = 3 in all the neighbors") step("verify bgp convergence before starting test case") bgp_convergence = verify_bgp_convergence(tgen, topo) assert bgp_convergence is True, "Testcase {} : Failed \n Error: {}".format( tc_name, bgp_convergence ) step( "Configure 4 IPv4 and 4 IPv6 nbrs with password with mismatch " " authentication between FRR routers " ) for addr_type in ADDR_TYPES: # Api call to modfiy BGP timerse input_dict = { "r2": { "bgp": { "local_as": "200", "address_family": { addr_type: { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link0": {"password": "******"}, "r2-link1": {"password": "******"}, "r2-link2": {"password": "******"}, "r2-link3": {"password": "******"}, } }, "r3": { "dest_link": { "r2-link0": {"password": "******"}, "r2-link1": {"password": "******"}, "r2-link2": {"password": "******"}, "r2-link3": {"password": "******"}, } }, } } } }, } } } result = create_router_bgp(tgen, topo, deepcopy(input_dict)) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result ) clear_bgp(tgen, addr_type, "r2") step(" All BGP nbrs are down as authentication is mismatch on both" " the sides") bgp_convergence = verify_bgp_convergence(tgen, topo, expected=False) assert bgp_convergence is not True, "Testcase {} : " "Failed \n BGP nbrs must be down. Error: {}".format(tc_name, bgp_convergence) step( "Configure 4 IPv4 and 4 IPv6 nbrs with macthing password " " authentication between FRR routers " ) for addr_type in ADDR_TYPES: input_dict = { "r2": { "bgp": { "local_as": "200", "address_family": { addr_type: { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link0": {"password": "******"}, "r2-link1": {"password": "******"}, "r2-link2": {"password": "******"}, "r2-link3": {"password": "******"}, } }, "r3": { "dest_link": { "r2-link0": {"password": "******"}, "r2-link1": {"password": "******"}, "r2-link2": {"password": "******"}, "r2-link3": {"password": "******"}, } }, } } } }, } } } result = create_router_bgp(tgen, topo, deepcopy(input_dict)) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result ) step("All BGP nbrs are up as authentication is matched now") bgp_convergence = verify_bgp_convergence(tgen, topo) assert bgp_convergence is True, "Testcase {} : Failed \n " "Error: {}".format( tc_name, bgp_convergence ) step("Create prefix list P1 to permit VM3 & deny VM1 v4 & v6 routes") step("Create prefix list P2 to permit VM6 IPv4 and IPv6 routes") for addr_type in ADDR_TYPES: input_dict_2 = { "r2": { "prefix_lists": { addr_type: { "pf_list_1_{}".format(addr_type): [ { "seqid": 10, "network": topo["routers"]["r2"]["links"]["vm3"][ addr_type ], "action": "permit", }, { "seqid": 20, "network": topo["routers"]["r2"]["links"]["vm1"][ addr_type ], "action": "deny", }, ], "pf_list_2_{}".format(addr_type): [ { "seqid": 10, "network": topo["routers"]["r2"]["links"]["vm6"][ addr_type ], "action": "permit", } ], } } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step( "Prefix list created with matching networks deny or permit " "show ip prefix list" ) result = verify_prefix_lists(tgen, input_dict_2) assert result is not True, "Testcase {} : Failed \n" " Error: {}".format(tc_name, result) step("Redistribute all the routes (connected, static)") input_dict_2_r1 = { "r1": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "static"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) input_dict_2_r2 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "static"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2_r2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) input_dict_2_r3 = { "r3": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "static"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2_r3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("configure redistribute connected in Router BGP") input_dict_2_r1 = { "r1": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "connected"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) input_dict_2_r3 = { "r3": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "connected"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2_r3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) input_dict_2 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": {"redistribute": [{"redist_type": "connected"}]} } } } } } result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Apply prefix list P1 on BGP neighbors 1 2 3 4 connected from " "frr r1") # Configure prefix list to bgp neighbor input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link0": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", } ] }, "r2-link1": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", } ] }, "r2-link2": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", } ] }, "r2-link3": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Apply prefix list P2 on BGP nbrs 5 & 6 connected from FRR-2") # Configure prefix list to bgp neighbor input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r3": { "dest_link": { "r2-link0": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", } ] }, "r2-link1": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", } ] }, "r2-link2": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", } ] }, "r2-link3": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) clear_bgp_and_verify(tgen, topo, "r2") step( "VM1 IPv4 and IPv6 Route which is denied using prefix list is " "not present on FRR1 side routing table , also not able to " "ping the routes show ip route" ) dut = "r1" protocol = "bgp" ntwk_r2_vm1 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r2"]["links"]["vm1"][addr_type]) ).network ) input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}} result4 = verify_rib( tgen, addr_type, dut, input_dict, protocol=protocol, expected=False ) assert result4 is not True, "Testcase {} : Failed , VM1 route is " "not filtered out via prefix list. \n Error: {}".format(tc_name, result4) step( "VM4 and VM6 IPV4 and IPv6 address are present in local and " "FRR2 routing table show ip bgp show ip route" ) dut = "r2" ntwk_r2_vm6 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r2"]["links"]["vm6"][addr_type]) ).network ) input_dict = {"r3": {"static_routes": [{"network": ntwk_r2_vm6}]}} result4 = verify_rib(tgen, addr_type, dut, input_dict) assert result4 is True, "Testcase {} : Failed.\n Error: {}".format( tc_name, result4 ) step("Remove prefix list from all the neighbors") input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link0": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link1": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link2": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link3": { "prefix_lists": [ { "name": "pf_list_1_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r3": { "dest_link": { "r2-link0": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link1": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link2": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, "r2-link3": { "prefix_lists": [ { "name": "pf_list_2_{}".format( addr_type ), "direction": "out", "delete": True, } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) clear_bgp_and_verify(tgen, topo, "r2") step("Create RouteMap_1 with prefix list P1 and weight 50") # Create route map rmap_dict = { "r2": { "route_maps": { "rmap_pf_list_1_{}".format(addr_type): [ { "action": "permit", "set": {"weight": 50}, "match": { addr_type: { "prefix_lists": "pf_list_1_{}".format(addr_type) } }, } ] } } } result = create_route_maps(tgen, rmap_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Create RouteMap_2 with prefix list P2 and weight 50") # Create route map rmap_dict = { "r2": { "route_maps": { "rmap_pf_list_2_{}".format(addr_type): [ { "action": "permit", "set": {"weight": 50}, "match": { addr_type: { "prefix_lists": "pf_list_2_{}".format(addr_type) } }, } ] } } } result = create_route_maps(tgen, rmap_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Verify Route-map created verify using show route-map") # verify rmap_pf_list_1 and rmap_pf_list_2 are present in router r2 input_dict = { "r2": { "route_maps": [ "rmap_pf_list_1_{}".format(addr_type), "rmap_pf_list_2_{}".format(addr_type), ] } } result = verify_route_maps(tgen, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Apply policy RouteMap_1 nbrs 1 2 3 4 to FRR 1") # Configure prefix list to bgp neighbor input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link0": { "route_maps": [ { "name": "rmap_pf_list_1_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link1": { "route_maps": [ { "name": "rmap_pf_list_1_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link2": { "route_maps": [ { "name": "rmap_pf_list_1_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link3": { "route_maps": [ { "name": "rmap_pf_list_1_" "{}".format(addr_type), "direction": "out", } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Apply policy RouteMap_2 nbrs 5 and 6 to FRR2") # Configure prefix list to bgp neighbor input_dict_4 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "neighbor": { "r3": { "dest_link": { "r2-link0": { "route_maps": [ { "name": "rmap_pf_list_2_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link1": { "route_maps": [ { "name": "rmap_pf_list_2_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link2": { "route_maps": [ { "name": "rmap_pf_list_2_" "{}".format(addr_type), "direction": "out", } ] }, "r2-link3": { "route_maps": [ { "name": "rmap_pf_list_2_" "{}".format(addr_type), "direction": "out", } ] }, } } } } } } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step( "After applying to BGP neighbors verify VM1 IPv4 and IPv6 Route" " which is denied using prefix list is not present on FRR side" " routing table , also not able to ping the routes show ip route" " and VM4 and VM6 IPV4 and IPv6 address are present in local and" " FRR routing table show ip bgp show ip route" ) dut = "r1" protocol = "bgp" ntwk_r2_vm1 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r2"]["links"]["vm1"][addr_type]) ).network ) input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}} result4 = verify_rib( tgen, addr_type, dut, input_dict, protocol=protocol, expected=False ) assert ( result4 is not True ), "Testcase {} : Failed \n" "routes are still present \n Error: {}".format( tc_name, result4 ) step("vm4 should be present in FRR1") dut = "r1" ntwk_r2_vm1 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r1"]["links"]["vm4"][addr_type]) ).network ) input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}} result4 = verify_rib(tgen, addr_type, dut, input_dict) assert result4 is True, "Testcase {} : Failed , VM1 route is " "not filtered out via prefix list. \n Error: {}".format(tc_name, result4) step("vm4 should be present in FRR2") dut = "r2" ntwk_r2_vm1 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r1"]["links"]["vm4"][addr_type]) ).network ) input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}} result4 = verify_rib(tgen, addr_type, dut, input_dict) assert result4 is True, "Testcase {} : Failed , VM1 route is " "not filtered out via prefix list. \n Error: {}".format(tc_name, result4) dut = "r3" protocol = "bgp" ntwk_r2_vm6 = str( ipaddress.ip_interface( u"{}".format(topo["routers"]["r2"]["links"]["vm6"][addr_type]) ).network ) input_dict = {"r3": {"static_routes": [{"network": ntwk_r2_vm6}]}} result4 = verify_rib(tgen, addr_type, dut, input_dict, protocol=protocol) assert result4 is True, "Testcase {} : Failed.\n Error: {}".format( tc_name, result4 ) write_test_footer(tc_name)
def test_ospf_gr_helper_tc1_p0(request): """Verify by default helper support is disabled for FRR ospf""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) step("Verify that GR helper route is disabled by default to the in" "the DUT.") input_dict = { "helperSupport": "Disabled", "strictLsaCheck": "Enabled", "restartSupoort": "Planned and Unplanned Restarts", "supportedGracePeriod": 1800, } dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT does not enter helper mode upon receiving the " "grace lsa.") # send grace lsa scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) input_dict = {"activeRestarterCnt": 1} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed. DUT entered helper role " " \n Error: {}".format( tc_name, result) step("Configure graceful restart in the DUT") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that GR helper route is enabled in the DUT.") input_dict = { "helperSupport": "Enabled", "strictLsaCheck": "Enabled", "restartSupoort": "Planned and Unplanned Restarts", "supportedGracePeriod": 1800, } dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Perform GR in RR.") step("Verify that DUT does enter helper mode upon receiving" " the grace lsa.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Unconfigure the GR helper command.") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True, "delete": True, } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = {"helperSupport": "Disabled"} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure gr helper using the router id") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": ["1.1.1.1"], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT does enter helper mode upon receiving" " the grace lsa.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Un Configure gr helper using the router id") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": ["1.1.1.1"], "opaque": True, "delete": True, } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that GR helper router is disabled in the DUT for" " router id x.x.x.x") input_dict = {"enabledRouterIds": [{"routerId": "1.1.1.1"}]} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed, Helper role enabled for RR\n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_mroute_with_RP_default_route_all_nodes_p2(request): """ TC_50 Verify mroute when LHR,FHR,RP and transit routers reachable using default routes """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON kill_iperf(tgen) clear_ip_mroute(tgen) reset_config_on_routers(tgen) clear_ip_pim_interface_traffic(tgen, topo) # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) step("Remove c1-c2 connected link to simulate topo " "c1(LHR)---l1(RP)----r2---f1-----c2(FHR)") intf_c1_c2 = topo["routers"]["c1"]["links"]["c2"]["interface"] intf_c2_c1 = topo["routers"]["c2"]["links"]["c1"]["interface"] shutdown_bringup_interface(tgen, "c1", intf_c1_c2, False) shutdown_bringup_interface(tgen, "c2", intf_c2_c1, False) step("Enable the PIM on all the interfaces of FRR1, FRR2, FRR3") step("Enable IGMP of FRR1 interface and send IGMP joins " " from FRR1 node for group range (225.1.1.1-5)") intf_c1_i4 = topo["routers"]["c1"]["links"]["i4"]["interface"] input_dict = { "c1": { "igmp": { "interfaces": { intf_c1_i4: { "igmp": { "version": "2" } } } } } } result = create_igmp_config(tgen, topo, input_dict) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) input_join = {"i4": topo["routers"]["i4"]["links"]["c1"]["interface"]} for recvr, recvr_intf in input_join.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, recvr, recvr_intf, GROUP_RANGE_1, join=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendIGMPJoin(tgen, recvr, IGMP_JOIN_RANGE_1, join_interval=1) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) step("Configure static RP for (225.1.1.1-5) as R2") input_dict = { "l1": { "pim": { "rp": [{ "rp_addr": topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0], "group_addr_range": GROUP_RANGE, }] } } } result = create_pim_config(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Send traffic from C2 to all the groups ( 225.1.1.1 to 225.1.1.5)") input_src = {"i5": topo["routers"]["i5"]["links"]["c2"]["interface"]} for src, src_intf in input_src.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, src, src_intf, GROUP_RANGE_1, traffic=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendTraffic(tgen, src, IGMP_JOIN_RANGE_1, 32, 2500) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) source_i5 = topo["routers"]["i5"]["links"]["c2"]["ipv4"].split("/")[0] input_dict_starg = [{ "dut": "c1", "src_address": "*", "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] input_dict_sg = [{ "dut": "c1", "src_address": source_i5, "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] step("Verify mroutes and iff upstream") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Delete static routes RP on all the nodes") input_dict = { "c2": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.3.2", "delete": True }] }, "c1": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.2.2", "delete": True }] }, "r2": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.12.1", "delete": True }] }, "f1": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.7.2", "delete": True }] }, } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error {}".format( tc_name, result) step("Verify RP info unknown after removing static route from c2 ") dut = "c2" rp_address = topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0] SOURCE = "Static" result = verify_pim_rp_info(tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], expected=False, ) assert ( result is not True ), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format( tc_name, result) result = verify_upstream_iif( tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1, expected=False, ) assert ( result is not True ), "Testcase {} : Failed \n " "upstream is still present \n Error: {}".format( tc_name, result) step("Configure default routes on all the nodes") intf_f1_c2 = topo["routers"]["f1"]["links"]["c2"]["ipv4"].split("/")[0] intf_l1_c1 = topo["routers"]["l1"]["links"]["c1"]["ipv4"].split("/")[0] intf_l1_r2 = topo["routers"]["l1"]["links"]["r2"]["ipv4"].split("/")[0] intf_r2_f1 = topo["routers"]["r2"]["links"]["f1"]["ipv4"].split("/")[0] input_dict = { "c1": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_l1_c1 }] }, "c2": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_f1_c2 }] }, "r2": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_l1_r2 }] }, "f1": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_r2_f1 }] }, } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error {}".format( tc_name, result) step("applying ip nht config on c2") raw_config = { "c1": { "raw_config": ["ip nht resolve-via-default"] }, "c2": { "raw_config": ["ip nht resolve-via-default"] }, "r2": { "raw_config": ["ip nht resolve-via-default"] }, "f1": { "raw_config": ["ip nht resolve-via-default"] }, "l1": { "raw_config": ["ip nht resolve-via-default"] }, } result = apply_raw_config(tgen, raw_config) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Verify RP info Not unknown after removing static route from c2 ") dut = "c2" step("Verify RP info is NOT unknown after removing static route from c2 ") result = verify_pim_rp_info(tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False) assert result is not True, ( "Testcase {} : Failed \n " "RP info is unknown after removing static route from c2 \n Error: {}". format(tc_name, result)) step("Verify (s,g) populated after adding default route ") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Verify (*,g) populated after adding default route ") for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_gr_helper_tc2_p0(request): """ OSPF GR on Broadcast : Verify DUT enters Helper mode when neighbor sends grace lsa, helps RR to restart gracefully (RR = DR) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") step("Configure DR priority as 99 in RR , DUT dr priority = 98 " "& reset ospf process in all the routers") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT enters into helper mode.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_PIM_hello_tx_rx_p1(request): """ TC_54 Verify received and transmit hello stats are getting cleared after PIM nbr reset """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON kill_iperf(tgen) clear_ip_mroute(tgen) reset_config_on_routers(tgen) clear_ip_pim_interface_traffic(tgen, topo) # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) step("Remove c1-c2 connected link to simulate topo " "c1(LHR)---l1(RP)----r2---f1-----c2(FHR)") intf_c1_c2 = topo["routers"]["c1"]["links"]["c2"]["interface"] intf_c2_c1 = topo["routers"]["c2"]["links"]["c1"]["interface"] shutdown_bringup_interface(tgen, "c1", intf_c1_c2, False) shutdown_bringup_interface(tgen, "c2", intf_c2_c1, False) step("Enable the PIM on all the interfaces of FRR1, FRR2, FRR3") step("Enable IGMP of FRR1 interface and send IGMP joins " " from FRR1 node for group range (225.1.1.1-5)") intf_c1_i4 = topo["routers"]["c1"]["links"]["i4"]["interface"] input_dict = { "c1": { "igmp": { "interfaces": { intf_c1_i4: { "igmp": { "version": "2" } } } } } } result = create_igmp_config(tgen, topo, input_dict) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) input_join = {"i4": topo["routers"]["i4"]["links"]["c1"]["interface"]} for recvr, recvr_intf in input_join.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, recvr, recvr_intf, GROUP_RANGE_1, join=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendIGMPJoin(tgen, recvr, IGMP_JOIN_RANGE_1, join_interval=1) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) step("Configure static RP for (225.1.1.1-5) as R2") input_dict = { "l1": { "pim": { "rp": [{ "rp_addr": topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0], "group_addr_range": GROUP_RANGE, }] } } } result = create_pim_config(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step( "Send Mcast traffic from C2 to all the groups ( 225.1.1.1 to 225.1.1.5)" ) input_src = {"i5": topo["routers"]["i5"]["links"]["c2"]["interface"]} for src, src_intf in input_src.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, src, src_intf, GROUP_RANGE_1, traffic=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendTraffic(tgen, src, IGMP_JOIN_RANGE_1, 32, 2500) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) source_i5 = topo["routers"]["i5"]["links"]["c2"]["ipv4"].split("/")[0] input_dict_starg = [{ "dut": "c1", "src_address": "*", "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] input_dict_sg = [{ "dut": "c1", "src_address": source_i5, "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] step( "(*,G) and (S,G) created on f1 and node verify using 'show ip mroute'") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) intf_l1_c1 = topo["routers"]["l1"]["links"]["c1"]["interface"] intf_c1_l1 = topo["routers"]["c1"]["links"]["l1"]["interface"] step("verify before stats on C1") state_dict = { "c1": { intf_c1_l1: ["helloTx", "helloRx"], } } c1_state_before = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step( "Flap PIM nbr while doing interface c1-l1 interface shut from f1 side") shutdown_bringup_interface(tgen, "c1", intf_c1_l1, False) step( "After shut of local interface from c1 , verify rx/tx hello counters are cleared on c1 side" "verify using 'show ip pim interface traffic'") shutdown_bringup_interface(tgen, "c1", intf_c1_l1, True) step("verify stats after on c1") c1_state_after = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on c1") result = verify_state_incremented(c1_state_before, c1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) step("verify before stats on l1") l1_state_dict = { "l1": { intf_l1_c1: ["helloTx", "helloRx"], } } l1_state_before = verify_pim_interface_traffic(tgen, l1_state_dict) assert isinstance( l1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("Flap PIM nbr while doing interface r2-c1 shut from r2 side") shutdown_bringup_interface(tgen, "l1", intf_l1_c1, False) step( "After shut the interface from r2 side , verify r2 side rx and tx of hello" "counters are resetted show ip pim interface traffic") shutdown_bringup_interface(tgen, "l1", intf_l1_c1, True) step("verify stats after on l1") l1_state_after = verify_pim_interface_traffic(tgen, l1_state_dict) assert isinstance( l1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on l1") result = verify_state_incremented(l1_state_before, l1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) step("Reinit the dict") c1_state_before = {} l1_state_before = {} c1_state_after = {} l1_state_after = {} step("verify before stats on C1") state_dict = { "c1": { intf_c1_l1: ["helloTx", "helloRx"], } } c1_state_before = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("Flap c1-r2 pim nbr while changing ip address from c1 side") c1_l1_ip_subnet = topo["routers"]["c1"]["links"]["l1"]["ipv4"] raw_config = { "c1": { "raw_config": [ "interface {}".format(intf_c1_l1), "no ip address {}".format(c1_l1_ip_subnet), "ip address {}".format(NEW_ADDRESS_2_SUBNET), ] } } result = apply_raw_config(tgen, raw_config) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("verify stats after on c1") c1_state_after = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on c1") result = verify_state_incremented(c1_state_before, c1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) write_test_footer(tc_name)
def test_ecmp_shut_bgp_neighbor(request, test_type): """ Shut BGP neigbors one by one and verify BGP and routing table updated accordingly in DUT """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() logger.info(INTF_LIST_R2) # Verifying RIB routes dut = "r3" protocol = "bgp" reset_config_on_routers(tgen) static_or_nw(tgen, topo, tc_name, test_type, "r2") for addr_type in ADDR_TYPES: input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for intf_num in range(len(INTF_LIST_R2) + 1, 16): intf_val = INTF_LIST_R2[intf_num:intf_num + 16] input_dict_1 = {"r2": {"interface_list": [intf_val], "status": "down"}} logger.info( "Shutting down neighbor interface {} on r2".format(intf_val)) result = interface_status(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for addr_type in ADDR_TYPES: if intf_num + 16 < 32: check_hops = NEXT_HOPS[addr_type] else: check_hops = [] input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib(tgen, addr_type, dut, input_dict, next_hop=check_hops, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict_1 = {"r2": {"interface_list": INTF_LIST_R2, "status": "up"}} logger.info("Enabling all neighbor interface {} on r2") result = interface_status(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) static_or_nw(tgen, topo, tc_name, test_type, "r2") for addr_type in ADDR_TYPES: input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_lan_ecmp_tc18_p0(request): """ OSPF ECMP. Verify OSPF ECMP with max path configured as 8 (Edge having 1 uplink port as broadcast network, connect to 8 TORs - LAN case) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step(". Configure ospf in all the routers on LAN interface.") reset_config_on_routers(tgen) step("Verify that OSPF is up with 8 neighborship sessions.") ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Configure a static route in all the routes and " "redistribute static/connected in OSPF.") for rtr in topo["routers"]: input_dict = { rtr: { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0" }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) dut = rtr redistribute_ospf(tgen, topo, dut, "static") step("Verify that route in R0 in stalled with 8 hops. " "Verify ospf route table and ip route table.") nh = [] for rtr in topo["routers"]: nh.append(topo["routers"][rtr]["links"]["s1"]["ipv4"].split("/")[0]) nh.remove(topo["routers"]["r1"]["links"]["s1"]["ipv4"].split("/")[0]) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" clear ip ospf interface on DUT(r0)") clear_ospf(tgen, "r0") step("Verify that after clearing the ospf interface all the " "neighbours are up and routes are installed with 8 next hop " "in ospf and ip route tables on R0") dut = "r0" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, lan=True) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step(" clear ip ospf interface on R2") clear_ospf(tgen, "r2") dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, lan=True) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Delete static/connected cmd in ospf in all the routes one by one.") for rtr in topo["routers"]: input_dict = { rtr: { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", "delete": True, }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that all the routes are withdrawn from R0") dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, retry_timeout=10, expected=False) assert ( result is not True ), "Testcase {} : Failed \n " "r1: OSPF routes are present \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, retry_timeout=10, expected=False, ) assert ( result is not True ), "Testcase {} : Failed \n " "r1: routes are still present \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ecmp_remove_nw_advertise(request): """ Verify routes are cleared from BGP and RIB table of DUT, when advertise network configuration is removed """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Verifying RIB routes dut = "r3" protocol = "bgp" reset_config_on_routers(tgen) static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") for addr_type in ADDR_TYPES: input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict_3 = { "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "advertise_networks": [{ "network": NETWORK["ipv4"], "delete": True }] } }, "ipv6": { "unicast": { "advertise_networks": [{ "network": NETWORK["ipv6"], "delete": True }] } }, } } } } logger.info("Withdraw advertised networks") result = create_router_bgp(tgen, topo, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for addr_type in ADDR_TYPES: input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict, next_hop=[], protocol=protocol, expected=False, ) assert ( result is not True ), "Testcase {} : Failed \n Routes still" " present in RIB".format( tc_name) static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") for addr_type in ADDR_TYPES: input_dict = { "r3": { "static_routes": [{ "network": NETWORK[addr_type] }] } } logger.info("Verifying %s routes on r3", addr_type) result = verify_rib( tgen, addr_type, dut, input_dict, next_hop=NEXT_HOPS[addr_type], protocol=protocol, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_admin_distance(request): " Verifying admin distance functionality" tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Api call to create static routes input_dict = { "r2": { "static_routes": [ { "network": "200.50.2.0/32", "admin_distance": 80, "next_hop": "10.0.0.14", }, { "network": "200.50.2.0/32", "admin_distance": 60, "next_hop": "10.0.0.18", }, { "network": "200:50:2::/128", "admin_distance": 80, "next_hop": "fd00::1", }, { "network": "200:50:2::/128", "admin_distance": 60, "next_hop": "fd00::1", }, ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Api call to redistribute static routes input_dict_2 = { "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, "ipv6": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, } } } } result = create_router_bgp(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying best path dut = "r1" attribute = "admin_distance" input_dict = { "ipv4": { "r2": { "static_routes": [ { "network": "200.50.2.0/32", "admin_distance": 80, "next_hop": "10.0.0.14", }, { "network": "200.50.2.0/32", "admin_distance": 60, "next_hop": "10.0.0.18", }, ] } }, "ipv6": { "r2": { "static_routes": [ { "network": "200:50:2::/128", "admin_distance": 80, "next_hop": "fd00::1", }, { "network": "200:50:2::/128", "admin_distance": 60, "next_hop": "fd00::1", }, ] } }, } for addr_type in ADDR_TYPES: result = verify_best_path_as_per_admin_distance( tgen, addr_type, dut, input_dict[addr_type], attribute ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_static_routes(request): """ Test to create and verify static routes. """ tgen = get_topogen() if BGP_CONVERGENCE is not True: pytest.skip("skipped because of BGP Convergence failure") # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Api call to create static routes input_dict = { "r1": { "static_routes": [ { "network": "10.0.20.1/32", "no_of_ip": 9, "admin_distance": 100, "next_hop": "10.0.0.2", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) # Api call to redistribute static routes input_dict_1 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } } } } } } result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r3" protocol = "bgp" next_hop = ["10.0.0.2", "10.0.0.5"] result = verify_rib( tgen, "ipv4", dut, input_dict, next_hop=next_hop, protocol=protocol ) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_next_hop_attribute(request): """ Verifying route are not getting installed in, as next_hop is unreachable, Making next hop reachable using next_hop_self command and verifying routes are installed. """ tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Api call to advertise networks input_dict = { "r7": { "bgp": { "address_family": { "ipv4": { "unicast": { "advertise_networks": [ {"network": "200.50.2.0/32"}, {"network": "200.60.2.0/32"}, ] } }, "ipv6": { "unicast": { "advertise_networks": [ {"network": "200:50:2::/128"}, {"network": "200:60:2::/128"}, ] } }, } } } } result = create_router_bgp(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r1" protocol = "bgp" # Verification should fail as nexthop-self is not enabled for addr_type in ADDR_TYPES: result = verify_rib( tgen, addr_type, dut, input_dict, protocol=protocol, expected=False ) assert ( result is not True ), "Testcase {} : Failed \n Error: " "{} routes are not present in RIB".format( addr_type, tc_name ) # Configure next-hop-self to bgp neighbor input_dict_1 = { "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, } } }, } result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r1" protocol = "bgp" for addr_type in ADDR_TYPES: result = verify_rib(tgen, addr_type, dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_ospf_lan_tc1_p0(request): """ OSPF Hello protocol - Verify DR BDR Elections """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") reset_config_on_routers(tgen) step("Verify that DR BDR DRother are elected in the LAN.") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "DR" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that all the routers are in FULL state with DR and BDR " "in the topology") input_dict = { "r1": { "ospf": { "neighbors": { "r0": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure DR pririty 100 on R0 and clear ospf neighbors " "on all the routers.") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "priority": 100 }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1", "r2", "r3"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure DR pririty 150 on R0 and clear ospf neighbors " "on all the routers.") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "priority": 150 }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure DR priority 0 on R0 & Clear ospf nbrs on all the routers") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "priority": 0 }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DRother") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "DR" }, "r2": { "state": "2-Way", "role": "DROther" }, "r3": { "state": "2-Way", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure DR priority to default on R0 and Clear ospf neighbors" " on all the routers") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": { "priority": 100 }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["s1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) result = verify_ospf_neighbor(tgen, topo, dut, lan=True, expected=False) assert ( result is not True ), "Testcase {} : Failed \n " "r0: OSPF neighbors-hip is up \n Error: {}".format( tc_name, result) step("No Shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["s1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "DR" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } step("Verify that after no shut ospf neighbours are full on R0.") result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Clear ospf on DR router in the topology.") clear_ospf(tgen, "r0") step("Verify that BDR is getting promoted to DR after clear.") step("Verify that all the nbrs are in FULL state with the elected DR.") result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Change the ip on LAN intf on R0 to other ip from the same subnet.") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3) + "/{}".format( intf_ip.split("/")[1]) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step("Verify that OSPF is in FULL state with other routers with " "newly configured IP.") result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Change the ospf router id on the R0 and clear ip ospf interface.") change_rid = {"r0": {"ospf": {"router_id": "100.1.1.100"}}} result = create_router_ospf(tgen, topo, change_rid) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) topo["routers"]["r0"]["ospf"]["router_id"] = "100.1.1.100" step("Reload the FRR router") stop_router(tgen, "r0") start_router(tgen, "r0") step("Verify that OSPF is in FULL state with other routers with" " newly configured router id.") input_dict = { "r1": { "ospf": { "neighbors": { "r0": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Reconfigure the original router id and clear ip ospf interface.") change_rid = {"r0": {"ospf": {"router_id": "100.1.1.0"}}} result = create_router_ospf(tgen, topo, change_rid) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) topo["routers"]["r0"]["ospf"]["router_id"] = "100.1.1.0" step("Reload the FRR router") # stop/start -> restart FRR router and verify stop_router(tgen, "r0") start_router(tgen, "r0") step("Verify that OSPF is enabled with router id previously configured.") input_dict = { "r1": { "ospf": { "neighbors": { "r0": { "state": "Full", "role": "Backup" }, "r2": { "state": "Full", "role": "DROther" }, "r3": { "state": "Full", "role": "DROther" }, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_weight_attribute(request): """ Test configure/modify weight attribute and verify best path is installed as per highest weight """ tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Api call to advertise networks input_dict = { "r7": { "bgp": { "address_family": { "ipv4": { "unicast": { "advertise_networks": [ {"network": "200.50.2.0/32"}, {"network": "200.60.2.0/32"}, ] } }, "ipv6": { "unicast": { "advertise_networks": [ {"network": "200:50:2::/128"}, {"network": "200:60:2::/128"}, ] } }, } } }, "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, } } }, } result = create_router_bgp(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Create Prefix list input_dict_2 = { "r1": { "prefix_lists": { "ipv4": { "pf_ls_1_ipv4": [ { "seqid": 10, "network": "200.0.0.0/8", "le": "32", "action": "permit", } ] }, "ipv6": { "pf_ls_1_ipv6": [ { "seqid": 10, "network": "200::/8", "le": "128", "action": "permit", } ] }, } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Create route map input_dict_3 = { "r1": { "route_maps": { "RMAP_WEIGHT": [ { "action": "permit", "seq_id": "5", "match": {"ipv4": {"prefix_lists": "pf_ls_1_ipv4"}}, "set": {"weight": 500}, }, { "action": "permit", "seq_id": "10", "match": {"ipv6": {"prefix_lists": "pf_ls_1_ipv6"}}, "set": {"weight": 500}, }, ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Configure neighbor for route map input_dict_4 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": { "route_maps": [ { "name": "RMAP_WEIGHT", "direction": "in", } ] } } } } } }, "ipv6": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": { "route_maps": [ { "name": "RMAP_WEIGHT", "direction": "in", } ] } } } } } }, } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying best path dut = "r1" attribute = "weight" for addr_type in ADDR_TYPES: result = verify_best_path_as_per_bgp_attribute( tgen, addr_type, dut, {"r7": input_dict["r7"]}, attribute ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Modify route map input_dict_3 = { "r1": { "route_maps": { "RMAP_WEIGHT": [ { "action": "permit", "seq_id": "5", "match": {"ipv4": {"prefix_lists": "pf_ls_1_ipv4"}}, "set": {"weight": 1000}, }, { "action": "permit", "seq_id": "10", "match": {"ipv6": {"prefix_lists": "pf_ls_1_ipv6"}}, "set": {"weight": 1000}, }, ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying best path dut = "r1" attribute = "weight" for addr_type in ADDR_TYPES: result = verify_best_path_as_per_bgp_attribute( tgen, addr_type, dut, {"r7": input_dict["r7"]}, attribute ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_ospf_ecmp_tc16_p0(request): """ Verify OSPF ECMP. Verify OSPF ECMP with max path configured as 8 (ECMP configured at FRR level) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step("Configure 8 interfaces between R1 and R2 and enable ospf in area 0.") reset_config_on_routers(tgen) step("Verify that OSPF is up with 8 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) step("Configure a static route in R0 and redistribute in OSPF.") input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) dut = "r0" red_static(dut) step("Verify that route in R2 in stalled with 8 next hops.") nh = [] for item in range(1, 7): nh.append( topo["routers"]["r0"]["links"]["r1-link1"]["ipv4"].split("/")[0]) nh2 = topo["routers"]["r0"]["links"]["r1"]["ipv4"].split("/")[0] nh.append(nh2) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("shut no shut all the interfaces on the remote router - R2") dut = "r1" for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format( intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format( intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("shut no shut on all the interfaces on DUT (r1)") for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format( intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format( intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) step("Verify that all the neighbours are up and routes are installed" " with 8 next hop in ospf and ip route tables on R1.") step("Verify that OSPF is up with 8 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" Un configure static route on R0") dut = "r0" red_static(dut, config=False) # Wait for R0 to flush external LSAs. sleep(10) step("Verify that route is withdrawn from R2.") dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, attempts=5, expected=False, ) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Re configure the static route in R0.") dut = "r0" red_static(dut) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_origin_attribute(request): """ Test origin attribute and verify best path is installed as per IGP>EGP>INCOMPLETE rule """ tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Api call to advertise networks input_dict = { "r4": { "bgp": { "address_family": { "ipv4": { "unicast": { "advertise_networks": [ {"network": "200.50.2.0/32"}, {"network": "200.60.2.0/32"}, ] } }, "ipv6": { "unicast": { "advertise_networks": [ {"network": "200:50:2::/128"}, {"network": "200:60:2::/128"}, ] } }, } } }, "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"next_hop_self": True}}} } } }, } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r3": {"next_hop_self": True}}} } } }, } } }, "r5": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, "ipv6": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, } } }, } result = create_router_bgp(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Api call to create static routes input_dict_3 = { "r5": { "static_routes": [ {"network": "200.50.2.0/32", "next_hop": "Null0"}, {"network": "200.60.2.0/32", "next_hop": "Null0"}, {"network": "200:50:2::/128", "next_hop": "Null0"}, {"network": "200:60:2::/128", "next_hop": "Null0"}, ] } } result = create_static_routes(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying best path dut = "r1" attribute = "origin" for addr_type in ADDR_TYPES: result = verify_best_path_as_per_bgp_attribute( tgen, addr_type, dut, {"r4": input_dict["r4"]}, attribute ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_modify_ecmp_max_paths(request, ecmp_num, test_type): """ Verify routes installed as per maximum-paths configuration (8/16/32). """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() reset_config_on_routers(tgen) static_or_nw(tgen, topo, tc_name, test_type, "r2") input_dict = { "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "maximum_paths": { "ibgp": ecmp_num, } } }, "ipv6": { "unicast": { "maximum_paths": { "ibgp": ecmp_num, } } }, } } } } logger.info("Configuring bgp maximum-paths %s on router r3", ecmp_num) result = create_router_bgp(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r3" protocol = "bgp" for addr_type in ADDR_TYPES: input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}} logger.info("Verifying %s routes on r3", addr_type) # Test only the count of nexthops, not the specific nexthop addresses - # they're not deterministic # result = verify_rib( tgen, addr_type, dut, input_dict_1, next_hop=NEXT_HOPS[addr_type][: int(ecmp_num)], protocol=protocol, count_only=True, ) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_large_community_match_all(request): """ Verify community and large-community list operations in route-map with all clause (exact, all, any, regex) works. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) config_router_r1(tgen, topo, tc_name) config_router_r2(tgen, topo, tc_name) config_router_additive(tgen, topo, tc_name) input_dict_1 = { "r4": { "bgp_community_lists": [ { "community_type": "standard", "action": "permit", "name": "ANY", "value": "1:1:1", "large": True, }, { "community_type": "standard", "action": "permit", "name": "ALL", "value": "1:1:1 1:2:1 1:3:1 1:4:1 1:5:1 2:1:1 2:2:1", "large": True, }, { "community_type": "expanded", "action": "permit", "name": "EXP_ALL", "value": "1:1:1 1:2:1 1:3:1 1:4:1 1:5:1 2:[1-5]:1", "large": True, }, ] } } step("Create bgp community lists for ANY, EXACT and EXP_ALL match") result = create_bgp_community_lists(tgen, input_dict_1) assert result is True, "Test case {} : Failed \n Error: {}".format(tc_name, result) input_dict_2 = { "r4": { "route_maps": { "LC4": [ { "action": "permit", "seq_id": "10", "match": {"large-community-list": {"id": "ANY"}}, }, { "action": "permit", "seq_id": "20", "match": {"large-community-list": {"id": "EXACT"}}, }, { "action": "permit", "seq_id": "30", "match": {"large-community-list": {"id": "EXP_ALL"}}, }, ] } } } step("Applying bgp community lits on LC4 route-map") result = create_route_maps(tgen, input_dict_2) assert result is True, "Test case {} : Failed \n Error: {}".format(tc_name, result) input_dict_3 = { "r4": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r5": { "dest_link": { "r4-link1": { "route_maps": [ {"name": "LC4", "direction": "in"} ] } } } } } }, "ipv6": { "unicast": { "neighbor": { "r5": { "dest_link": { "r4-link1": { "route_maps": [ {"name": "LC4", "direction": "in"} ] } } } } } }, } } } } step("Apply route-mpa LC4 on r4 for r2 neighbor, direction 'in'") result = create_router_bgp(tgen, topo, input_dict_3) assert result is True, "Test case {} : Failed \n Error: {}".format(tc_name, result) input_dict_4 = { "largeCommunity": "1:1:1 1:2:1 1:3:1 1:4:1 1:5:1 2:1:1 2:2:1 2:3:1 " "2:4:1 2:5:1" } for adt in ADDR_TYPES: result = verify_bgp_community(tgen, adt, "r4", [NETWORK[adt][0]], input_dict_4) assert result is True, "Test case {} : Should fail \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)