def test_caching_redis_keys(self, match_engine):
"""
Scenario: Test the caching mechanism which reduces number of redis calls
"""
global num_hits, num_miss, msgs
num_hits, num_miss, msgs = 0, 0, []
def verbose_print_mock(msg):
global num_hits, num_miss, msgs
if "Cache Hit for Key:" in msg:
num_hits = num_hits + 1
elif "Cache Miss for Key:" in msg:
num_miss = num_miss + 1
else:
return
msgs.append(msg)
with patch("dump.match_infra.verbose_print", verbose_print_mock):
m_route = Route(match_engine)
params = {Route.ARG_NAME: "20c0:e6e0:0:80::/64", "namespace": ""}
returned = m_route.execute(params)
expect = create_template_dict(dbs=["APPL_DB", "ASIC_DB"])
expect["APPL_DB"]["keys"].append("ROUTE_TABLE:20c0:e6e0:0:80::/64")
expect["ASIC_DB"]["keys"].extend(
self.get_asic_nh_group_expected(
get_asic_route_key("20c0:e6e0:0:80::/64")))
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
print(msgs)
assert num_hits == 0
assert num_miss == 11
num_hits, num_miss, msgs = 0, 0, []
params = {Route.ARG_NAME: "192.168.0.4/24", "namespace": ""}
returned = m_route.execute(params)
expect = create_template_dict(dbs=["APPL_DB", "ASIC_DB"])
expect["APPL_DB"]["keys"].append("ROUTE_TABLE:192.168.0.4/24")
expect["ASIC_DB"]["keys"].extend(
self.get_asic_nh_group_expected(
get_asic_route_key("192.168.0.4/24")))
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
print(msgs)
assert num_hits == 10
assert num_miss == 1
num_hits, num_miss, msgs = 0, 0, []
params = {Route.ARG_NAME: "192.168.0.10/22", "namespace": ""}
returned = m_route.execute(params)
expect = create_template_dict(dbs=["APPL_DB", "ASIC_DB"])
expect["APPL_DB"]["keys"].append("ROUTE_TABLE:192.168.0.10/22")
expect["ASIC_DB"]["keys"].extend(
self.get_asic_nh_group_expected(
get_asic_route_key("192.168.0.10/22")))
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
print(msgs)
assert num_hits == 10
assert num_miss == 1
def test_missing_state(self, match_engine):
"""
Scenario: When the application table is applied and state_db table is missing
"""
params = {Evpn.ARG_NAME: "Vlan2345:11.1.0.35", "namespace": ""}
m_evpn = Evpn(match_engine)
returned = m_evpn.execute(params)
expect = create_template_dict(dbs=["APPL_DB", "ASIC_DB", "STATE_DB"])
expect["APPL_DB"]["keys"].append(
"VXLAN_REMOTE_VNI_TABLE:Vlan2345:11.1.0.35")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL:oid:0x2a0000000007e3")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY:oid:0x2b0000000007e3"
)
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ea")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007e9")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ec")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007eb")
expect["STATE_DB"]["tables_not_found"].append("VXLAN_TUNNEL_TABLE")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_copp_cfg_file_group_and_copp_cfg_file_trap_with_diff(
self, match_engine):
'''
Scenario: User has added a trap_id to a COPP_TRAP entry. The COPP_TRAP entry is already present in copp_cfg file (i.e diff)
and the relevant trap group is in copp_cfg file
'''
params = {Copp.ARG_NAME: "ospfv6", "namespace": ""}
m_copp = Copp(match_engine)
returned = m_copp.execute(params)
print(returned)
expect = create_template_dict(
dbs=["CONFIG_FILE", "CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_FILE"]["keys"].extend(
["COPP_GROUP|queue4_group1", "COPP_TRAP|bgp"])
expect["CONFIG_DB"]["keys"].append("COPP_TRAP|bgp")
expect["APPL_DB"]["keys"].append("COPP_TABLE:queue4_group1")
expect["STATE_DB"]["keys"].extend(
["COPP_GROUP_TABLE|queue4_group1", "COPP_TRAP_TABLE|bgp"])
expect["ASIC_DB"]["keys"].extend([
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF_TRAP:oid:0x220000000004df",
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF_TRAP_GROUP:oid:0x110000000004db",
"ASIC_STATE:SAI_OBJECT_TYPE_POLICER:oid:0x120000000004dc",
"ASIC_STATE:SAI_OBJECT_TYPE_QUEUE:oid:0x150000000002a1"
])
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_working_state(self, match_engine):
"""
Scenario: When the appl info is properly applied and propagated
"""
params = {Evpn.ARG_NAME: "Vlan2345:11.1.0.32", "namespace": ""}
m_evpn = Evpn(match_engine)
returned = m_evpn.execute(params)
expect = create_template_dict(dbs=["APPL_DB", "ASIC_DB", "STATE_DB"])
expect["APPL_DB"]["keys"].append(
"VXLAN_REMOTE_VNI_TABLE:Vlan2345:11.1.0.32")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL:oid:0x2a0000000007e1")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY:oid:0x2b0000000007e1"
)
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ea")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007e9")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ec")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007eb")
expect["STATE_DB"]["keys"].append("VXLAN_TUNNEL_TABLE|EVPN_11.1.0.32")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def execute(self, params):
self.ret_temp = create_template_dict(dbs=["CONFIG_DB", "ASIC_DB"])
acl_table_name = params[self.ARG_NAME]
self.ns = params["namespace"]
self.init_acl_table_config_info(acl_table_name)
self.init_acl_table_asic_info(acl_table_name)
return self.ret_temp
def test_lag_type_interface(self, match_engine):
"""
Scenario: Test the flow fetching objs related to LAG_TYPE iface
"""
params = {Interface.ARG_NAME: "PortChannel1234", "namespace": ""}
m_intf = Interface(match_engine)
returned = m_intf.execute(params)
expect = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].extend([
"PORTCHANNEL_INTERFACE|PortChannel1234",
"PORTCHANNEL_INTERFACE|PortChannel1234|7.7.7.1/24"
])
expect["APPL_DB"]["keys"].extend([
"INTF_TABLE:PortChannel1234",
"INTF_TABLE:PortChannel1234:7.7.7.1/24"
])
expect["STATE_DB"]["keys"].extend([
"INTERFACE_TABLE|PortChannel1234",
"INTERFACE_TABLE|PortChannel1234|7.7.7.1/24"
])
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE:oid:0x60000000005ec")
ddiff = DeepDiff(sort_lists(returned),
sort_lists(expect),
ignore_order=True)
assert not ddiff, ddiff
def test_missing_asic_vxlan_tunnel_term(self, match_engine):
"""
Scenario: When the config was applied and just SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY is missing in the asic db
"""
params = {Vxlan_tunnel.ARG_NAME: "vtep_1000", "namespace": ""}
m_vxlan_tunnel = Vxlan_tunnel(match_engine)
returned = m_vxlan_tunnel.execute(params)
expect = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("VXLAN_TUNNEL|vtep_1000")
expect["APPL_DB"]["keys"].append("VXLAN_TUNNEL_TABLE:vtep_1000")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL:oid:0x2a0000000007ef")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ba")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007b9")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007bc")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007bb")
expect["ASIC_DB"]["tables_not_found"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY")
expect["STATE_DB"]["tables_not_found"].append("VXLAN_TUNNEL_TABLE")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_working_state(self, match_engine):
"""
Scenario: When the config is properly applied and propagated
"""
params = {Vxlan_tunnel.ARG_NAME: "vtep_1336", "namespace": ""}
m_vxlan_tunnel = Vxlan_tunnel(match_engine)
returned = m_vxlan_tunnel.execute(params)
expect = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("VXLAN_TUNNEL|vtep_1336")
expect["APPL_DB"]["keys"].append("VXLAN_TUNNEL_TABLE:vtep_1336")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL:oid:0x2a0000000007ed")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY:oid:0x2b0000000007ee"
)
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ea")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007e9")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007ec")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007eb")
expect["STATE_DB"]["tables_not_found"].append("VXLAN_TUNNEL_TABLE")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_copp_cfg_file_trap_and_copp_cfg_file_grp_with_diff(
self, match_engine):
'''
Scenario: Both the Trap ID and Trap Group are configured through copp_cfg file.
In addition, User also provided a diff for the COPP_GROUP entry
'''
params = {Copp.ARG_NAME: "sample_packet", "namespace": ""}
m_copp = Copp(match_engine)
returned = m_copp.execute(params)
print(json.dumps(returned, indent=2))
expect = create_template_dict(
dbs=["CONFIG_FILE", "CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_FILE"]["keys"].extend(
["COPP_GROUP|queue2_group1", "COPP_TRAP|sflow"])
expect["CONFIG_DB"]["keys"].append("COPP_GROUP|queue2_group1")
expect["APPL_DB"]["keys"].append("COPP_TABLE:queue2_group1")
expect["STATE_DB"]["keys"].extend(
["COPP_GROUP_TABLE|queue2_group1", "COPP_TRAP_TABLE|sflow"])
expect["ASIC_DB"]["keys"].extend([
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF_TRAP:oid:0x220000000004de",
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF_TRAP_GROUP:oid:0x110000000004db",
"ASIC_STATE:SAI_OBJECT_TYPE_POLICER:oid:0x120000000004dc",
"ASIC_STATE:SAI_OBJECT_TYPE_QUEUE:oid:0x150000000002a1",
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd0000000004d6",
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF_TABLE_ENTRY:oid:0x230000000004d8"
])
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def execute(self, params):
self.ret_temp = create_template_dict(
dbs=["APPL_DB", "ASIC_DB", "STATE_DB"])
fdb_entry = params[Fdb.ARG_NAME]
self.ns = params["namespace"]
self.init_fdb_appl_info(fdb_entry)
self.init_asic_fdb_info(fdb_entry)
self.init_state_fdb_info(fdb_entry)
return self.ret_temp
def execute(self, params_dict):
self.ret_temp = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
vlan_name = params_dict[Vlan.ARG_NAME]
self.ns = params_dict["namespace"]
self.init_vlan_config_info(vlan_name)
self.init_vlan_appl_info(vlan_name)
self.init_state_vlan_info(vlan_name)
self.init_asic_vlan_info(vlan_name)
return self.ret_temp
def execute(self, params):
self.ret_temp = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
port_name = params[Port.ARG_NAME]
self.ns = params["namespace"]
self.init_port_config_info(port_name)
self.init_port_appl_info(port_name)
port_asic_obj = self.init_asic_hostif_info(port_name)
self.init_asic_port_info(port_asic_obj)
self.init_state_port_info(port_name)
return self.ret_temp
def execute(self, params):
self.ret_temp = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB"])
vxlan_tunnel_map_name = params[Vxlan_tunnel_map.ARG_NAME]
self.ns = params["namespace"]
self.init_vxlan_tunnel_map_config_info(vxlan_tunnel_map_name)
self.init_vxlan_tunnel_map_appl_info(vxlan_tunnel_map_name)
self.init_asic_vxlan_tunnel_map_entry_info()
self.init_asic_vxlan_tunnel_map_info()
return self.ret_temp
def test_no_counter_mapping(self, match_engine):
"""
Scenario: When there is no ACL_COUNTER_RULE_MAP mapping for rule
"""
params = {Acl_Table.ARG_NAME: "DATAACL1", "namespace": ""}
m_acl_table = Acl_Table(match_engine)
returned = m_acl_table.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "ASIC_DB"])
expect["CONFIG_DB"]["keys"].append("ACL_TABLE|DATAACL1")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect))
assert not ddiff, ddiff
def execute(self, params):
self.ret_temp = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB", "CONFIG_FILE"])
self.ns = params["namespace"]
self.trap_id = params[Copp.ARG_NAME]
self.copp_trap_cfg_key = ""
self.trap_group = ""
self.handle_user_and_default_config()
self.handle_appl_db()
self.handle_asic_db()
self.handle_state_db()
return self.ret_temp
def execute(self, params):
self.ret_temp = create_template_dict(dbs=["CONFIG_DB", "ASIC_DB"])
try:
acl_table_name, acl_rule_name = params[self.ARG_NAME].split(CFG_DB_SEPARATOR, 1)
except ValueError:
raise ValueError(f"Invalid rule name passed {params[self.ARG_NAME]}")
self.ns = params["namespace"]
self.init_acl_rule_config_info(acl_table_name, acl_rule_name)
self.init_acl_rule_asic_info(acl_table_name, acl_rule_name)
return self.ret_temp
def test_loopback_interface(self, match_engine):
"""
Scenario: Test the flow fetching objs related to loopback iface
"""
params = {Interface.ARG_NAME: "Loopback0", "namespace": ""}
m_intf = Interface(match_engine)
returned = m_intf.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].extend(["LOOPBACK_INTERFACE|Loopback0", "LOOPBACK_INTERFACE|Loopback0|10.1.0.1/32"])
expect["APPL_DB"]["keys"].extend(["INTF_TABLE:Loopback0", "INTF_TABLE:Loopback0:10.1.0.1/32"])
expect["STATE_DB"]["keys"].extend(["INTERFACE_TABLE|Loopback0", "INTERFACE_TABLE|Loopback0|10.1.0.1/32"])
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def test_working_state_vlan(self, match_engine):
params = {}
params["namespace"] = ""
params[Vlan.ARG_NAME] = "Vlan4"
m_vlan = Vlan(match_engine)
returned = m_vlan.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("VLAN|Vlan4")
expect["APPL_DB"]["keys"].append("VLAN_TABLE:Vlan4")
expect["STATE_DB"]["keys"].append("VLAN_TABLE|Vlan4")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_VLAN:oid:0x26000000000619")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def execute(self, params):
self.ret_temp = create_template_dict(
dbs=["APPL_DB", "ASIC_DB", "STATE_DB"])
evpn_name = params[Evpn.ARG_NAME]
self.remote_ip = evpn_name.split(':')[-1]
self.remote_vlan = evpn_name.split(':')[0]
self.ns = params["namespace"]
self.init_evpn_appl_info(evpn_name)
self.init_asic_evpn_info()
self.init_asic_evpn_map_info()
self.init_asic_evpn_term_info()
self.init_state_evpn_info(evpn_name)
return self.ret_temp
def test_garbage_number_vlan(self, match_engine):
params = {}
params[Vlan.ARG_NAME] = "614"
params["namespace"] = ""
m_vlan = Vlan(match_engine)
returned = m_vlan.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["tables_not_found"].append("VLAN")
expect["APPL_DB"]["tables_not_found"].append("VLAN_TABLE")
expect["STATE_DB"]["tables_not_found"].append("VLAN_TABLE")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_VLAN")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_basic(self, match_engine):
"""
Scenario: When the config is properly applied and propagated
"""
params = {Acl_Rule.ARG_NAME: "DATAACL|R0", "namespace": ""}
m_acl_rule = Acl_Rule(match_engine)
returned = m_acl_rule.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "ASIC_DB"])
expect["CONFIG_DB"]["keys"].append("ACL_RULE|DATAACL|R0")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_COUNTER:oid:0x9000000000606")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_ENTRY:oid:0x8000000000609")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect))
assert not ddiff, ddiff
def test_no_interface(self, match_engine):
"""
Scenario: Test the flow fetching objs related to an interface which is not present
"""
params = {Interface.ARG_NAME: "Ethernet160", "namespace": ""}
m_intf = Interface(match_engine)
returned = m_intf.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["tables_not_found"].extend(["INTERFACE"])
expect["APPL_DB"]["tables_not_found"].extend(["INTF_TABLE"])
expect["STATE_DB"]["tables_not_found"].extend(["INTERFACE_TABLE"])
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def test_missing_asic_db_member(self, match_engine):
params = {}
params[Vlan_Member.ARG_NAME] = "Vlan8|Ethernet72"
params["namespace"] = ""
m_vlan = Vlan_Member(match_engine)
returned = m_vlan.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("VLAN_MEMBER|Vlan8|Ethernet72")
expect["APPL_DB"]["keys"].append("VLAN_MEMBER_TABLE:Vlan8:Ethernet72")
expect["STATE_DB"]["keys"].append("VLAN_MEMBER_TABLE|Vlan8|Ethernet72")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_VLAN_MEMBER")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_BRIDGE_PORT")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def test_no_vxlan_tunnel_map(self, match_engine):
"""
Scenario: When the config was not present
"""
params = {Vxlan_tunnel_map.ARG_NAME: "vtep_1338|map_1339_Vlan2348", "namespace": ""}
m_vxlan_tunnel_map = Vxlan_tunnel_map(match_engine)
returned = m_vxlan_tunnel_map.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB"])
expect["CONFIG_DB"]["tables_not_found"].append("VXLAN_TUNNEL_MAP")
expect["APPL_DB"]["tables_not_found"].append("VXLAN_TUNNEL_MAP_TABLE")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_missing_asic_vxlan_tunnel_map_entry(self, match_engine):
"""
Scenario: When the config was applied and asic db tables are missing
"""
params = {Vxlan_tunnel_map.ARG_NAME: "vtep_1336|map_1337_Vlan2346", "namespace": ""}
m_vxlan_tunnel_map = Vxlan_tunnel_map(match_engine)
returned = m_vxlan_tunnel_map.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB"])
expect["CONFIG_DB"]["keys"].append("VXLAN_TUNNEL_MAP|vtep_1336|map_1337_Vlan2346")
expect["APPL_DB"]["keys"].append("VXLAN_TUNNEL_MAP_TABLE:vtep_1336:map_1337_Vlan2346")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY")
expect["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_working_state(self, match_engine):
"""
Scenario: When the config is properly applied and propagated
"""
params = {Vxlan_tunnel_map.ARG_NAME: "vtep_1336|map_1336_Vlan2345", "namespace": ""}
m_vxlan_tunnel_map = Vxlan_tunnel_map(match_engine)
returned = m_vxlan_tunnel_map.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB"])
expect["CONFIG_DB"]["keys"].append("VXLAN_TUNNEL_MAP|vtep_1336|map_1336_Vlan2345")
expect["APPL_DB"]["keys"].append("VXLAN_TUNNEL_MAP_TABLE:vtep_1336:map_1336_Vlan2345")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY:oid:0x3b0000000007ef")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP:oid:0x290000000007e9")
ddiff = DeepDiff(returned, expect, ignore_order=True)
assert not ddiff, ddiff
def test_working_state_vlan_member2(self, match_engine):
params = {}
params["namespace"] = ""
params[Vlan_Member.ARG_NAME] = "Vlan4|Ethernet24"
m_vlan = Vlan_Member(match_engine)
returned = m_vlan.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("VLAN_MEMBER|Vlan4|Ethernet24")
expect["APPL_DB"]["keys"].append("VLAN_MEMBER_TABLE:Vlan4:Ethernet24")
expect["STATE_DB"]["keys"].append("VLAN_MEMBER_TABLE|Vlan4|Ethernet24")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_VLAN_MEMBER:oid:0x27000000000624")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_BRIDGE_PORT:oid:0x3a000000000623")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def execute(self, params):
self.ret_temp = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "STATE_DB", "ASIC_DB"])
self.intf_name = params[Interface.ARG_NAME]
self.ns = params["namespace"]
# CONFIG_DB
self.intf_type = self.init_intf_config_info()
# APPL_DB
self.init_intf_appl_info()
# STATE_DB
self.init_intf_state_info()
# ASIC_DB
self.init_intf_asic_info()
return self.ret_temp
def test_vlan_type_interface(self, match_engine):
"""
Scenario: Test the flow fetching objs related to VLAN_TYPE interfac
"""
params = {Interface.ARG_NAME: "Vlan10", "namespace": ""}
m_intf = Interface(match_engine)
returned = m_intf.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].extend(["VLAN_INTERFACE|Vlan10", "VLAN_INTERFACE|Vlan10|2.2.2.1/24"])
expect["APPL_DB"]["keys"].extend(["INTF_TABLE:Vlan10", "INTF_TABLE:Vlan10:2.2.2.1/24"])
expect["STATE_DB"]["keys"].extend(["INTERFACE_TABLE|Vlan10", "INTERFACE_TABLE|Vlan10|2.2.2.1/24"])
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE:oid:0x6000000000c7b")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
def test_subintf_with_invalid_vlan(self, match_engine):
"""
Scenario: Test the flow fetching objs related to a subintf with invalid vlan
"""
params = {Interface.ARG_NAME: "Eth4.1", "namespace": ""}
m_intf = Interface(match_engine)
returned = m_intf.execute(params)
expect = create_template_dict(dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].extend(["VLAN_SUB_INTERFACE|Eth4.1"])
expect["APPL_DB"]["keys"].extend(["INTF_TABLE:Eth4.1"])
expect["STATE_DB"]["tables_not_found"].extend(["INTERFACE_TABLE"])
expect["ASIC_DB"]["tables_not_found"].extend(["ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE"])
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect), ignore_order=True)
assert not ddiff, ddiff
