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_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 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_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_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 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
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_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 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_with_ranges(self, match_engine):
"""
Scenario: When ACL rule has range configuration
"""
params = {Acl_Rule.ARG_NAME: "DATAACL2|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|DATAACL2|R0")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_COUNTER:oid:0x9100000000606")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_ENTRY:oid:0x8100000000609")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_RANGE:oid:0xa100000000607")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_RANGE:oid:0xa100000000608")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect))
assert not ddiff, ddiff
def test_basic(self, match_engine):
"""
Scenario: When the basic config is properly applied and propagated
"""
params = {Acl_Table.ARG_NAME: "DATAACL", "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|DATAACL")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE:oid:0x7000000000600")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP_MEMBER:oid:0xc000000000601")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP_MEMBER:oid:0xc000000000602")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP:oid:0xb0000000005f5")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP:oid:0xb0000000005f7")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect))
assert not ddiff, ddiff
def test_with_table_type(self, match_engine):
"""
Scenario: When there is ACL_TABLE_TYPE configured for this table
"""
params = {Acl_Table.ARG_NAME: "DATAACL2", "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|DATAACL2")
expect["CONFIG_DB"]["keys"].append("ACL_TABLE_TYPE|MY_TYPE")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE:oid:0x7100000000600")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP_MEMBER:oid:0xc100000000601")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP_MEMBER:oid:0xc100000000602")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP:oid:0xb0000000005f5")
expect["ASIC_DB"]["keys"].append("ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP:oid:0xb0000000005f7")
ddiff = DeepDiff(sort_lists(returned), sort_lists(expect))
assert not ddiff, ddiff
def test_missing_asic_port(self, match_engine):
"""
Scenario: When the config was applied and just the SAI_OBJECT_TYPE_PORT is missing
"""
params = {Port.ARG_NAME: "Ethernet160", "namespace": ""}
m_port = Port(match_engine)
returned = m_port.execute(params)
expect = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("PORT|Ethernet160")
expect["APPL_DB"]["keys"].append("PORT_TABLE:Ethernet160")
expect["STATE_DB"]["keys"].append("PORT_TABLE|Ethernet160")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd000000000a49")
expect["ASIC_DB"]["tables_not_found"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_PORT")
ddiff = DeepDiff(sort_lists(returned),
sort_lists(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 = {Port.ARG_NAME: "Ethernet176", "namespace": ""}
m_port = Port(match_engine)
returned = m_port.execute(params)
expect = create_template_dict(
dbs=["CONFIG_DB", "APPL_DB", "ASIC_DB", "STATE_DB"])
expect["CONFIG_DB"]["keys"].append("PORT|Ethernet176")
expect["APPL_DB"]["keys"].append("PORT_TABLE:Ethernet176")
expect["STATE_DB"]["keys"].append("PORT_TABLE|Ethernet176")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_PORT:oid:0x100000000036a")
expect["ASIC_DB"]["keys"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF:oid:0xd000000000a4d")
ddiff = DeepDiff(sort_lists(returned),
sort_lists(expect),
ignore_order=True)
assert not ddiff, ddiff
