def test_large_community_after_clear_bgp(request):
"""
Clear BGP neighbor-ship and check if large community and community
attributes are getting re-populated.
"""
tc_name = request.node.name
write_test_header(tc_name)
tgen = get_topogen()
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
reset_config_on_routers(tgen)
config_router_r1(tgen, topo, tc_name)
input_dict = {"largeCommunity": LARGE_COMM["r1"], "community": STANDARD_COMM["r1"]}
for adt in ADDR_TYPES:
result = verify_bgp_community(tgen, adt, "r2", [NETWORK[adt][0]], input_dict)
assert result is True, "Test case {} : Failed \n Error: {}".format(
tc_name, result
)
step("Clearing BGP on r1")
clear_bgp_and_verify(tgen, topo, "r1")
for adt in ADDR_TYPES:
result = verify_bgp_community(tgen, adt, "r2", [NETWORK[adt][0]], input_dict)
assert result is True, "Test case {} : Failed \n Error: {}".format(
tc_name, result
)
write_test_footer(tc_name)
def test_bgp_timers_functionality(request):
"""
Test to modify bgp timers and verify timers functionality.
"""
tgen = get_topogen()
if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure')
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Api call to modfiy BGP timerse
input_dict = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r2": {
"dest_link":{
"r1": {
"keepalivetimer": 60,
"holddowntimer": 180,
}
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, deepcopy(input_dict))
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
# Api call to clear bgp, so timer modification would take place
clear_bgp_and_verify(tgen, topo, 'r1')
# Verifying bgp timers functionality
result = verify_bgp_timers_and_functionality(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
write_test_footer(tc_name)
def test_ecmp_after_clear_bgp(request):
""" Verify BGP table and RIB in DUT after clear BGP routes and neighbors"""
tc_name = request.node.name
write_test_header(tc_name)
tgen = get_topogen()
reset_config_on_routers(tgen)
# Verifying RIB routes
dut = "r3"
protocol = "bgp"
static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES:
input_dict_1 = {
"r3": {
"static_routes": [{
"network": NETWORK[addr_type]
}]
}
}
logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen,
addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
# Clear bgp
result = clear_bgp_and_verify(tgen, topo, dut)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
input_dict_1 = {
"r3": {
"static_routes": [{
"network": NETWORK[addr_type]
}]
}
}
logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen,
addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_clear_bgp_and_verify(request):
"""
Created few static routes and verified all routes are learned via BGP
cleared BGP and verified all routes are intact
"""
tgen = get_topogen()
if BGP_CONVERGENCE is not True:
pytest.skip("skipped because of BGP Convergence failure")
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# clear ip bgp
result = clear_bgp_and_verify(tgen, topo, "r1")
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name)
def test_static_routes_rmap_pfxlist_p0_tc7_ibgp(request):
"""
Verify static route are blocked from route-map & prefix-list applied in BGP
nbrs
"""
tc_name = request.node.name
write_test_header(tc_name)
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
reset_config_on_routers(tgen)
step("Configure holddown timer = 1 keep alive = 3 in all the neighbors")
step("verify bgp convergence before starting test case")
bgp_convergence = verify_bgp_convergence(tgen, topo)
assert bgp_convergence is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, bgp_convergence
)
step(
"Configure 4 IPv4 and 4 IPv6 nbrs with password with mismatch "
" authentication between FRR routers "
)
for addr_type in ADDR_TYPES:
# Api call to modfiy BGP timerse
input_dict = {
"r2": {
"bgp": {
"local_as": "200",
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2-link0": {"password": "******"},
"r2-link1": {"password": "******"},
"r2-link2": {"password": "******"},
"r2-link3": {"password": "******"},
}
},
"r3": {
"dest_link": {
"r2-link0": {"password": "******"},
"r2-link1": {"password": "******"},
"r2-link2": {"password": "******"},
"r2-link3": {"password": "******"},
}
},
}
}
}
},
}
}
}
result = create_router_bgp(tgen, topo, deepcopy(input_dict))
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
clear_bgp(tgen, addr_type, "r2")
step(" All BGP nbrs are down as authentication is mismatch on both" " the sides")
bgp_convergence = verify_bgp_convergence(tgen, topo, expected=False)
assert bgp_convergence is not True, "Testcase {} : "
"Failed \n BGP nbrs must be down. Error: {}".format(tc_name, bgp_convergence)
step(
"Configure 4 IPv4 and 4 IPv6 nbrs with macthing password "
" authentication between FRR routers "
)
for addr_type in ADDR_TYPES:
input_dict = {
"r2": {
"bgp": {
"local_as": "200",
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2-link0": {"password": "******"},
"r2-link1": {"password": "******"},
"r2-link2": {"password": "******"},
"r2-link3": {"password": "******"},
}
},
"r3": {
"dest_link": {
"r2-link0": {"password": "******"},
"r2-link1": {"password": "******"},
"r2-link2": {"password": "******"},
"r2-link3": {"password": "******"},
}
},
}
}
}
},
}
}
}
result = create_router_bgp(tgen, topo, deepcopy(input_dict))
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
step("All BGP nbrs are up as authentication is matched now")
bgp_convergence = verify_bgp_convergence(tgen, topo)
assert bgp_convergence is True, "Testcase {} : Failed \n " "Error: {}".format(
tc_name, bgp_convergence
)
step("Create prefix list P1 to permit VM3 & deny VM1 v4 & v6 routes")
step("Create prefix list P2 to permit VM6 IPv4 and IPv6 routes")
for addr_type in ADDR_TYPES:
input_dict_2 = {
"r2": {
"prefix_lists": {
addr_type: {
"pf_list_1_{}".format(addr_type): [
{
"seqid": 10,
"network": topo["routers"]["r2"]["links"]["vm3"][
addr_type
],
"action": "permit",
},
{
"seqid": 20,
"network": topo["routers"]["r2"]["links"]["vm1"][
addr_type
],
"action": "deny",
},
],
"pf_list_2_{}".format(addr_type): [
{
"seqid": 10,
"network": topo["routers"]["r2"]["links"]["vm6"][
addr_type
],
"action": "permit",
}
],
}
}
}
}
result = create_prefix_lists(tgen, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"Prefix list created with matching networks deny or permit "
"show ip prefix list"
)
result = verify_prefix_lists(tgen, input_dict_2)
assert result is not True, "Testcase {} : Failed \n"
" Error: {}".format(tc_name, result)
step("Redistribute all the routes (connected, static)")
input_dict_2_r1 = {
"r1": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "static"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
input_dict_2_r2 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "static"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2_r2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
input_dict_2_r3 = {
"r3": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "static"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2_r3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("configure redistribute connected in Router BGP")
input_dict_2_r1 = {
"r1": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
input_dict_2_r3 = {
"r3": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2_r3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
input_dict_2 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Apply prefix list P1 on BGP neighbors 1 2 3 4 connected from " "frr r1")
# Configure prefix list to bgp neighbor
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2-link0": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link1": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link2": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link3": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Apply prefix list P2 on BGP nbrs 5 & 6 connected from FRR-2")
# Configure prefix list to bgp neighbor
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r2-link0": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link1": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link2": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
}
]
},
"r2-link3": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
clear_bgp_and_verify(tgen, topo, "r2")
step(
"VM1 IPv4 and IPv6 Route which is denied using prefix list is "
"not present on FRR1 side routing table , also not able to "
"ping the routes show ip route"
)
dut = "r1"
protocol = "bgp"
ntwk_r2_vm1 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r2"]["links"]["vm1"][addr_type])
).network
)
input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}}
result4 = verify_rib(
tgen, addr_type, dut, input_dict, protocol=protocol, expected=False
)
assert result4 is not True, "Testcase {} : Failed , VM1 route is "
"not filtered out via prefix list. \n Error: {}".format(tc_name, result4)
step(
"VM4 and VM6 IPV4 and IPv6 address are present in local and "
"FRR2 routing table show ip bgp show ip route"
)
dut = "r2"
ntwk_r2_vm6 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r2"]["links"]["vm6"][addr_type])
).network
)
input_dict = {"r3": {"static_routes": [{"network": ntwk_r2_vm6}]}}
result4 = verify_rib(tgen, addr_type, dut, input_dict)
assert result4 is True, "Testcase {} : Failed.\n Error: {}".format(
tc_name, result4
)
step("Remove prefix list from all the neighbors")
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2-link0": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link1": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link2": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link3": {
"prefix_lists": [
{
"name": "pf_list_1_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r2-link0": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link1": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link2": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
"r2-link3": {
"prefix_lists": [
{
"name": "pf_list_2_{}".format(
addr_type
),
"direction": "out",
"delete": True,
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
clear_bgp_and_verify(tgen, topo, "r2")
step("Create RouteMap_1 with prefix list P1 and weight 50")
# Create route map
rmap_dict = {
"r2": {
"route_maps": {
"rmap_pf_list_1_{}".format(addr_type): [
{
"action": "permit",
"set": {"weight": 50},
"match": {
addr_type: {
"prefix_lists": "pf_list_1_{}".format(addr_type)
}
},
}
]
}
}
}
result = create_route_maps(tgen, rmap_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Create RouteMap_2 with prefix list P2 and weight 50")
# Create route map
rmap_dict = {
"r2": {
"route_maps": {
"rmap_pf_list_2_{}".format(addr_type): [
{
"action": "permit",
"set": {"weight": 50},
"match": {
addr_type: {
"prefix_lists": "pf_list_2_{}".format(addr_type)
}
},
}
]
}
}
}
result = create_route_maps(tgen, rmap_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Verify Route-map created verify using show route-map")
# verify rmap_pf_list_1 and rmap_pf_list_2 are present in router r2
input_dict = {
"r2": {
"route_maps": [
"rmap_pf_list_1_{}".format(addr_type),
"rmap_pf_list_2_{}".format(addr_type),
]
}
}
result = verify_route_maps(tgen, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Apply policy RouteMap_1 nbrs 1 2 3 4 to FRR 1")
# Configure prefix list to bgp neighbor
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r2-link0": {
"route_maps": [
{
"name": "rmap_pf_list_1_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link1": {
"route_maps": [
{
"name": "rmap_pf_list_1_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link2": {
"route_maps": [
{
"name": "rmap_pf_list_1_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link3": {
"route_maps": [
{
"name": "rmap_pf_list_1_"
"{}".format(addr_type),
"direction": "out",
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Apply policy RouteMap_2 nbrs 5 and 6 to FRR2")
# Configure prefix list to bgp neighbor
input_dict_4 = {
"r2": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r2-link0": {
"route_maps": [
{
"name": "rmap_pf_list_2_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link1": {
"route_maps": [
{
"name": "rmap_pf_list_2_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link2": {
"route_maps": [
{
"name": "rmap_pf_list_2_"
"{}".format(addr_type),
"direction": "out",
}
]
},
"r2-link3": {
"route_maps": [
{
"name": "rmap_pf_list_2_"
"{}".format(addr_type),
"direction": "out",
}
]
},
}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"After applying to BGP neighbors verify VM1 IPv4 and IPv6 Route"
" which is denied using prefix list is not present on FRR side"
" routing table , also not able to ping the routes show ip route"
" and VM4 and VM6 IPV4 and IPv6 address are present in local and"
" FRR routing table show ip bgp show ip route"
)
dut = "r1"
protocol = "bgp"
ntwk_r2_vm1 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r2"]["links"]["vm1"][addr_type])
).network
)
input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}}
result4 = verify_rib(
tgen, addr_type, dut, input_dict, protocol=protocol, expected=False
)
assert (
result4 is not True
), "Testcase {} : Failed \n" "routes are still present \n Error: {}".format(
tc_name, result4
)
step("vm4 should be present in FRR1")
dut = "r1"
ntwk_r2_vm1 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r1"]["links"]["vm4"][addr_type])
).network
)
input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}}
result4 = verify_rib(tgen, addr_type, dut, input_dict)
assert result4 is True, "Testcase {} : Failed , VM1 route is "
"not filtered out via prefix list. \n Error: {}".format(tc_name, result4)
step("vm4 should be present in FRR2")
dut = "r2"
ntwk_r2_vm1 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r1"]["links"]["vm4"][addr_type])
).network
)
input_dict = {"r1": {"static_routes": [{"network": ntwk_r2_vm1}]}}
result4 = verify_rib(tgen, addr_type, dut, input_dict)
assert result4 is True, "Testcase {} : Failed , VM1 route is "
"not filtered out via prefix list. \n Error: {}".format(tc_name, result4)
dut = "r3"
protocol = "bgp"
ntwk_r2_vm6 = str(
ipaddress.ip_interface(
u"{}".format(topo["routers"]["r2"]["links"]["vm6"][addr_type])
).network
)
input_dict = {"r3": {"static_routes": [{"network": ntwk_r2_vm6}]}}
result4 = verify_rib(tgen, addr_type, dut, input_dict, protocol=protocol)
assert result4 is True, "Testcase {} : Failed.\n Error: {}".format(
tc_name, result4
)
write_test_footer(tc_name)
def test_modify_prefix_lists_out_permit_to_deny(request):
"""
Modify ip prefix list and test permit to deny prefixes OUT direction
"""
tgen = get_topogen()
if BGP_CONVERGENCE is not True:
pytest.skip("skipped because of BGP Convergence failure")
# test case name
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
reset_config_on_routers(tgen)
# Create Static Routes
input_dict = {
"r1": {
"static_routes": [
{"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"}
]
}
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Api call to redistribute static routes
# Create ip prefix list
input_dict_1 = {
"r3": {
"prefix_lists": {
"ipv4": {
"pf_list_1": [
{
"seqid": "10",
"network": "10.0.0.0/8",
"le": "32",
"action": "permit",
}
]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Configure prefix list to bgp neighbor
input_dict_2 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [
{"redist_type": "static"},
{"redist_type": "connected"},
]
}
}
}
}
},
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r4": {
"dest_link": {
"r3": {
"prefix_lists": [
{
"name": "pf_list_1",
"direction": "out",
}
]
}
}
}
}
}
}
}
}
},
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Verifying RIB routes
dut = "r4"
protocol = "bgp"
result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Modify ip prefix list
input_dict_1 = {
"r3": {
"prefix_lists": {
"ipv4": {
"pf_list_1": [
{
"seqid": "10",
"network": "10.0.0.0/8",
"le": "32",
"action": "deny",
},
{"seqid": "11", "network": "any", "action": "permit"},
]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Api call to clear bgp, so config changes would be reflected
dut = "r3"
result = clear_bgp_and_verify(tgen, topo, dut)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Verifying RIB routes
dut = "r4"
protocol = "bgp"
result = verify_rib(
tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False
)
assert (
result is not True
), "Testcase {} : Failed \n Error: Routes still" " present in RIB".format(tc_name)
write_test_footer(tc_name)
