honeycomb package

access_control_lists module

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}

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}

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}

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}

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 |


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

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 |


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

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}

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}

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  ValueError: No JSON object could be decoded  Get classify table oper data  ${node}  ${table_name}

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  VAT: no JSON data.  Get classify table data  ${node}  ${table_index}

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}

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}

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  *HoneycombError: *Status code: 404.  Get classify session oper data  ${node}  ${table_name}  ${session_match}

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}

Interface ACL settings 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 settings from Honeycomb should be | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 | table0 |


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

Interface ACL settings 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 settings 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']}

Interface ACL settings 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 settings from Honeycomb should be empty | ${nodes[‘DUT1’]} | GigabithEthernet0/8/0 |


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

Interface ACL settings 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 settings 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}

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}

Honeycomb creates ACL chain through IETF node

Creates classify chain through the high-levelIETF-ACL node.

Arguments: - node - Information about a DUT node. Type: dictionary - acl_list_name - Name for the classify chain. Type: string - layer - Classification layer (L2, L3, L4, mixed). Type: string - acl_list_settings - classify rules. Type: dictionary

Example:

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


Create IETF classify chain  ${node}  ${acl_list_name}  ${layer}  ${acl_list_settings}

Honeycomb assigns IETF-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 apply classifier to. Type: string - layer - Classification layer (L2, L3, L4, mixed). Type: string - direction - Ingress or Egress ACL. Type: string - acl_list_name - Name of the classify chain to apply. Type: string - default_action - Default classify action: permit or deny.Type: string

Example:

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


Set IETF interface ACL  ${node}  ${interface}  ${layer}  ${direction}  ${acl_list_name}  ${default-action}  ${mode}

Clear IETF-ACL settings

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 IETF-ACL settings ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


Delete IETF interface ACLs  ${node}  ${interface}
Delete IETF classify chains  ${node}

bridge_domain module

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}

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}

Bridge domain configuration 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 configuration 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}']}

Bridge domain configuration 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 configuration 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}']}

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}} |


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

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}=  interfaceAPI.Get interface oper data  ${node}  ${interface1}
${if2_data}=  interfaceAPI.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']}

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']}

Honeycomb should not show interfaces assigned to bridge domain

Uses Honeycomb API to verify interfaces are not assignedto bridge domain.

Arguments: - node - Information about a DUT node. Type: dictionary - interface1, interface2 - Names of interfaces to checkbridge domain assignment on. Type: string - bd_name - Name of the bridge domain. Type: string

Example:

| Honeycomb should not show interfaces assigned to bridge domain | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 | bd-04 |


${if1_data_oper}=  interfaceAPI.Get interface oper data  ${node}  ${interface1}
${if2_data_oper}=  interfaceAPI.Get interface oper data  ${node}  ${interface2}
${if1_data_cfg}=  interfaceAPI.Get interface cfg data  ${node}  ${interface1}
${if1_data_cfg}=  interfaceAPI.Get interface cfg data  ${node}  ${interface2}
Run keyword and expect error  *KeyError: 'v3po:l2'*  Set Variable  ${if1_data_oper['v3po:l2']}
Run keyword and expect error  *KeyError: 'v3po:l2'*  Set Variable  ${if2_data_oper['v3po:l2']}
Run keyword and expect error  *KeyError: 'v3po:l2'*  Set Variable  ${if1_data_cfg['v3po:l2']}
Run keyword and expect error  *KeyError: 'v3po:l2'*  Set Variable  ${if2_data_cfg['v3po:l2']}

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}

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}

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}

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}} |


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

Bridge domain configuration in interface operational data 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 configuration in interface operational data should be empty | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


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

Bridge domain configuration in interface operational data 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 configuration in interface operational data should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${if_bd_settings} |


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

VAT removes bridge domain


[Documentation] Remove the specified bridge domain using VAT.  *Arguments:*  - node - Information about a DUT node. Type: dictionary  - bd_id - Bridge domain ID. Type: integer  *Example:*  \| VAT removes bridge domain \  \| ${nodes['DUT1']} \| 1 \|
Delete Bridge Domain VAT  ${node}  ${bd_id}

honeycomb module

Setup 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}
Wait until keyword succeeds  4min  15sec  Check honeycomb startup state  @{duts}

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}
Wait until keyword succeeds  30sec  5sec  Check honeycomb shutdown state  @{duts}

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}

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’]} |


Log  Performing clean restart of Honeycomb and VPP.  console=True
Stop Honeycomb service on DUTs  ${node}
Clear persisted Honeycomb configuration  ${node}
Setup DUT  ${node}
Setup Honeycomb service on DUTs  ${node}

Archive Honeycomb log file

Copy honeycomb.log file from Honeycomb nodeto test executor. Arguments: - node - information about a DUT node. Type: dictionary

Example:

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


Archive Honeycomb log  ${node}

interfaces module

Honeycomb sets 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 sets interface state | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | up |


interfaceAPI.Set interface state  ${node}  ${interface}  ${state}

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}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
${api_state}=  Set Variable  ${api_data['admin-status']}
Should be equal  ${api_state}  ${state}

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}=  InterfaceCLI.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}

Honeycomb sets interface ipv4 address

Uses Honeycomb API to change ipv4 addressof 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 - 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 |


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

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: int

Example:

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


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

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 | 255.255.255.0


${api_data}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Should be equal  ${address}  ${api_data['ietf-ip:ipv4']['address'][0]['ip']}
Should be equal  ${prefix}  ${api_data['ietf-ip:ipv4']['address'][0]['prefix-length']}

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 - netmask - subnet mask to expect. Type: string

Example:

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


${vpp_data}=  interfaceCLI.VPP get interface ip addresses  ${node}  ${interface}  ipv4
Should be equal  ${vpp_data[0]['ip']}  ${address}
Should be equal  ${vpp_data[0]['netmask']}  ${netmask}

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}

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}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'ietf-ip:ipv4'  Set Variable  ${api_data['ietf-ip:ipv4']['address']}

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*  InterfaceCLI.VPP get interface ip addresses  ${node}  ${interface}  ipv4

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


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

IPv4 neighbor from Honeycomb should be

Retrieves ipv4 neighbor list through Honeycomband compares the first entry with addresses 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}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Should be equal  ${ip_address}  ${api_data['ietf-ip:ipv4']['neighbor'][0]['ip']}
Should be equal  ${mac_address}  ${api_data['ietf-ip:ipv4']['neighbor'][0]['link-layer-address']}

Honeycomb clears all interface ipv4 neighbors

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

Example:

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


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

Honeycomb sets interface ipv6 address

Uses Honeycomb API to change ipv6 addressof 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 sets interface ipv6 address | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


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

IPv6 address from Honeycomb should be

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 be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


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

IPv6 address from VAT should be

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 be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 10::10 | 64 |


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

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 and routing configuration | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${{‘mtu’: 1500}}


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

Interface ethernet configuration 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 and routing configuration from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${{‘mtu’: 1500}} |


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

Interface ethernet configuration 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 and routing configuration from VAT should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | ${1500} |


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

Interface configuration 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 configuration from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


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

Interface configuration 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 configuration from VAT should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


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

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}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
${vat_data}=  InterfaceCLI.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}

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}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Return from keyword  ${data['if-index']}

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} |


interfaceAPI.check disabled interface  ${node}  ${index}

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}

l2_fib module

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}

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}

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']}
interfaceAPI.Compare Data Structures  ${l2_fib_data}  ${l2_fib_ref_data}

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}

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}

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}

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}

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']}
interfaceAPI.Compare Data Structures  ${l2_fib_data}  ${l2_fib_ref_data}

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}

lisp module

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}  enable

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 enables Lisp | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0| loc_01 |


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

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}

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}

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’]} |


${data}=  Get Lisp operational data  ${node}
Should be equal as strings  ${data['lisp-state']['enable']}  False
${data}=  Set Variable  ${data['lisp-state']['lisp-feature-data']}
Should match  ${data['pitr-cfg']['locator-set']}  N/A
Variable should not exist  ${data['eid-table']['vni-table'][0]}

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}

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}

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}

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}

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']}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

nat module

NAT configuration 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 configuration from Honeycomb should be empty | ${nodes[‘DUT1’]} | ${default_settings} |


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

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}

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['nat-instances']['nat-instance'][${instance}]['mapping-table']}
Compare data structures  ${data}  ${settings}

NAT entries from VAT should be

Uses VPP test API to retrieve NAT entriesand compares against expected settings.

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

Example:

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


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

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}

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}

NAT interface configuration 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 configuration 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}']}

NAT interface configuration 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 configuration 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}']}

NAT interface configuration 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 configuration from VAT should be | ${nodes[‘DUT1’]} | ${settings} |


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

netconf module

Netconf session is established

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

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

Example:

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


Create session  ${node}  ${hello}

Error trigger is sent

Send the specified error trigger through the channel.

Arguments: - trigger - RPC sequence that triggers a specific error. Type: string

Example:

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


Send  ${trigger}

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

notifications module

Notification listener is established

Connects to Honeycomb notification service.

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

Example:

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


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

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>

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>

nsh module

NSH configuration 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 configuration from Honeycomb should be empty | ${nodes[‘DUT1’]} |


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

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}

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}

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}

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}

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}

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}

NSH entry from Honeycomb should not exist

Retrieves oper data for NSH entry and expects to fail.

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

Example:

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


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

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}

Honeycomb clears NSH configuration

Uses Honeycomb API to remove all NSH settings.


Clear NSH settings  ${node}

persistence module

Honeycomb is restarted

Restarts Honeycomb without clearing persistence data.

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

Example:

| Honeycomb is restarted | ${nodes[‘DUT1’]} |


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

VPP is restarted

Restarts VPP and waits until it reconnects with Honeycomb.

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

Example:

| VPP is restarted | ${nodes[‘DUT1’]} |


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

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}

Honeycomb and VPP are restarted

Stops Honeycomb, restarts VPP and then starts Honeycombagain.

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

Example:

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


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

Honeycomb configures every setting

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:

| Honeycomb configures every setting | ${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 sets 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}

Honeycomb and VPP should verify every setting

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:

| Honeycomb and VPP should verify every setting | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 |


VxLAN configuration from Honeycomb should be  ${node}  ${vx_interface}  ${vxlan_settings}
VxLAN configuration from VAT should be  ${node}  ${vxlan_settings}
Bridge domain configuration from Honeycomb should be  ${node}  ${bd_name}  ${bd_settings}
Bridge domain configuration from VAT should be  ${node}  ${0}  ${bd_settings}
TAP configuration from Honeycomb should be  ${node}  ${tap_interface}  ${tap_settings}
TAP configuration from VAT should be  ${node}  ${tap_interface}  ${tap_settings}
Vhost-user configuration from Honeycomb should be  ${node}  ${vhost_interface}  ${vhost_user_client}
Vhost-user configuration from VAT should be  ${node}  ${vhost_user_client}
Sub-interface configuration from Honeycomb should be  ${node}  ${interface}  ${sub_if_id}  ${sub_if_1_oper}
Sub-interface configuration 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 configuration from Honeycomb should be  ${node}  ${interface}  ${sub_if_id}  ${sub_bd_settings}
Sub-interface bridge domain configuration 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}

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 configuration from Honeycomb should be empty  ${node}  ${vx_interface}
VxLAN configuration from VAT should be empty  ${node}
Honeycomb should show no bridge domains  ${node}
VAT should show no bridge domains  ${node}
TAP configuration from Honeycomb should be empty  ${node}  ${tap_interface}
TAP configuration from VAT should be empty  ${node}  ${tap_interface}
Vhost-user configuration from Honeycomb should be empty  ${node}  ${vhost_interface}
Vhost-user configuration 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

Honeycomb and VPP should not have default configuration

Uses Honeycomb and VAT to verify settings for VxLAN,bridge domains, TAP, vhost-user and VLAN. Expects anyconfiguration other than default.

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

Example:

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


Run keyword and expect error  *  Honeycomb and VPP should have default configuration  ${node}

Honeycomb should show no rogue interfaces

Checks if operational data contains interfaces notpresent in configuration and vice versa.

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

Example:

| Honeycomb should show no rogue interfaces | ${nodes[‘DUT1’]} |


${data_conf}=  InterfaceAPI.Get all interfaces cfg data  ${node}
${data_oper}=  InterfaceAPI.Get all interfaces oper data  ${node}
Compare interface lists  ${data_conf}  ${data_oper}

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}
Setup Honeycomb service on DUTs  ${node}

port_mirroring module

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: Argument list -any number of strings

Example:

| Honeycomb Configures SPAN on interface | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 |


InterfaceAPI.Configure interface SPAN  ${node}  ${dst_interface}  @{src_interfaces}

Interface SPAN configuration 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 configuration from Honeycomb should be | ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | GigabitEthernet0/9/0 |


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

Interface SPAN configuration 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 configuration 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}

Honeycomb removes interface SPAN configuration

Uses Honeycomb API to remove SPAN confirugationfrom 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 |


InterfaceAPI.Configure interface SPAN  ${node}  ${dst_interface}

Interface SPAN configuration 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}=  InterfaceAPI.Get interface oper data  ${node}  ${dst_interface}
Run keyword and expect error  *KeyError*  Set Variable  ${data['span']['mirrored-interfaces']['mirrored-interface']}

SPAN configuration from VAT should not exist

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

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

Example:

| SPAN configuration 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

provider_backbone_bridge module

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} |


IfAPI.Set Interface Up  ${node}  ${super_if}
IfAPI.Create PBB Sub Interface  ${node}  ${super_if}  ${params}

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}

PBB Sub Interface Operational Data From Honeycomb Should Be

Retrieves PBB sub-interface operational data from Honeycomb and compares with expected configuration.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - sub_if_id - Sub-interface ID. Type: string - expected_params - Expected operational data. Type: dictionary

Example: | PBB sub interface operational data from Honeycomb should be| ${node} | ${super_if} | ${cfg_pbb_sub_if_1_ID}| ${oper_pbb_sub_if_1} |


${data}=  IfAPI.Get PBB Sub Interface Oper Data  ${node}  ${super_if}  ${sub_if_id}
Compare data structures  ${data}  ${expected_params}

PBB Sub Interface Operational Data From Honeycomb Should Be Empty

Retrieves interface BPP configuration from Honeycomb,and expects an empty dictionary.

Arguments: - node - Information about a DUT node. Type: dictionary - super_if - Super-interface. Type: string - sub_if_id - Sub-interface ID. Type: string

Example: | PBB sub interface operational data from Honeycomb should be empty| ${node} | ${super_if} | ${cfg_pbb_sub_if_1_ID} |


${data}=  IfAPI.Get PBB Sub Interface Oper Data  ${node}  ${super_if}  ${sub_if_id}
Should be empty  ${data}

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} |


IfAPI.Set Interface Up  ${node}  ${super_if}
Run keyword and expect error  *HoneycombError*not successful*.  IfAPI.Create PBB Sub Interface  ${node}  ${super_if}  ${params}

sub_interface module

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} |


interfaceAPI.Create sub interface  ${node}  ${super_interface}  ${match}  ${tags}  &{sub_interface_settings}

Sub-interface configuration 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 configuration from Honeycomb should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1| ${sub_if_1_params} |


${api_data}=  interfaceAPI.Get sub interface oper data  ${node}  ${super_interface}  ${identifier}
interfaceAPI.Compare Data Structures  ${api_data}  ${sub_if_settings}

Sub-interface configuration 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 configuration from Honeycomb should be empty| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 |


Run keyword and expect error  *KeyError: 'vpp-vlan:sub-interfaces'*  interfaceAPI.Get sub interface oper data  ${node}  ${super_interface}  ${identifier}

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}=  interfaceAPI.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}

Sub-interface configuration 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 configuration from VAT should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 | ${sub_if_1_params} |


${vat_data}=  InterfaceCLI.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

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}=  InterfaceCLI.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

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}=  interfaceAPI.Get sub interface oper data  ${node}  ${super_interface}  ${identifier}
${vat_data}=  InterfaceCLI.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}

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 |


interfaceAPI.Set sub interface state  ${node}  ${super_interface}  ${identifier}  up

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 |


interfaceAPI.Set sub interface state  ${node}  ${super_interface}  ${identifier}  down

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.  interfaceAPI.Set sub interface state  ${node}  ${super_interface}  ${identifier}  up

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} |


interfaceAPI.Add bridge domain to sub interface  ${node}  ${super_if}  ${identifier}  ${sub_bd_setings}

Sub-interface bridge domain configuration 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 configuration from Honeycomb should be| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0 | 1 | ${bd_settings} |


${if_data}=  interfaceAPI.Get BD data from sub interface  ${node}  ${super_if}  ${identifier}
Should be equal  ${if_data['bridge-domain']}  ${settings['bridge-domain']}

Sub-interface bridge domain configuration 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 configuration 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']}

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.  interfaceAPI.Remove all sub interfaces  ${node}  ${super_if}

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} |


interfaceAPI.Configure tag rewrite  ${node}  ${super_if}  ${identifier}  ${settings}

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*  interfaceAPI.Get tag rewrite oper data  ${node}  ${super_if}  ${identifier}

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}=  interfaceAPI.Get tag rewrite oper data  ${node}  ${super_if}  ${identifier}
interfaceAPI.Compare Data Structures  ${api_data}  ${settings}

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}=  InterfaceCLI.VPP get interface data  ${node}  ${interface}
interfaceAPI.Compare Data Structures  ${vat_data}  ${rw_settings}

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.  interfaceAPI.Configure tag rewrite  ${node}  ${super_if}  ${identifier}  ${settings}

VAT disables tag-rewrite

The keyword disables the tag-rewrite using VAT.

Arguments: - node - Information about a DUT node. Type: dictionary - sub_interface - Name of an sub-interface on the specified node.Type: string

Example: | VAT disables tag-rewrite| ${nodes[‘DUT1’]} | GigabitEthernet0/8/0.1 |


${sw_if_index}=  interfaceCLI.Get sw if index  ${node}  ${sub_interface}
L2 tag rewrite  ${node}  ${sw_if_index}  disable

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 ipv4 address to sub_interface  ${node}  ${super_if}  ${identifier}  ${address}  ${prefix}

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}=  interfaceAPI.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}

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}

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 ipv4 addresses from sub_interface  ${node}  ${super_if}  ${identifier}

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}=  interfaceAPI.Get sub interface oper data  ${node}  ${super_if}  ${identifier}
Run keyword and expect error  *KeyError: 'ipv4'*  Set Variable  ${if_data['ipv4']['address'][0]['ip']}

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

tap module

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}} |


interfaceAPI.Create TAP interface  ${node}  ${interface}  &{settings}

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}} |


interfaceAPI.Configure interface TAP  ${node}  ${interface}  &{settings}

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 |


interfaceAPI.Delete interface  ${node}  ${interface}

TAP configuration 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 configuration from Honeycomb should be | ${nodes[‘DUT1’]} | tap_int1 | ${{‘tap-name’:’tap1’,’mac’:‘08:00:27:60:26:ab’, ‘device-instance’:3}} |


${api_data}=  interfaceAPI.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']}

TAP configuration 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 configuration 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']}

TAP configuration 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 configuration from Honeycomb should be empty| ${nodes[‘DUT1’]} | tap_int1 |


${api_data}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:tap'  Set Variable  ${api_data['v3po:tap']}

TAP configuration 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 configuration 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}

vhost_user module

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} |


interfaceAPI.Create vhost user interface  ${node}  ${interface}  &{settings}

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 |


interfaceAPI.Delete interface  ${node}  ${interface}

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} |


interfaceAPI.Configure interface vhost user  ${node}  ${interface}  &{settings}

Vhost-user configuration 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 configuration from Honeycomb should be| ${nodes[‘DUT1’]} | vhost_test | ${vhost_user_settings} |


${api_data}=  interfaceAPI.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}']}

Vhost-user configuration 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 configuration 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']}']}

Vhost-user configuration 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 configuration from Honeycomb should be empty| ${nodes[‘DUT1’]} | vhost_test |


${api_data}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:vhost-user'  Should be empty  ${api_data['v3po:vhost-user']}

Vhost-user configuration 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 configuration from VAT should be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  vhost user Dump  ${node}

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.  interfaceAPI.Configure interface vhost user  ${node}  ${interface}  &{settings}

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.  interfaceAPI.Configure interface vhost user  ${node}  ${interface}  &{settings}

vxlan module

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}} |


interfaceAPI.Create VxLAN interface  ${node}  ${interface}  &{settings}

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 |


interfaceAPI.Delete interface  ${node}  ${interface}

VxLAN configuration 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 configuration 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}=  interfaceAPI.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}']}

VxLAN configuration 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 configuration 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']}

VxLAN configuration 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 configuration from Honeycomb should be empty|${nodes[‘DUT1’]} | vxlan_01 |


${api_data}=  interfaceAPI.Get interface oper data  ${node}  ${interface}
Run keyword and expect error  *KeyError: 'v3po:vxlan'  Set Variable  ${api_data['v3po:vxlan']}

VxLAN configuration 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 configuration from VAT should be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  VxLAN Dump  ${node}

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.  interfaceAPI.Configure interface vxlan  ${node}  ${interface}  &{settings}

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.  interfaceAPI.Create VxLAN interface  ${node}  ${interface}  &{settings}

vxlan_gpe module

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} |


interfaceAPI.Create VxLAN GPE interface  ${node}  ${interface}  &{base_settings}  &{vxlan_gpe_settings}

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 |


interfaceAPI.Delete interface  ${node}  ${interface}

VxLAN GPE configuration 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 configuration from Honeycomb should be | ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 | ${base_params} | ${vxlan_gpe_params} |


${api_data}=  interfaceAPI.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

VxLAN GPE configuration 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 configuration 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']}']}

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}=  interfaceAPI.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}

VxLAN GPE configuration 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 configuration from Honeycomb should be empty| ${nodes[‘DUT1’]} | vxlan_gpe_tunnel0 |


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

VxLAN GPE configuration 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 configuration from VAT should be empty| ${nodes[‘DUT1’]} |


Run Keyword And Expect Error  ValueError: No JSON object could be decoded  VxLAN Dump  ${node}

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.  interfaceAPI.Create VxLAN GPE interface  ${node}  ${interface}  &{base_settings}  &{vxlan_gpe_settings}