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_routemaps_functionality_tc24_p0(request): """ OSPF Route map - Multiple set clauses. Verify OSPF route map support functionality when we add/remove route-maps with multiple match clauses and without any set statement.(Match only) """ 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": 1, "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", "route_map": "rmap_ipv4" }] } } } result = create_router_ospf(tgen, topo, ospf_red_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Create ip prefix list pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [{ "seqid": 10, "network": "any", "action": "permit" }] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("verify that prefix-list is created in R0.") result = verify_prefix_lists(tgen, pfx_list) assert result is not True, ("Testcase {} : Failed \n Prefix list not " "present. Error: {}".format(tc_name, result)) # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that metric falls back to original metric for ospf routes.") dut = "r1" protocol = "ospf" 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) 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"][1], "no_of_ip": 1, "next_hop": "Null0", "tag": 1000, }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Create ip prefix list pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [{ "seqid": 10, "network": "any", "action": "permit" }] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("verify that prefix-list is created in R0.") result = verify_prefix_lists(tgen, pfx_list) assert result is not True, ("Testcase {} : Failed \n Prefix list not " "present. Error: {}".format(tc_name, result)) # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "tag": "1000" } } }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that metric falls back to original metric for ospf routes.") dut = "r1" protocol = "ospf" 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) step("Delete the match clause with tag in route map") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "tag": "1000", "delete": True } }, }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that metric falls back to original metric for ospf routes.") dut = "r1" protocol = "ospf" 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) step("Delete the match clause with metric in route map.") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) 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_show_p1(request): """Verify ospf show commands with json output.""" 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) ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence) dut = "r1" input_dict = { "r1": { "links": { "r0": { "ospf": { "ifUp": True, "ifFlags": "<UP,BROADCAST,RUNNING,MULTICAST>", "ospfEnabled": True, "ipAddressPrefixlen": 24, "ospfIfType": "Broadcast", "area": "0.0.0.0", "networkType": "BROADCAST", "cost": 10, "transmitDelaySecs": 1, "state": "DR", "priority": 1, "mcastMemberOspfAllRouters": True, "timerMsecs": 1000, "timerDeadSecs": 4, "timerWaitSecs": 4, "timerRetransmitSecs": 5, "nbrCount": 1, "nbrAdjacentCount": 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) # show ip ospf route 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) 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_routemaps_functionality_tc20_p0(request): """ OSPF route map support functionality. Verify OSPF route map support functionality when route map is not configured at system level but configured in OSPF """ 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 and 10.0.20.2/32) in R0") # 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) step("Redistribute to ospf using route map ( non existent route map)") ospf_red_r1 = { "r0": { "ospf": { "redistribute": [{ "redist_type": "static", "route_map": "rmap_ipv4" }] } } } result = create_router_ospf(tgen, topo, ospf_red_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that routes are not allowed in OSPF even tough no " "matching routing map is configured.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, attempts=2, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, attempts=2, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("configure the route map with the same name that is used " "in the ospf with deny rule.") # Create route map routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"action": "deny"}]}}} result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("verify that now route map is activated & routes are denied in OSPF.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) # Create route map routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"action": "deny"}]}}} result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("verify that now route map is activated & routes are denied in OSPF.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) step("Delete the route map.") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "deny", "delete": True }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that routes are allowed in OSPF even tough " "no matching routing map is configured.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) 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_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_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_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_routemaps_functionality_tc21_p0(request): """ OSPF route map support functionality. Verify OSPF route map support functionality with set/match clauses /call/continue/goto in a route-map to see if it takes immediate effect. """ 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) redistribute_ospf(tgen, topo, "r0", "static", route_map="rmap_ipv4") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "seq_id": 10 }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that route is advertised to R2.") dut = "r1" protocol = "ospf" 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) # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "delete": True, "seq_id": 10 }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" Configure route map with set clause (set metric)") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "set": { "med": 123 }, "seq_id": 10 }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that configured metric is applied to ospf routes.") dut = "r1" 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("Configure route map with match clause (match metric) with " "some actions(change metric).") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "med": 123 }, "set": { "med": 150 }, "seq_id": 10, }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure route map with call clause") # Create ip prefix list input_dict_2 = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [{ "seqid": 10, "network": "any", "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 = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 150 }, "call": "rmap_match_pf_2_ipv4", "seq_id": 10, }], "rmap_match_pf_2_ipv4": [{ "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 200 }, "seq_id": 10, }], } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) 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) # Create route map routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"delete": True}]}}} result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure route map with continue clause") # Create route map input_dict_3 = { "r0": { "route_maps": { "rmap_ipv4": [ { "action": "permit", "seq_id": "10", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 150 }, "continue": "30", "seq_id": 10, }, { "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 100 }, "seq_id": 20, }, { "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 50 }, "seq_id": 30, }, ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) 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) step("Configure route map with goto clause") # Create route map input_dict_3 = { "r0": { "route_maps": { "rmap_ipv4": [ { "action": "permit", "seq_id": "10", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "goto": "30", }, { "action": "permit", "seq_id": "20", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 100 }, }, { "action": "permit", "seq_id": "30", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, "set": { "med": 200 }, }, ] } } } result = create_route_maps(tgen, input_dict_3) 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_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_ospf_routemaps_functionality_tc19_p0(request): """ OSPF Route map - Verify OSPF route map support functionality. """ 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 and 10.0.20.2/32) in R0") # 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) redistribute_ospf(tgen, topo, "r0", "static") dut = "r1" lsid = NETWORK["ipv4"][0].split("/")[0] rid = routerids[0] protocol = "ospf" 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) redistribute_ospf(tgen, topo, "r0", "static", delete=True) step("Create prefix-list in R0 to permit 10.0.20.1/32 prefix &" " deny 10.0.20.2/32") # Create ip prefix list pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ { "seqid": 10, "network": NETWORK["ipv4"][0], "action": "permit", }, { "seqid": 11, "network": "any", "action": "deny" }, ] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "permit", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure route map rmap1 and redistribute static routes to" " ospf using route map rmap1") redistribute_ospf(tgen, topo, "r0", "static", route_map="rmap_ipv4") step("Change prefix rules to permit 10.0.20.2 and deny 10.0.20.1") # Create ip prefix list pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ { "seqid": 10, "network": NETWORK["ipv4"][1], "action": "permit", }, { "seqid": 11, "network": "any", "action": "deny" }, ] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that route 10.0.20.2 is allowed and 10.0.20.1 is denied.") dut = "r1" input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][1], "no_of_ip": 1, "next_hop": "Null0" }] } } 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) input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 1, "next_hop": "Null0" }] } } 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 present in fib \n Error: {}".format(tc_name, result)) step("Delete and reconfigure prefix list.") # Create ip prefix list pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ { "seqid": 10, "network": NETWORK["ipv4"][1], "action": "permit", "delete": True, }, { "seqid": 11, "network": "any", "action": "deny", "delete": True, }, ] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) result = verify_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0" }] } } 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: OSPF routes are present \n Error: {}".format(tc_name, result)) pfx_list = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ { "seqid": 10, "network": NETWORK["ipv4"][1], "action": "permit", }, { "seqid": 11, "network": "any", "action": "deny" }, ] } } } } result = create_prefix_lists(tgen, pfx_list) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that route 10.0.20.2 is allowed and 10.0.20.1 is denied.") dut = "r1" input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][1], "no_of_ip": 1, "next_hop": "Null0" }] } } 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) input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 1, "next_hop": "Null0" }] } } 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)) write_test_footer(tc_name)
def test_ospf_chaos_tc32_p1(request): """Verify ospf functionality after restart FRR service. """ 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("Restart frr on R0") stop_router(tgen, 'r0') start_router(tgen, 'r0') step("Verify OSPF neighbors are up after restarting 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("Restart frr on R1") stop_router(tgen, 'r1') start_router(tgen, 'r1') step("Verify OSPF neighbors are up after restarting 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_ospf_rfc2328_appendinxE_p0(request): """ Test OSPF appendinx E RFC2328. """ 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("Verify that OSPF neighbours are Full.") # 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 ) redistribute_ospf(tgen, topo, "r0", "static") step("Configure static route with prefix 24, 16, 8 to check ") input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][0], "no_of_ip": 1, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][1], "no_of_ip": 1, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][2], "no_of_ip": 1, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that ospf originates routes with mask 24, 16, 8") ip_net = NETWORK_APP_E["ipv4"][0] input_dict = {"r1": {"static_routes": [{"network": ip_net, "no_of_ip": 1}]}} 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) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) ip_net = NETWORK_APP_E["ipv4"][1] input_dict = {"r1": {"static_routes": [{"network": ip_net, "no_of_ip": 1}]}} 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) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) ip_net = NETWORK_APP_E["ipv4"][2] input_dict = {"r1": {"static_routes": [{"network": ip_net, "no_of_ip": 1}]}} 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) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Delete static route with prefix 24, 16, 8 to check ") input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][0], "no_of_ip": 1, "next_hop": "Null0", "delete": True, } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][1], "no_of_ip": 1, "next_hop": "Null0", "delete": True, } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": { "static_routes": [ { "network": NETWORK_APP_E["ipv4"][2], "no_of_ip": 1, "next_hop": "Null0", "delete": True, } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_routemaps_functionality_tc22_p0(request): """ OSPF Route map - Multiple sequence numbers. Verify OSPF route map support functionality with multiple sequence numbers in a single route-map for different match/set clauses. """ 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("Configure route map with seq number 10 to with ip prefix" " permitting route 10.0.20.1/32 in R1") step("Configure route map with seq number 20 to with ip prefix" " permitting route 10.0.20.2/32 in R1") # Create route map input_dict_3 = { "r0": { "route_maps": { "rmap_ipv4": [ { "action": "permit", "seq_id": "10", "match": { "ipv4": { "prefix_lists": "pf_list_1_ipv4" } }, }, { "action": "permit", "seq_id": "20", "match": { "ipv4": { "prefix_lists": "pf_list_2_ipv4" } }, }, ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Create ip prefix list input_dict_2 = { "r0": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [{ "seqid": 10, "network": NETWORK["ipv4"][0], "action": "permit" }] } } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # Create ip prefix list input_dict_2 = { "r0": { "prefix_lists": { "ipv4": { "pf_list_2_ipv4": [{ "seqid": 10, "network": NETWORK["ipv4"][1], "action": "permit" }] } } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure static routes 10.0.20.1/32 and 10.0.20.2 in R1") # 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) step("Configure redistribute static route with route map.") ospf_red_r0 = { "r0": { "ospf": { "redistribute": [{ "redist_type": "static", "route_map": "rmap_ipv4" }] } } } result = create_router_ospf(tgen, topo, ospf_red_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][0], "no_of_ip": 2, "next_hop": "Null0", }] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that both routes are learned in R1 and R2") dut = "r1" protocol = "ospf" 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) dut = "r2" protocol = "ospf" 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) step("Change route map with seq number 20 to deny.") # Create route map input_dict_3 = { "r0": { "route_maps": { "rmap_ipv4": [{ "action": "deny", "seq_id": "20", "match": { "ipv4": { "prefix_lists": "pf_list_2_ipv4" } }, }] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify the route 10.0.20.2/32 is withdrawn and not present " "in the routing table of R0 and R1.") input_dict = { "r0": { "static_routes": [{ "network": NETWORK["ipv4"][1], "next_hop": "Null0" }] } } dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) dut = "r2" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_routemaps_functionality_tc25_p0(request): """ OSPF route map support functionality. Verify OSPF route map support functionality when route map actions are toggled. """ 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", "route_map": "rmap_ipv4" }] } } } result = create_router_ospf(tgen, topo, ospf_red_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure route map with permit rule") # Create route map routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"action": "permit"}]}}} result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that route is advertised to R1.") dut = "r1" protocol = "ospf" 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) step("Configure route map with deny rule") # Create route map routemaps = { "r0": { "route_maps": { "rmap_ipv4": [{ "seq_id": 10, "action": "deny" }] } } } result = create_route_maps(tgen, routemaps) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) # 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 not advertised to R1.") dut = "r1" protocol = "ospf" result = verify_ospf_rib(tgen, dut, input_dict, expected=False) assert result is not True, "Testcase {} : Failed \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 Error: {}".format( tc_name, result) write_test_footer(tc_name)