From 816fdbbf53538e6401e0ceecfb643310cef903b0 Mon Sep 17 00:00:00 2001 From: nguggarigoud Date: Wed, 25 Nov 2020 05:34:06 +0530 Subject: [PATCH] tests : Adding 3 base ospf testcases. Test suite execution time is 90 Secs. Signed-off-by: nguggarigoud --- .../test_ospf_routemaps.py | 650 ++++++++++++++++++ .../test_ospf_single_area.py | 292 ++++++++ 2 files changed, 942 insertions(+) diff --git a/tests/topotests/ospf_basic_functionality/test_ospf_routemaps.py b/tests/topotests/ospf_basic_functionality/test_ospf_routemaps.py index 64edc1ebbf..04b1f4b878 100644 --- a/tests/topotests/ospf_basic_functionality/test_ospf_routemaps.py +++ b/tests/topotests/ospf_basic_functionality/test_ospf_routemaps.py @@ -197,6 +197,323 @@ def teardown_module(mod): # Test cases start here. # ################################## +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) + + ospf_red_r1 = { + "r0": { + "ospf": { + "redistribute": [{ + "redist_type": "static" + }] + } + } + } + result = create_router_ospf(tgen, topo, ospf_red_r1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + 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) + + ospf_red_r1 = { + "r0": { + "ospf": { + "redistribute": [{ + "redist_type": "static", + "del_action": True + }] + } + } + } + result = create_router_ospf(tgen, topo, ospf_red_r1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + 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") + + 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("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 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 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 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) + + 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 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_tc20_p0(request): """ @@ -329,6 +646,339 @@ def test_ospf_routemaps_functionality_tc20_p0(request): 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) + + 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 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_routemaps_functionality_tc24_p0(request): """ OSPF Route map - Multiple set clauses. diff --git a/tests/topotests/ospf_basic_functionality/test_ospf_single_area.py b/tests/topotests/ospf_basic_functionality/test_ospf_single_area.py index f563637b3c..3a269d853c 100644 --- a/tests/topotests/ospf_basic_functionality/test_ospf_single_area.py +++ b/tests/topotests/ospf_basic_functionality/test_ospf_single_area.py @@ -776,6 +776,298 @@ def test_ospf_show_p1(request): write_test_footer(tc_name) + +def test_ospf_dead_tc11_p0(request): + """ + OSPF timers. + + Verify OSPF interface timer dead interval functionality + """ + 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("modify dead interval from default value to some other value on r1") + + topo1 = { + 'r1': { + 'links': { + 'r0': { + 'interface': topo['routers']['r1']['links']['r0'][ + 'interface'], + 'ospf': { + 'hello_interval': 12, + 'dead_interval': 48 + } + } + } + } + } + + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + step( + "verify that new timer value is configured and applied using " + "the show ip ospf interface command.") + dut = 'r1' + input_dict= { + 'r1': { + 'links':{ + 'r0': { + 'ospf':{ + 'timerDeadSecs': 48 + } + } + } + } + } + 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 dead interval from default value to r1" + "dead interval timer on r2") + + topo1 = { + 'r0': { + 'links': { + 'r1': { + 'interface': topo['routers']['r0']['links']['r1'][ + 'interface'], + 'ospf': { + 'dead_interval': 48, + 'hello_interval': 12 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + + step("verify that new timer value is configured.") + input_dict= { + 'r0': { + 'links':{ + 'r1': { + 'ospf':{ + 'timerDeadSecs': 48 + } + } + } + } + } + dut = 'r0' + 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("verify that ospf neighbours are full") + ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) + assert ospf_covergence is True, ("setup_module :Failed \n Error:" + " {}".format(ospf_covergence)) + + step( + "reconfigure the default dead interval timer value to " + "default on r1 and r2") + topo1 = { + 'r0': { + 'links': { + 'r1': { + 'interface': topo['routers']['r0']['links']['r1'][ + 'interface'], + 'ospf': { + 'dead_interval': 40 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + topo1 = { + 'r1': { + 'links': { + 'r0': { + 'interface': topo['routers']['r1']['links']['r0'][ + 'interface'], + 'ospf': { + 'dead_interval': 40 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + step("verify that new timer value is configured.") + input_dict= { + 'r0': { + 'links':{ + 'r1': { + 'ospf':{ + 'timerDeadSecs': 40 + } + } + } + } + } + dut = 'r0' + 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("verify that ospf neighbours are full") + ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) + assert ospf_covergence is True, ("setup_module :Failed \n Error:" + " {}".format(ospf_covergence)) + + + step(" Configure dead timer = 65535 on r1 and r2") + + topo1 = { + 'r0': { + 'links': { + 'r1': { + 'interface': topo['routers']['r0']['links']['r1'][ + 'interface'], + 'ospf': { + 'dead_interval': 65535 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + topo1 = { + 'r1': { + 'links': { + 'r0': { + 'interface': topo['routers']['r1']['links']['r0'][ + 'interface'], + 'ospf': { + 'dead_interval': 65535 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + step("verify that new timer value is configured.") + input_dict= { + 'r0': { + 'links':{ + 'r1': { + 'ospf':{ + 'timerDeadSecs': 65535 + } + } + } + } + } + dut = 'r0' + 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("verify that ospf neighbours are full") + ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) + assert ospf_covergence is True, ("setup_module :Failed \n Error:" + " {}".format(ospf_covergence)) + + + step(" Try configuring timer values outside range for example 65536") + topo1 = { + 'r0': { + 'links': { + 'r1': { + 'interface': topo['routers']['r0']['links']['r1'][ + 'interface'], + 'ospf': { + 'dead_interval': 65536 + } + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is not True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + step("Unconfigure the dead timer from the interface from r1 and r2.") + + topo1 = { + 'r1': { + 'links': { + 'r0': { + 'interface': topo['routers']['r1']['links']['r0'][ + 'interface'], + 'ospf': { + 'dead_interval': 65535 + }, + 'delete': True + } + } + } + } + + result = create_interfaces_cfg(tgen, topo1) + assert result is True, "Testcase {} : Failed \n Error: {}".format( + tc_name, result) + + step( + "Verify that timer value is deleted from intf & " + "set to default value 40 sec.") + input_dict= { + 'r1': { + 'links':{ + 'r0': { + 'ospf':{ + 'timerDeadSecs': 40 + } + } + } + } + } + dut = 'r1' + 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) + + if __name__ == "__main__": args = ["-s"] + sys.argv[1:] sys.exit(pytest.main(args)) -- 2.39.5