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_ospfv3_bit_mismatch(request):
"""OSPF verify E-bit and N-bit mismatch."""
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)
input_dict = {"r3": {"ospf6": {"neighbors": []}}}
step("Configure r3 as stub router")
stub = {"r3": {"ospf6": {"area": [{"id": "1.1.1.1", "type": "stub"}]}}}
result = create_router_ospf(tgen, topo, stub)
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
# Verify r3 lost its adjacency with r2 due to E-bit mismatch
result = verify_ospf6_neighbor(tgen, topo, dut="r3", input_dict=input_dict)
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
step("Configure r2 as stub router")
stub = {"r2": {"ospf6": {"area": [{"id": "1.1.1.1", "type": "stub"}]}}}
result = create_router_ospf(tgen, topo, stub)
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
# Verify r3 has an adjacency up with r2 again
result = verify_ospf6_neighbor(tgen, topo, dut="r3")
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
step("Configure r3 as NSSA router")
nssa = {"r3": {"ospf6": {"area": [{"id": "1.1.1.1", "type": "nssa"}]}}}
result = create_router_ospf(tgen, topo, nssa)
# Verify r3 lost its adjacency with r2 due to N-bit mismatch
result = verify_ospf6_neighbor(tgen, topo, dut="r3", input_dict=input_dict)
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
step("Configure r2 as NSSA router")
nssa = {"r2": {"ospf6": {"area": [{"id": "1.1.1.1", "type": "nssa"}]}}}
result = create_router_ospf(tgen, topo, nssa)
# Verify r3 has an adjacency up with r2 again
result = verify_ospf6_neighbor(tgen, topo, dut="r3")
assert result is True, "Testcase {}: Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def red_connected(dut, config=True):
"""Local def for Redstribute connected routes inside ospf."""
global topo
tgen = get_topogen()
if config:
ospf_red = {
dut: {
"ospf": {
"redistribute": [{
"redist_type": "connected"
}]
}
}
}
else:
ospf_red = {
dut: {
"ospf": {
"redistribute": [{
"redist_type": "connected",
"del_action": True
}]
}
}
}
result = create_router_ospf(tgen, topo, ospf_red)
assert result is True, "Testcase: Failed \n Error: {}".format(result)
def delete_ospf():
"""delete ospf process after each test"""
tgen = get_topogen()
step("Delete ospf process")
for rtr in topo["routers"]:
ospf_del = {rtr: {"ospf": {"delete": True}}}
result = create_router_ospf(tgen, topo, ospf_del)
assert result is True, "Testcase: Failed \n Error: {}".format(result)
def ospfv3_router_id_tc14_p2(request):
"""OSPF Router ID - Verify OSPF router id changes."""
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("Configure system router id as 1.1.1.1 on R1 , clear ospf router")
ospf_rid = {"r0": {"ospf6": {"router_id": "1.1.1.1"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
step("configure ospf router id as 1.1.1.2 on R1, clear ospf router")
ospf_rid = {"r1": {"ospf6": {"router_id": "1.1.1.2"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
topo1 = deepcopy(topo)
step("Verify that OSPF takes system router ID as ospf router id.")
topo1["routers"]["r0"]["ospf6"]["router_id"] = "1.1.1.1"
topo1["routers"]["r1"]["ospf6"]["router_id"] = "1.1.1.2"
for rtr in topo["routers"]:
clear_ospf(tgen, rtr, ospf="ospf6")
ospf_covergence = verify_ospf6_neighbor(tgen, topo1)
assert ospf_covergence is True, "OSPF NBRs not up.Failed \n Error:" " {}".format(
ospf_covergence)
step(" delete ospf router id and clear ospf process.")
ospf_rid = {"r0": {"ospf6": {"del_router_id": "1.1.1.1"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
ospf_rid = {"r1": {"ospf6": {"del_router_id": "1.1.1.2"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
reset_config_on_routers(tgen)
step(" Configure R0 R1 R2 with same router ids")
ospf_rid = {"r0": {"ospf6": {"router_id": "1.1.1.1"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
step("configure ospf router id as 1.1.1.2 on R1, reboot router")
ospf_rid = {"r1": {"ospf6": {"router_id": "1.1.1.1"}}}
result = create_router_ospf(tgen, topo, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
ospf_covergence = verify_ospf6_neighbor(tgen, topo, expected=False)
assert (ospf_covergence
is not True), "OSPF NBRs are up.Failed \n Error:" " {}".format(
ospf_covergence)
topo1 = {}
topo1 = deepcopy(topo)
for rtr in ["r1", "r2", "r3", "r0"]:
topo1["routers"][rtr]["ospf6"].pop("router_id")
build_config_from_json(tgen, topo1, save_bkup=False)
ospf_covergence = verify_ospf6_neighbor(tgen, topo)
assert ospf_covergence is not True, (
"Testcase {} :Failed \n Neighborship "
"should not up as no router id is configured. Error: {}".format(
tc_name, result))
step("Clear ospf process and check nbrs should not be up.")
for rtr in topo["routers"]:
clear_ospf(tgen, rtr, ospf="ospf6")
ospf_covergence = verify_ospf6_neighbor(tgen, topo)
assert ospf_covergence is not True, (
"Testcase {} :Failed \n Neighborship "
"should not up as no router id is configured. Error: {}".format(
tc_name, result))
topo1 = deepcopy(topo)
step("Configure system router id on routers , clear ospf router")
ospf_rid = {
"r0": {
"ospf6": {
"router_id": "1.1.1.1"
}
},
"r1": {
"ospf6": {
"router_id": "1.1.1.2"
}
},
"r2": {
"ospf6": {
"router_id": "1.1.1.3"
}
},
"r3": {
"ospf6": {
"router_id": "1.1.1.4"
}
},
}
result = create_router_ospf(tgen, topo1, ospf_rid)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
topo1["routers"]["r0"]["ospf6"]["router_id"] = "1.1.1.1"
topo1["routers"]["r1"]["ospf6"]["router_id"] = "1.1.1.2"
topo1["routers"]["r2"]["ospf6"]["router_id"] = "1.1.1.3"
topo1["routers"]["r3"]["ospf6"]["router_id"] = "1.1.1.4"
ospf_covergence = verify_ospf6_neighbor(tgen, topo1)
assert ospf_covergence is True, "OSPF NBRs not up.Failed \n Error:" " {}".format(
ospf_covergence)
step(" Bring up the base config as per the topology")
reset_config_on_routers(tgen)
ospf_covergence = verify_ospf6_neighbor(tgen, topo)
assert ospf_covergence is True, "OSPF NBRs not up.Failed \n Error:" " {}".format(
ospf_covergence)
write_test_footer(tc_name)
def test_ospfv3_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"],
"ospf6": {
"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": {
"ospf6": {
"timerIntervalsConfigDead": 48
}
}
}
}
}
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("modify dead interval from default value to r1"
"dead interval timer on r2")
topo1 = {
"r0": {
"links": {
"r1": {
"interface":
topo["routers"]["r0"]["links"]["r1"]["interface"],
"ospf6": {
"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": {
"ospf6": {
"timerIntervalsConfigDead": 48
}
}
}
}
}
dut = "r0"
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("verify that ospf neighbours are full")
ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut)
assert ospf_covergence is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, ospf_covergence)
step("remove ospf on R0")
ospf_del = {"r0": {"ospf6": {"delete": True}}}
result = create_router_ospf(tgen, topo, ospf_del)
assert result is True, "Testcase : Failed \n Error: {}".format(result)
# reconfiguring deleted ospf process by resetting the configs.
reset_config_on_routers(tgen)
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"],
"ospf6": {
"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"],
"ospf6": {
"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": {
"ospf6": {
"timerIntervalsConfigDead": 40
}
}
}
}
}
dut = "r0"
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("verify that ospf neighbours are full")
ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut)
assert ospf_covergence is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, ospf_covergence)
step(" Configure dead timer = 65535 on r1 and r2")
topo1 = {
"r0": {
"links": {
"r1": {
"interface":
topo["routers"]["r0"]["links"]["r1"]["interface"],
"ospf6": {
"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"],
"ospf6": {
"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": {
"ospf6": {
"timerIntervalsConfigDead": 65535
}
}
}
}
}
dut = "r0"
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("verify that ospf neighbours are full")
ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut)
assert ospf_covergence is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, ospf_covergence)
step(" Try configuring timer values outside range for example 65536")
topo1 = {
"r0": {
"links": {
"r1": {
"interface":
topo["routers"]["r0"]["links"]["r1"]["interface"],
"ospf6": {
"dead_interval": 65536
},
}
}
}
}
result = create_interfaces_cfg(tgen, topo1)
assert (
result is not True
), "Testcase {} : Failed \n Create interface config failed. 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"],
"ospf6": {
"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": {
"ospf6": {
"timerIntervalsConfigDead": 40
}
}
}
}
}
dut = "r1"
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_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_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_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_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_gr_helper_tc8_p1(request):
"""
Test ospf gr helper
Verify helper functionality when dut is helping RR and new grace lsa
is received from RR.
"""
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("Enable GR")
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)
input_dict = {"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 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)
step("Send the Grace LSA again to DUT when RR is in GR.")
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_ospfv3_routemaps_functionality_tc23_p0(request):
"""
OSPF Route map - Multiple set clauses.
Verify OSPF route map support functionality when we add/remove route-maps
with multiple set clauses and without any match statement.(Set 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["ipv6"][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": {
"ospf6": {
"redistribute": [{
"redist_type": "static",
"route_map": "rmap_ipv6"
}]
}
}
}
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 set clause (set metric)")
# Create route map
routemaps = {
"r0": {
"route_maps": {
"rmap_ipv6": [{
"action": "permit",
"seq_id": 10,
"set": {
"metric": 123
}
}]
}
}
}
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_ospf6_rib(tgen, dut, input_dict, metric=123)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
result = verify_rib(tgen,
"ipv6",
dut,
input_dict,
protocol=protocol,
metric=123)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("un configure the set clause")
# Create route map
routemaps = {
"r0": {
"route_maps": {
"rmap_ipv6": [{
"action": "permit",
"seq_id": 10,
"set": {
"metric": 123,
"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_ospf6_rib(tgen, dut, input_dict, metric=20)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
result = verify_rib(tgen,
"ipv6",
dut,
input_dict,
protocol=protocol,
metric=20)
assert result is True, "Testcase {} : Failed \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_gr_helper_tc7_p1(request):
"""
Test ospf gr helper
Verify helper when grace lsa is received with different configured
value in process level (higher, lower, grace lsa timer above 1800)
"""
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")
step("Enable GR on RR and DUT with grace period on RR = 333"
"and grace period on DUT = 300")
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)
input_dict = {"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("Configure grace period = 1801 on RR and restart ospf .")
grace_period_1801 = "01005e00000570708bd051ef080045c0005cbeb10000015907d111010101e00000050204004801010101000000009714000000000000000000000000000100010209030000000101010180000001c8e9002c000100040000016800020001010000000003000411010101"
gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1,
grace_period_1801)
step("Verify R0 does not enter helper mode.")
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)
delete_ospf()
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)
def test_ospf_gr_helper_tc4_p1(request):
"""
OSPF GR on Broadcast : Verify DUT enters Helper mode when neighbor
sends grace lsa, helps RR to restart gracefully (RR = DRother)
"""
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)
step("Configure DR pririty 100 on R0 and clear ospf neighbors "
"on all the routers.")
input_dict = {
"r0": {
"links": {
sw_name: {
"interface":
topo["routers"]["r0"]["links"][sw_name]["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 topo["routers"]:
clear_ospf(tgen, rtr)
step("Verify that DR election is triggered and R0 is elected as 2-Way")
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)
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_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_ospfv3_def_rte_tc9_p0(request):
"""OSPF default route - Verify OSPF default route origination."""
tc_name = request.node.name
write_test_header(tc_name)
tgen = get_topogen()
global topo
step("Bring up the base config.")
step("Configure OSPF on all the routers of the topology.")
if tgen.routers_have_failure():
check_router_status(tgen)
reset_config_on_routers(tgen)
step(" Configure default-information originate always on R0.")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
dut = "r0"
step(" Configure default-information originate always on R0.")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify that default route is originated in area always.")
dut = "r1"
step(" Configure default-information originate metric type 1 on R0.")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
"metric-type": 1,
}
}
}
}
step("Verify that default route is originated in area when external "
"routes are present in R0 with metric type as 1.")
dut = "r0"
step("Verify that on R1 default route with type 1 is installed"
" (R1 is DUT in this case)")
dut = "r1"
step("Configure default-information originate metric type 2 on R0.")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
"metric-type": 2,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify that default route is originated in area when external"
" routes are present in R0 with metric type as 2.")
dut = "r1"
step(" Configure default-information originate metric 100 on R0")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
"metric-type": 2,
"metric": 100,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify that default route is originated with cost as 100 on R0.")
dut = "r1"
step("Delete the default-information command")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
"delete": True,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
dut = "r0"
step("Configure default-information originate always on R0.")
input_dict = {
"r0": {
"ospf6": {
"default-information": {
"originate": True,
"always": True,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Configure default route originate with active def route in zebra")
input_dict = {
"r0": {
"static_routes": [{
"network": "0::0/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": {
"ospf6": {
"default-information": {
"originate": True,
}
}
}
}
result = create_router_ospf(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify that default route is originated by R0.")
dut = "r1"
step("Delete static route")
input_dict = {
"r0": {
"static_routes": [{
"network": "0::0/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)
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_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_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"]:
red_static(rtr)
red_connected(rtr)
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"]:
ospf_red = {
rtr: {
"ospf": {
"redistribute": [{
"redist_type": "static",
"delete": True
}]
}
}
}
result = create_router_ospf(tgen, topo, ospf_red)
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 = 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_ospfv3_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_ospf6_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["ipv6"][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.")
llip = get_llip("r0", "r1-link1")
assert llip is not None, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
nh1 = llip
llip = get_llip("r0", "r1")
assert llip is not None, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
nh2 = llip
nh = [nh1, nh2]
dut = "r1"
result = verify_ospf6_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,
"ipv6",
dut,
input_dict,
protocol=protocol,
next_hop=nh)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Configure ECMP value as 1.")
max_path = {"r1": {"ospf6": {"maximum-paths": 1}}}
result = create_router_ospf(tgen, topo, max_path)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
result = verify_rib(tgen,
"ipv6",
dut,
input_dict,
protocol=protocol,
next_hop=nh2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
dut = "r1"
max_path = {"r1": {"ospf6": {"maximum-paths": 2}}}
result = create_router_ospf(tgen, topo, max_path)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
result = verify_rib(tgen,
"ipv6",
dut,
input_dict,
protocol=protocol,
next_hop=nh)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Configure cost on R0 as 100")
r0_ospf_cost = {"r0": {"links": {"r1": {"ospf6": {"cost": 100}}}}}
result = config_ospf6_interface(tgen, topo, r0_ospf_cost)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
dut = "r1"
result = verify_ospf6_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,
"ipv6",
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_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)
