3.5. honeycomb

3.5.1. access_control_lists suite

3.5.1.1. Honeycomb creates ACL table

Uses Honeycomb API to create an ACL table.

Arguments: - node - information about a DUT node. Type: dictionary - settings - ACL table settings. Type: dictionary

Example:

| Honeycomb creates ACL table | ${nodes[‘DUT1’]} | ${settings} |


Add classify table  ${node}  ${settings}

3.5.1.2. Honeycomb removes ACL table

Uses Honeycomb API to remove and existing ACL table.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string

Example:

| Honeycomb removes ACL table | ${nodes[‘DUT1’]} | table0 |


Remove classify table  ${node}  ${table_name}

3.5.1.3. Honeycomb adds ACL session

Uses Honeycomb API to create an ACL session.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string - settings - ACL session settings. Type: dictionary

Example:

| Honeycomb adds ACL session | ${nodes[‘DUT1’]} | table0 | ${settings} |


Add classify session  ${node}  ${table_name}  ${settings}

3.5.1.4. Honeycomb removes ACL session

Uses Honeycomb API to remove an ACL session.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string - match - ACL session match setting. Type: string

Example:

| Honeycomb removes ACL session | ${nodes[‘DUT1’]} | table0 | 00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00 |


Remove classify session  ${node}  ${table_name}  ${match}

3.5.1.5. Honeycomb enables ACL on interface

Uses Honeycomb API to enable ACL on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - table_name - name of an ACL table. Type: string

Example:

| Honeycomb enables ACL on interface | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 | table0 |


Enable ACL on interface  ${node}  ${interface}  ${table_name}

3.5.1.6. Honeycomb disables ACL on interface

Uses Honeycomb API to disable ACL on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb disables ACL on interface | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 |


Disable ACL on interface  ${node}  ${interface}

3.5.1.7. ACL table from Honeycomb should be

Retrieves ACL table information from Honeycomband compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - settings - expected ACL table settings. Type: dictionary

Example:

| ACL table from Honeycomb should be | ${nodes[‘DUT1’]} | ${settings} |


${data}=  Get classify table oper data  ${node}  ${settings['name']}
Compare data structures  ${data}  ${settings}

3.5.1.8. ACL table from VAT should be

Retrieves ACL table information from VATand compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - table_index - VPP internal index of an ACL table. Type: integer - settings - expected ACL table settings. Type: dictionary

Example:

| ACL session from VAT should be | ${nodes[‘DUT1’]} | ${0} | ${settings} |


${data}=  Get classify table data  ${node}  ${table_index}
Compare data structures  ${data}  ${settings}

3.5.1.9. ACL table from Honeycomb should not exist

Retrieves ACL table information from Honeycomband expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string

Example:

| ACL table from Honeycomb should not exist | ${nodes[‘DUT1’]} | table0 |


Run keyword and expect error  *  Get classify table oper data  ${node}  ${table_name}

3.5.1.10. ACL table from VAT should not exist

Retrieves ACL table information from VATand expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - table_index - VPP internal index of an ACL table. Type: integer

Example:

| ACL table from VAT should not exist | ${nodes[‘DUT1’]} | ${0} |


Run keyword and expect error  *  Get classify table data  ${node}  ${table_index}

3.5.1.11. ACL session from Honeycomb should be

Retrieves ACL session information from Honeycomband compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string - settings - expected ACL session settings. Type: dictionary

Example:

| ACL session from Honeycomb should be | ${nodes[‘DUT1’]} | table0 | ${settings} |


${data}=  Get classify session oper data  ${node}  ${table_name}  ${settings['match']}
Compare data structures  ${data}  ${settings}

3.5.1.12. ACL session from VAT should be

Retrieves ACL session information from VATand compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - table_index - VPP internal index of an ACL table. Type: integer - session_index - VPP internal index of an ACL session. Type: integer - settings - expected ACL session settings. Type: dictionary

Example:

| ACL session from VAT should be | ${nodes[‘DUT1’]} | ${0} | ${0} | ${settings} |


${data}=  Get classify session data  ${node}  ${table_index}  ${session_index}
Compare data structures  ${data}  ${settings}

3.5.1.13. ACL session from Honeycomb should not exist

Retrieves ACL session information from Honeycomband expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - table_name - name of an ACL table. Type: string - session_match - ACL session match setting. Type: string

Example:

| ACL session from Honeycomb should not exist | ${nodes[‘DUT1’]} | table0 | 00:00:00:00:00:00:01:02:03:04:05:06:00:00:00:00 |


Run keyword and expect error  *KeyError:*  Get classify session oper data  ${node}  ${table_name}  ${session_match}

3.5.1.14. ACL session from VAT should not exist

Retrieves ACL session information from VATand compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - table_index - VPP internal index of an ACL table. Type: integer - session_index - VPP internal index of an ACL session. Type: integer

Example:

| ACL session from VAT should not exist | ${nodes[‘DUT1’]} | ${0} | ${0} |


Run keyword if  ${session_index} == 0  Run keyword and expect error  ValueError: No JSON object could be decoded  Get classify session data  ${node}  ${table_index}  ${session_index}
Run keyword if  ${session_index} > 0  Run keyword and expect error  IndexError: list index out of range  Get classify session data  ${node}  ${table_index}  ${session_index}

3.5.1.15. Interface ACL configuration from Honeycomb should be

Retrieves ACL interface settings from Honeycomband compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - table_name - expected ACL table name. Type: string

Example:

| Interface ACL configuration from Honeycomb should be | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 | table0 |


${data}=  Get interface oper data  ${node}  ${interface}
Should be equal  ${table_name}  ${data['vpp-interface-acl:acl']['ingress']['l2-acl']['classify-table']}  ${data['vpp-interface-acl:acl']['ingress']['ip4-acl']['classify-table']}

3.5.1.16. Interface ACL configuration from VAT should be

Retrieves ACL interface settings from VATand compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - table_index - VPP internal index of an ACL table. Type: integer

Example:

| Interface ACL configuration from VAT should be | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 | ${0} |


${data}=  Get interface classify table  ${node}  ${interface}
Should be equal  ${table_index}  ${data['l2_table_id']}
Should be equal  ${table_index}  ${data['ip4_table_id']}

3.5.1.17. Interface ACL configuration from Honeycomb should be empty

Retrieves ACL interface settings from Honeycomband expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Interface ACL configuration from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 |


${data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'vpp-interface-acl:acl'  Set Variable  ${data['vpp-interface-acl:acl']['l2-acl']['classify-table']}

3.5.1.18. Interface ACL configuration from VAT should be empty

Retrieves ACL interface settings from VATand expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Interface ACL configuration from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 |


${data}=  Get interface classify table  ${node}  ${interface}
Should be equal  ${data['l2_table_id']}  ${-1}
Should be equal  ${data['ip4_table_id']}  ${-1}

3.5.1.19. Clear all ACL settings

Removes all ACL sessions and tables from Honeycombconfiguration.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Clear all ACL settings | ${nodes[‘DUT1’]} |


Remove all classify tables  ${node}

3.5.1.20. Honeycomb creates ACL chain through ACL plugin

Creates classify chain using the ACL plugin.

Arguments: - node - Information about a DUT node. Type: dictionary - acl_list_name - Name for the classify chain. Type: string - acl_list_settings - classify rules. Type: dictionary - macip - Use MAC+IP classifier. Optional. Type: boolean

Example:

| Honeycomb creates ACL chain through ACL plugin | ${nodes[‘DUT1’]} | acl_test | ${settings} |


Create ACL plugin classify chain  ${node}  ${acl_list_name}  ${acl_list_settings}

3.5.1.21. Honeycomb assigns plugin-ACL chain to interface

Applies classification through the high-levelIETF-ACL node to an interface.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Interface to assign classifier to. Type: string - acl_list_name - Name of the clasify chain. Type: string - direction - Classifier direction, ingress or egress. Type: string - macip - Use MAC+IP classifier. Optional. Type: boolean

Example:

| Honeycomb assigns plugin-ACL chain to interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | acl_test | ingress |


Set ACL plugin interface  ${node}  ${interface}  ${acl_list_name}  ${direction}

3.5.1.22. Clear plugin-ACL configuration

Removes ACl assignment from interface, then deletesIETF-ACL chain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Interface to clean classifiers from. Type: string

Example:

| Clear plugin-ACL configuration ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Delete interface plugin ACLs  ${node}  ${interface}
Delete ACL plugin classify chains  ${node}

3.5.1.23. Read plugin-ACL configuration from VAT

Obtains ACL-plugin configuration through VAT and logsthe reply.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Read plugin-ACL configuration from VAT | ${nodes[‘DUT1’]} |


VPP log plugin acl settings  ${node}
VPP log plugin acl interface assignment  ${node}

3.5.1.24. Send ICMP packet with type and code and verify received packet

Sends an ICMP packet with specified code and type.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: integer
  • dst_ip - IP of destination interface (TG-if2). Type: integer
  • tx_port - Source interface (TG-if1). Type: string
  • tx_mac - MAC address of source interface (TG-if1). Type: string
  • rx_port - Destionation interface (TG-if1). Type: string
  • rx_mac - MAC address of destination interface (TG-if1). Type: string
  • icmp_type - ICMP type to use. Type: int
  • icmp_code - ICMP code to use. Type: int

Example:

| Send ICMP packet with type and code and verify received packet | ${nodes[‘TG’]} | 16.0.0.1 | 32.0.0.1 | eth2 | 08:00:27:cc:4f:54 | eth4 | 08:00:27:c9:6a:d5 | ${1} | ${1} |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --src_mac  ${tx_mac}  --dst_mac  ${rx_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}  --icmp_type  ${icmp_type}  --icmp_code  ${icmp_code}
Run Traffic Script On Node  send_icmp_type_code.py  ${tg_node}  ${args}

3.5.2. bgp suite

3.5.2.1. Configure BGP module

Edit Honeycomb’s configuration file for the BGP feature.Honeycomb needs to be restarted for the changes to take effect.

Arguments: - node - information about a DUT node. Type: dictionary - ip_address - IP address to bind BGP listener to. Type: string - port - Port number to bind BGP listener to. Type: integer - as_number - Autonomous System (AS) ID number. Type: integer

Example:

| Configure BGP module | ${nodes[‘DUT1’]} | 192.168.0.1 | ${179} | ${65000} |


Configure BGP base  ${node}  ${ip_address}  ${port}  ${as_number}

3.5.2.2. No BGP peers should be configured

Uses Honeycomb API to read BGP configuration and checks if there ary BGP peers conffigured.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| No BGP peers should be configured | ${nodes[‘DUT1’]} |


${oper_data}=  Get Full BGP Configuration  ${node}
Should be Empty  ${oper_data['bgp-openconfig-extensions:bgp']['neighbors']}

3.5.2.3. Honeycomb adds BGP peer

Uses Honeycomb API to add a BGP peer.

Arguments: - node - Information about a DUT node. Type: dictionary - address - IP address of the peer. Type: string - data - Peer configuration data. Type: dictionary

Example:

| Honeycomb adds BGP peer | ${nodes[‘DUT1’]} | 192.168.0.1 | ${data} |


Add BGP Peer  ${node}  ${address}  ${data}

3.5.2.4. BGP Peer From Honeycomb Should be

Uses Honeycomb API to verify BGP peer config data.

Arguments: - node - Information about a DUT node. Type: dictionary - address - IP address of the peer. Type: string - data - Peer configuration data. Type: dictionary

Example:

| BGP Peer From Honeycomb Should be | ${nodes[‘DUT1’]} | 192.168.0.1 | ${data} |


${oper_data}=  Get BGP Peer  ${node}  ${address}
Compare Data Structures  ${oper_data}  ${data}

3.5.2.5. Peer Operational Data From Honeycomb Should be

Uses Honeycomb API to verify BGP peer operational data.

Arguments: - node - Information about a DUT node. Type: dictionary - address - IP address of the peer. Type: string - data - Peer configuration data. Type: dictionary

Example:

| BGP Peer From Honeycomb Should be | ${nodes[‘DUT1’]} | 192.168.0.1 | ${data} |


${oper_data}=  Get BGP Peer  ${node}  ${address}  operational
Should be Equal  ${oper_data['peer'][0]['peer-id']}  bgp://${address}

3.5.2.6. Honeycomb removes BGP peer

Uses Honeycomb API to add a BGP peer.

Arguments: - node - Information about a DUT node. Type: dictionary - address - IP address of the peer. Type: string

Example:

| Honeycomb adds BGP peer | ${nodes[‘DUT1’]} | 192.168.0.1 |


Remove BGP Peer  ${node}  ${address}

3.5.2.7. Honeycomb configures BGP route

Uses Honeycomb API to add a BGP routeto the specified peer.

Arguments: - node - Information about a DUT node. Type: dictionary - peer_address - IP address of the peer. Type: string - data - Peer configuration data. Type: dictionary - route_address - IP address of the route. Type: string - route_index - Numeric index of the route under the peer.Type: integer - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| Honeycomb adds BGP peer | ${nodes[‘DUT1’]} | 192.168.0.1 | ${data} | 192.168.0.2 | ${0} | ipv4 |


Configure BGP Route  ${node}  ${peer_address}  ${data}  ${route_address}  ${route_index}  ${ip_version}

3.5.2.8. BGP Route From Honeycomb Should be

Uses Honeycomb API to verify BGP route operational data.

Arguments: - node - Information about a DUT node. Type: dictionary - peer_address - IP address of the peer. Type: string - data - Peer configuration data. Type: dictionary - route_address - IP address of the route. Type: string - route_index - Numeric index of the route under the peer.Type: integer - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| BGP Peers From Honeycomb Should Include | ${nodes[‘DUT1’]} | ${data} |


${oper_data}=  Get BGP Route  ${node}  ${peer_address}  ${route_address}  ${route_index}  ${ip_version}
Compare Data Structures  ${oper_data}  ${data}

3.5.2.9. Honeycomb removes BGP route

Uses Honeycomb API to remove a BGP route.

Arguments: - node - Information about a DUT node. Type: dictionary - peer_address - IP address of the peer. Type: string - route_address - IP address of the route. Type: string - route_index - Numeric index of the route under the peer.Type: integer - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| Honeycomb removes BGP route | ${nodes[‘DUT1’]} | 192.168.0.1 | 192.168.0.2 | ${0} | ipv4 |


Remove BGP Route  ${node}  ${peer_address}  ${route_address}  ${route_index}  ${ip_version}

3.5.2.10. No BGP routes should be configured

Uses Honeycomb API to verify that no BGP routesare configured under the specified peer.

Arguments: - node - Information about a DUT node. Type: dictionary - peer_address - IP address of the peer. Type: string - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| No BGP routes should be configured | ${nodes[‘DUT1’]} | 192.168.0.1 | ipv4 |


${oper_data}=  Get All Peer Routes  ${node}  ${peer_address}  ${ip_version}
Should be Empty  ${oper_data['bgp-inet:${ip_version}-routes']}

3.5.2.11. BGP Loc-RIB table should include

Uses Honeycomb API to retrieve local BGP RIB tableAnd verifies that it contains the specified entry.

Arguments: - node - Information about a DUT node. Type: dictionary - data - RIB that should be present in operational data.Type: dictionary

Example:

| BGP Loc-RIB table should include | ${nodes[‘DUT1’]} | ${data} |


${oper_data}=  Get BGP Local RIB  ${node}
${oper_data}=  Set Variable  ${oper_data['loc-rib']['tables']}
${data}=  Set Variable  ${data['loc-rib']['tables']}
Compare RIB Tables  ${oper_data}  ${data}

3.5.2.12. Receive BGP OPEN message

Open a TCP listener on BGP port(179) and listenfor BGP OPEN message. Verify ID and holdtime fields.

Arguments: - tg_node - Information about the TG node. Type: dictionary - rx_ip - IP address to listen on. Type: string - src_ip - IP address of the BGP speaker. Also acts as BGP peer ID.Type: string - holdtime - Expected value of HOLD_TIME field in received message.Type: integer

Example:

| Receive BGP OPEN message | ${node[‘TG’]} | 192.168.0.1 | 192.168.0.2 | ${0}


${args}=  Catenate  --rx_ip  ${rx_ip}  --src_ip  ${src_ip}  --rx_port  ${port}  --as_number  ${as_number}  --holdtime  ${holdtime}
Run Traffic Script On Node  honeycomb/bgp_open.py  ${tg_node}  ${args}

3.5.3. bridge_domain suite

3.5.3.1. Honeycomb creates first L2 bridge domain

Uses Honeycomb API to create a bridge domain on the VPP node. Any other bridge domains will be removed in the process.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the created bridge domain. Type: string - settings - Settings for the created bridge domain. Type: dictionary

Example:

| Honeycomb creates first L2 bridge domain | ${nodes[‘DUT1’]} | bd-04 | ${{flood:True, learn:False}} |


Add first BD  ${node}  ${bd_name}  &{settings}

3.5.3.2. Honeycomb creates L2 bridge domain

Uses Honeycomb API to create a bridge domain on the VPP node.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the created bridge domain. Type: string - settings - Settings for the created bridge domain. Type: dictionary

Example:

| Honeycomb creates L2 bridge domain | ${nodes[‘DUT1’]} | bd-04 | ${{flood:True, learn:False}} |


Add BD  ${node}  ${bd_name}  &{settings}

3.5.3.3. Bridge domain Operational Data From Honeycomb Should Be

Uses Honeycomb API to verify bridge domain settingsagainst provided values.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - settings - Expected settings for the bridge domain. Type: dictionary

Example:

| Bridge domain Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | bd-04 | ${{flood:True,learn:False}} |


${api_data}=  Get bd oper data  ${node}  ${bd_name}
: FOR  ${key}  IN  @{settings.keys()}
\    Should be equal  ${settings['${key}']}  ${api_data['${key}']}

3.5.3.4. Bridge domain Operational Data From VAT Should Be

Uses VAT to verify bridge domain settingsagainst provided values.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - settings - Expected settings for the bridge domain. Type: dictionary

Example:

| Bridge domain Operational Data From VAT Should Be | ${nodes[‘DUT1’]} | bd-04 | ${{flood:True,learn:False}} |


${vat_data}=  VPP get bridge domain data  ${node}
${vat_data}=  Set Variable  ${vat_data[${bd_index}]}
: FOR  ${key}  IN  @{settings.keys()}
\    Run keyword if  $key in $vat_data.keys()  Should be equal  ${settings['${key}']}  ${vat_data['${key}']}

3.5.3.5. Honeycomb adds interfaces to bridge domain

Uses Honeycomb API to assign interfaces to a bridgedomain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface1, interface2 - Names of interfaces to assign to bridgedomain. Type: string - bd_name - Name of the bridge domain. Type: string - settings - Bridge domain specific interface settings.Type: dictionary

Example:

| Honeycomb adds interfaces to bridge domain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 | bd-04 | ${{split_horizon_group:2, bvi:False}} |


Add bridge domain to interface  ${node}  ${interface1}  ${bd_name}  &{settings}
Add bridge domain to interface  ${node}  ${interface2}  ${bd_name}  &{settings}

3.5.3.6. Honeycomb should show interfaces assigned to bridge domain

Uses Honeycomb API to verify interface assignment tobridge domain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface1, interface2 - Names of interfaces to assign to bridgedomain. Type: string - bd_name - Name of the bridge domain. Type: string - settings - Bridge domain specific interface settings.Type: dictionary

Example:

| Honeycomb should show interfaces assigned to bridge domain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 | bd-04 | ${{split_horizon_group:2, bvi:False}} |


${if1_data}=  Get interface oper data  ${node}  ${interface1}
${if2_data}=  Get interface oper data  ${node}  ${interface2}
Should be equal  ${if1_data['v3po:l2']['bridge-domain']}  ${if2_data['v3po:l2']['bridge-domain']}  ${bd_name}
Should be equal  ${if1_data['v3po:l2']['split-horizon-group']}  ${if2_data['v3po:l2']['split-horizon-group']}  ${settings['split_horizon_group']}
Should be equal  ${if1_data['v3po:l2']['bridged-virtual-interface']}  ${if2_data['v3po:l2']['bridged-virtual-interface']}  ${settings['bvi']}

3.5.3.7. VAT should show interfaces assigned to bridge domain

Uses VAT to verify interface assignment tobridge domain.

Arguments: - node - Information about a DUT node. Type: dictionary - index - Index of bridge domains on VPP node. Starts from 0,new BDs reuse numbers after a bridge domain is removed. Type: int - interface1, interface2 - names of interfaces to check bridge domainassignment on. Type: string - settings - bridge domain specific interface settings.Type: dictionary

Example:

| VAT should show interfaces assigned to bridge domain | ${nodes[‘DUT1’]} | ${4} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 | ${{split_horizon_group:2, bvi:False}} |


${if1_link}=  Get interface by name  ${node}  ${interface1}
${if2_link}=  Get interface by name  ${node}  ${interface2}
${if_indices}=  Create list  ${node['interfaces']['${if1_link}']['vpp_sw_index']}  ${node['interfaces']['${if2_link}']['vpp_sw_index']}
${bd_data}=  VPP get bridge domain data  ${node}
${bd_interfaces}=  Set Variable  ${bd_data[${index}]['sw_if']}
@{bd_interfaces}=  Create List  ${bd_interfaces[0]}  ${bd_interfaces[1]}
: FOR  ${interface}  IN  @{bd_interfaces}
\    Should contain  ${if_indices}  ${interface['sw_if_index']}
\    Should be equal  ${interface['shg']}  ${settings['split_horizon_group']}

3.5.3.8. Honeycomb removes all bridge domains

Uses Honeycomb API to remove all bridge domains from the VPP node.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb removes all bridge domains | ${nodes[‘DUT1’]} |


: FOR  ${interface}  IN  @{interfaces}
\    Remove bridge domain from interface  ${node}  ${interface}
Remove all bridge domains  ${node}

3.5.3.9. Honeycomb should show no bridge domains

Uses Honeycomb API to verify the removal of allbridge domains.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb should show no bridge domains | ${nodes[‘DUT1’]} |


Run keyword and expect error  *Not possible*Status code: 404*  Get all BDs oper data  ${node}

3.5.3.10. VAT should show no bridge domains

Uses VAT to verify the removal of all bridge domains.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| VAT should show no bridge domains | ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  VPP get bridge domain data  ${node}

3.5.3.11. Honeycomb adds interface to bridge domain

Uses Honeycomb API to assign interface to a bridgedomain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Name of interface to assign to bridge domain.Type: string - bd_name - Name of the bridge domain. Type: string - settings - Bridge domain specific interface settings.Type: dictionary

Example:

| Honeycomb adds interfaces to bridge domain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | bd-04 | ${{split_horizon_group:2, bvi:False}} |


Add bridge domain to interface  ${node}  ${interface}  ${bd_name}  ${settings['split-horizon-group']}  ${settings['bridged-virtual-interface']}

3.5.3.12. Bridge domain Operational Interface Assignment should be empty

Get interface operational data and retrieve bridge domain configuration from it. It should be empty.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Name of interface where the bridge domain parameters will be checked.Type: string

Example: | Bridge domain Operational Interface Assignment should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${if_data}=  Get BD Oper Data From Interface  ${node}  ${interface}
Should be empty  ${if_data}

3.5.3.13. Bridge domain Operational Interface Assignment should be

Get interface operational data and retrieve bridge domain configuration from it. Compare the data to the expected one.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Name of interface where the bridge domain parameters will be checked. Type: string - bd_settings - The referential bridge domain data. Type: dictionary

Example: | Bridge domain Operational Interface Assignment should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${if_bd_settings} |


${if_data}=  Get BD Oper Data From Interface  ${node}  ${interface}
Compare Data Structures  ${if_data}  ${bd_settings}

3.5.4. dhcp suite

3.5.4.1. DHCP relay Operational Data From Honeycomb Should Be empty

Uses Honeycomb API to retrieve DHCP relay configurationand expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| DHCP relay Operational Data From Honeycomb Should Be empty | ${nodes[‘DUT1’]} |


Run keyword and expect error  *Status code: 404*  Get DHCP relay oper data  ${node}

3.5.4.2. Log DHCP relay configuration from VAT

Uses VAT to retrieve DHCP relay configuration from VPP.

Arguments: - node - information about a DUT node. Type: dictionary - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| Log DHCP relay configuration from VAT | ${nodes[‘DUT1’]} | ipv4 |


VPP get DHCP proxy  ${node}  ${ip_version}

3.5.4.3. Honeycomb configures DHCP relay

Uses Honeycomb API to configure DHCP relay.

Arguments: - node - information about a DUT node. Type: dictionary - data - settings for the DHCP relay. Type: dictionary - ip_version - IP protocol version, ipv4 or ipv6. Type: string - vrf - vrf ID to configure DHCP on. Type: integer

Example:

| Honeycomb configures DHCP relay | ${nodes[‘DUT1’]} | ${data} | ipv4 | ${0} |


Add DHCP relay  ${node}  ${data}  ${ip_version}  ${vrf}

3.5.4.4. Honeycomb clears DHCP relay configuration

Uses Honeycomb API to delete all configured DHCP relays.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb clears DHCP relay configuration | ${nodes[‘DUT1’]} |


Clear DHCP relay configuration  ${node}

3.5.4.5. DHCP relay configuration from Honeycomb should contain

Retrieves oper data for DHCP relay and compareswith provided values.

Arguments: - node - information about a DUT node. Type: dictionary - data - expected DHCP relay settings. Type dictionary

Example:

| DHCP relay configuration from Honeycomb should contain | ${nodes[‘DUT1’]} | ${data} |


${oper_data}=  Get DHCP relay oper data  ${node}
${oper_data}=  Set Variable  ${oper_data['relays']['relay'][0]}
Sort List  ${oper_data['server']}
Sort List  ${data['server']}
Should be equal  ${oper_data}  ${data}

3.5.5. fib suite

3.5.5.1. Honeycomb configures FIB table

Uses Honeycomb API to configure a FIB table.

Arguments: - node - information about a DUT node. Type: dictionary - ip_version - IP protocol version, ipv4 or ipv6. Type:string - vrf - vrf-id the new table will belong to. Type: integer

Example:

| Honeycomb configures FIB table | ${nodes[‘DUT1’]} | ipv4 | ${vrf} |


Configure FIB table  ${node}  ${ip_version}  ${vrf}

3.5.5.2. FIB table data from Honeycomb should contain

Uses Honeycomb API to retrieve operational data abouta FIB table, and compares with the data provided.

Arguments: - node - information about a DUT node. Type: dictionary - ip_version - IP protocol version, ipv4 or ipv6. Type:string - vrf - vrf-id the new table will belong to. Type: integer - expected_data - Data to compare against. Type: dictionary

Example:

| FIB table data from Honeycomb should contain | ${nodes[‘DUT1’]} | ipv4 | ${data} |


${data}=  Get FIB Table Oper  ${node}  ${ip_version}  ${vrf}
Should Contain  ${data}  ${expected_data}

3.5.5.3. Honeycomb removes FIB configuration

Uses Honeycomb API to remove Honeycomb-createdFIB configuration from the node. Entries configured automaticallyby VPP will not be removed.

Arguments: - node - information about a DUT node. Type: dictionary - ip_version - IP protocol version, ipv4 or ipv6. Type:string - vrf - vrf-id the new table will belong to. Type: integer

Example:

| Honeycomb removes FIB configuration | ${nodes[‘DUT1’]} | ${ip_version} | ${vrf} |


Delete FIB table  ${node}  ${ip_version}  ${vrf}

3.5.6. honeycomb suite

3.5.6.1. Configure Honeycomb service on DUTs

Setup environment for honeycomb testing.

_Setup steps:_ - 1. Login to each honeycomb node using ssh - 2. Startup honeycomb service - 3. Monitor service startup using HTTP GET request loop Expected sequence of HTTP replies: connection refused -> 404 -> 401 -> 503 or 500 -> 200 (pass) - 4. Configure honeycomb nodes using HTTP PUT request

_Arguments:_ - duts - list of nodes to setup Honeycomb on

_Used global constants and variables:_ - RESOURCES_TPL_HC - path to honeycomb templates directory - HTTPCodes - HTTP protocol status codes


Start honeycomb on DUTs  @{duts}
: FOR  ${dut}  IN  @{duts}
\    Check honeycomb startup state  @{duts}
\    Sleep  5s  Make sure all modules are loaded and ready.

3.5.6.2. Stop Honeycomb service on DUTs

Cleanup environment after honeycomb testing.

_Teardown steps:_ - 1. Login to each honeycomb node using ssh - 2. Stop honeycomb service - 3. Monitor service shutdown using HTTP GET request loop Expected sequence of HTTP replies: 200 -> 404 -> connection refused (pass)

_Arguments:_ - duts - list of nodes to stop Honeycomb on

_Used global constants and variables:_ - RESOURCES_TPL_HC - path to honeycomb templates directory - HTTPCodes - HTTP protocol status codes


Stop honeycomb on DUTs  @{duts}
: FOR  ${dut}  IN  @{duts}
\    Wait until keyword succeeds  60sec  15sec  Check honeycomb shutdown state  @{duts}

3.5.6.3. Clear persisted Honeycomb configuration

Delete saved configuration.

Arguments: - duts - one or more nodes to clear persistence on. Type: dictionary

Example:

| Clear persisted Honeycomb configuration | ${nodes[‘DUT1’]} |


Clear persisted Honeycomb config  @{duts}

3.5.6.4. Restart Honeycomb and VPP and clear persisted configuration

Restarts Honeycomb and VPP with default configuration.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart Honeycomb and VPP and clear persisted configuration | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Clear persisted Honeycomb configuration  ${node}
Setup DUT  ${node}
Sleep  10s  Wait 10sec so VPP is up for sure.
Configure Honeycomb service on DUTs  ${node}

3.5.6.5. Restart Honeycomb and VPP

Stops the Honeycomb service and verifies it is stopped. Then restarts VPP, starts Honeycomb again and verifies it is running.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart Honeycomb and VPP | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Setup DUT  ${node}
Sleep  10s  Wait 10sec so VPP is up for sure.
Configure Honeycomb service on DUTs  ${node}

3.5.6.6. Restart Honeycomb and VPP in performance test

Stops Honeycomb and VPP and verifies HC is stopped. Then restarts VPP, starts Honeycomb again and verifies it is running.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart Honeycomb and VPP | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Stop VPP service on DUT  ${node}
Setup DUT  ${node}
Sleep  10s  Wait 10sec so VPP is up for sure.
Configure Honeycomb service on DUTs  ${node}
Check honeycomb startup state  ${node}  timeout=120

3.5.6.7. Archive Honeycomb logs

Copies log files from Honeycomb nodeto test executor.

Arguments: - node - information about a DUT node. Type: dictionary - perf - Running on performance testbed? Yes/no Type: boolean

Example:

| Archive Honeycomb logs | ${nudes[‘DUT1’]} |


Archive Honeycomb log  ${node}  ${perf}
Archive ODL log  ${node}

3.5.6.8. Configure ODL Client Service On DUT

Configure and start ODL client, then repeatedly check if it is running.

Arguments: - node - information about a DUT node. Type: dictionary - odl_name - Name of ODL client version. Type: string

Example:

| Configure ODL Client Service on DUT | ${nodes[‘DUT1’]} | carbon-SR1 |


Copy ODL Client  ${node}  ${odl_name}  /mnt/common  /tmp
Setup ODL Client  ${node}  /tmp
Wait until keyword succeeds  3min  30sec  Install ODL Features  ${node}  ${odl_name}  /tmp
Wait until keyword succeeds  4min  15sec  Mount Honeycomb on ODL  ${node}
Wait until keyword succeeds  2min  15sec  Check ODL startup state  ${node}
Check honeycomb startup state  ${node}  timeout=120

3.5.6.9. Configure Honeycomb for functional testing

Configure Honeycomb with parameters for functional testing, then start Honeycomb and repeatedly check startup status.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Configure Honeycomb for functional testing | ${nodes[‘DUT1’]} |


Configure Restconf binding address  ${node}
Configure Log Level  ${node}  TRACE
Configure Persistence  ${node}  disable
Configure jVPP timeout  ${node}  ${10}
Generate Honeycomb startup configuration for ODL test  ${node}
Clear Persisted Honeycomb Configuration  ${node}
Configure Honeycomb service on DUTs  ${node}

3.5.6.10. Configure ODL Client for functional testing

Read external variable HC_ODL. Depending on its value either: do nothing, or setup ODL client for testing and create a global variable that modifies Restconf requests to use ODL.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Configure ODL Client for functional testing | ${nodes[‘DUT1’]} |


${use_odl_client}=  Get Variable Value  ${HC_ODL}
Run Keyword If  '${use_odl_client}' != '${NONE}'  Run Keywords  Set Global Variable  ${use_odl_client}  AND  Configure ODL Client Service On DUT  ${node}  ${use_odl_client}  ELSE  Log  Variable HC_ODL is not present. Not using ODL.  level=INFO

3.5.6.11. Set Up Honeycomb Functional Test Suite

Generic test suite setup for Honeycomb functional tests. Restarts VPP, then enables Honeycomb and optionally ODL, based on external variable.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Set Up Honeycomb Functional Test Suite | ${nodes[‘DUT1’]} |


Setup DUT  ${node}
Configure all TGs for traffic script
Configure Honeycomb for functional testing  ${node}
Configure ODL Client for functional testing  ${node}

3.5.6.12. Tear Down Honeycomb Functional Test Suite

Generic test suite teardown for Honeycomb functional tests. Stops ODL client (if used), then stops Honeycomb and verifies that they are both stopped.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Tear Down Honeycomb Functional Test Suite | ${nodes[‘DUT1’]} |


Append suite to Honeycomb log file  ${node}
${use_odl_client}=  Get Variable Value  ${HC_ODL}
Run Keyword If  '${use_odl_client}' != '${NONE}'  Run Keywords  Append suite to ODL log file  ${node}  ${use_odl_client}  AND  Stop ODL Client  ${node}  /tmp  AND  Wait until keyword succeeds  3min  15sec  Check ODL shutdown state  ${node}  AND  Set Global Variable  ${use_odl_client}  ${NONE}
Stop Honeycomb service on DUTs  ${node}
Clear Honeycomb Log  ${node}
Stop VPP Service on DUT  ${node}

3.5.6.13. Enable Honeycomb Feature

Enable the specified feature in Honeycomb configuration. Requires a restart of Honeycomb to take effect.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Enable Honeycomb Feature | ${nodes[‘DUT1’]} | NSH |


Manage Honeycomb Features  ${node}  ${feature}

3.5.6.14. Disable Honeycomb Feature

Disable the specified feature in Honeycomb configuration. Requires a restart of Honeycomb to take effect.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Disable Honeycomb Feature | ${nodes[‘DUT1’]} | NSH |


Manage Honeycomb Features  ${node}  ${feature}  disable=${True}

3.5.6.15. Honeycomb Performance Suite Setup Generic

Generic test suite setup for Honeycomb performance tests. Performs multiple attempts to start Honeycomb+VPP stack.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb Performance Suite Setup Generic | ${nodes[‘DUT1’]} |


Wait until keyword succeeds  8min  2min  Restart Honeycomb and VPP in Performance test  ${node}

3.5.6.16. Honeycomb Performance Suite Teardown Generic

Generic test suite teardown for Honeycomb performance tests. Logs CPU usage before stopping Honeycomb.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb Performance Suite Teardown Generic | ${nodes[‘DUT1’]} |


Log Honeycomb and VPP process distribution on cores  ${node}
Append suite to Honeycomb log file  ${node}
Stop Honeycomb service on DUTs  ${node}
Clear Honeycomb Log  ${node}
Stop VPP Service on DUT  ${node}

3.5.6.17. Append suite to Honeycomb log file

Add the contents of honeycomb.log for the current suiteto the full log which will be archived.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Append suite to Honeycomb log file | ${nodes[‘DUT1’]} |


Append Honeycomb log  ${node}  ${SUITE_NAME}

3.5.6.18. Append suite to ODL log file

Add the contents of ODL karaf.log for the current suiteto the full log which will be archived.

Arguments: - node - information about a DUT node. Type: dictionary - odl_name - name of ODL client version. Type: string

Example:

| Append suite to ODL karaf log file | ${nodes[‘DUT1’]} | Oxygen |


Append ODL log  ${node}  ${odl_name}  ${SUITE_NAME}

3.5.6.19. Generate Honeycomb startup configuration for ODL test

Create HC startup configuration and apply to config file on DUT. Requires Honeycomb restart to take effect.

Arguments: - node - Honeycomb node. Type: dictionary

Example:

| Generate Honeycomb startup configuration for ODL test | ${nodes[DUT1]} |


Import Library  resources.libraries.python.honeycomb.HoneycombSetup.HoneycombStartupConfig  WITH NAME  HC_config
Run Keyword  HC_config.Set SSH Security provider
Run Keyword  HC_config.Set Memory Size  ${32}
Run Keyword  HC_config.Set Metaspace Size  ${32}
Run Keyword  HC_config.Apply config  ${node}

3.5.7. interfaces suite

3.5.7.1. Honeycomb configures interface state

Uses Honeycomb API to change the admin stateof the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - state - state to set on interface. Type:string

Example:

| Honeycomb configures interface state | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | up |


Honeycomb Set Interface State  ${node}  ${interface}  ${state}

3.5.7.2. Interface state from Honeycomb should be

Retrieves interface admin state through Honeycomb andcompares with state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - state - expected interface state. Type: string

Example:

| Interface state from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | up |


${api_data}=  Get interface oper data  ${node}  ${interface}
${api_state}=  Set Variable  ${api_data['admin-status']}
Should be equal  ${api_state}  ${state}

3.5.7.3. Interface state from VAT should be

Retrieves interface admin state through VAT and compareswith state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - state - expected interface state. Type: string

_NOTE:_ Vat returns state as int (1/0) instead of string (up/down). This keyword also handles translation.

Example:

| Interface state from VAT should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | up |


${vat_data}=  VPP get interface data  ${node}  ${interface}
${vat_state}=  Set Variable if  ${vat_data['admin_up_down']} == 1  up  down
Should be equal  ${vat_state}  ${state}

3.5.7.4. Honeycomb sets interface IPv4 address

Uses Honeycomb API to change ipv4 addressof the specified interface. Any existing addresses will be removed.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - netmask - subnet mask to set. Type: string

Example:

| Honeycomb sets interface IPv4 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | 255.255.255.0 |


Add first ipv4 address  ${node}  ${interface}  ${address}  ${netmask}

3.5.7.5. Honeycomb sets interface IPv4 address with prefix

Uses Honeycomb API to assign an ipv4 address to thespecified interface. Any existing addresses will be removed.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of address network prefix. Type: integer

Example:

| Honeycomb sets interface IPv4 address with prefix | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | 24 |


Add first ipv4 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.6. Honeycomb adds interface IPv4 address

Uses Honeycomb API to add an ipv4 address to thespecified interface, without removing existing addresses.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of address network prefix. Type: integer

Example:

| Honeycomb adds interface IPv4 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | 24 |


Add ipv4 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.7. Honeycomb fails to add interface IPv4 address

Uses Honeycomb API to add an ipv4 address to thespecified interface, and expects to fail with code 500.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of address network prefix. Type: integer

Example:

| Honeycomb fails to add interface IPv4 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | 24 |


Run Keyword and Expect Error  *not successful. Status code: 500.  Honeycomb adds interface IPv4 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.8. IPv4 address from Honeycomb should be

Retrieves interface ipv4 address through Honeycomband compares with state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to expect. Type: string - prefix - prefix length to expect. Type: string

Example:

| IPv4 address from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | ${24} |


${api_data}=  Get interface oper data  ${node}  ${interface}
${settings}=  Create Dictionary  ip=${address}  prefix-length=${prefix}
Should contain  ${api_data['ietf-ip:ipv4']['address']}  ${settings}

3.5.7.9. IPv4 address from VAT should be

Retrieves interface ipv4 address through VAT andcompares with state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to expect. Type: string - prefix - prefix length to expect. Type: string - netmask - subnet mask to expect. Type: string

Example:

| IPv4 address from VAT should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.2 | ${24} | 255.255.255.0 |


${vpp_data}=  VPP get interface ip addresses  ${node}  ${interface}  ipv4
${settings}=  Create Dictionary  ip=${address}  netmask=${netmask}  prefix_length=${prefix}
Should contain  ${vpp_data}  ${settings}

3.5.7.10. Honeycomb removes interface IPv4 addresses

Removes all configured ipv4 addresses from the specifiedinterface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb removes interface IPv4 addresses | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Remove all ipv4 addresses  ${node}  ${interface}

3.5.7.11. IPv4 address from Honeycomb should be empty

Retrieves interface ipv4 configuration through Honeycomband expects to find no IPv4 addresses.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv4 address from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError:*  Set Variable  ${api_data['ietf-ip:ipv4']['address']}

3.5.7.12. IPv4 address from VAT should be empty

Retrieves interface ipv4 configuration through VAT andand expects to find no ipv4 addresses.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv4 config from VAT should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Run keyword and expect error  *No JSON object could be decoded*  VPP get interface ip addresses  ${node}  ${interface}  ipv4

3.5.7.13. Honeycomb adds interface IPv4 neighbor

Uses Honeycomb API to assign an ipv4 neighbor to thespecified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - fib_address - IP address to add to fib table. Type: string - fib_mac - MAC address to add to fib table. Type: string

Example:

| Honeycomb adds interface IPv4 neighbor | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.3 | 08:00:27:c0:5d:37


Add ipv4 neighbor  ${node}  ${interface}  ${fib_address}  ${fib_mac}

3.5.7.14. IPv4 neighbor from Honeycomb should be

Retrieves ipv4 neighbor list through Honeycomband checks if it contains address supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - ip_address - ipv4 address of expected neighbor entry. Type: string - mac_address - MAC address of expected neighbor entry. Type: string

Example:

| IPv4 neighbor from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.4 | 08:00:27:60:26:ab |


${api_data}=  Get interface oper data  ${node}  ${interface}
${settings}=  Create Dictionary  ip=${ip_address}  link-layer-address=${mac_address}  origin=static
Should contain  ${api_data['ietf-ip:ipv4']['neighbor']}  ${settings}

3.5.7.15. Honeycomb clears all interface IPv4 neighbors

Uses Honeycomb API to remove all ipv4 neighbors from thespecified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb clears all interface IPv4 neighbors | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Remove all ipv4 neighbors  ${node}  ${interface}

3.5.7.16. IPv4 neighbor from Honeycomb should be empty

Retrieves ipv4 neighbor list through Honeycomband expects to find no ipv4 neighbors.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv4 neighbor from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError:*  Set Variable  ${api_data['ietf-ip:ipv4']['neighbor'][0]['ip']}

3.5.7.17. Honeycomb sets interface IPv6 address

Uses Honeycomb API to change ipv6 addressof the specified interface. Existing IPv6 addresses will be removed,with the exception of self-configured link-layer IPv6.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of subnet prefix to set. Type: string

Example:

| Honeycomb sets interface IPv6 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


Add first ipv6 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.18. Honeycomb adds interface IPv6 address

Uses Honeycomb API to add an ipv6 addressto the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of subnet prefix to set. Type: string

Example:

| Honeycomb adds interface IPv6 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


Add ipv6 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.19. Honeycomb fails to add interface IPv6 address

Uses Honeycomb API to add an ipv6 address to thespecified interface, and expects to fail with code 500.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to set. Type: string - prefix - length of address network prefix. Type:integer

Example:

| Honeycomb fails to add interface IPv6 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


Run Keyword and Expect Error  *not successful. Status code: 500.  Honeycomb adds interface IPv6 address  ${node}  ${interface}  ${address}  ${prefix}

3.5.7.20. IPv6 address from Honeycomb should contain

Retrieves interface ipv6 address through Honeycomband compares with state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to expect. Type: string - prefix - length of subnet prefix to expect. Type: string

Example:

| IPv6 address from Honeycomb should contain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


${api_data}=  Get interface oper data  ${node}  ${interface}
${settings}=  Create Dictionary  ip=${address}  prefix-length=${prefix}
Should contain  ${api_data['ietf-ip:ipv6']['address']}  ${settings}

3.5.7.21. IPv6 address from VAT should contain

Retrieves interface ipv6 address through VAT andcompares with state supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - address - IP address to expect. Type: string - prefix - length of subnet prefix to expect. Type: string

Example:

| IPv6 address from VAT should contain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


${vpp_data}=  VPP get interface ip addresses  ${node}  ${interface}  ipv6
${settings}=  Create Dictionary  ip=${address}  prefix_length=${prefix}
Should contain  ${vpp_data}  ${settings}

3.5.7.22. Honeycomb removes interface IPv6 addresses

Removes all configured ipv6 addresses from the specifiedinterface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb removes interface IPv6 addresses | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Remove all ipv6 addresses  ${node}  ${interface}

3.5.7.23. IPv6 address from Honeycomb should be empty

Retrieves interface ipv6 configuration through Honeycomband expects to find no IPv6 addresses.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv6 address from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError:*  Set Variable  ${api_data['ietf-ip:ipv6']['address']}

3.5.7.24. IPv6 address from VAT should be empty

Retrieves interface ipv6 configuration through VAT andexpects to find no ipv6 addresses.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv6 config from VAT should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Run keyword and expect error  *No JSON object could be decoded*  VPP get interface ip addresses  ${node}  ${interface}  ipv6

3.5.7.25. Honeycomb adds interface IPv6 neighbor

Uses Honeycomb API to assign an ipv6 neighbor to thespecified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - fib_address - IP address to add to fib table. Type: string - fib_mac - MAC address to add to fib table. Type: string

Example:

| Honeycomb adds interface IPv6 neighbor | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.3 | 08:00:27:c0:5d:37 |


Add ipv6 neighbor  ${node}  ${interface}  ${fib_address}  ${fib_mac}

3.5.7.26. IPv6 neighbor from Honeycomb should be

Retrieves ipv6 neighbor list through Honeycomband checks if it contains address supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - ip_address - ipv6 address of expected neighbor entry. Type: string - mac_address - MAC address of expected neighbor entry. Type: string

Example:

| IPv6 neighbor from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 192.168.0.4 | 08:00:27:60:26:ab |


${api_data}=  Get interface oper data  ${node}  ${interface}
${settings}=  Create Dictionary  ip=${ip_address}  link-layer-address=${mac_address}  origin=static
Should contain  ${api_data['ietf-ip:ipv6']['neighbor']}  ${settings}

3.5.7.27. Honeycomb clears all interface IPv6 neighbors

Uses Honeycomb API to remove all ipv6 neighbors from thespecified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb clears all interface IPv6 neighbors | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Remove all ipv6 neighbors  ${node}  ${interface}

3.5.7.28. IPv6 neighbor from Honeycomb should be empty

Retrieves ipv6 neighbor list through Honeycomband expects to find no ipv6 neighbors.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| IPv6 neighbor from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError:*  Set Variable  ${api_data['ietf-ip:ipv6']['neighbor'][0]['ip']}

3.5.7.29. Honeycomb sets interface ethernet configuration

Uses Honeycomb API to change interface ethernetconfiguration.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - ethernet - interface ethernet settings. Type: dictionary

Example:

| Honeycomb sets interface ethernet configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${{‘mtu’: 1500}}


: FOR  ${key}  IN  @{ethernet.keys()}
\    Configure interface ethernet  ${node}  ${interface}  ${key}  ${ethernet['${key}']}

3.5.7.30. Interface ethernet Operational Data From Honeycomb Should Be

Retrieves interface ethernet configurationthrough Honeycomb and compares with settings supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - ethernet - interface ethernet settings. Type: dictionary

Example:

| Interface ethernet Operational Data From Honeycomb Should Be should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${{‘mtu’: 1500}} |


${api_data}=  Get interface oper data  ${node}  ${interface}
: FOR  ${key}  IN  @{ethernet.keys()}
\    Should be equal  ${api_data['v3po:ethernet']['${key}']}  ${ethernet['${key}']}

3.5.7.31. Interface ethernet Operational Data From VAT Should Be

Retrieves interface ethernet configurationthrough VAT and compares with settings supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - mtu - value of maximum transmission unit expected. Type: integer

Example:

| Interface ethernet Operational Data From VAT Should Be should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1500} |


${vat_data}=  VPP get interface data  ${node}  ${interface}
Should be equal  ${vat_data['mtu']}  ${mtu}

3.5.7.32. Honeycomb sets interface VRF ID

Uses Honeycomb API to change interface vrfconfiguration.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - vrf_id - vrf ID to configure. Type:integer

Example:

| Honeycomb sets interface VRF ID | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | ipv4 |


Configure interface routing  ${node}  ${interface}  ${ip_version}-vrf-id  ${vrf_id}

3.5.7.33. Interface VRF ID from Honeycomb should be

Retrieves interface ethernet configurationthrough Honeycomb and compares with settings supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - vrf_id - vrf ID to expect. Type:integer - ip_version - IP protocol version, ipv4 or ipv6. Type: string

Example:

| Interface VRF ID from Honeycomb should be should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | ipv4 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Should be equal  ${api_data['v3po:routing']['${ip_version}-vrf-id']}  ${vrf_id}

3.5.7.34. Interface VRF ID from VAT should be

Retrieves interface ethernet configurationthrough VAT and compares with settings supplied in arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - vrf_id - vrf ID to expect. Type:integer

Example:

| Interface VRF ID from VAT should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


${vat_data}=  get interface vrf table  ${node}  ${interface}
Should be equal  ${vat_data}  ${vrf_id}

3.5.7.35. Interface Operational Data From Honeycomb Should Be empty

Attempts to retrieve interface configuration throughHoneycomb and expects to get empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of a interface on the specified node. Type:string

Example: | Interface Operational Data From Honeycomb Should Be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Should be empty  ${api_data}

3.5.7.36. Interface Operational Data From VAT Should Be empty

Attempts to retrieve Interface configuration throughVAT and expects to get empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of a Interface on the specified node. Type:string

Example: | Interface Operational Data From VAT Should Be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${vat_data}=  VPP get interface data  ${node}  ${interface}
Should be empty  ${vat_data}

3.5.7.37. Interface indices from Honeycomb and VAT should correspond

Uses VAT and Honeycomb to get operational data about thegiven interface and compares the interface indexes. The interface index from Honeycomb should be greater than index from VAT by one.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of the interface to be checked. Type: string

Example:

| Interface indices from Honeycomb and VAT should correspond | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
${vat_data}=  VPP get interface data  ${node}  ${interface}
${sw_if_index}=  EVALUATE  ${vat_data['sw_if_index']} + 1
Should be equal as strings  ${api_data['if-index']}  ${sw_if_index}

3.5.7.38. Get interface index from oper data

Retrieves interface operational data and returnsif-index of the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of the interface. Type: string

Example:

| Get interface index from oper data | ${nodes[‘DUT1’]} | local0 |


${data}=  Get interface oper data  ${node}  ${interface}
Return from keyword  ${data['if-index']}

3.5.7.39. Honeycomb should show disabled interface in oper data

Retrieves list of disabled interfacesand verifies that there is at least one.

Arguments: - node - information about a DUT node. Type: dictionary - index - index of the interface to be checked. Type: string

Example:

| Honeycomb should show disabled interface in oper data | ${nodes[‘DUT1’]} | ${vx_interface} |


check disabled interface  ${node}  ${index}

3.5.7.40. Honeycomb should not show disabled interface in oper data

Retrieves list of disabled interfacesand expects to fail with a 404 - not found.

Arguments: - node - information about a DUT node. Type: dictionary - index - index of the interface to be checked. Type: string

Example:

| Honeycomb should not show disabled interface in oper data | ${nodes[‘DUT1’]} | ${vx_interface} |


Run keyword and expect error  *  Honeycomb should show disabled interface in oper data  ${node}  ${index}

3.5.7.41. Ping and verify IP address

Sends ICMP packet from IP (with source mac) to IP (with dest mac), then waits for ICMP reply.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: integer
  • dst_ip - IP of destination interface (TG-if2). Type: integer
  • tx_port - Source interface (TG-if1). Type: string
  • tx_mac - MAC address of source interface (TG-if1). Type: string
  • rx_port - Destionation interface (TG-if1). Type: string
  • rx_mac - MAC address of destination interface (TG-if1). Type: string

Example:

| Ping verify IP address | ${nodes[‘TG’]} | 16.0.0.1 | 32.0.0.1 | eth2 | 08:00:27:cc:4f:54 | eth4 | 08:00:27:c9:6a:d5 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --src_mac  ${tx_mac}  --dst_mac  ${rx_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}  --timeout  ${5}
Run Traffic Script On Node  send_icmp_wait_for_reply.py  ${tg_node}  ${args}

3.5.7.42. Honeycomb adds unnumbered configuration to interface

Adds unnumbered configuration to interface, borrowing IP address from the other specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - Name of the interface to be configured. Type: string - interface_src - Name of the interface to borrow IP address from.Type: string

Example:

| Honeycomb adds unnumbered configuration to interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 |


Configure interface unnumbered  ${node}  ${interface}  ${interface_src}

3.5.7.43. Honeycomb removes unnumbered configuration from interface

Removes unnumbered configuration from the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - Name of the interface to be configured. Type: string

Example:

| Honeycomb adds unnumbered configuration to interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Configure interface unnumbered  ${node}  ${interface}

3.5.8. ipv6_control suite

3.5.8.1. Convert data-plane interface to control-plane

Unbinds an interface from VPP and binds it to kerneldriver specified in topology.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the interface in topology. Type: string

Example:

| Convert data-plane interface to control-plane | ${nodes[‘DUT1’]} | port3 |


${new_driver}=  Get Variable Value  ${node['interfaces']['${interface}']['driver']}
PCI Driver Unbind  ${node}  ${node['interfaces']['${interface}']['pci_address']}
Run Keyword If  '${new_driver}' == 'None'  PCI Driver Bind  ${node}  ${node['interfaces']['${interface}']['pci_address']}  virtio-pci  ELSE  PCI Driver Bind  ${node}  ${node['interfaces']['${interface}']['pci_address']}  ${new_driver}

3.5.9. l2_fib suite

3.5.9.1. Honeycomb adds L2 FIB entry to bridge domain

Add L2 FIB entry to the specified bridge domain using Honyecomb API.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - l2_fib_settings - The parameters of the new L2 FIB entry. Type: dictionary

Example: | Honeycomb adds L2 FIB entry to bridge domain | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_forward_cfg} |


Add L2 FIB Entry  ${node}  ${bd_name}  ${l2_fib_settings}

3.5.9.2. L2 FIB Table from Honeycomb should be empty

Check if the L2 FIB table in the specified bridge domain is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string

Example: | L2 FIB Table from Honeycomb should be empty | ${nodes[‘DUT1’]} | test_bd |


${l2_fib_data}=  Get All L2 FIB Entries  ${node}  ${bd_name}
Should be empty  ${l2_fib_data}

3.5.9.3. L2 FIB Entry from Honeycomb should be

Retrieves the operational data about the specified L2 FIB entry and checks if they are as expected.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - l2_fib_ref_data - L2 FIB entry referential data. Type: dictionay

Example: | L2 FIB Entry from Honeycomb should be | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_forward_oper} |


${l2_fib_data}=  Get L2 FIB Entry  ${node}  ${bd_name}  ${l2_fib_ref_data['phys-address']}
Compare Data Structures  ${l2_fib_data}  ${l2_fib_ref_data}

3.5.9.4. Honeycomb removes L2 FIB entry

Remove the specified L2 FIB entry from the bridge domain’s L2 FIB table.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - mac - MAC address used as the key in L2 FIB data structure. Type: string

Example: | Honeycomb removes L2 FIB entry | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_forward_oper[‘phys-address’]} |


Remove L2 FIB Entry  ${node}  ${bd_name}  ${mac}

3.5.9.5. Honeycomb removes all L2 FIB entries

Remove all L2 FIB enties from the bridge domain’s L2 FIB table.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string

Example: | Honeycomb removes all L2 FIB entries | ${nodes[‘DUT1’]} | test_bd |


Remove all L2 FIB entries  ${node}  ${bd_name}

3.5.9.6. Honeycomb fails to add wrong L2 FIB entry

Honeycomb tries to add a wrong L2 FIB entry and expects that it fails.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - l2_fib_settings - The wrong parameters of the new L2 FIB entry. Type: dictionary

Example: | Honeycomb fails to add wrong L2 FIB entry | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_wrong_cfg} |


Run keyword and expect error  *HoneycombError: * was not successful. *00.  Add L2 FIB Entry  ${node}  ${bd_name}  ${l2_fib_settings}

3.5.9.7. Honeycomb fails to modify L2 FIB entry

Honeycomb tries to modify an existing L2 FIB entry and expects to fail.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_name - Name of the bridge domain. Type: string - mac - MAC address used as the key in L2 FIB data structure. Type: string - param - The parameter to be modified. Type: string - value - The new value of the parameter. Type: string or integer

Example: | Honeycomb fails to modify L2 FIB entry | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_forward_oper[‘phys-address’]} | action | l2-fib-forward |


Run keyword and expect error  *HoneycombError: * was not successful. *00.  Modify L2 FIB Entry  ${node}  ${bd_name}  ${mac}  ${param}  ${value}

3.5.9.8. L2 FIB entry from VAT should be

Retrieves the operational data about the specified L2 FIB entry using VAT and checks if it is as expected.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_index - Index of the bridge domain. Type: integer - l2_fib_ref_data - L2 FIB entry referential data. Type: dictionay

Example: | L2 FIB entry from VAT should be | ${nodes[‘DUT1’]} | test_bd | ${l2_fib_forward_oper} |


${l2_fib_data}=  Get L2 FIB entry VAT  ${node}  ${bd_index}  ${l2_fib_ref_data['mac']}
Compare Data Structures  ${l2_fib_data}  ${l2_fib_ref_data}

3.5.9.9. L2 FIB Table from VAT should be empty

Check if the L2 FIB table in the specified bridge domain is empty. VAT is used to get operational data.

Arguments: - node - Information about a DUT node. Type: dictionary - bd_index - Index of the bridge domain. Type: integer

Example: | L2 FIB Table from VAT should be empty | ${nodes[‘DUT1’]} | test_bd |


${l2_fib_data}=  Get L2 FIB table VAT  ${node}  ${bd_index}
Should be empty  ${l2_fib_data}

3.5.10. lisp suite

3.5.10.1. Honeycomb enables LISP

Uses Honeycomb API to enable LISP.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb enables LISP | ${nodes[‘DUT1’]} |


Set LISP state  ${node}  ${TRUE}

3.5.10.2. Honeycomb disables LISP

Uses Honeycomb API to disable LISP.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb disables LISP | ${nodes[‘DUT1’]} |


Set LISP state  ${node}  ${FALSE}

3.5.10.3. Honeycomb adds locator set

Uses Honeycomb API to enable LISP.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Name of an interface on the node. Type: string - locator_set - Name for the new locator set. Type: string

Example:

| Honeycomb adds locator set | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | loc_01 |


Add locator  ${node}  ${interface}  ${locator_set}

3.5.10.4. Honeycomb adds LISP Mapping

Uses Honeycomb API to configure a LISP mapping.

Arguments: - node - Information about a DUT node. Type: dictionary - data - LISP settings to use. Type: dictionary

Example:

| Honeycomb adds LISP Mapping | ${nodes[‘DUT1’]} | ${data} |


Configure LISP Mapping  ${node}  ${data}

3.5.10.5. Honeycomb removes all LISP mappings

Uses Honeycomb API to clear the eid-table.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb removes all LISP mappings | ${nodes[‘DUT1’]} |


Configure LISP mapping  ${node}  ${NONE}

3.5.10.6. LISP should not be configured

Retrieves LISP configuration from Honeycomb operationaldata, and expects an empty dictionary.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| LISP should not be configured | ${nodes[‘DUT1’]} |


Run keyword and Expect Error  KeyError: 'lisp-feature-data'  Get LISP operational data  ${node}

3.5.10.7. LISP state from Honeycomb should be

Retrieves LISP state from Honeycomb operationaldata, and compares LISP state with expected value.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Expected LISP state. Type: string

Example:

| LISP state from Honeycomb should be | ${nodes[‘DUT1’]} | enabled |


${data}=  Get LISP operational data  ${node}
Run keyword if  $state == 'enabled'  Should be equal as strings  ${data['lisp-state']['enable']}  ${True}
Run keyword if  $state == 'disabled'  Should be equal as strings  ${data['lisp-state']['enable']}  ${False}

3.5.10.8. LISP state from VAT should be

Retrieves LISP state from VAT,and compares LISP state with expected value.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Expected LISP state. Type: string

Example:

| LISP state from VAT should be | ${nodes[‘DUT1’]} | enabled |


${status}=  VPP show LISP State  ${node}
Should match  ${status['feature_status']}  ${state}

3.5.10.9. LISP mapping from Honeycomb should be

Retrieves LISP mapping from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - settings - Expected LISP mapping data. Type: dictionary

Example:

| LISP mapping from Honeycomb should be | ${nodes[‘DUT1’]} | ${settings} |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['eid-table']['vni-table'][0]}
Compare data structures  ${data}  ${settings}

3.5.10.10. LISP mapping from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - settings - Expected LISP mapping data. Type: dictionary

Example:

| LISP mapping from VAT should be | ${nodes[‘DUT1’]} | ${settings} |


${data}=  VPP show LISP eid table  ${node}
Compare data structures  ${data[0]}  ${settings}

3.5.10.11. LISP mappings from Honeycomb should not exist

Retrieves LISP mappings from operationaldata, and expects to find none.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| LISP mappings from Honeycomb should not exist | ${nodes[‘DUT1’]} |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
Should be empty  ${data['eid-table']['vni-table']}

3.5.10.12. LISP mappings from VAT should not exist

Retrieves LISP mappings from VAT,and expects to receive an empty list.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| LISP mappings from VAT should not exist | ${nodes[‘DUT1’]} |


${data}=  VPP show LISP eid table  ${node}
Should be empty  ${data}

3.5.10.13. Locator set from Honeycomb should be

Retrieves LISP locator set from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Interface that should be referenced by locator.Type: dictionary - locator_set - Expected locator set name. Type: string

Example:

| Locator set From Honeycomb Should Be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | loc01 |


${data}=  Get LISP operational data  ${node}
${loc_data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']['locator-sets']}
Should be equal  ${loc_data['locator-set'][0]['name']}  ${locator_set}
Should be equal  ${loc_data['locator-set'][0]['interface'][0]['interface-ref']}  ${interface}

3.5.10.14. Honeycomb adds LISP adjacency

Uses Honeycomb API to configure LISP adjacency.

Arguments: - node - Information about a DUT node. Type: dictionary - vni - Virtual network identifier number. Type: integer - map - Name of an existing remote mapping. Type: string - adjacency - Name for the new adjacency. Type: string - data - LISP adjacency settings to use. Type: dictionary

Example:

| Honeycomb adds LISP adjacency | ${nodes[‘DUT1’]} | ${1} | map1| adj1 | ${data} |


Add LISP adjacency  ${node}  ${vni}  ${map}  ${adjacency}  ${data}

3.5.10.15. Honeycomb adds LISP map resolver

Uses Honeycomb API to configure LISP map resolver.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_address - IP address for the map resolver. Type: string

Example:

| Honeycomb adds LISP map resolver | ${nodes[‘DUT1’]} | 192.168.0.2 |


Add map resolver  ${node}  ${ip_address}

3.5.10.16. Honeycomb adds LISP Map register

Uses Honeycomb API to configure LISP map register.

Arguments: - node - Information about a DUT node. Type: dictionary - add_map_register - Set boolean value of map register. Type: bool

Example:

| Honeycomb adds LISP Map register | ${nodes[‘DUT1’]} | ${True} |


Set Map Register  ${node}  ${add_map_register}

3.5.10.17. Honeycomb sets LISP Map request Mode

Uses Honeycomb API to configure LISP map request mode.

Arguments: - node - Information about a DUT node. Type: dictionary - set_map_request - Set boolean value of map request mode. Type: bool

Example:

| Honeycomb adds LISP Map Request Mode | ${nodes[‘DUT1’]} | ${True} |


Set Map Request Mode  ${node}  ${set_map_request}

3.5.10.18. Map resolver from Honeycomb should be

Retrieves LISP map resolver from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_address - IP address that should be referenced in map resolver.Type: string

Example:

| Map resolver From Honeycomb Should Be | ${nodes[‘DUT1’]} | 192.168.1.2 |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['map-resolvers']['map-resolver'][0]}
Should be equal  ${data['ip-address']}  ${ip_address}

3.5.10.19. Map resolver from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_address - IP address that should be referenced in map resolver.Type: string

Example:

| Map resolver From VAT Should Be | ${nodes[‘DUT1’]} | 192.168.1.2 |


${data}=  Vpp show LISP map resolver  ${node}
Should be equal  ${data[0]['map resolver']}  ${ip_address}

3.5.10.20. Honeycomb adds LISP Map Server

Uses Honeycomb API to configure LISP Map Server.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_addresses - IP addresses for the Map Server.Type: any number of strings

Example:

| Honeycomb adds LISP Map Server | ${nodes[‘DUT1’]} | 192.168.0.2 | 192.168.0.3 |


Add Map Server  ${node}  @{ip_addresses}

3.5.10.21. Map Register from Honeycomb should be

Retrieves LISP Map Register from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Desired state - True. Type: bool

Example:

| Map Register From Honeycomb Should Be | ${nodes[‘DUT1’]} | ${True} |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['map-register']}
Should be equal  ${data['enabled']}  ${state}

3.5.10.22. Map Server from Honeycomb should be

Retrieves LISP Map Server from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_addresses - IP addresses that should be referencedin Map Server. Type: any number of strings

Example:

| Map Server From Honeycomb Should Be | ${nodes[‘DUT1’]} | 192.168.1.2 | 192.168.1.7 |


${data}=  Get LISP operational data  ${node}
Verify Map Server Data from Honeycomb  ${data}  ${ip_addresses}

3.5.10.23. Map Server from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_addresses - IP addresses that should be referencedin Map Server. Type: any number of strings

Example:

| Map Server From VAT Should Be | ${nodes[‘DUT1’]} | 192.168.1.2 | 192.168.1.7 |


${data}=  Vpp show LISP Map Server  ${node}
Verify Map Server Data from VAT  ${data}  ${ip_addresses}

3.5.10.24. Map Register from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Desired state - “enabled”. Type: string

Example:

| Map Register From VAT Should Be | ${nodes[‘DUT1’]} | enabled |


${data}=  Vpp show LISP Map Register  ${node}
Should be equal  ${data['state']}  ${state}

3.5.10.25. Map Request Mode from VAT should be

Retrieves LISP Request Mode from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - destination - Source or Destination in MapRequest Mode. Type: string

Example:

| Map Request Mode From VAT Should Be | ${nodes[‘DUT1’]} | src-dst |


${data}=  Vpp show LISP Map Request Mode  ${node}
Should be equal  ${data['map_request_mode']}  ${destination}

3.5.10.26. Honeycomb enables LISP PITR feature

Uses Honeycomb API to configure LISP PITR feature.

Arguments: - node - Information about a DUT node. Type: dictionary - locator_set - Name of an existing locator set. Type: string

Example:

| Honeycomb enables LISP PITR feature | ${nodes[‘DUT1’]} | loc1 |


Configure PITR  ${node}  ${locator_set}

3.5.10.27. Honeycomb enables LISP PETR feature

Uses Honeycomb API to configure LISP PETR feature.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_address - IP address. Type: string

Example:

| Honeycomb enables LISP PETR feature | ${nodes[‘DUT1’]}| 192.168.0.1 |


Configure PETR  ${node}  ${ip_address}

3.5.10.28. Honeycomb enables LISP RLOC feature

Uses Honeycomb API to enable the LISP RLOC feature.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb enables LISP RLOC feature| ${nodes[‘DUT1’]} |


Set RLOC probe state  ${node}  ${TRUE}

3.5.10.29. PITR config from Honeycomb should be

Retrieves PITR config from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - locator_set - Name of locator set that should be referencedin PITR config. Type: string

Example:

| PITR config from Honeycomb should be | ${nodes[‘DUT1’]} | loc01 |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['pitr-cfg']}
Should be equal  ${data['locator-set']}  ${locator_set}

3.5.10.30. PETR configuration from Honeycomb should be

Retrieves PETR config from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - ip_address - IP address for PETR config. Type: string

Example:

| PETR config from Honeycomb should be | ${nodes[‘DUT1’]} | 192.168.0.1 |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['petr-cfg']['petr-address']}
Should be equal  ${data}  ${ip_address}

3.5.10.31. Map Request Mode from Honeycomb should be

Retrieves List Map Request Mode from Honeycomboperational data, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - destination - source-destination. Type: string

Example:

| List Map Request Mode from Honeycomb should be | ${nodes[‘DUT1’]}| 192.168.0.1 |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['map-request-mode']['mode']}
Should be equal  ${data}  ${destination}

3.5.10.32. RLOC probing from Honeycomb should be

Retrieves RLOC config from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - state - desired state -True/False. Type: bool

Example:

| RLOC probing from Honeycomb should be | ${nodes[‘DUT1’]} | ${True} |


${data}=  Get LISP operational data  ${node}
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
${data}=  Set Variable  ${data['rloc-probe']['enabled']}
Should be equal  ${data}  ${state}

3.5.10.33. PETR configuration from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - state - state of PETR config - enabled/disabled.Type: string

Example:

| PETR configuration From VAT Should Be | ${nodes[‘DUT1’]} | enabled |


${data}=  Vpp show LISP PETR config  ${node}
Should be equal  ${data['status']}  ${state}

3.5.10.34. RLOC probing from VAT should be

Retrieves LISP mapping from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - state - state of RLOC config - enabled/disabled.Type: string

Example:

| RLOC configuration From VAT Should Be | ${nodes[‘DUT1’]} | enabled |


${data}=  Vpp show LISP RLOC config  ${node}
Should be equal  ${data['state']}  ${state}

3.5.10.35. PITR config from VAT should be

Retrieves PITR config from VAT,and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - locator_set - Name of locator set that should be referencedin PITR config. Type: string

Example:

| PITR config from VAT should be | ${nodes[‘DUT1’]} | loc01 |


${data}=  VPP show LISP PITR  ${node}
Should be equal  ${data['status']}  enabled
Should be equal  ${data['locator_set']}  ${locator_set}

3.5.10.36. Honeycomb disables all LISP features

Uses Honeycomb API to remove all LISP configuration.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb disables all LISP features | ${nodes[‘DUT1’]} |


Disable LISP  ${node}

3.5.10.37. Send packet and verify LISP encap

Send ICMP packet to DUT out one interface and receivea LISP encapsulated packet on the other interface.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: string
  • dst_ip - IP of destination interface (TG-if2). Type: string
  • tx_src_port - Interface of TG-if1. Type: string
  • tx_src_mac - MAC address of TG-if1. Type: string
  • tx_dst_mac - MAC address of DUT-if1. Type: string
  • rx_port - Interface of TG-if1. Type: string
  • rx_src_mac - MAC address of DUT1-if2. Type: string
  • rx_dst_mac - MAC address of TG-if2. Type: string
  • src_rloc - configured RLOC source address. Type: string
  • dst_rloc - configured RLOC destination address. Type: string

Return: - No value returned

Example:

| Send packet and verify LISP encap | ${nodes[‘TG’]} | 10.0.0.1 | 32.0.0.1 | eth2 | 08:00:27:ee:fd:b3 | 08:00:27:a2:52:5b | eth3 | 08:00:27:4d:ca:7a | 08:00:27:7d:fd:10 | 10.0.1.1 | 10.0.1.2 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_src_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --tg_src_mac  ${tx_src_mac}  --tg_dst_mac  ${rx_dst_mac}  --dut_if1_mac  ${tx_dst_mac}  --dut_if2_mac  ${rx_src_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}  --src_rloc  ${src_rloc}  --dst_rloc  ${dst_rloc}
Run Traffic Script On Node  lisp/lisp_check.py  ${tg_node}  ${args}

3.5.10.38. LISP Functional Traffic Test Teardown

Teardown for LISP functional traffic test.


Show Packet Trace on all DUTs  ${nodes}
VPP Show LISP EID Table  ${node}
Disable LISP  ${node}

3.5.11. lisp_gpe suite

3.5.11.1. Honeycomb enables LISP GPE

Uses Honeycomb API to enable LISP GPE.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb enables LISP GPE | ${nodes[‘DUT1’]} |


Set LISPGPE state  ${node}  ${TRUE}

3.5.11.2. Honeycomb disables LISP GPE

Uses Honeycomb API to disable LISP GPE.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb disables LISP GPE | ${nodes[‘DUT1’]} |


Set LISPGPE state  ${node}  ${FALSE}

3.5.11.3. Honeycomb adds first LISP GPE Mapping

Uses Honeycomb API to configure a LISP mapping. Removes any existing mappings.

Arguments: - node - Information about a DUT node. Type: dictionary - data - LISP settings to use. Type: dictionary

Example:

| Honeycomb adds first LISP GPE Mapping | ${nodes[‘DUT1’]} | ${data} |


Configure LISPGPE Mapping  ${node}  ${data}

3.5.11.4. Honeycomb adds LISP GPE Mapping

Uses Honeycomb API to configure a LISP mapping.

Arguments: - node - Information about a DUT node. Type: dictionary - data - LISP settings to use. Type: dictionary

Example:

| Honeycomb adds LISP GPE Mapping | ${nodes[‘DUT1’]} | ${data} |


Add LISPGPE Mapping  ${node}  ${data['id']}  ${data}

3.5.11.5. Honeycomb removes LISP GPE mapping

Uses Honeycomb API to remove the specified mapping.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb removes LISP GPE mapping | ${nodes[‘DUT1’]} | map_name |


Delete LISPGPE mapping  ${node}  ${mapping}

3.5.11.6. LISP GPE should not be configured

Retrieves LISP GPE configuration from Honeycomb operationaldata, and expects an empty dictionary.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| LISP GPE should not be configured | ${nodes[‘DUT1’]} |


${data}=  Get LISP GPE operational data  ${node}
Should be Equal  ${data['gpe-state']['gpe-feature-data']['enable']}  ${FALSE}

3.5.11.7. LISP GPE state from Honeycomb should be

Retrieves LISP GPE state from Honeycomb operationaldata, and compares LISP state with expected value.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Expected LISP state. Type: string

Example:

| LISP GPE state from Honeycomb should be | ${nodes[‘DUT1’]} | enabled |


${data}=  Get LISPGPE operational data  ${node}
Run keyword if  $state == 'enabled'  Should be equal as strings  ${data['gpe-state']['gpe-feature-data']['enable']}  ${True}
Run keyword if  $state == 'disabled'  Should be equal as strings  ${data['gpe-state']['gpe-feature-data']['enable']}  ${False}

3.5.11.8. LISP GPE state from VAT should be

Retrieves LISP state from VAT,and compares LISP state with expected value.

Arguments: - node - Information about a DUT node. Type: dictionary - state - Expected LISP state. Type: string

Example:

| LISP state from VAT should be | ${nodes[‘DUT1’]} | enabled |


${status}=  VPP show LISP State  ${node}
Should match  ${status['gpe_status']}  ${state}

3.5.11.9. LISP GPE mapping from Honeycomb should be

Retrieves LISP GPE mapping from Honeycomb operationaldata, and compares with expected data.

Arguments: - node - Information about a DUT node. Type: dictionary - settings - Expected LISP mapping data. Type: dictionary

Example:

| LISP GPE mapping from Honeycomb should be | ${nodes[‘DUT1’]} | ${settings} |


${data}=  Get LISPGPE mapping  ${node}  ${settings['id']}
Compare data structures  ${data}  ${settings}

3.5.11.10. LISP GPE mappings from Honeycomb should not exist

Retrieves LISP GPE mappings from operationaldata, and expects to find none.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| LISP GPE mappings from Honeycomb should not exist | ${nodes[‘DUT1’]} |


${data}=  Get LISPGPE operational data  ${node}
Variable Should Not Exist  ${data['gpe-state']['gpe-feature-data']['gpe-entry']}

3.5.11.11. Honeycomb disables all LISP GPE features

Uses Honeycomb API to remove all LISP GPE configuration.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Honeycomb disables all LISP GPE features | ${nodes[‘DUT1’]} |


Disable LISPGPE  ${node}

3.5.11.12. Send packet and verify LISP GPE encap

Send ICMP packet to DUT out one interface and receivea LISP-GPE encapsulated packet on the other interface.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: string
  • dst_ip - IP of destination interface (TG-if2). Type: string
  • tx_src_port - Interface of TG-if1. Type: string
  • tx_src_mac - MAC address of TG-if1. Type: string
  • tx_dst_mac - MAC address of DUT-if1. Type: string
  • rx_port - Interface of TG-if1. Type: string
  • rx_src_mac - MAC address of DUT1-if2. Type: string
  • rx_dst_mac - MAC address of TG-if2. Type: string
  • src_rloc - configured RLOC source address. Type: string
  • dst_rloc - configured RLOC destination address. Type: string

Return: - No value returned

Example:

| Send packet and verify LISP GPE encap | ${nodes[‘TG’]} | 10.0.0.1 | 32.0.0.1 | | eth2 | 08:00:27:ee:fd:b3 | 08:00:27:a2:52:5b | eth3 | 08:00:27:4d:ca:7a | 08:00:27:7d:fd:10 | 10.0.1.1 | 10.0.1.2 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_src_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --tg_src_mac  ${tx_src_mac}  --tg_dst_mac  ${rx_dst_mac}  --dut_if1_mac  ${tx_dst_mac}  --dut_if2_mac  ${rx_src_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}  --src_rloc  ${src_rloc}  --dst_rloc  ${dst_rloc}
Run Traffic Script On Node  lisp/lispgpe_check.py  ${tg_node}  ${args}

3.5.11.13. LISPGPE Functional Traffic Test Teardown

Teardown for LISP GPE functional traffic test.


Show Packet Trace on all DUTs  ${nodes}
VPP Show LISP EID Table  ${node}
Disable LISPGPE  ${node}

3.5.12. nat suite

3.5.12.1. NAT Operational Data From Honeycomb Should Be empty

Uses Honeycomb API to retrieve NAT operational dataand expects to find only default values.

Arguments: - node - information about a DUT node. Type: dictionary - default_settings - NAT default settings. Type: dictionary

Example:

| NAT Operational Data From Honeycomb Should Be empty | ${nodes[‘DUT1’]} | ${default_settings} |


${data}=  Get NAT Oper data  ${node}
Compare data structures  ${data}  ${default_settings}

3.5.12.2. Honeycomb configures NAT entry

Uses Honeycomb API to configure a static NAT entry.

Arguments: - node - information about a DUT node. Type: dictionary - data - NAT entry to configure. Type: dictionary - instance - NAT instance on VPP node. Type: integer - index - Index of NAT entry. Type: integer

Example:

| Honeycomb configures NAT entry | ${nodes[‘DUT1’]} | ${data} | ${0} | ${1} |


Configure NAT entries  ${node}  ${data}  ${instance}  ${index}

3.5.12.3. NAT entries from Honeycomb should be

Uses Honeycomb API to retrieve NAT operational dataand compares against expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - settings - NAT entry to expect. Type: dictionary - instance - NAT instance on VPP node. Type: integer

Example:

| NAT entries from Honeycomb should be | ${nodes[‘DUT1’]} | ${settings} | ${0} |


${data}=  Get NAT Oper data  ${node}
${data}=  Set Variable  ${data['instances']['instance'][${instance}]['mapping-table']}
Compare data structures  ${data}  ${settings}

3.5.12.4. Honeycomb configures NAT on interface

Uses Honeycomb API to configure NAT on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - direction - NAT direction parameter, inbound or outbound.Type: string

Example:

| Honeycomb configures NAT on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | outbound |


Configure NAT on interface  ${node}  ${interface}  ${direction}

3.5.12.5. Honeycomb removes NAT interface configuration

Uses Honeycomb API to remove an existing NAT interfaceconfiguration.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - direction - NAT direction parameter, inbound or outbound.Type: string

Example:

| Honeycomb removes NAT interface configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | outbound |


Configure NAT on interface  ${node}  ${interface}  ${direction}  ${True}

3.5.12.6. NAT interface Operational Data From Honeycomb Should Be

Uses Honeycomb API to retrieve interface operational dataand compares the NAT section against expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - direction - NAT direction parameter, inbound or outbound.Type: string

Example:

| NAT interface Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | outbound |


${data}=  Get interface oper data  ${node}  ${interface}
Variable should exist  ${data['interface-nat:nat']['${direction}']}

3.5.12.7. NAT interface Operational Data From Honeycomb Should Be empty

Uses Honeycomb API to retrieve interface operational dataand expects to find no data for the given direction.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - direction - NAT direction parameter, inbound or outbound.Type: string

Example:

| NAT interface Operational Data From Honeycomb Should Be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | outbound |


${data}=  Get interface oper data  ${node}  ${interface}
Variable should not exist  ${data['interface-nat:nat']['${direction}']}

3.5.12.8. NAT interface Operational Data From VAT Should Be

Uses Honeycomb API to retrieve NAT configured interfacesand compares with expected settings.

Arguments: - node - information about a DUT node. Type: dictionary - settings - settings to expect. Type: dictionary Type: string

Example:

| NAT interface Operational Data From VAT Should Be | ${nodes[‘DUT1’]} | ${settings} |


${data}=  VPP get NAT interfaces  ${node}
Compare data structures  ${data}  ${settings}

3.5.13. netconf suite

3.5.13.1. Netconf session should be established

Open a communication channel on the Netconf sessionand exchange hello messages.

Arguments: - node - information about a DUT node. Type: dict

Example:

| Netconf session should be established | ${nodes[‘DUT1’]} |


Create session  ${node}  ${hello}

3.5.13.2. Error trigger is sent

Send the specified error trigger through the channel.

Arguments: - trigger - RPC sequence that triggers a specific error. Type: string - params - Parameters for the trigger template. Type: string

Example:

| Error trigger is sent | <rpc>_some data_</rpc>]]>]]> |


Send  ${trigger}  &{params}

3.5.13.3. Replies should not contain RPC errors

Read response received through the channel, and check ifit is an error report.

Arguments: none

Example:

| Replies should not contain RPC errors |


${resp}=  Get all responses
should not contain  ${resp}  rpc-error

3.5.14. notifications suite

3.5.14.1. Notification listener should be established

Connects to Honeycomb notification service.

Arguments: - node - information about a DUT node. Type: dict

Example:

| Notification listener should be established | ${nodes[‘DUT1’]} |


Create session  ${node}  ${hello}
Add notification listener  ${subscription}

3.5.14.2. Honeycomb should send interface state notification

Reads notification from Honeycomb and verifiesnotification type, interface name and interface admin-state.

Arguments: - interface - name of the affected interface. Type: string - state - expected state of interface, ‘up’ or ‘down’. Type: string

Example:

| Honeycomb should send interface state notification | GigabitEthernet0/8/0 | up |


${reply}=  Get notification
Should contain  ${reply}  <interface-state-change
Should contain  ${reply}  <name>${interface}</name>
Should contain  ${reply}  <admin-status>${state}</admin-status>

3.5.14.3. Honeycomb should send interface deleted notification

Reads notification from Honeycomb and verifiesnotification type and interface name.

Arguments: - interface - name of the deleted interface. Type: string

Example:

| Honeycomb should send interface deleted notification | temp_interface |


${reply}=  Get notification
Should contain  ${reply}  <interface-deleted
Should contain  ${reply}  <name>${interface}</name>

3.5.15. nsh suite

3.5.15.1. NSH Operational Data From Honeycomb Should Be empty

Uses Honeycomb API to retrieve NSH configurationand expects to fail.

Arguments: - node - information about a DUT node. Type: dict

Example:

| NSH Operational Data From Honeycomb Should Be empty | ${nodes[‘DUT1’]} |


Run keyword and expect error  *Status code: 404*  Get NSH oper data  ${node}

3.5.15.2. Honeycomb adds NSH entry

Uses Honeycomb API to configure an NSH entry.

Arguments: - node - information about a DUT node. Type: dict - name - name for the NSH entry. Type: string - data - settings for the NSH entry. Type: dictionary

Example:

| Honeycomb configures NSH entry | ${nodes[‘DUT1’]} | nsh_1 | ${data} |


Add NSH entry  ${node}  ${name}  ${data}

3.5.15.3. Honeycomb removes NSH entry

Uses Honeycomb API to delete the specified NSH entry.

Arguments: - node - information about a DUT node. Type: dict - name - name of the NSH entry to be deleted. Type: string

Example:

| Honeycomb removes NSH entry | ${nodes[‘DUT1’]} | nsh_1 |


Remove NSH entry  ${node}  ${name}

3.5.15.4. Honeycomb adds NSH map

Uses Honeycomb API to configure an NSH map.

Arguments: - node - information about a DUT node. Type: dict - name - name for the NSH map. Type: string - data - settings for the NSH map. Type: dictionary

Example:

| Honeycomb configures NSH map | ${nodes[‘DUT1’]} | nsh_1 | ${data} |


Add NSH map  ${node}  ${name}  ${data}

3.5.15.5. Honeycomb removes NSH map

Uses Honeycomb API to delete an NSH map.

Arguments: - node - information about a DUT node. Type: dict - name - name of the NSH map to be deleted. Type: string

Example:

| Honeycomb removes NSH map | ${nodes[‘DUT1’]} | nsh_1 |


Remove NSH map  ${node}  ${name}

3.5.15.6. NSH entry from Honeycomb should be

Retrieves oper data for NSH entry and compareswith provided values.

Arguments: - node - information about a DUT node. Type: dict - name - name of the NSH entry. Type: string - data - expected NSH entry settings. Type dictionary

Example:

| NSH entry from Honeycomb should be | ${nodes[‘DUT1’]} | nsh_1 | ${data} |


${oper_data}=  Get NSH oper data  ${node}  entry_name=${name}
Compare data structures  ${oper_data}  ${data}

3.5.15.7. NSH map from Honeycomb should be

Retrieves oper data for NSH map and compareswith provided values.

Arguments: - node - information about a DUT node. Type: dict - name - name of the NSH map. Type: string - data - expected NSH map settings. Type dictionary

Example:

| NSH map from Honeycomb should be | ${nodes[‘DUT1’]} | nsh_1 | ${data} |


${oper_data}=  Get NSH oper data  ${node}  map_name=${name}
Compare data structures  ${oper_data}  ${data}

3.5.15.8. NSH map from Honeycomb should not exist

Retrieves oper data for NSH map and expects to fail.

Arguments: - node - information about a DUT node. Type: dict - name - name of the NSH map. Type: string

Example:

| NSH map from Honeycomb should not exist | ${nodes[‘DUT1’]} | nsh_1 |


Run keyword and expect error  *Status code: 404*  Get NSH oper data  ${node}  map_name=${name}

3.5.15.9. Honeycomb clears NSH configuration

Uses Honeycomb API to remove all NSH settings.


Clear NSH settings  ${node}

3.5.16. performance suite

3.5.16.1. Configure Honeycomb Netconf threads

Modify thread configuration of Honeycomb’s Netconf server, Requires a restart of Honeycomb to take effect.

Arguments: - node - Node to change configuration on. Type: dictionary - threads - Number of threads to configure. Type: integer

Example:

| Configure Honeycomb Netconf Threads | ${nodes[DUT1]} | ${2} |


Configure Netconf Threads  ${node}  ${threads}

3.5.16.2. Run base operational read performance trial

Send Netconf requests over plain TCP to obtain VPP version from Honeycomb operational data.

Arguments: - node - Node to run test on. Type: dictionary - cores - Number of available processor cores. Type: integer - cycles - Number of test cycles to run. Final results willbe averaged across all runs. Type: integer - threads - Number of threads to use for generating traffic.Type: integer - requests - Number of requests to send in each thread and cycle.Type: integer

Example:

| Run base operational read performance trial | ${nodes[DUT1]} | ${36} | ${1} | ${4} | ${10000} |


${result}=  Run traffic script on DUT  ${node}  read_vpp_version.py  ${cores}  cycles=${cycles}  threads=${threads}  requests=${requests}
Set Test Message  ${result}

3.5.16.3. Generate VPP Startup Configuration for Honeycomb Test on DUT

Create VPP base startup configuration on DUT, then restart VPP to apply the configuration.

Arguments: - node - VPP node to configure. Type: dictionary

Example:

| Generate VPP Startup Configuration for Honeycomb Test on DUT | ${nodes[DUT1]} |


Import Library  resources.libraries.python.VppConfigGenerator  WITH NAME  VPP_config
Run keyword  VPP_config.Set Node  ${node}
Run keyword  VPP_config.Add Unix Log
Run keyword  VPP_config.Add Unix CLI Listen
Run keyword  VPP_config.Add Unix Nodaemon
Run keyword  VPP_config.Add CPU Main Core  ${1}
Run keyword  VPP_config.Apply Config

3.5.16.4. Log Honeycomb and VPP process distribution on cores

Log the distribution of VPP and Honeycomb child processes over the CPU cores.

Arguments: - node - Honeycomb node. Type: dictionary

Example:

| Log Honeycomb and VPP process distribution on cores | ${nodes[DUT1]} |


Log Core Schedule  ${node}  vpp
Log Core Schedule  ${node}  java

3.5.16.5. Generate Honeycomb startup configuration for performance test

Create HC startup configuration and apply to config file on DUT. Requires Honeycomb restart to take effect.

Arguments: - node - Honeycomb node. Type: dictionary

Example:

| Generate Honeycomb startup configuration for performance test | ${nodes[DUT1]} |


Import Library  resources.libraries.python.honeycomb.HoneycombSetup.HoneycombStartupConfig  WITH NAME  HC_config
Run Keyword  HC_config.Set CPU Scheduler  FIFO
Run Keyword  HC_config.Set CPU Core Affinity  ${2}  ${cores}
Run Keyword  HC_config.Set JIT Compiler Mode  server
Run Keyword  HC_config.Set Memory Size  ${512}  ${2048}
Run Keyword  HC_config.Set Metaspace Size  ${128}  ${512}
Run Keyword  HC_config.Set NUMA Optimization
Run Keyword  HC_config.apply config  ${node}

3.5.17. persistence suite

3.5.17.1. Restart Honeycomb

Restarts Honeycomb without clearing persistence data.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart Honeycomb | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Log Persisted Configuration  ${node}
Configure Honeycomb service on DUTs  ${node}

3.5.17.2. Restart VPP

Restarts VPP and waits until it reconnects with Honeycomb.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart VPP | ${nodes[‘DUT1’]} |


Setup DUT  ${node}
Check VPP connection  ${node}

3.5.17.3. Check VPP connection

Checks if Honeycomb is connected to VPP by reading VPPversion number from Honeycomb operational data.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Check VPP connection | ${nodes[‘DUT1’]} |


Wait until keyword succeeds  2min  20sec  Check Honeycomb startup state  ${node}

3.5.17.4. Restart Honeycomb and VPP in pesistence test

Stops Honeycomb, restarts VPP and then starts Honeycombagain.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Restart Honeycomb and VPP | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Log Persisted Configuration  ${node}
Setup DUT  ${node}
Configure Honeycomb service on DUTs  ${node}

3.5.17.5. Multi-Feature Persistence Test Configuration

Uses Honeycomb to set basic settings for VxLAN,bridge domains, TAP, vhost-user and VLAN.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Multi-Feature Persistence Test Configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Honeycomb sets interface VxLAN configuration  ${node}  ${vx_interface}  ${vxlan_settings}
Honeycomb creates first l2 bridge domain  ${node}  ${bd_name}  ${bd_settings}
Honeycomb creates TAP interface  ${node}  ${tap_interface}  ${tap_settings}
Honeycomb creates vhost-user interface  ${node}  ${vhost_interface}  ${vhost_user_client}
Honeycomb creates sub-interface  ${node}  ${interface}  ${sub_if_1_match}  ${sub_if_1_tags}  ${sub_if_1_settings}
Honeycomb configures interface state  ${node}  ${interface}  up
Honeycomb sets the sub-interface up  ${node}  ${interface}  ${sub_if_id}
Honeycomb adds sub-interface to bridge domain  ${node}  ${interface}  ${sub_if_id}  ${sub_bd_settings}
Honeycomb configures tag rewrite  ${node}  ${interface}  ${sub_if_id}  ${tag_rewrite_pop_1}

3.5.17.6. Multi-Feature persistence Test Verification

Uses Honeycomb and VAT to verify settings for VxLAN,bridge domains, TAP, vhost-user and VLAN.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Multi-Feature persistence Test Verification | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


VxLAN Operational Data From Honeycomb Should Be  ${node}  ${vx_interface}  ${vxlan_settings}
VxLAN Operational Data From VAT Should Be  ${node}  ${vxlan_settings}
Bridge domain Operational Data From Honeycomb Should Be  ${node}  ${bd_name}  ${bd_settings}
Bridge domain Operational Data From VAT Should Be  ${node}  ${0}  ${bd_settings}
TAP Operational Data From Honeycomb Should Be  ${node}  ${tap_interface}  ${tap_settings}
TAP Operational Data From VAT Should Be  ${node}  ${tap_interface}  ${tap_settings}
Vhost-user Operational Data From Honeycomb Should Be  ${node}  ${vhost_interface}  ${vhost_user_client}
Vhost-user Operational Data From VAT Should Be  ${node}  ${vhost_user_client}
Sub-interface Operational Data From Honeycomb Should Be  ${node}  ${interface}  ${sub_if_id}  ${sub_if_1_oper}
Sub-interface Operational Data From VAT Should Be  ${node}  ${sub_if_name}  ${sub_if_1_oper}
Interface state from Honeycomb should be  ${node}  ${interface}  up
Interface state from VAT should be  ${node}  ${interface}  up
Sub-interface bridge domain Operational Data From Honeycomb Should Be  ${node}  ${interface}  ${sub_if_id}  ${sub_bd_settings}
Sub-interface bridge domain Operational Data From VAT Should Be  ${node}  ${sub_if_name}  ${sub_bd_settings}
Rewrite tag from Honeycomb should be  ${node}  ${interface}  ${sub_if_id}  ${tag_rewrite_pop_1_oper}
Rewrite tag from VAT should be  ${node}  ${sub_if_name}  ${tag_rewrite_pop_1_VAT}
${data_conf}=  Get all interfaces cfg data  ${node}
${data_oper}=  Get all interfaces oper data  ${node}
Compare interface lists  ${data_conf}  ${data_oper}

3.5.17.7. Honeycomb and VPP should have default configuration

Uses Honeycomb and VAT to verify settings for VxLAN,bridge domains, TAP, vhost-user and VLAN. Expects defaultconfiguration.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb and VPP should have default configuration | ${nodes[‘DUT1’]} |


VxLAN Operational Data From Honeycomb Should Be empty  ${node}  ${vx_interface}
VxLAN Operational Data From VAT Should Be empty  ${node}
Honeycomb should show no bridge domains  ${node}
VAT should show no bridge domains  ${node}
TAP Operational Data From Honeycomb Should Be empty  ${node}  ${tap_interface}
TAP Operational Data From VAT Should Be empty  ${node}  ${tap_interface}
Vhost-user Operational Data From Honeycomb Should Be empty  ${node}  ${vhost_interface}
Vhost-user Operational Data From VAT Should Be empty  ${node}
interface state from Honeycomb should be  ${node}  ${interface}  down
  And interface state from VAT should be  ${node}  ${interface}  down

3.5.17.8. Persistence file is damaged during restart

Shuts down Honeycomb, modifies persistence files tosimulate damage, then restarts VPP and starts up Honeycomb again.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Persistence file is damaged during restart | ${nodes[‘DUT1’]} |


Stop Honeycomb service on DUTs  ${node}
Modify persistence files  ${node}  {  abc
Setup DUT  ${node}
Configure Honeycomb service on DUTs  ${node}

3.5.17.9. Log persisted configuration on node

Logs the content of Honeycomb’s persitence files.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Log persisted configuration on node | ${nodes[‘DUT1’]} |


Log persisted configuration  ${node}

3.5.17.10. Interface Persistence Setup

Configure interface state, ipv4 and ipv6 addresses and neighbors.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Interface Persistence Setup | ${nodes[‘DUT1’]} |


Honeycomb and VPP should have default configuration  ${node}
Import Variables  resources/test_data/honeycomb/interface_ip.py
Honeycomb configures interface state  ${node}  ${interface}  up
Honeycomb sets interface IPv4 address with prefix  ${node}  ${interface}  ${ipv4_address}  ${ipv4_prefix}
Honeycomb adds interface IPv4 neighbor  ${node}  ${interface}  ${ipv4_neighbor}  ${neighbor_mac}
Honeycomb sets interface IPv6 address  ${node}  ${interface}  ${ipv6_address}  ${ipv6_prefix}
Honeycomb adds interface IPv6 neighbor  ${node}  ${interface}  ${ipv6_neighbor}  ${neighbor_mac}

3.5.17.11. Interface Persistence Check

Verify interface state, ipv4 and ipv6 addresses and neighbors.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Interface Persistence Check | ${nodes[‘DUT1’]} |


Interface state from Honeycomb should be  ${node}  ${interface}  up
IPv4 address from Honeycomb should be  ${node}  ${interface}  ${ipv4_address}  ${ipv4_prefix}
IPv4 address from VAT should be  ${node}  ${interface}  ${ipv4_address}  ${ipv4_prefix}  ${ipv4_mask}
IPv4 neighbor from Honeycomb should be  ${node}  ${interface}  ${ipv4_neighbor}  ${neighbor_mac}
IPv6 address from Honeycomb should contain  ${node}  ${interface}  ${ipv6_address}  ${ipv6_prefix}
IPv6 address from VAT should contain  ${node}  ${interface}  ${ipv6_address}  ${ipv6_prefix}
IPv6 neighbor from Honeycomb should be  ${node}  ${interface}  ${ipv6_neighbor}  ${neighbor_mac}

3.5.17.12. Bridge Domain Persistence Setup

Configure bridge domain, BD interface assignment and L2 fib entry.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Bridge Domain Persistence Setup | ${nodes[‘DUT1’]} |


Honeycomb and VPP should have default configuration  ${node}
Import Variables  resources/test_data/honeycomb/l2_fib.py  ${node}  ${interface}  ${interface}
Honeycomb creates first l2 bridge domain  ${node}  ${bd_name}  ${bd_settings}
Honeycomb adds interface to bridge domain  ${node}  ${interface}  ${bd_name}  ${if_bd_settings}
Honeycomb adds L2 FIB entry to bridge domain  ${node}  ${bd_name}  ${l2_fib_forward_cfg}

3.5.17.13. Bridge Domain Persistence Check

Verify bridge domain, BD interface assignment and L2 fib entry.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Bridge Domain Persistence Check | ${nodes[‘DUT1’]} |


Bridge domain Operational Data From Honeycomb Should Be  ${node}  ${bd_name}  ${bd_settings}
Bridge domain Operational Data From VAT Should Be  ${node}  ${0}  ${bd_settings}
Bridge domain Operational Interface Assignment should be  ${node}  ${interface}  ${if_bd_settings}
L2 FIB Entry from Honeycomb should be  ${node}  ${bd_name}  ${l2_fib_forward_oper}
L2 FIB entry from VAT should be  ${node}  ${bd_index}  ${l2_fib_forward_vat}

3.5.18. policer suite

3.5.18.1. Honeycomb Configures Policer

Uses Honeycomb API to configure Policer on the specifiedinterface.

Arguments: - node - information about a DUT node. Type: dictionary - policer_data - data needed to configure Policer. Type: dictionary

Example:

| Honeycomb Configures Policer | ${node} | ${policer_data} |


Configure Policer  ${node}  ${policer_data['name']}  ${policer_data}

3.5.18.2. Policer Operational Data From Honeycomb Should Be

Retrieves Policer operational data and verifies ifPolicer is configured correctly.

Arguments: - node - information about a DUT node. Type: dictionary - policer_data - data to compare configuration Policer with.Type: dictionary

Example:

| Policer Operational Data From Honeycomb Should Be | ${node} | ${policer_data} |


${data}=  Get Policer oper data  ${node}  ${policer_data['name']}
Compare data structures  ${data[0]}  ${policer_data}

3.5.18.3. Policer Operational Data From Honeycomb Should Be empty

Checks whether Policer configuration from Honeycomb is empty.

Arguments: - node - Information about a DUT node. Type: dictionary

Example:

| Policer Operational Data From Honeycomb Should Be empty | ${node} |


Run keyword and expect error  HoneycombError*404*  Get Policer oper data  ${node}  ${policer_data['name']}

3.5.18.4. Honeycomb removes Policer configuration

Uses Honeycomb API to remove Policer configurationfrom the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb removes Policer configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Configure Policer  ${node}  ${policer_data['name']}

3.5.18.5. Tear down policer test

Uses Honeycomb API to remove Policer configurationand reset interface state.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb removes Policer configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Honeycomb removes Policer configuration  ${node}

3.5.18.6. Honeycomb enables Policer on interface

Uses Honeycomb API to enable Policer on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - table_name - name of an ACL table. Type: string

Example:

| Honeycomb enables ACL on interface | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 | table0 |


Enable Policer on interface  ${node}  ${interface}  ${table_name}

3.5.18.7. Honeycomb disables Policer on interface

Uses Honeycomb API to disable Policer on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb disables Policer on interface | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 |


Disable Policer on interface  ${node}  ${interface}

3.5.18.8. Honeycomb Send packet and verify marking

Send packet and verify DSCP of the received packet.

Arguments: - node - TG node. Type: dictionary - tx_if - TG transmit interface. Type: string - rx_if - TG receive interface. Type: string - src_mac - Packet source MAC. Type: string - dst_mac - Packet destination MAC. Type: string - src_ip - Packet source IP address. Type: string - dst_ip - Packet destination IP address. Type: string - dscp_num - DSCP value to verify. Type: integer

Example:

| ${dscp}= | DSCP AF22 | | Send packet and verify marking | ${nodes[‘TG’]} | eth1 | eth2 | 08:00:27:87:4d:f7 | 52:54:00:d4:d8:22 | 192.168.122.2 | 192.168.122.1 | ${dscp} |


${tx_if_name}=  Get Interface Name  ${node}  ${tx_if}
${rx_if_name}=  Get Interface Name  ${node}  ${rx_if}
${args}=  Traffic Script Gen Arg  ${rx_if_name}  ${tx_if_name}  ${src_mac}  ${dst_mac}  ${src_ip}  ${dst_ip}
${args}=  Set Variable  ${args} --dscp ${dscp_num}
Run Traffic Script On Node  policer.py  ${node}  ${args}

3.5.19. port_mirroring suite

3.5.19.1. Honeycomb configures SPAN on interface

Uses Honeycomb API to configure SPAN on the specifiedinterface, mirroring one or more interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string - src_interfaces - Mirroring source interfaces. Type: list of dictionaries

Example:

| Honeycomb configures SPAN on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | [{‘iface-ref’: ‘GigabitEthernet0/10/0’, | ‘state’: ‘transmit’}, | {‘iface-ref’: ‘local0’, ‘state’: ‘both’}] |


Configure interface SPAN  ${node}  ${dst_interface}  ${src_interfaces}

3.5.19.2. Interface SPAN Operational Data From Honeycomb Should Be

Retrieves interface operational data and verifies thatSPAN mirroring is configured with the provided interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string - src_interfaces - Mirroring source interfaces. Type: Argument list -any number of strings

Example:

| Interface SPAN Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 |


${data}=  Get interface oper data  ${node}  ${dst_interface}
${data}=  Set Variable  ${data['v3po:span']['mirrored-interfaces']['mirrored-interface']}
Sort list  ${data}
Sort list  ${src_interfaces}
Lists should be equal  ${data}  ${src_interfaces}

3.5.19.3. Interface SPAN Operational Data From Honeycomb Should Be empty

Checks whether SPAN configuration from Honeycomb is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string

Example:

| Interface SPAN Operational Data From Honeycomb Should Be empty | ${node} | GigabitEthernetO/8/0 |


${data}=  Get interface oper data  ${node}  ${dst_interface}
Variable should not exist  ${data['v3po:span']['mirrored-interfaces']['mirrored-interface']}

3.5.19.4. Interface SPAN Operational Data From VAT Should Be

Retrieves SPAN configuration from VAT dump and verifiesthat SPAN mirroring is configured with the provided interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string - src_interfaces - Mirroring source interfaces. Type: Argument list -any number of strings

Example:

| Interface SPAN Operational Data From VAT Should Be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 |


${data}=  VPP get SPAN configuration by interface  ${node}  ${dst_interface}  name
Sort list  ${data}
Sort list  ${src_interfaces}
Lists should be equal  ${data}  ${src_interfaces}

3.5.19.5. Honeycomb removes interface SPAN configuration

Uses Honeycomb API to remove SPAN configurationfrom the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string

Example:

| Honeycomb removes interface SPAN configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Configure interface SPAN  ${node}  ${dst_interface}

3.5.19.6. Interface SPAN Operational Data from Honeycomb should not exist

Retrieves interface operational data and verifies thatSPAN mirroring is not configured.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination interface. Type: string

Example:

|


${data}=  Get interface oper data  ${node}  ${dst_interface}
Run keyword and expect error  *KeyError*  Set Variable  ${data['span']['mirrored-interfaces']['mirrored-interface']}

3.5.19.7. SPAN Operational Data from VAT should not exist

Attmepts to retrieve SPAN Operational Data from VAT dump,and expects to fail with no data retrieved.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| SPAN Operational Data from VAT should not exist | ${nodes[‘DUT1’]} |


Run keyword and expect error  ValueError: No JSON object could be decoded  VPP get SPAN configuration by interface  ${node}  local0

3.5.19.8. Honeycomb Configures SPAN on sub-interface

Uses Honeycomb API to configure SPAN on the specifiedsub-interface, mirroring one or more interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination super-interface. Type: string - index - Index of mirroring destination sub-interface. Type: integer - src_interfaces - Mirroring source interfaces. Type: list of dictionaries

Example:

| Honeycomb Configures SPAN on sub-interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |[{‘iface-ref’: ‘GigabitEthernet0/10/0’, ‘state’: ‘transmit’}, | {‘iface-ref’: ‘local0’, ‘state’: ‘both’}] |


Configure sub interface SPAN  ${node}  ${dst_interface}  ${index}  ${src_interfaces}

3.5.19.9. Sub-Interface SPAN Operational Data from Honeycomb should be

Retrieves sub-interface operational data and verifiesthat SPAN mirroring is configured with the provided interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination super-interface. Type: string - index - Index of mirroring destination sub-interface. Type: integer - src_interfaces - Mirroring source interfaces. Type: Argument list -any number of strings

Example:

| Sub-Interface SPAN Operational Data from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | GigabitEthernet0/9/0 |


${data}=  Get sub interface oper data  ${node}  ${dst_interface}  ${index}
${data}=  Set Variable  ${data['subinterface-span:span-state']['mirrored-interfaces']['mirrored-interface']}
Sort list  ${data}
Sort list  ${src_interfaces}
Lists should be equal  ${data}  ${src_interfaces}

3.5.19.10. Sub-Interface SPAN Operational Data from Honeycomb should be empty

Checks whether SPAN Operational Data from Honeycomb is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - dst_interface - Mirroring destination super-interface. Type: string - index - Index of mirroring destination sub-interface. Type: integer

Example:

| Interface SPAN Operational Data from Honeycomb should be empty | ${node} | GigabitEthernetO/8/0 | ${1} |


${data}=  Get sub interface oper data  ${node}  ${dst_interface}  ${index}
Variable should not exist  ${data['subinterface-span:span-state']['mirrored-interfaces']['mirrored-interface']}

3.5.19.11. Honeycomb removes sub-interface SPAN configuration

Uses Honeycomb API to remove SPAN Operational Datafrom the specified sub-interface.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination super-interface. Type: string - index - Index of mirroring destination sub-interface. Type: integer

Example:

| Honeycomb removes sub-interface SPAN configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


Configure sub interface SPAN  ${node}  ${dst_interface}  ${index}

3.5.19.12. Sub-Interface SPAN Operational Data from Honeycomb should not exist

Retrieves sub-interface operational data and verifies that SPAN mirroring is not configured.

Arguments: - node - information about a DUT node. Type: dictionary - dst_interface - Mirroring destination super-interface. Type: string - index - Index of mirroring destination sub-interface. Type: integer

Example:

| Sub-Interface SPAN Operational Data from Honeycomb should not exist | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


....
${data}=  Get sub interface oper data  ${node}  ${dst_interface}  ${index}
Run keyword and expect error  *KeyError*  Set Variable  ${data['subinterface-span:span-state']['mirrored-interfaces']['mirrored-interface']}

3.5.20. provider_backbone_bridge suite

3.5.20.1. Honeycomb creates PBB sub-interface

Uses Honeycomb API to set PBB sub-interface on aninterface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - sub_if_id - Sub-interface ID. Type: string - params - Parameters of the sub-interface to be created. Type - dictionary

Example: | Honeycomb creates PBB sub-interface | ${node} | ${super_if}| ${cfg_pbb_sub_if_1} |


Set Interface Up  ${node}  ${super_if}
Create PBB Sub Interface  ${node}  ${super_if}  ${params}

3.5.20.2. Honeycomb removes PBB sub-interface

Uses Honeycomb API to remove PBB sub-interface from itssuper interface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - sub_if_id - Sub-interface ID. Type: string

Example: | Honeycomb removes PBB sub-interface| ${node} | ${super_if} |


Delete PBB Sub Interface  ${node}  ${super_if}

3.5.20.3. Honeycomb fails to create PBB sub-interface

Uses Honeycomb API to set PBB sub-interface with wrongparameter(s) and expects to fail.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - sub_if_id - Sub-interface ID. Type: string - params - Parameters of the sub-interface to be created. Type - dictionary

Example: | Honeycomb fails to create PBB sub-interface| ${node} | ${super_if} | ${cfg_pbb_sub_if_no_vlan_tag} |


Set Interface Up  ${node}  ${super_if}
Run keyword and expect error  *HoneycombError*not successful*.  Create PBB Sub Interface  ${node}  ${super_if}  ${params}

3.5.21. proxyarp suite

3.5.21.1. Honeycomb configures proxyARP

Uses Honeycomb API to configure proxyARP for a specificdestination IP range.

Arguments: - node - information about a DUT node. Type: dictionary - data - Configuration to use. Type: dictionary

Example:

| Honeycomb configures proxyARP | ${nodes[‘DUT1’]} | ${data} |


Configure proxyARP  ${node}  ${data}

3.5.21.2. Honeycomb removes proxyARP configuration

Uses Honeycomb API to remove existing proxyARPIP range configuration.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Honeycomb removes proxyARP configuration | ${nodes[‘DUT1’]} |


Remove proxyARP configuration  ${node}

3.5.21.3. Honeycomb enables proxyARP on interface

Uses Honeycomb API to enable the proxyARPfeature on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| Honeycomb enables proxyARP on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Set proxyARP interface config  ${node}  ${interface}  enable

3.5.21.4. Honeycomb disables proxyARP on interface

Uses Honeycomb API to disable the proxyARPfeature on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| Honeycomb disables proxyARP on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Set proxyARP interface config  ${node}  ${interface}  disable

3.5.21.5. Honeycomb configures IPv6 ND proxy on interface

Uses Honeycomb API to enable the IPv6 ND proxyfeature on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - addresses - one or more addresses to configure ND proxy with.Type: string

Example:

| Honeycomb configures IPv6 ND proxy on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 10::11 |


Configure IPv6ND  ${node}  ${interface}  ${addresses}

3.5.21.6. Honeycomb disables IPv6 ND proxy on interface

Uses Honeycomb API to disable the IPv6 ND proxyfeature on an interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| Honeycomb disables IPv6 ND proxy on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Configure IPv6ND  ${node}  ${interface}

3.5.21.7. IPv6 ND proxy from Honeycomb should be

Retrieves IPv6 ND proxy operational data and compareswith expected values.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - addresses - one or more addresses to expect. Type: string

Example:

| IPv6 ND proxy from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 10::11 |


${oper_data}=  Get interface oper data  ${node}  ${interface}
${oper_data}=  Set Variable  ${oper_data['ietf-ip:ipv6']['nd-proxy:nd-proxies']['nd-proxy']}
${data}=  Evaluate  [{"address":x} for x in $addresses]
Sort List  ${oper_data}
Sort List  ${data}
Should be equal  ${oper_data}  ${data}

3.5.21.8. IPv6 ND proxy from Honeycomb should be empty

Retrieves IPv6 ND proxy operational data and expectsto fail due to no data present.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

|IPv6 ND proxy from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


${oper_data}=  Get interface oper data  ${node}  ${interface}
Variable Should Not Exist  ${oper_data['ietf-ip:ipv6']['nd-proxy:nd-proxies']['nd-proxy']}

3.5.21.9. Verify IPv6ND proxy

Send and receive ICMPv6 messages between TG interfaces through Neighbor Discovery proxy.

Arguments: - tg_node - TG node. Type: dictionary - tg_interface1 - TG interface. Type: string - tg_interface2 - TG interface. Type: string - src_ip - Source IPv6 address to use. Type: string - dst_ip - Destination IPv6 address to use. Type: string - src_mac - MAC address of source interface. Type: string - dst_mac - MAC address of destination interface. Type: string - proxy_to_src_mac - MAC address of DUT interface on link to sourceTG interface. Type: string - proxy_to_dst_mac - MAC address of DUT interface on link to destTG interface. Type: string

Return: - No value returned.

Example:

| Verify IPv6ND proxy | ${nodes[‘TG’]} | eth3 | eth4 | 3ffe:62::1 | 3ffe:63::2 | 08:00:27:cc:4f:54 | 08:00:27:64:18:d2 | 08:00:27:c9:6a:d5 | 08:00:27:c4:75:3a |


${tg_interface_name1}=  Get interface name  ${tg_node}  ${tg_interface1}
${tg_interface_name2}=  Get interface name  ${tg_node}  ${tg_interface2}
${args}=  Catenate  --tx_if  ${tg_interface_name1}  --rx_if  ${tg_interface_name2}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --src_mac  ${src_mac}  --dst_mac  ${dst_mac}  --proxy_to_src_mac  ${proxy_to_src_mac}  --proxy_to_dst_mac  ${proxy_to_dst_mac}
Run Traffic Script On Node  ipv6_nd_proxy_check.py  ${tg_node}  ${args}

3.5.22. routing suite

3.5.22.1. Honeycomb configures routing table

Uses Honeycomb API to configure a routing table.

Arguments: - node - information about a DUT node. Type: dictionary - name - name for the new routing table. Type: string - ip_version - IP protocol version, ipv4 or ipv6. Type:string - data - Settings for the new routing table. Type: dictionary - vrf - vrf-id the new table will belong to. Type: integer - special - Does the table contain special rules. Type: boolean

Example:

| Honeycomb configures routing table | ${nodes[‘DUT1’]} | table1 | ipv4 | ${data} | ${1} | ${TRUE} |


Configure routing table  ${node}  ${name}  ${ip_version}  ${data}  ${vrf}  ${special}

3.5.22.2. Routing data from Honeycomb should contain

Uses Honeycomb API to retrieve operational data abouta routing table, and compares with the data provided.

Arguments: - node - information about a DUT node. Type: dictionary - name - name of the routing table. Type: string - ip_version - IP protocol version, ipv4 or ipv6. Type:string - expected_data - Data to compare against. Type: dictionary

Example:

| Routing data from Honeycomb should contain | ${nodes[‘DUT1’]} | table1 | ipv4 | ${data} |


${data}=  Get Routing Table Oper  ${node}  ${name}  ${ip_version}
Should Contain  ${data}  ${expected_data}

3.5.22.3. Log routing configuration from VAT

Uses test API to read routing configuration from VPPand prints received response into robot log.

Arguments: - node - information about a DUT node. Type: dictionary

Example:

| Log routing configuration from VAT | ${nodes[‘DUT1’]} |


Log routing configuration  ${node}

3.5.22.4. Honeycomb removes routing configuration

Uses Honeycomb API to remove Honeycomb-createdrouting configuration from the node. Entries configured automaticallyby VPP will not be removed.

Arguments: - node - information about a DUT node. Type: dictionary - name - name of the routing table to remove. Type: string

Example:

| Honeycomb removes routing configuration | ${nodes[‘DUT1’]} | table1 |


Delete routing table  ${node}  ${name}

3.5.22.5. Verify route IPv4

Send an ICMP packet from one TG interface and receiveit on the other TG interface.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: integer
  • dst_ip - IP of destination interface (TG-if2). Type: integer
  • tx_port - Source interface (TG-if1). Type: string
  • tx_mac - MAC address of source interface (TG-if1). Type: string
  • rx_port - Destionation interface (TG-if2). Type: string
  • rx_mac - MAC address of DUT interface (DUT-if1). Type: string

Example:

| Verify route IPv4 | ${nodes[‘TG’]} | 16.0.0.1 | 32.0.0.1 | eth1 | 08:00:27:cc:4f:54 | eth2 | 08:00:27:c9:6a:d5 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --src_mac  ${tx_mac}  --dst_mac  ${rx_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}
Run Traffic Script On Node  send_ip_icmp.py  ${tg_node}  ${args}

3.5.22.6. Verify route IPv6

Send an ICMPv6 packet from one TG interface and receiveit on the other TG interface.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: integer
  • dst_ip - IP of destination interface (TG-if2). Type: integer
  • tx_port - Source interface (TG-if1). Type: string
  • tx_mac - MAC address of source interface (TG-if1). Type: string
  • rx_port - Destionation interface (TG-if2). Type: string
  • rx_mac - MAC address of DUT interface (DUT-if1). Type: string

Example:

| Verify route IPv6 | ${nodes[‘TG’]} | 10::1 | 11::1 | eth2 | 08:00:27:cc:4f:54 | eth4 | 08:00:27:c9:6a:d5 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --src_mac  ${tx_mac}  --dst_mac  ${rx_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}
Run Traffic Script On Node  send_ip_icmp.py  ${tg_node}  ${args}

3.5.22.7. Verify multipath route

Send 100 ICMP or ICMPv6 packets from one TG interfaceand receive them on the other TG interface. Verify destination MACaddresses of the packets so that exactly 50 of them use the firstaddress and the other 50 use the second address.

Arguments:

_NOTE:_ Arguments are based on topology: TG(if1)->(if1)DUT(if2)->TG(if2)

  • tg_node - Node to execute scripts on (TG). Type: dictionary
  • src_ip - IP of source interface (TG-if1). Type: integer
  • dst_ip - IP of destination interface (TG-if2). Type: integer
  • tx_port - Source interface (TG-if1). Type: string
  • tx_src_mac - MAC address of source interface (TG-if1). Type: string
  • rx_port - Destionation interface (TG-if2). Type: string
  • tx_dst_mac - MAC address of DUT ingress interface (DUT-if1).Type: string
  • rx_src_mac - MAC address of DUT egress interface (DUT-if2).Type: string
  • rx_dst_mac1 - MAC address of first next-hop option. Type: string
  • rx_dst_mac2 - MAC address of second next-hop option. Type: string

Example:

| Verify multipath route | ${nodes[‘TG’]} | 16.0.0.1 | 32.0.0.1 | eth2 | 08:00:27:cc:4f:54 | eth4 | 08:00:27:c9:6a:d5 | | 00:00:00:00:00:01 | 00:00:00:00:00:02 |


${tx_port_name}=  Get interface name  ${tg_node}  ${tx_port}
${rx_port_name}=  Get interface name  ${tg_node}  ${rx_port}
${args}=  Catenate  --tg_if1_mac  ${tx_src_mac}  --dut_if1_mac  ${tx_dst_mac}  --src_ip  ${src_ip}  --dst_ip  ${dst_ip}  --tx_if  ${tx_port_name}  --rx_if  ${rx_port_name}  --dut_if2_mac  ${rx_src_mac}  --path_1_mac  ${rx_dst_mac_1}  --path_2_mac  ${rx_dst_mac_2}
Run Traffic Script On Node  send_icmp_check_multipath.py  ${tg_node}  ${args}

3.5.23. slaac suite

3.5.23.1. Honeycomb configures SLAAC

Uses Honeycomb API to configure SLAAC on the specifiedinterface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - slaac_data - data needed to configure SLAAC. Type: dictionary

Example:

| Honeycomb configures SLAAC | ${node} | ${interface} | ${slaac_data} |


Configure interface SLAAC  ${node}  ${interface}  ${slaac_data}

3.5.23.2. SLAAC Operational Data From Honeycomb Should Be

Retrieves SLAAC operational data and verifies thatSLAAC is configured with the provided interfaces.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string - slaac_data - data to compare configuration SLAAC with.Type: dictionary

Example:

| SLAAC Operational Data From Honeycomb Should Be | ${node} | ${interface} | ${slaac_data} |


${data}=  Get interface SLAAC oper data  ${node}  ${interface}
Dictionaries should be equal  ${data}  ${slaac_data}

3.5.23.3. SLAAC Operational Data From Honeycomb Should Be empty

Checks whether SLAAC configuration from Honeycomb is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| SLAAC Operational Data From Honeycomb Should Be empty | ${node} | ${interface} |


Run keyword and expect error  HoneycombError*40*  Get interface SLAAC oper data  ${node}  ${interface}

3.5.23.4. Honeycomb removes SLAAC configuration

Uses Honeycomb API to remove SLAAC confirugationfrom the specified interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| Honeycomb removes SLAAC configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Configure interface SLAAC  ${node}  ${interface}

3.5.23.5. SLAAC test teardown

Uses Honeycomb API to remove SLAAC confirugationand reset interface state.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the node. Type: string

Example:

| Honeycomb removes SLAAC configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Honeycomb removes SLAAC configuration  ${node}  ${interface}
  And Honeycomb configures interface state  ${node}  ${interface}  down
Honeycomb removes interface IPv6 addresses  ${node}  ${interface}

3.5.24. sub_interface suite

3.5.24.1. Honeycomb creates sub-interface

Create a sub-interface using Honeycomb API.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface where a sub-interface will becreated. Type: string - match - Match type. Type: string - tags - List of tags to be set while creating the sub-interface.Type: list - sub_interface_settings - Sub-inteface parameters to be set whilecreating the sub-interface. Type: dictionary

Example: | Honeycomb creates sub-interface| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0| vlan-tagged-exact-match | ${sub_if_1_tags}| ${sub_if_1_settings} |


Honeycomb Create sub interface  ${node}  ${super_interface}  ${match}  ${tags}  &{sub_interface_settings}

3.5.24.2. Sub-interface Operational Data From Honeycomb Should Be

Retrieves sub-interface configuration through Honeycomband compares it with settings supplied in argument.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - sub_if_settings - Operational data for sub-interface to be checked.Type: dictionary

Example: | Sub-interface Operational Data From Honeycomb Should Be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1| ${sub_if_1_params} |


${api_data}=  Get sub interface oper data  ${node}  ${super_interface}  ${identifier}
Compare Data Structures  ${api_data}  ${sub_if_settings}

3.5.24.3. Sub-interface Operational Data From Honeycomb Should Be empty

Retrieves sub-interface configuration through Honeycomb and expects no data.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | Sub-interface Operational Data From Honeycomb Should Be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Run keyword and expect error  *KeyError: 'vpp-vlan:sub-interfaces'*  Get sub interface oper data  ${node}  ${super_interface}  ${identifier}

3.5.24.4. Sub-interface state from Honeycomb should be

Retrieves sub-interface configuration through Honeycomb and checks the administrative and operational state.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - admin_state - Required administrative state - up or down. Type: string - oper_state - Required operational state - up or down. Type: string

Example: | Sub-interface state from Honeycomb should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 | up | up |


${api_data}=  Get sub interface oper data  ${node}  ${super_interface}  ${identifier}
Should be equal  ${api_data['admin-status']}  ${admin_state}
Should be equal  ${api_data['oper-status']}  ${oper_state}

3.5.24.5. Sub-interface Operational Data From VAT Should Be

Retrieves sub-interface configuration through VAT andcompares it with settings supplied in argument.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string - sub_interface_settings - Operational data specific for asub-interface to be checked. Type: dictionary

Example: | Sub-interface Operational Data From VAT Should Be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 | ${sub_if_1_params} |


${vat_data}=  VPP get interface data  ${node}  ${sub_interface}
Should be equal as strings  ${vat_data['sub_id']}  ${sub_interface_settings['identifier']}
Should be equal as strings  ${vat_data['interface_name']}  ${sub_interface}
Run keyword if  ${vat_data['link_up_down']} == 0  Should be equal as strings  ${sub_interface_settings['oper-status']}  down
Run keyword if  ${vat_data['link_up_down']} == 1  Should be equal as strings  ${sub_interface_settings['oper-status']}  up

3.5.24.6. Sub-interface state from VAT should be

Retrieves sub-interface configuration through VAT and checks the administrative and operational state.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node. Type: string - admin_state - Required administrative state - up or down. Type: string - oper_state - Required operational state - up or down. Type: string

Example: | Sub-interface state from VAT should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 | up | up |


${vat_data}=  VPP get interface data  ${node}  ${sub_interface}
Run keyword if  '${admin_state}' == 'down'  Should be equal as strings  ${vat_data['admin_up_down']}  0
Run keyword if  '${admin_state}' == 'up'  Should be equal as strings  ${vat_data['admin_up_down']}  1
Run keyword if  '${oper_state}' == 'down'  Should be equal as strings  ${vat_data['link_up_down']}  0
Run keyword if  '${oper_state}' == 'up'  Should be equal as strings  ${vat_data['link_up_down']}  1

3.5.24.7. Sub-interface indices from Honeycomb and VAT should correspond

Uses VAT and Honeycomb to get operational data about thegiven sub-interface and compares the interface indexes. The sub-interface index from Honeycomb should be greater than index from VAT by one.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example:

| Sub-interface indices from Honeycomb and VAT should correspond | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


${api_data}=  Get sub interface oper data  ${node}  ${super_interface}  ${identifier}
${vat_data}=  VPP get interface data  ${node}  ${super_interface}.${identifier}
${sw_if_index}=  EVALUATE  ${vat_data['sw_if_index']} + 1
Should be equal as strings  ${api_data['if-index']}  ${sw_if_index}

3.5.24.8. Honeycomb sets the sub-interface up

Honeycomb sets the sub-interface up.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: Honeycomb sets the sub-interface up| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Set sub interface state  ${node}  ${super_interface}  ${identifier}  up

3.5.24.9. Honeycomb sets the sub-interface down

Honeycomb sets the sub-interface down.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: Honeycomb sets the sub-interface down| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Set sub interface state  ${node}  ${super_interface}  ${identifier}  down

3.5.24.10. Honeycomb fails to set sub-interface up

Honeycomb tries to set sub-interface up and expects error.

Arguments: - node - Information about a DUT node. Type: dictionary - super_interface - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | Honeycomb fails to set sub-interface up| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Run keyword and expect error  *HoneycombError: * was not successful. * 500.  Set sub interface state  ${node}  ${super_interface}  ${identifier}  up

3.5.24.11. Honeycomb adds sub-interface to bridge domain

Honeycomb adds the given sub-interface to bridge domain.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - sub_bd_setings - Bridge domain parameters to be set while addingthe sub-interface to the bridge domain. Type: dictionary

Example: | Honeycomb adds sub-interface to bridge domain| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 | ${bd_settings} |


Add bridge domain to sub interface  ${node}  ${super_if}  ${identifier}  ${sub_bd_setings}

3.5.24.12. Sub-interface bridge domain Operational Data From Honeycomb Should Be

Uses Honeycomb API to verify sub-interface assignment toa bridge domain.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - settings - Bridge domain parameters to be checked. Type: dictionary

Example: | Sub-interface bridge domain Operational Data From Honeycomb Should Be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 | ${bd_settings} |


${if_data}=  Get BD data from sub interface  ${node}  ${super_if}  ${identifier}
Should be equal  ${if_data['bridge-domain']}  ${settings['bridge-domain']}

3.5.24.13. Sub-interface bridge domain Operational Data From VAT Should Be

Uses VAT to verify sub-interface assignment to a bridgedomain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface - Name of a sub-interface on the specified node. Type:string - setings - Parameters to be checked. Type: dictionary

Example: | Sub-interface bridge domain Operational Data From VAT Should Be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 | ${sub_bd_setings} |


${bd_data}=  VPP get bridge domain data  ${node}
${bd_intf}=  Set Variable  ${bd_data[0]}
${sw_if_data}=  Set Variable  ${bd_intf['sw_if'][0]}
Should be equal as integers  ${bd_intf['flood']}  ${bd_settings['flood']}
Should be equal as integers  ${bd_intf['forward']}  ${bd_settings['forward']}
Should be equal as integers  ${bd_intf['learn']}  ${bd_settings['learn']}
Should be equal as strings  ${sw_if_data['shg']}  ${settings['split-horizon-group']}

3.5.24.14. Honeycomb fails to remove all sub-interfaces

Honeycomb tries to remove all sub-interfaces usingHoneycomb API. This operation must fail.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string

Example: | Honeycomb fails to remove all sub-interfaces| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Run keyword and expect error  *HoneycombError:*not successful. * code: 500.  Remove all sub interfaces  ${node}  ${super_if}

3.5.24.15. Honeycomb configures tag rewrite

Honeycomb configures tag-rewrite

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - settings - tag-rewrite parameters. Type: dictionary.

Example: | Honeycomb configures tag rewrite| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1| ${tag_rewrite_push} |


Configure tag rewrite  ${node}  ${super_if}  ${identifier}  ${settings}

3.5.24.16. Rewrite tag from Honeycomb should be empty

Checks if the tag-rewrite is empty or does not exist.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | Rewrite tag from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Run keyword and expect error  *Hon*Error*oper*does not contain*tag-rewrite*  Get tag rewrite oper data  ${node}  ${super_if}  ${identifier}

3.5.24.17. Rewrite tag from Honeycomb should be

Checks if the operational data retrieved from Honeycombare as expected.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - settings - tag-rewrite operational parameters to be checked.Type: dictionary.

Example: | Rewrite tag from Honeycomb should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1| ${tag_rewrite_push_oper} |


${api_data}=  Get tag rewrite oper data  ${node}  ${super_if}  ${identifier}
Compare Data Structures  ${api_data}  ${settings}

3.5.24.18. Rewrite tag from VAT should be

Retrieves sub-interface configuration through VAT andcompares values of rewrite tag parameters with settings supplied inargument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of a sub-interface on the specified node.Type: string - rw_settings - Parameters to be set while setting the rewrite tag.Type: dictionary

Example: | Rewrite tag from VAT should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 | ${rw_params} |


${vat_data}=  VPP get interface data  ${node}  ${interface}
Compare Data Structures  ${vat_data}  ${rw_settings}

3.5.24.19. Honeycomb fails to set wrong rewrite tag

Honeycomb tries to set wrong rewrite tag and expectsan error.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - settings - tag-rewrite parameters. Type: dictionary.

Example: | Honeycomb fails to set wrong rewrite tag| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1| ${tag_rewrite_push_WRONG} |


Run keyword and expect error  *HoneycombError: * was not successful. *00.  Configure tag rewrite  ${node}  ${super_if}  ${identifier}  ${settings}

3.5.24.20. Honeycomb sets sub-interface ipv4 address

Uses Honeycomb API to configure an ipv4 address on thespcified sub-interface. Replaces any existing ipv4 addresses.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - address - IPv4 address to set. Type: string - prefix - IPv4 network prefix length to set. Type: integer

Example: | Honeycomb sets sub-interface ipv4 address| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | 192.168.0.2 | ${24} |


Add ip address to sub_interface  ${node}  ${super_if}  ${identifier}  ${address}  ${prefix}  ipv4

3.5.24.21. Sub-interface ipv4 address from Honeycomb should be

Uses Honeycomb API to verify ipv4 address configurationon the specified sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - address - IPv4 address to expect. Type: string - prefix - IPv4 network prefix length to expect. Type: integer

Example: | sub-interface ipv4 address from Honeycomb should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | 192.168.0.2 | ${24} |


${if_data}=  Get sub interface oper data  ${node}  ${super_if}  ${identifier}
Should be equal  ${if_data['ipv4']['address'][0]['ip']}  ${address}
Should be equal  ${if_data['ipv4']['address'][0]['prefix-length']}  ${prefix}

3.5.24.22. Sub-interface ipv4 address from VAT should be

Uses VAT to verify ipv4 address configurationon the specified sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string - address - IPv4 address to expect. Type: string - prefix - IPv4 network prefix length to expect. Type: integer

Example: | sub-interface ipv4 address from VAT should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 |


${data}=  VPP get interface ip addresses  ${node}  ${sub_interface}  ipv4
Should be equal  ${data[0]['ip']}  ${address}
Should be equal  ${data[0]['prefix_length']}  ${prefix}

3.5.24.23. Honeycomb removes all sub-interface ipv4 addresses

Uses Honeycomb API to remove all configured ipv4addresses from the sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | Honeycomb removes all sub-interface ipv4 addresses| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


Remove all ip addresses from sub_interface  ${node}  ${super_if}  ${identifier}  ipv4

3.5.24.24. Sub-interface ipv4 address from Honeycomb should be empty

Uses Honeycomb API to verify that ipv4 addressconfiguration on the specified sub-interface is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | sub-interface ipv4 address from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


${if_data}=  Get sub interface oper data  ${node}  ${super_if}  ${identifier}
Run keyword and expect error  *KeyError: 'ipv4'*  Set Variable  ${if_data['ipv4']['address'][0]['ip']}

3.5.24.25. Sub-interface ipv4 address from VAT should be empty

Uses VAT to verify that ipv4 addressconfiguration on the specified sub-interface is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string

Example: | sub-interface ipv4 address from VAT should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 |


Run keyword and expect error  *No JSON object could be decoded*  VPP get interface ip addresses  ${node}  ${sub_interface}  ipv4

3.5.24.26. Honeycomb sets sub-interface ipv6 address

Uses Honeycomb API to configure an ipv6 address on thespcified sub-interface. Replaces any existing ipv6 addresses.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - address - IPv6 address to set. Type: string - prefix - IPv6 network prefix length to set. Type: integer

Example: | Honeycomb sets sub-interface ipv6 address| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | 10::10 | ${64} |


Add ip address to sub_interface  ${node}  ${super_if}  ${identifier}  ${address}  ${prefix}  ipv6

3.5.24.27. Sub-interface IPv6 address from Honeycomb should contain

Uses Honeycomb API to verify ipv6 address configurationon the specified sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string - address - IPv6 address to expect. Type: string - prefix - IPv6 network prefix length to expect. Type: integer

Example: | sub-interface IPv6 address from Honeycomb should contain| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} | 10::10 | ${64} |


${if_data}=  Get sub interface oper data  ${node}  ${super_if}  ${identifier}
${settings}=  Create Dictionary  ip=${address}  prefix-length=${prefix}
Should contain  ${if_data['ipv6']['address']}  ${settings}

3.5.24.28. Sub-interface IPv6 address from VAT should contain

Uses VAT to verify ipv6 address configurationon the specified sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string - address - IPv6 address to expect. Type: string - prefix - IPv6 network prefix length to expect. Type: integer

Example: | sub-interface IPv6 address from VAT should contain| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 |


${data}=  VPP get interface ip addresses  ${node}  ${sub_interface}  ipv6
Should be equal  ${data[0]['ip']}  ${address}
Should be equal  ${data[0]['prefix_length']}  ${prefix}

3.5.24.29. Honeycomb removes all sub-interface ipv6 addresses

Uses Honeycomb API to remove all configured ipv6addresses from the sub-interface.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | Honeycomb removes all sub-interface ipv6 addresses| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


Remove all ip addresses from sub_interface  ${node}  ${super_if}  ${identifier}  ipv6

3.5.24.30. Sub-interface ipv6 address from Honeycomb should be empty

Uses Honeycomb API to verify that ipv6 addressconfiguration on the specified sub-interface is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - identifier - Sub-interface ID. Type: integer or string

Example: | sub-interface ipv6 address from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1} |


${if_data}=  Get sub interface oper data  ${node}  ${super_if}  ${identifier}
Run keyword and expect error  *KeyError: 'ipv6'*  Set Variable  ${if_data['ipv6']['address'][0]['ip']}

3.5.24.31. Sub-interface ipv6 address from VAT should be empty

Uses VAT to verify that ipv6 addressconfiguration on the specified sub-interface is empty.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string

Example: | sub-interface ipv6 address from VAT should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 |


Run keyword and expect error  *No JSON object could be decoded*  VPP get interface ip addresses  ${node}  ${sub_interface}  ipv6

3.5.25. tap suite

3.5.25.1. Honeycomb creates TAP interface

Uses Honeycomb API to configure a new TAP interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for TAP. Type: dictionary

Example: | Honeycomb creates TAP interface | ${nodes[‘DUT1’]} | tap_int1 | ${{‘tap-name’:’tap1’,’mac’:‘08:00:27:60:26:ab’, ‘device-instance’:3}} |


Create TAP interface  ${node}  ${interface}  &{settings}

3.5.25.2. Honeycomb configures TAP interface

Uses Honeycomb API to configure an existing TAP interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for TAP. Type: dictionary

Example: | Honeycomb configures TAP interface | ${nodes[‘DUT1’]} | tap_int1 | ${{‘tap-name’:’tap1’,’mac’:‘08:00:27:60:26:ab’, ‘device-instance’:3}} |


Configure interface TAP  ${node}  ${interface}  &{settings}

3.5.25.3. Honeycomb removes TAP interface

Uses Honeycomb API to remove a TAP interface.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb removes TAP interface | ${nodes[‘DUT1’]} | tap_int1 |


Delete interface  ${node}  ${interface}

3.5.25.4. TAP Operational Data From Honeycomb Should Be

Retrieves interface TAP configuration through Honeycomband compares with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for TAP. Type: dictionary

Example:

| TAP Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | tap_int1 | ${{‘tap-name’:’tap1’,’mac’:‘08:00:27:60:26:ab’, ‘device-instance’:3}} |


${api_data}=  Get interface oper data  ${node}  ${interface}
${api_tap}=  Set Variable  ${api_data['v3po:tap']}
Should be equal  ${api_tap['tap-name']}  ${settings['tap-name']}
${api_mac}=  Set Variable  ${api_data['phys-address']}
Should be equal  ${api_mac}  ${settings['mac']}

3.5.25.5. TAP Operational Data From VAT Should Be

Retrieves interface TAP configuration through VAT andcompares with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - settings - Configuration data for TAP. Type: dictionary

Example:

| TAP Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | ${{‘tap-name’:’tap1’,’mac’:‘08:00:27:60:26:ab’, ‘device-instance’:3}} |


${vat_data}=  TAP Dump  ${node}  ${interface}
Should be equal  ${vat_data['dev_name']}  ${settings['tap-name']}

3.5.25.6. TAP Operational Data From Honeycomb Should Be empty

Attempts to retrieve interface TAP configurationthrough Honeycomb and expects to recieve an empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| TAP Operational Data From Honeycomb Should Be empty| ${nodes[‘DUT1’]} | tap_int1 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:tap'  Set Variable  ${api_data['v3po:tap']}

3.5.25.7. TAP Operational Data From VAT Should Be empty

Attempts to retrieve interface TAP configurationthrough VAT and expects a “no data” error.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| TAP Operational Data From VAT Should Be empty| ${nodes[‘DUT1’]} | tap_int1 |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  TAP Dump  ${node}  ${interface}

3.5.26. vhost_user suite

3.5.26.1. Honeycomb creates vhost-user interface

Create a vhost-user interface using Honeycomb API.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for vhost-user interface.Type: dictionary

Example: | Honeycomb creates vhost-user interface| ${nodes[‘DUT1’]} | vhost_test | ${vhost_user_settings} |


Create vhost user interface  ${node}  ${interface}  &{settings}

3.5.26.2. Honeycomb removes vhost-user interface

Remove a vhost-user interface using Honeycomb API.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example: | Honeycomb removes vhost-user interface| ${nodes[‘DUT1’]} | vhost_test |


Delete interface  ${node}  ${interface}

3.5.26.3. Honeycomb configures vhost-user interface

Configure a vhost-user interface using Honeycomb API.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for vhost-user interface.Type: dictionary

Example: | Honeycomb configures vhost-user interface| ${nodes[‘DUT1’]} | vhost_test | ${new_vhost_user_settings} |


Configure interface vhost user  ${node}  ${interface}  &{settings}

3.5.26.4. Vhost-user Operational Data From Honeycomb Should Be

Retrieves interface vhost-user configuration throughHoneycomb and compares it with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for vhost-user interface.Type: dictionary

Example: | Vhost-user Operational Data From Honeycomb Should Be| ${nodes[‘DUT1’]} | vhost_test | ${vhost_user_settings} |


${api_data}=  Get interface oper data  ${node}  ${interface}
${api_vhost}=  Set Variable  ${api_data['v3po:vhost-user']}
: FOR  ${key}  IN  @{settings.keys()}
\    Should be equal  ${api_vhost['${key}']}  ${settings['${key}']}

3.5.26.5. Vhost-user Operational Data From VAT Should Be

Retrieves interface vhost-user configuration through VATand compares it with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - settings - Configuration data for vhost-user interface.Type: dictionary

Example: | Vhost-user Operational Data From VAT Should Be| ${nodes[‘DUT1’]} | vhost_test |

Note: Due to the difficulty of identifying newly created interfaces by nameor by sw_index, this keyword assumes there is only one vhost-userinterface present on the specified node.


&{translate}=  Create dictionary  server=1  client=0
${vat_data}=  vhost user Dump  ${node}
${vat_data}=  Set Variable  ${vat_data[0]}
Should be equal  ${vat_data['sock_filename']}  ${settings['socket']}
should be equal as strings  ${vat_data['is_server']}  ${translate['${settings['role']}']}

3.5.26.6. Vhost-user Operational Data From Honeycomb Should Be empty

Attempts to retrieve interface vhost-user configurationthrough Honeycomb and expects to recieve an empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example: | Vhost-user Operational Data From Honeycomb Should Be empty| ${nodes[‘DUT1’]} | vhost_test |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:vhost-user'  Should be empty  ${api_data['v3po:vhost-user']}

3.5.26.7. Vhost-user Operational Data From VAT Should Be empty

Attempts to retrieve interface vhost-user configurationthrough VAT and expects a “no data” error.

Arguments: - node - information about a DUT node. Type: dictionary

Example: | Vhost-user Operational Data From VAT Should Be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  vhost user Dump  ${node}

3.5.26.8. Honeycomb fails setting vhost-user on different interface type

Attempts to set vhost-user settings on an ethernettype interface and expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for vhost-user. Type: dictionary

Example: | Honeycomb fails setting vhost-user on different interface type| ${nodes[‘DUT1’]} | ${interface} | ${vhost_user_settings} |


Run Keyword And Expect Error  HoneycombError: * Status code: 500.  Configure interface vhost user  ${node}  ${interface}  &{settings}

3.5.26.9. Honeycomb fails setting invalid vhost-user configuration

Attempts to create a vhost-user interface with invalidconfiguration and expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings_list - Bad configuration data for vhost-user. Type: list

Example: | Honeycomb fails setting invalid vhost-user configuration| ${nodes[‘DUT1’]} | vhost_test | ${vhost_user_settings} |


Run Keyword And Expect Error  HoneycombError: * Status code: 400.  Configure interface vhost user  ${node}  ${interface}  &{settings}

3.5.27. vxlan suite

3.5.27.1. Honeycomb sets interface VxLAN configuration

Uses Honeycomb API to configure a VxLAN tunnel.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for VxLAN. Type: dictionary

Example: | Honeycomb sets interface VxLAN configuration |${nodes[‘DUT1’]} | vxlan_01 | ${{‘src’:‘192.168.0.2’,’dst’:‘192.168.0.3’, ‘vni’:5, ‘encap-vrf-id’:0}} |


Honeycomb Create VxLAN interface  ${node}  ${interface}  &{settings}

3.5.27.2. Honeycomb removes VxLAN tunnel settings

Uses Honeycomb API to disable a VxLAN tunnel and removeit from configuration data.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| Honeycomb removes VxLAN tunnel | ${nodes[‘DUT1’]} | vxlan_01 |


Delete interface  ${node}  ${interface}

3.5.27.3. VxLAN Operational Data From Honeycomb Should Be

Retrieves interface VxLAN configuration through Honeycomband compares with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for VxLAN. Type: dictionary

Example:

| VxLAN Operational Data From Honeycomb Should Be |${nodes[‘DUT1’]} | vxlan_01 | ${{‘src’:‘192.168.0.2’,’dst’:‘192.168.0.3’, ‘vni’:5, ‘encap-vrf-id’:0}} |


${api_data}=  Get interface oper data  ${node}  ${interface}
${api_vxlan}=  Set Variable  ${api_data['v3po:vxlan']}
: FOR  ${key}  IN  @{settings.keys()}
\    Should be equal  ${api_vxlan['${key}']}  ${settings['${key}']}

3.5.27.4. VxLAN Operational Data From VAT Should Be

Retrieves interface VxLAN configuration through VAT andcompares with settings supplied in argument.

Arguments: - node - information about a DUT node. Type: dictionary - settings - Configuration data for VxLAN. Type: dictionary

Example:

| VxLAN Operational Data From Honeycomb Should Be |${nodes[‘DUT1’]} | ${{‘src’:‘192.168.0.2’,’dst’:‘192.168.0.3’, ‘vni’:5, ‘encap-vrf-id’:0}} |

Note: Due to the difficulty of identifying newly created interfaces by nameor by sw_index, this keyword assumes there is only one VxLAN tunnelpresent on the specified node.


${vat_data}=  VxLAN Dump  ${node}
${vat_data}=  Set Variable  ${vat_data[0]}
Should be equal  ${vat_data['dst_address']}  ${settings['dst']}
Should be equal  ${vat_data['src_address']}  ${settings['src']}
Should be equal  ${vat_data['vni']}  ${settings['vni']}
Should be equal  ${vat_data['encap_vrf_id']}  ${settings['encap-vrf-id']}

3.5.27.5. VxLAN Operational Data From Honeycomb Should Be empty

Attempts to retrieve interface VxLAN configurationthrough Honeycomb and expects to recieve an empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| VxLAN Operational Data From Honeycomb Should Be empty|${nodes[‘DUT1’]} | vxlan_01 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:vxlan'  Set Variable  ${api_data['v3po:vxlan']}

3.5.27.6. VxLAN Operational Data From VAT Should Be empty

Attempts to retrieve interface VxLAN configurationthrough VAT and expects a “no data” error.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string

Example:

| VxLAN Operational Data From VAT Should Be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  VxLAN Dump  ${node}

3.5.27.7. Honeycomb fails setting VxLan on different interface type

Attempts to set VxLAN settings on an ethernettype interface and expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings - Configuration data for VxLAN. Type: dictionary

Example:

| Honeycomb fails setting VxLan on different interface type|${nodes[‘DUT1’]} | GigabitEthernet0/9/0 | ${{‘src’:‘192.168.0.2’,’dst’:‘192.168.0.3’, ‘vni’:5, ‘encap-vrf-id’:0}} |


Run Keyword And Expect Error  HoneycombError: * Status code: 500.  Honeycomb Configure interface vxlan  ${node}  ${interface}  &{settings}

3.5.27.8. Honeycomb fails setting invalid VxLAN configuration

Attempts to create a VxLAN interface with invalidconfiguration and expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface on the specified node. Type: string - settings_list - Bad configuration data for VxLAN. Type: list

Example:

| Honeycomb fails setting invalid VxLAN configuration|${nodes[‘DUT1’]} | vxlan_01 | ${{‘src’:’abcd’, ‘vni’:-3}} |


: FOR  ${settings}  IN  @{settings_list}
\    Run Keyword And Expect Error  HoneycombError: * Status code: 500.  Honeycomb Create VxLAN interface  ${node}  ${interface}  &{settings}

3.5.28. vxlan_gpe suite

3.5.28.1. Honeycomb creates VxLAN GPE interface

Uses Honeycomb API to configure a VxLAN tunnel.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface to be created. Type: string - base_settings - configuration data common for all interfaces.Type: dictionary - vxlan_gpe_settings - VxLAN GPE specific parameters. Type: dictionary

Example: | Honeycomb creates VxLAN GPE interface | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 | ${base_params} | ${vxlan_gpe_params} |


Create VxLAN GPE interface  ${node}  ${interface}  &{base_settings}  &{vxlan_gpe_settings}

3.5.28.2. Honeycomb removes VxLAN GPE interface

Uses Honeycomb API to remove VxLAN GPE interface fromnode.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of the interface to be removed. Type: string

Example:

| Honeycomb removes VxLAN GPE interface | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 |


Delete interface  ${node}  ${interface}

3.5.28.3. VxLAN GPE Operational Data From Honeycomb Should Be

Uses Honeycomb API to get operational data about thegiven interface and compares them to the values provided as arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface to be checked. Type: string - base_settings - configuration data common for all interfaces.Type: dictionary - vxlan_gpe_settings - VxLAN GPE specific parameters. Type: dictionary

Example: | VxLAN GPE Operational Data From Honeycomb Should Be | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 | ${base_params} | ${vxlan_gpe_params} |


${api_data}=  Get interface oper data  ${node}  ${interface}
Should be equal as strings  ${api_data['name']}  ${base_settings['name']}
Should be equal as strings  ${api_data['type']}  v3po:vxlan-gpe-tunnel
Run keyword if  $base_settings['enabled'] == True  Run keywords  Should be equal as strings  ${api_data['admin-status']}  up  AND  Should be equal as strings  ${api_data['oper-status']}  up  ELSE  Run keywords  Should be equal as strings  ${api_data['admin-status']}  down  AND  Should be equal as strings  ${api_data['oper-status']}  down

3.5.28.4. VxLAN GPE Operational Data From VAT Should Be

Uses VAT to get operational data about the giveninterface and compares them to the values provided as arguments.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface to be checked. Type: string - vxlan_gpe_settings - VxLAN GPE specific parameters. Type: dictionary

Example: | VxLAN GPE Operational Data From VAT Should Be | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 | ${vxlan_gpe_params} |


${vat_data}=  VxLAN GPE Dump  ${node}  ${interface}
Should be equal as strings  ${vat_data['local']}  ${vxlan_gpe_params['local']}
Should be equal as strings  ${vat_data['remote']}  ${vxlan_gpe_params['remote']}
Should be equal as strings  ${vat_data['vni']}  ${vxlan_gpe_params['vni']}
Should be equal as strings  ${vat_data['encap_vrf_id']}  ${vxlan_gpe_params['encap-vrf-id']}
Should be equal as strings  ${vat_data['decap_vrf_id']}  ${vxlan_gpe_params['decap-vrf-id']}
Should be equal as strings  ${vat_data['protocol']/16777216}  ${protocols['${vxlan_gpe_params['next-protocol']}']}

3.5.28.5. VxLAN GPE Interface indices from Honeycomb and VAT should correspond

Uses VAT and Honeycomb to get operational data about the given VxLAN GPE interface and compares the interface indexes. The VxLAN GPE interface index from Honeycomb should be greater than index from VAT by one.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of the interface to be checked. Type: string

Example:

| VxLAN GPE Interface indices from Honeycomb and VAT should correspond | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
${vat_data}=  VxLAN GPE Dump  ${node}  ${interface}
${sw_if_index}=  EVALUATE  ${vat_data['sw_if_index']} + 1
Should be equal as strings  ${api_data['if-index']}  ${sw_if_index}

3.5.28.6. VxLAN GPE Operational Data From Honeycomb Should Be empty

Uses Honeycomb API to get operational data aboutthe given interface and expects to fail.

Arguments: - node - information about a DUT node. Type: dictionary

Example: | VxLAN GPE Operational Data From Honeycomb Should Be empty| ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 |


${api_data}=  Get interface oper data  ${node}  ${interface}
Should be empty  ${api_data}

3.5.28.7. VxLAN GPE Operational Data From VAT Should Be empty

Uses VAT to get operational data about the giveninterface and expects an empty dictionary.

Arguments: - node - information about a DUT node. Type: dictionary

Example: | VxLAN GPE Operational Data From VAT Should Be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  VxLAN Dump  ${node}

3.5.28.8. Honeycomb fails to create VxLAN GPE interface

Uses Honeycomb API to configure a VxLAN tunnel with wrongconfiguration data.

Arguments: - node - information about a DUT node. Type: dictionary - interface - name of an interface to be created. Type: string - base_settings - Configuration data common for all interfaces.Type: dictionary - vxlan_gpe_settings - VxLAN GPE specific parameters. Type: dictionary

Example: | Honeycomb fails to create VxLAN GPE interface | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 | ${wrong_base_params} | ${vxlan_gpe_params} |


Run keyword and expect error  *HoneycombError*not successful. * code: *00.  Create VxLAN GPE interface  ${node}  ${interface}  &{base_settings}  &{vxlan_gpe_settings}