proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-16 00:25:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #8180 from kuldeepkash/topojson_framework

Browse Source 
tests: Improve error/assert message logging
This commit is contained in:
Donatas Abraitis 2021-03-08 09:32:09 +02:00 committed by GitHub
commit f79d311b3e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 544 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
tests/topotests/bgp_gr_functionality_topo1/test_bgp_gr_functionality_topo1.py
View File

@ -1317,18 +1317,20 @@ def test_BGP_GR_TC_4_p0(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Phase 5] : R2 is about to come up now ") logger.info("[Phase 5] : R2 is about to come up now ")
@ -1788,9 +1790,10 @@ def test_BGP_GR_TC_6_1_2_p1(request):
result = verify_r_bit( result = verify_r_bit(
tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: R-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("Restart BGPd on R2 ") logger.info("Restart BGPd on R2 ")
kill_router_daemons(tgen, "r2", ["bgpd"]) kill_router_daemons(tgen, "r2", ["bgpd"])
@ -1808,9 +1811,10 @@ def test_BGP_GR_TC_6_1_2_p1(request):
result = verify_r_bit( result = verify_r_bit(
tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: R-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -2092,18 +2096,20 @@ def test_BGP_GR_TC_17_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Phase 5] : R2 is about to come up now ") logger.info("[Phase 5] : R2 is about to come up now ")
@ -2122,9 +2128,10 @@ def test_BGP_GR_TC_17_p1(request):
result = verify_r_bit( result = verify_r_bit(
tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: R-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
# Verifying BGP RIB routes # Verifying BGP RIB routes
next_hop = next_hop_per_address_family( next_hop = next_hop_per_address_family(
@ -2450,18 +2457,20 @@ def test_BGP_GR_TC_20_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Phase 5] : R2 is about to come up now ") logger.info("[Phase 5] : R2 is about to come up now ")
@ -2734,9 +2743,10 @@ def test_BGP_GR_TC_31_1_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("[Phase 4] : R1 is about to come up now ") logger.info("[Phase 4] : R1 is about to come up now ")
start_router_daemons(tgen, "r1", ["bgpd"]) start_router_daemons(tgen, "r1", ["bgpd"])
@ -3215,9 +3225,10 @@ def test_BGP_GR_TC_9_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
@ -3225,9 +3236,10 @@ def test_BGP_GR_TC_9_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Phase 5] : R2 is about to come up now ") logger.info("[Phase 5] : R2 is about to come up now ")
@ -3257,9 +3269,10 @@ def test_BGP_GR_TC_9_p1(request):
result = verify_f_bit( result = verify_f_bit(
tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: F-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -3391,9 +3404,10 @@ def test_BGP_GR_TC_17_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
@ -3401,9 +3415,10 @@ def test_BGP_GR_TC_17_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Phase 5] : R2 is about to come up now ") logger.info("[Phase 5] : R2 is about to come up now ")
@ -3425,9 +3440,10 @@ def test_BGP_GR_TC_17_p1(request):
result = verify_r_bit( result = verify_r_bit(
tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: R-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
# Verifying BGP RIB routes # Verifying BGP RIB routes
next_hop = next_hop_per_address_family( next_hop = next_hop_per_address_family(
@ -3647,9 +3663,10 @@ def test_BGP_GR_TC_43_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "bgp" protocol = "bgp"
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
@ -3954,9 +3971,10 @@ def test_BGP_GR_TC_44_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
@ -4981,9 +4999,10 @@ def test_BGP_GR_TC_48_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
dut = "r2" dut = "r2"
peer = "r1" peer = "r1"
@ -4994,15 +5013,17 @@ def test_BGP_GR_TC_48_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Bring up BGP on R1 and remove Peer-level GR config from R1") step("Bring up BGP on R1 and remove Peer-level GR config from R1")
@ -5361,15 +5382,17 @@ def test_BGP_GR_TC_52_p1(request):
result = verify_bgp_rib( result = verify_bgp_rib(
tgen, addr_type, dut, input_topo, next_hop, expected=False tgen, addr_type, dut, input_topo, next_hop, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False tgen, addr_type, dut, input_topo, next_hop, protocol, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Bring up BGP on R2 and remove Peer-level GR config from R1") step("Bring up BGP on R2 and remove Peer-level GR config from R1")

146
tests/topotests/bgp_gr_functionality_topo2/test_bgp_gr_functionality_topo2.py
View File

@ -555,9 +555,10 @@ def test_BGP_GR_TC_3_p0(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False
) )
assert result is not True, ( assert result is not True, ("Testcase {} : Failed \n "
"Testcase " + tc_name + " : Failed \n Error: {}".format(result) "r2: EOR is set to True\n Error: {}".format(
) tc_name, result
))
logger.info( logger.info(
"Waiting for selection deferral timer({} sec)..".format(GR_SELECT_DEFER_TIMER) "Waiting for selection deferral timer({} sec)..".format(GR_SELECT_DEFER_TIMER)
@ -700,9 +701,10 @@ def test_BGP_GR_TC_11_p0(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict, dut="r1", peer="r3", expected=False tgen, topo, addr_type, input_dict, dut="r1", peer="r3", expected=False
) )
assert result is not True, ( assert result is not True, ("Testcase {} : Failed \n "
"Testcase " + tc_name + " : Failed \n Error: {}".format(result) "r1: EOR is set to True\n Error: {}".format(
) tc_name, result
))
logger.info( logger.info(
"Waiting for selection deferral timer({} sec).. ".format( "Waiting for selection deferral timer({} sec).. ".format(
@ -729,9 +731,10 @@ def test_BGP_GR_TC_11_p0(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict, dut="r3", peer="r1", expected=False tgen, topo, addr_type, input_dict, dut="r3", peer="r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: EOR is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -1465,31 +1468,35 @@ def test_BGP_GR_18_p1(request):
dut = "r6" dut = "r6"
input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} input_dict_1 = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r6: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes before shutting down BGPd daemon # Verifying RIB routes before shutting down BGPd daemon
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r6: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes # Verifying BGP RIB routes
dut = "r2" dut = "r2"
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes before shutting down BGPd daemon # Verifying RIB routes before shutting down BGPd daemon
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r6: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -1950,16 +1957,18 @@ def test_BGP_GR_chaos_29_p1(request):
# Verifying BGP RIB routes before shutting down BGPd daemon # Verifying BGP RIB routes before shutting down BGPd daemon
input_dict = {key: topo["routers"][key] for key in ["r1"]} input_dict = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes before shutting down BGPd daemon # Verifying RIB routes before shutting down BGPd daemon
result = verify_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 4] : Start BGPd daemon on R1..") logger.info("[Step 4] : Start BGPd daemon on R1..")
@ -2201,9 +2210,10 @@ def test_BGP_GR_chaos_33_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_2, next_hop_4, expected=False tgen, addr_type, dut, input_dict_2, next_hop_4, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
if addr_type == "ipv6": if addr_type == "ipv6":
@ -2215,9 +2225,10 @@ def test_BGP_GR_chaos_33_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_2, next_hop_6, expected=False tgen, addr_type, dut, input_dict_2, next_hop_6, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 4] : Start BGPd daemon on R1 and R4..") logger.info("[Step 4] : Start BGPd daemon on R1 and R4..")
@ -2398,24 +2409,27 @@ def test_BGP_GR_chaos_34_2_p1(request):
result = verify_f_bit( result = verify_f_bit(
tgen, topo, addr_type, input_dict, "r3", "r1", expected=False tgen, topo, addr_type, input_dict, "r3", "r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: F-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon # Verifying BGP RIB routes after starting BGPd daemon
input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} input_dict_1 = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -2552,9 +2566,10 @@ def test_BGP_GR_chaos_34_1_p1(request):
result = verify_f_bit( result = verify_f_bit(
tgen, topo, addr_type, input_dict_2, "r3", "r1", expected=False tgen, topo, addr_type, input_dict_2, "r3", "r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: F-bit is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 3] : Kill BGPd daemon on R1..") logger.info("[Step 3] : Kill BGPd daemon on R1..")
@ -2570,16 +2585,18 @@ def test_BGP_GR_chaos_34_1_p1(request):
# Verifying BGP RIB routes # Verifying BGP RIB routes
input_dict = {key: topo["routers"][key] for key in ["r1"]} input_dict = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Start BGPd daemon on R1 # Start BGPd daemon on R1
@ -2753,24 +2770,27 @@ def test_BGP_GR_chaos_32_p1(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict_3, dut="r5", peer="r1", expected=False tgen, topo, addr_type, input_dict_3, dut="r5", peer="r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r5: EOR is set to TRUE\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon # Verifying BGP RIB routes after starting BGPd daemon
input_dict_1 = {key: topo["routers"][key] for key in ["r5"]} input_dict_1 = {key: topo["routers"][key] for key in ["r5"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes # Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -2876,9 +2896,10 @@ def test_BGP_GR_chaos_37_p1(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict, dut="r3", peer="r1", expected=False tgen, topo, addr_type, input_dict, dut="r3", peer="r1", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: EOR is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon # Verifying BGP RIB routes after starting BGPd daemon
@ -2941,9 +2962,10 @@ def test_BGP_GR_chaos_37_p1(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict_3, dut="r1", peer="r3", expected=False tgen, topo, addr_type, input_dict_3, dut="r1", peer="r3", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: EOR is set to True\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -3095,16 +3117,18 @@ def test_BGP_GR_chaos_30_p1(request):
# Verifying BGP RIB routes before shutting down BGPd daemon # Verifying BGP RIB routes before shutting down BGPd daemon
input_dict = {key: topo["routers"][key] for key in ["r3"]} input_dict = {key: topo["routers"][key] for key in ["r3"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes before shutting down BGPd daemon # Verifying RIB routes before shutting down BGPd daemon
result = verify_rib(tgen, addr_type, dut, input_dict, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -3506,9 +3530,10 @@ def BGP_GR_TC_7_p1(request):
dut = "r1" dut = "r1"
input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} input_dict_1 = {key: topo["routers"][key] for key in ["r3"]}
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -3682,9 +3707,10 @@ def test_BGP_GR_TC_23_p1(request):
result = verify_eor( result = verify_eor(
tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False tgen, topo, addr_type, input_dict, dut="r1", peer="r2", expected=False
) )
assert result is not True, ( assert result is not True, ("Testcase {} : Failed \n "
"Testcase " + tc_name + " :Failed \n Error: {}".format(result) "r1: EOR is set to True\n Error: {}".format(
) tc_name, result
))
# Verifying BGP RIB routes received from router R1 # Verifying BGP RIB routes received from router R1
dut = "r1" dut = "r1"
@ -3805,16 +3831,18 @@ def test_BGP_GR_20_p1(request):
dut = "r3" dut = "r3"
input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} input_dict_1 = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes before shutting down BGPd daemon # Verifying RIB routes before shutting down BGPd daemon
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info(" Expected behavior: {}".format(result)) logger.info(" Expected behavior: {}".format(result))
# Start BGPd daemon on R1 # Start BGPd daemon on R1

15
tests/topotests/bgp_large_community/test_bgp_large_community_topo_2.py
View File

@ -598,9 +598,10 @@ def test_large_community_lists_with_rmap_apply_and_remove(request):
result = verify_bgp_community( result = verify_bgp_community(
tgen, adt, dut, NETWORKS[adt], input_dict_4, expected=False tgen, adt, dut, NETWORKS[adt], input_dict_4, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"largeCommunity is still present after deleting route-map \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -898,9 +899,10 @@ def test_large_community_lists_with_rmap_set_none(request):
dut = "r6" dut = "r6"
for adt in ADDR_TYPES: for adt in ADDR_TYPES:
result = verify_bgp_community(tgen, adt, dut, NETWORKS[adt], expected=False) result = verify_bgp_community(tgen, adt, dut, NETWORKS[adt], expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Community-list is still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -2236,9 +2238,10 @@ def test_large_community_lists_with_rmap_match_regex(request):
result = verify_bgp_community( result = verify_bgp_community(
tgen, adt, dut, NETWORKS[adt], input_dict_7, expected=False tgen, adt, dut, NETWORKS[adt], input_dict_7, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"largeCommunity is still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)

15
tests/topotests/bgp_multi_vrf_topo1/test_bgp_multi_vrf_topo1.py
View File

@ -504,9 +504,10 @@ def test_ambiguous_overlapping_addresses_in_different_vrfs_p0(request):
) )
result = verify_rib(tgen, addr_type, dut, input_dict_1, tag=500, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, tag=500, expected=False)
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are present with tag value 500 \n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("Expected Behavior: {}".format(result)) logger.info("Expected Behavior: {}".format(result))
step( step(
@ -1142,9 +1143,10 @@ def test_prefixes_leaking_p0(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_1, metric=123, expected=False tgen, addr_type, dut, input_dict_1, metric=123, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are present with metric value 123 \n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("Expected Behavior: {}".format(result)) logger.info("Expected Behavior: {}".format(result))
result = verify_rib(tgen, addr_type, dut, input_dict_2, metric=123) result = verify_rib(tgen, addr_type, dut, input_dict_2, metric=123)
@ -1155,9 +1157,10 @@ def test_prefixes_leaking_p0(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_2, metric=0, expected=False tgen, addr_type, dut, input_dict_2, metric=0, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are present with metric value 0 \n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("Expected Behavior: {}".format(result)) logger.info("Expected Behavior: {}".format(result))
write_test_footer(tc_name) write_test_footer(tc_name)

10
tests/topotests/bgp_multi_vrf_topo2/test_bgp_multi_vrf_topo2.py
View File

@ -2214,14 +2214,16 @@ def test_restart_bgpd_daemon_p1(request):
} }
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present in VRF RED_A and RED_B \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib(tgen, addr_type, dut, input_dict_2, expected=False) result = verify_rib(tgen, addr_type, dut, input_dict_2, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present in VRF BLUE_A and BLUE_B \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Bring up BGPd daemon on R1.") step("Bring up BGPd daemon on R1.")
start_router_daemons(tgen, "r1", ["bgpd"]) start_router_daemons(tgen, "r1", ["bgpd"])

72
tests/topotests/bgp_recursive_route_ebgp_multi_hop/test_bgp_recursive_route_ebgp_multi_hop.py
View File

@ -20,7 +20,7 @@
# #
""" """
Following tests are covered to test bgp recursive route and ebgp Following tests are covered to test bgp recursive route and ebgp
multi-hop functionality: multi-hop functionality:
1. Verify that BGP routes are installed in iBGP peer, only when there 1. Verify that BGP routes are installed in iBGP peer, only when there
@ -365,9 +365,10 @@ def test_recursive_routes_iBGP_peer_p1(request):
protocol="bgp", protocol="bgp",
expected=False, expected=False,
) )
assert result is not True, "Testcase : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Reconfigure the same static route on R2 again") step("Reconfigure the same static route on R2 again")
dut = "r2" dut = "r2"
@ -485,9 +486,10 @@ def test_recursive_routes_iBGP_peer_p1(request):
result = verify_rib( result = verify_rib(
tgen, addr_type, "r2", input_dict_4, protocol="bgp", expected=False tgen, addr_type, "r2", input_dict_4, protocol="bgp", expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -596,9 +598,10 @@ def test_next_hop_as_self_ip_p1(request):
next_hop=topo["routers"]["r2"]["links"]["r4"][addr_type].split("/")[0], next_hop=topo["routers"]["r2"]["links"]["r4"][addr_type].split("/")[0],
expected=False, expected=False,
) )
assert result is not True, "Testcase : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Shut interface on R2 that has IP from the subnet as BGP next-hop") step("Shut interface on R2 that has IP from the subnet as BGP next-hop")
intf_r2_r4 = topo["routers"]["r2"]["links"]["r4"]["interface"] intf_r2_r4 = topo["routers"]["r2"]["links"]["r4"]["interface"]
@ -673,9 +676,10 @@ def test_next_hop_as_self_ip_p1(request):
next_hop=topo["routers"]["r2"]["links"]["r4"][addr_type].split("/")[0], next_hop=topo["routers"]["r2"]["links"]["r4"][addr_type].split("/")[0],
expected=False, expected=False,
) )
assert result is not True, "Testcase : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -1618,9 +1622,10 @@ def test_BGP_peering_bw_loopback_and_physical_p1(request):
step("Verify that once eBGP multi-hop is removed, BGP session goes down") step("Verify that once eBGP multi-hop is removed, BGP session goes down")
result = verify_bgp_convergence_from_running_config(tgen, expected=False) result = verify_bgp_convergence_from_running_config(tgen, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Add ebgp-multihop command on R3 again") step("Add ebgp-multihop command on R3 again")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
@ -1658,9 +1663,10 @@ def test_BGP_peering_bw_loopback_and_physical_p1(request):
step("Verify that BGP session goes down, when update-source is removed") step("Verify that BGP session goes down, when update-source is removed")
result = verify_bgp_convergence_from_running_config(tgen, expected=False) result = verify_bgp_convergence_from_running_config(tgen, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Add update-source command on R1 again") step("Add update-source command on R1 again")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
@ -1709,16 +1715,18 @@ def test_BGP_peering_bw_loopback_and_physical_p1(request):
next_hop=topo["routers"]["r1"]["links"]["r3"][addr_type].split("/")[0], next_hop=topo["routers"]["r1"]["links"]["r3"][addr_type].split("/")[0],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
sleep(3) sleep(3)
step("Verify that BGP session goes down, when static route is removed") step("Verify that BGP session goes down, when static route is removed")
result = verify_bgp_convergence_from_running_config(tgen, expected=False) result = verify_bgp_convergence_from_running_config(tgen, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Add static route on R3 again") step("Add static route on R3 again")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
@ -1760,9 +1768,10 @@ def test_BGP_peering_bw_loopback_and_physical_p1(request):
sleep(3) sleep(3)
step("Verify that BGP neighborship between R1 and R3 goes down") step("Verify that BGP neighborship between R1 and R3 goes down")
result = verify_bgp_convergence_from_running_config(tgen, expected=False) result = verify_bgp_convergence_from_running_config(tgen, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
intf_r1_r3 = topo["routers"]["r1"]["links"]["r3"]["interface"] intf_r1_r3 = topo["routers"]["r1"]["links"]["r3"]["interface"]
shutdown_bringup_interface(tgen, "r1", intf_r1_r3, True) shutdown_bringup_interface(tgen, "r1", intf_r1_r3, True)
@ -2078,9 +2087,10 @@ def test_BGP_active_standby_preemption_and_ecmp_p1(request):
], ],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Reconfigure multipath-relax command on R4") step("Reconfigure multipath-relax command on R4")
result = create_router_bgp(tgen, topo, maxpath_relax) result = create_router_bgp(tgen, topo, maxpath_relax)
@ -2137,9 +2147,10 @@ def test_BGP_active_standby_preemption_and_ecmp_p1(request):
], ],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"Routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Re-configure maximum-path 2 command on R4") step("Re-configure maximum-path 2 command on R4")
input_dict_8 = { input_dict_8 = {
@ -2327,9 +2338,10 @@ def test_password_authentication_for_eBGP_and_iBGP_peers_p1(request):
"configured but not peer routers" "configured but not peer routers"
) )
result = verify_bgp_convergence(tgen, topo, expected=False) result = verify_bgp_convergence(tgen, topo, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("configure same password on R2 and R3") step("configure same password on R2 and R3")
for routerN in ["r2", "r3"]: for routerN in ["r2", "r3"]:
@ -2356,9 +2368,10 @@ def test_password_authentication_for_eBGP_and_iBGP_peers_p1(request):
"strings are in CAPs on R2 and R3" "strings are in CAPs on R2 and R3"
) )
result = verify_bgp_convergence(tgen, topo, expected=False) result = verify_bgp_convergence(tgen, topo, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Configure same password on R2 and R3 without CAPs") step("Configure same password on R2 and R3 without CAPs")
for routerN in ["r2", "r3"]: for routerN in ["r2", "r3"]:
@ -2382,9 +2395,10 @@ def test_password_authentication_for_eBGP_and_iBGP_peers_p1(request):
step("Verify if password is removed from R1, both sessions go down again") step("Verify if password is removed from R1, both sessions go down again")
result = verify_bgp_convergence(tgen, topo, expected=False) result = verify_bgp_convergence(tgen, topo, expected=False)
assert result is not True, "Testcase {} : Failed \n Error : {}".format( assert result is not True, ("Testcase {} : Failed \n "
"BGP is converged \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Configure alphanumeric password on R1 and peer routers R2,R3") step("Configure alphanumeric password on R1 and peer routers R2,R3")
for bgp_neighbor in ["r2", "r3"]: for bgp_neighbor in ["r2", "r3"]:

4
tests/topotests/evpn_type5_test_topo1/test_evpn_type5_topo1.py
View File

@ -1312,14 +1312,14 @@ def test_evpn_routes_from_VNFs_p1(request):
) )
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_routes = {key: topo["routers"][key] for key in ["r1"]} input_routes = {key: topo["routers"][key] for key in ["r1"]}
result = verify_rib(tgen, addr_type, "d2", input_routes, expected=True) result = verify_rib(tgen, addr_type, "d2", input_routes)
assert result is True, "Testcase {} :Failed \n Error: {}".format( assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result tc_name, result
) )
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_routes = {key: topo["routers"][key] for key in ["r2"]} input_routes = {key: topo["routers"][key] for key in ["r2"]}
result = verify_rib(tgen, addr_type, "d2", input_routes, expected=True) result = verify_rib(tgen, addr_type, "d2", input_routes)
assert result is True, "Testcase {} :Failed \n Error: {}".format( assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result tc_name, result
) )

45
tests/topotests/multicast-pim-bsm-topo1/test_mcast_pim_bsmp_01.py
View File

@ -692,7 +692,10 @@ def test_BSR_CRP_with_blackhole_address_p1(request):
step("Verify if b1 chosen as BSR in l1") step("Verify if b1 chosen as BSR in l1")
result = verify_pim_bsr(tgen, topo, "l1", BSR_IP_1, expected=False) result = verify_pim_bsr(tgen, topo, "l1", BSR_IP_1, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"b1 is not chosen as BSR in l1 \n Error: {}".format(
tc_name, result
))
state_after = verify_pim_interface_traffic(tgen, state_dict) state_after = verify_pim_interface_traffic(tgen, state_dict)
assert isinstance( assert isinstance(
@ -838,7 +841,10 @@ def test_new_router_fwd_p0(request):
# Verify bsr state in l1 # Verify bsr state in l1
step("Verify no BSR in l1 as i1 would not forward the no-forward bsm") step("Verify no BSR in l1 as i1 would not forward the no-forward bsm")
result = verify_pim_bsr(tgen, topo, "l1", bsr_ip, expected=False) result = verify_pim_bsr(tgen, topo, "l1", bsr_ip, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"BSR data is present after no-forward bsm also \n Error: {}".format(
tc_name, result
))
# unconfigure unicast bsm on f1-i1-eth2 # unconfigure unicast bsm on f1-i1-eth2
step("unconfigure unicast bsm on f1-i1-eth2, will forward with only mcast") step("unconfigure unicast bsm on f1-i1-eth2, will forward with only mcast")
@ -960,7 +966,10 @@ def test_int_bsm_config_p1(request):
result = verify_ip_mroutes( result = verify_ip_mroutes(
tgen, "i1", src_addr, GROUP_ADDRESS, iif, oil, expected=False tgen, "i1", src_addr, GROUP_ADDRESS, iif, oil, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"Mroutes are still present \n Error: {}".format(
tc_name, result
))
# unconfigure bsm processing on f1 on f1-i1-eth2 # unconfigure bsm processing on f1 on f1-i1-eth2
step("unconfigure bsm processing on f1 in f1-i1-eth2, will drop bsm") step("unconfigure bsm processing on f1 in f1-i1-eth2, will drop bsm")
@ -980,14 +989,20 @@ def test_int_bsm_config_p1(request):
# Verify bsr state in i1 # Verify bsr state in i1
step("Verify if b1 is not chosen as BSR in i1") step("Verify if b1 is not chosen as BSR in i1")
result = verify_pim_bsr(tgen, topo, "i1", bsr_ip, expected=False) result = verify_pim_bsr(tgen, topo, "i1", bsr_ip, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"b1 is chosen as BSR in i1 \n Error: {}".format(
tc_name, result
))
# check if mroute still not installed because of rp not available # check if mroute still not installed because of rp not available
step("check if mroute still not installed because of rp not available") step("check if mroute still not installed because of rp not available")
result = verify_ip_mroutes( result = verify_ip_mroutes(
tgen, "i1", src_addr, GROUP_ADDRESS, iif, oil, expected=False tgen, "i1", src_addr, GROUP_ADDRESS, iif, oil, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"mroute installed but rp not available \n Error: {}".format(
tc_name, result
))
# configure bsm processing on i1 on f1-i1-eth2 # configure bsm processing on i1 on f1-i1-eth2
step("configure bsm processing on f1 in f1-i1-eth2, will accept bsm") step("configure bsm processing on f1 in f1-i1-eth2, will accept bsm")
@ -1449,7 +1464,10 @@ def test_BSM_timeout_p0(request):
tgen, topo, "f1", group, rp_source="BSR", expected=False tgen, topo, "f1", group, rp_source="BSR", expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"bsr has not aged out in f1 \n Error: {}".format(
tc_name, result
))
# Verify RP mapping removed after hold timer expires # Verify RP mapping removed after hold timer expires
group = "225.1.1.1/32" group = "225.1.1.1/32"
@ -1473,14 +1491,20 @@ def test_BSM_timeout_p0(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, src_addr, GROUP_ADDRESS, expected=False tgen, dut, iif, src_addr, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"join state is up and join timer is running in l1 \n Error: {}".format(
tc_name, result
))
# Verify ip mroute is not installed # Verify ip mroute is not installed
step("Verify mroute not installed in l1") step("Verify mroute not installed in l1")
result = verify_ip_mroutes( result = verify_ip_mroutes(
tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, expected=False tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"mroute installed in l1 \n Error: {}".format(
tc_name, result
))
step("clear BSM database before moving to next case") step("clear BSM database before moving to next case")
clear_bsrp_data(tgen, topo) clear_bsrp_data(tgen, topo)
@ -1633,7 +1657,10 @@ def test_iif_join_state_p0(request):
result = verify_ip_mroutes( result = verify_ip_mroutes(
tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, expected=False tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"mroute installed in l1 \n Error: {}".format(
tc_name, result
))
# Add back route for RP to make it reachable # Add back route for RP to make it reachable
step("Add back route for RP to make it reachable") step("Add back route for RP to make it reachable")

10
tests/topotests/multicast-pim-bsm-topo2/test_mcast_pim_bsmp_02.py
View File

@ -454,7 +454,10 @@ def test_starg_mroute_p0(request):
result = verify_ip_mroutes( result = verify_ip_mroutes(
tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, wait=20, expected=False tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, wait=20, expected=False
) )
assert result is not True, "Testcase {}:Failed \n Error: {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"mroute installed in l1 \n Error: {}".format(
tc_name, result
))
# Send BSM again to configure rp # Send BSM again to configure rp
step("Add back RP by sending BSM from b1") step("Add back RP by sending BSM from b1")
@ -804,7 +807,10 @@ def test_BSR_election_p0(request):
# Verify bsr state in FHR # Verify bsr state in FHR
step("Verify if b2 is not chosen as bsr in f1") step("Verify if b2 is not chosen as bsr in f1")
result = verify_pim_bsr(tgen, topo, "f1", bsr_ip2, expected=False) result = verify_pim_bsr(tgen, topo, "f1", bsr_ip2, expected=False)
assert result is not True, "Testcase {} :Failed \n Error {}".format(tc_name, result) assert result is not True, ("Testcase {} : Failed \n "
"b2 is chosen as bsr in f1 \n Error: {}".format(
tc_name, result
))
# Verify if b1 is still chosen as bsr # Verify if b1 is still chosen as bsr
step("Verify if b1 is still chosen as bsr in f1") step("Verify if b1 is still chosen as bsr in f1")

12
tests/topotests/multicast-pim-sm-topo3/test_multicast_pim_sm_topo3.py
View File

@ -3487,9 +3487,11 @@ def test_prune_sent_to_LHR_and_FHR_when_PIMnbr_down_p2(request):
IGMP_JOIN_RANGE_1, IGMP_JOIN_RANGE_1,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"upstream is still present after shut the link from "
"FHR to RP from RP node \n Error: {}".format(
tc_name, result tc_name, result
) ))
step(" No shut the link from FHR to RP from RP node") step(" No shut the link from FHR to RP from RP node")
@ -3636,9 +3638,11 @@ def test_prune_sent_to_LHR_and_FHR_when_PIMnbr_down_p2(request):
IGMP_JOIN_RANGE_1, IGMP_JOIN_RANGE_1,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"upstream is still present after shut the link from "
"FHR to RP from FHR node \n Error: {}".format(
tc_name, result tc_name, result
) ))
step(" No shut the link from FHR to RP from FHR node") step(" No shut the link from FHR to RP from FHR node")

40
tests/topotests/multicast-pim-sm-topo3/test_multicast_pim_sm_topo4.py
View File

@ -490,9 +490,10 @@ def test_mroute_when_RP_reachable_default_route_p2(request):
data["oil"], data["oil"],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"mroutes(S,G) are present after delete of static routes on c1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_upstream_iif( result = verify_upstream_iif(
tgen, tgen,
@ -502,9 +503,10 @@ def test_mroute_when_RP_reachable_default_route_p2(request):
IGMP_JOIN_RANGE_1, IGMP_JOIN_RANGE_1,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"upstream is present after delete of static routes on c1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
for data in input_dict_starg: for data in input_dict_starg:
result = verify_ip_mroutes( result = verify_ip_mroutes(
@ -516,9 +518,10 @@ def test_mroute_when_RP_reachable_default_route_p2(request):
data["oil"], data["oil"],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"mroutes(*,G) are present after delete of static routes on c1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_upstream_iif( result = verify_upstream_iif(
tgen, tgen,
@ -528,9 +531,10 @@ def test_mroute_when_RP_reachable_default_route_p2(request):
IGMP_JOIN_RANGE_1, IGMP_JOIN_RANGE_1,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"upstream is present after delete of static routes on c1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Configure default routes on c2") step("Configure default routes on c2")
@ -553,9 +557,10 @@ def test_mroute_when_RP_reachable_default_route_p2(request):
result = verify_pim_rp_info( result = verify_pim_rp_info(
tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"RP info is unknown after removing static route from c2 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Verify (s,g) populated after adding default route ") step("Verify (s,g) populated after adding default route ")
@ -782,9 +787,10 @@ def test_mroute_with_RP_default_route_all_nodes_p2(request):
data["oil"], data["oil"],
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"mroutes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_upstream_iif( result = verify_upstream_iif(
tgen, tgen,
@ -794,9 +800,10 @@ def test_mroute_with_RP_default_route_all_nodes_p2(request):
IGMP_JOIN_RANGE_1, IGMP_JOIN_RANGE_1,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"upstream is still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Configure default routes on all the nodes") step("Configure default routes on all the nodes")
@ -833,9 +840,10 @@ def test_mroute_with_RP_default_route_all_nodes_p2(request):
result = verify_pim_rp_info( result = verify_pim_rp_info(
tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"RP info is unknown after removing static route from c2 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Verify (s,g) populated after adding default route ") step("Verify (s,g) populated after adding default route ")

226
tests/topotests/multicast-pim-static-rp-topo1/test_multicast_pim_static_rp.py
View File

@ -423,9 +423,10 @@ def test_add_delete_static_RP_p0(request):
dut = "r1" dut = "r1"
interface = "r1-r0-eth0" interface = "r1-r0-eth0"
result = verify_igmp_groups(tgen, dut, interface, GROUP_ADDRESS, expected=False) result = verify_igmp_groups(tgen, dut, interface, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: igmp group present without any IGMP join \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify show ip pim interface traffic without any IGMP join") step("r1: Verify show ip pim interface traffic without any IGMP join")
state_dict = {"r1": {"r1-r2-eth1": ["pruneTx"]}} state_dict = {"r1": {"r1-r2-eth1": ["pruneTx"]}}
@ -491,23 +492,26 @@ def test_add_delete_static_RP_p0(request):
result = verify_pim_rp_info( result = verify_pim_rp_info(
tgen, topo, dut, GROUP_RANGE_ALL, iif, rp_address, SOURCE, expected=False tgen, topo, dut, GROUP_RANGE_ALL, iif, rp_address, SOURCE, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: RP info present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify upstream IIF interface") step("r1: Verify upstream IIF interface")
result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False) result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream IIF interface present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify upstream join state and join timer") step("r1: Verify upstream join state and join timer")
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream join state is up and join timer is running \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify PIM state") step("r1: Verify PIM state")
result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False) result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False)
@ -517,9 +521,10 @@ def test_add_delete_static_RP_p0(request):
step("r1: Verify ip mroutes") step("r1: Verify ip mroutes")
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: mroutes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify show ip pim interface traffic without any IGMP join") step("r1: Verify show ip pim interface traffic without any IGMP join")
state_after = verify_pim_interface_traffic(tgen, state_dict) state_after = verify_pim_interface_traffic(tgen, state_dict)
@ -676,9 +681,10 @@ def test_SPT_RPT_path_same_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S, G) upstream join state is up and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r2-eth1" oif = "r3-r2-eth1"
@ -805,15 +811,17 @@ def test_not_reachable_static_RP_p0(request):
"using show ip pim state" "using show ip pim state"
) )
result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False) result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"OIL is not same and IIF is not cleared on R1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: upstream IIF should be unknown , verify using show ip pim" "upstream") step("r1: upstream IIF should be unknown , verify using show ip pim" "upstream")
result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False) result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream IIF is not unknown \n Error: {}".format(
tc_name, result tc_name, result
) ))
step( step(
"r1: join state should not be joined and join timer should stop," "r1: join state should not be joined and join timer should stop,"
@ -822,9 +830,10 @@ def test_not_reachable_static_RP_p0(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: join state is joined and timer is not stopped \n Error: {}".format(
tc_name, result tc_name, result
) ))
step( step(
"r1: (*,G) prune is sent towards the RP interface, verify using" "r1: (*,G) prune is sent towards the RP interface, verify using"
@ -841,9 +850,10 @@ def test_not_reachable_static_RP_p0(request):
step("r1: (*, G) cleared from mroute table using show ip mroute") step("r1: (*, G) cleared from mroute table using show ip mroute")
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: (*, G) are not cleared from mroute table \n Error: {}".format(
tc_name, result tc_name, result
) ))
logger.info("Expected behavior: {}".format(result)) logger.info("Expected behavior: {}".format(result))
# Uncomment next line for debugging # Uncomment next line for debugging
@ -910,9 +920,10 @@ def test_add_RP_after_join_received_p1(request):
result = verify_pim_rp_info( result = verify_pim_rp_info(
tgen, topo, dut, GROUP_RANGE_ALL, iif, rp_address, SOURCE, expected=False tgen, topo, dut, GROUP_RANGE_ALL, iif, rp_address, SOURCE, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: rp-info is present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("joinTx value before join sent") step("joinTx value before join sent")
state_dict = {"r1": {"r1-r2-eth1": ["joinTx"]}} state_dict = {"r1": {"r1-r2-eth1": ["joinTx"]}}
@ -933,30 +944,34 @@ def test_add_RP_after_join_received_p1(request):
step("r1: Verify upstream IIF interface") step("r1: Verify upstream IIF interface")
result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False) result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream IFF interface is present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify upstream join state and join timer") step("r1: Verify upstream join state and join timer")
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream join state is joined and timer is running \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify PIM state") step("r1: Verify PIM state")
result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False) result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: PIM state is up\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Verify ip mroutes") step("r1: Verify ip mroutes")
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: mroutes are still present\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Configure static RP") step("r1: Configure static RP")
input_dict = { input_dict = {
@ -1080,29 +1095,33 @@ def test_reachable_static_RP_after_join_p0(request):
step("r1 : Verify upstream IIF interface") step("r1 : Verify upstream IIF interface")
iif = "r1-r2-eth1" iif = "r1-r2-eth1"
result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False) result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream IIF interface is present\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1 : Verify upstream join state and join timer") step("r1 : Verify upstream join state and join timer")
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False tgen, dut, iif, STAR, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: upstream join state is joined and timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1 : Verify PIM state") step("r1 : Verify PIM state")
result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False) result = verify_pim_state(tgen, dut, iif, oif, GROUP_ADDRESS, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: PIM state is up\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1 : Verify ip mroutes") step("r1 : Verify ip mroutes")
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: mroutes are still present\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r1: Make RP reachable") step("r1: Make RP reachable")
intf = "r1-r2-eth1" intf = "r1-r2-eth1"
@ -1343,9 +1362,10 @@ def test_send_join_on_higher_preffered_rp_p1(request):
result = verify_pim_rp_info( result = verify_pim_rp_info(
tgen, topo, dut, GROUP_RANGE, oif, rp_address_2, SOURCE, expected=False tgen, topo, dut, GROUP_RANGE, oif, rp_address_2, SOURCE, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: rp-info is present for group 225.1.1.1 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step( step(
"r1 : Verify RPF interface updated in mroute when higher preferred" "r1 : Verify RPF interface updated in mroute when higher preferred"
@ -1599,9 +1619,11 @@ def test_RP_configured_as_LHR_1_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S, G) upstream join state is joined and join"
" timer is running \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -1806,9 +1828,10 @@ def test_RP_configured_as_LHR_2_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2013,9 +2036,10 @@ def test_RP_configured_as_FHR_1_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2221,9 +2245,10 @@ def test_RP_configured_as_FHR_2_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2347,9 +2372,10 @@ def test_SPT_RPT_path_different_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2368,9 +2394,10 @@ def test_SPT_RPT_path_different_p1(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (S, G) ip mroutes") step("r2: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -2596,9 +2623,10 @@ def test_restart_pimd_process_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2763,9 +2791,10 @@ def test_multiple_groups_same_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -2784,9 +2813,10 @@ def test_multiple_groups_same_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (S, G) ip mroutes") step("r2: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -2902,9 +2932,10 @@ def test_multiple_groups_same_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (S, G) ip mroutes") step("r2: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -2921,9 +2952,10 @@ def test_multiple_groups_same_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -3100,9 +3132,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (S, G) ip mroutes") step("r2: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -3121,9 +3154,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -3190,9 +3224,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r4: Verify (S, G) ip mroutes") step("r4: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -3364,9 +3399,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (S, G) ip mroutes") step("r2: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -3385,9 +3421,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -3454,9 +3491,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r4: Verify (S, G) ip mroutes") step("r4: Verify (S, G) ip mroutes")
oif = "none" oif = "none"
@ -3475,9 +3513,10 @@ def test_multiple_groups_different_RP_address_p2(request):
result = verify_join_state_and_timer( result = verify_join_state_and_timer(
tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, expected=False
) )
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (S, G) ip mroutes") step("r3: Verify (S, G) ip mroutes")
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
@ -3604,27 +3643,30 @@ def test_shutdown_primary_path_p1(request):
iif = "r1-r3-eth2" iif = "r1-r3-eth2"
oif = "r1-r0-eth0" oif = "r1-r0-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: (*,G) mroutes are not cleared after shut of R1 to R3 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (*, G) ip mroutes") step("r2: Verify (*, G) ip mroutes")
dut = "r2" dut = "r2"
iif = "lo" iif = "lo"
oif = "r2-r3-eth1" oif = "r2-r3-eth1"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (*,G) mroutes are not cleared after shut of R1 to R3 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: Verify (*, G) ip mroutes") step("r3: Verify (*, G) ip mroutes")
dut = "r3" dut = "r3"
iif = "r3-r2-eth1" iif = "r3-r2-eth1"
oif = "r3-r1-eth0" oif = "r3-r1-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r3: (*,G) mroutes are not cleared after shut of R1 to R3 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r3: No shutdown the link from R1 to R3 from R3 node") step("r3: No shutdown the link from R1 to R3 from R3 node")
dut = "r3" dut = "r3"
@ -3784,18 +3826,20 @@ def test_delete_RP_shut_noshut_upstream_interface_p1(request):
iif = "r1-r2-eth1" iif = "r1-r2-eth1"
oif = "r1-r0-eth0" oif = "r1-r0-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (*, G) ip mroutes cleared") step("r2: Verify (*, G) ip mroutes cleared")
dut = "r2" dut = "r2"
iif = "lo" iif = "lo"
oif = "r2-r1-eth0" oif = "r2-r1-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -3905,18 +3949,20 @@ def test_delete_RP_shut_noshut_RP_interface_p1(request):
iif = "r1-r2-eth1" iif = "r1-r2-eth1"
oif = "r1-r0-eth0" oif = "r1-r0-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: (*,G) mroutes are not cleared after shut of R1 to R2 and R3 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
step("r2: Verify (*, G) ip mroutes cleared") step("r2: Verify (*, G) ip mroutes cleared")
dut = "r2" dut = "r2"
iif = "lo" iif = "lo"
oif = "r2-r1-eth0" oif = "r2-r1-eth0"
result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False) result = verify_ip_mroutes(tgen, dut, STAR, GROUP_ADDRESS, iif, oif, expected=False)
assert result is not True, "Testcase {} :Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r2: (*,G) mroutes are not cleared after shut of R1 to R2 and R3 link\n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)

30
tests/topotests/ospf_basic_functionality/test_ospf_chaos.py
View File

@ -249,16 +249,17 @@ def test_ospf_chaos_tc31_p1(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol,
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False expected=False)
) assert result is not True, ("Testcase {} : Failed \n "
assert result is not True, "Testcase {} : Failed \n Error: {}".format( "r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Bring up OSPFd daemon on R0.") step("Bring up OSPFd daemon on R0.")
start_router_daemons(tgen, "r0", ["ospfd"]) start_router_daemons(tgen, "r0", ["ospfd"])
@ -481,16 +482,17 @@ def test_ospf_chaos_tc34_p1(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol,
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False expected=False)
) assert result is not True, ("Testcase {} : Failed \n "
assert result is not True, "Testcase {} : Failed \n Error: {}".format( "r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Bring up staticd daemon on R0.") step("Bring up staticd daemon on R0.")
start_router_daemons(tgen, "r0", ["staticd"]) start_router_daemons(tgen, "r0", ["staticd"])

30
tests/topotests/ospf_basic_functionality/test_ospf_ecmp.py
View File

@ -259,17 +259,19 @@ def test_ospf_ecmp_tc16_p0(request):
shutdown_bringup_interface(tgen, dut, intf, False) shutdown_bringup_interface(tgen, dut, intf, False)
result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
for intfr in range(1, 7): for intfr in range(1, 7):
intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"] intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"]
@ -324,9 +326,10 @@ def test_ospf_ecmp_tc16_p0(request):
result = verify_ospf_rib( result = verify_ospf_rib(
tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
@ -339,9 +342,10 @@ def test_ospf_ecmp_tc16_p0(request):
attempts=5, attempts=5,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Re configure the static route in R0.") step("Re configure the static route in R0.")
dut = "r0" dut = "r0"
@ -428,9 +432,10 @@ def test_ospf_ecmp_tc17_p0(request):
result = verify_ospf_rib( result = verify_ospf_rib(
tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
@ -443,9 +448,10 @@ def test_ospf_ecmp_tc17_p0(request):
attempts=5, attempts=5,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Reconfigure the static route in R0.Change ECMP value to 2.") step("Reconfigure the static route in R0.Change ECMP value to 2.")
dut = "r0" dut = "r0"

10
tests/topotests/ospf_basic_functionality/test_ospf_ecmp_lan.py
View File

@ -307,9 +307,10 @@ def test_ospf_lan_ecmp_tc18_p0(request):
result = verify_ospf_rib( result = verify_ospf_rib(
tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False tgen, dut, input_dict, next_hop=nh, attempts=5, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
@ -322,9 +323,10 @@ def test_ospf_lan_ecmp_tc18_p0(request):
attempts=5, attempts=5,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)

5
tests/topotests/ospf_basic_functionality/test_ospf_lan.py
View File

@ -397,9 +397,10 @@ def test_ospf_lan_tc1_p0(request):
shutdown_bringup_interface(tgen, dut, intf, False) shutdown_bringup_interface(tgen, dut, intf, False)
result = verify_ospf_neighbor(tgen, topo, dut, lan=True, expected=False) result = verify_ospf_neighbor(tgen, topo, dut, lan=True, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r0: OSPF neighbors-hip is up \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("No Shut interface on R0") step("No Shut interface on R0")
dut = "r0" dut = "r0"

70
tests/topotests/ospf_basic_functionality/test_ospf_routemaps.py
View File

@ -332,16 +332,18 @@ def test_ospf_routemaps_functionality_tc19_p0(request):
} }
} }
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are present in fib \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Delete and reconfigure prefix list.") step("Delete and reconfigure prefix list.")
# Create ip prefix list # Create ip prefix list
@ -381,16 +383,18 @@ def test_ospf_routemaps_functionality_tc19_p0(request):
} }
} }
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
pfx_list = { pfx_list = {
"r0": { "r0": {
@ -434,16 +438,18 @@ def test_ospf_routemaps_functionality_tc19_p0(request):
} }
} }
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)
@ -490,16 +496,18 @@ def test_ospf_routemaps_functionality_tc20_p0(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, attempts=2, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, attempts=2, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, attempts=2, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, attempts=2, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step( step(
"configure the route map with the same name that is used " "configure the route map with the same name that is used "
@ -515,16 +523,18 @@ def test_ospf_routemaps_functionality_tc20_p0(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
# Create route map # Create route map
routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"action": "deny"}]}}} routemaps = {"r0": {"route_maps": {"rmap_ipv4": [{"action": "deny"}]}}}
@ -535,16 +545,18 @@ def test_ospf_routemaps_functionality_tc20_p0(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Delete the route map.") step("Delete the route map.")
# Create route map # Create route map
@ -561,16 +573,18 @@ def test_ospf_routemaps_functionality_tc20_p0(request):
dut = "r1" dut = "r1"
protocol = "ospf" protocol = "ospf"
result = verify_ospf_rib(tgen, dut, input_dict, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present \n Error: {}".format(
tc_name, result tc_name, result
) ))
result = verify_rib( result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: routes are still present \n Error: {}".format(
tc_name, result tc_name, result
) ))
write_test_footer(tc_name) write_test_footer(tc_name)

24
tests/topotests/ospf_basic_functionality/test_ospf_rte_calc.py
View File

@ -247,9 +247,11 @@ def test_ospf_redistribution_tc5_p0(request):
if result is not True: if result is not True:
break break
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present after deleting ip address of newly "
"configured interface of R0 \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
@ -262,9 +264,11 @@ def test_ospf_redistribution_tc5_p0(request):
attempts=5, attempts=5,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present in fib after deleting ip address of newly "
"configured interface of R0 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Add back the deleted ip address on newly configured interface of R0") step("Add back the deleted ip address on newly configured interface of R0")
topo1 = { topo1 = {
@ -366,9 +370,11 @@ def test_ospf_redistribution_tc6_p0(request):
result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False) result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False)
if result is not True: if result is not True:
break break
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present after deleting ip address of newly "
"configured loopback of R0 \n Error: {}".format(
tc_name, result tc_name, result
) ))
protocol = "ospf" protocol = "ospf"
result = verify_rib( result = verify_rib(
@ -380,9 +386,11 @@ def test_ospf_redistribution_tc6_p0(request):
next_hop=nh, next_hop=nh,
expected=False, expected=False,
) )
assert result is not True, "Testcase {} : Failed \n Error: {}".format( assert result is not True, ("Testcase {} : Failed \n "
"r1: OSPF routes are present in fib after deleting ip address of newly "
"configured loopback of R0 \n Error: {}".format(
tc_name, result tc_name, result
) ))
step("Add back the deleted ip address on newly configured interface of R0") step("Add back the deleted ip address on newly configured interface of R0")
topo1 = { topo1 = {

5
tests/topotests/static_routing_with_ebgp/test_static_routes_topo4_ebgp.py
View File

@ -949,9 +949,10 @@ def static_routes_rmap_pfxlist_p0_tc7_ebgp(request):
result4 = verify_rib( result4 = verify_rib(
tgen, addr_type, dut, input_dict, protocol=protocol, expected=False tgen, addr_type, dut, input_dict, protocol=protocol, expected=False
) )
assert result4 is not True, "Testcase {} : Failed \n" "Error: {}".format( assert result4 is not True, ("Testcase {} : Failed \n"
"routes are still present \n Error: {}".format(
tc_name, result4 tc_name, result4
) ))
step("vm4 should be present in FRR1") step("vm4 should be present in FRR1")
dut = "r1" dut = "r1"

5
tests/topotests/static_routing_with_ibgp/test_static_routes_topo4_ibgp.py
View File

@ -947,9 +947,10 @@ def test_static_routes_rmap_pfxlist_p0_tc7_ibgp(request):
result4 = verify_rib( result4 = verify_rib(
tgen, addr_type, dut, input_dict, protocol=protocol, expected=False tgen, addr_type, dut, input_dict, protocol=protocol, expected=False
) )
assert result4 is not True, "Testcase {} : Failed \n" "Error: {}".format( assert result4 is not True, ("Testcase {} : Failed \n"
"routes are still present \n Error: {}".format(
tc_name, result4 tc_name, result4
) ))
step("vm4 should be present in FRR1") step("vm4 should be present in FRR1")
dut = "r1" dut = "r1"