1 # Copyright (c) 2017 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
15 | Library | resources.libraries.python.honeycomb.Lisp.LispKeywords
16 | Library | resources.libraries.python.LispUtil
17 | Documentation | Keywords used to test Honeycomb Lisp features.
20 | Honeycomb enables LISP
21 | | [Documentation] | Uses Honeycomb API to enable LISP.
23 | | ... | *Arguments:*
24 | | ... | - node - Information about a DUT node. Type: dictionary
28 | | ... | \| Honeycomb enables LISP \| ${nodes['DUT1']} \|
30 | | [Arguments] | ${node}
32 | | Set LISP state | ${node} | ${TRUE}
34 | Honeycomb disables LISP
35 | | [Documentation] | Uses Honeycomb API to disable LISP.
37 | | ... | *Arguments:*
38 | | ... | - node - Information about a DUT node. Type: dictionary
42 | | ... | \| Honeycomb disables LISP \| ${nodes['DUT1']} \|
44 | | [Arguments] | ${node}
46 | | Set LISP state | ${node} | ${FALSE}
48 | Honeycomb adds locator set
49 | | [Documentation] | Uses Honeycomb API to enable LISP.
51 | | ... | *Arguments:*
52 | | ... | - node - Information about a DUT node. Type: dictionary
53 | | ... | - interface - Name of an interface on the node. Type: string
54 | | ... | - locator_set - Name for the new locator set. Type: string
58 | | ... | \| Honeycomb adds locator set \| ${nodes['DUT1']} \
59 | | ... | \| GigabitEthernet0/8/0 \| loc_01 \|
61 | | [Arguments] | ${node} | ${interface} | ${locator_set}
63 | | Add locator | ${node} | ${interface} | ${locator_set}
65 | Honeycomb adds LISP Mapping
66 | | [Documentation] | Uses Honeycomb API to configure a LISP mapping.
68 | | ... | *Arguments:*
69 | | ... | - node - Information about a DUT node. Type: dictionary
70 | | ... | - data - LISP settings to use. Type: dictionary
74 | | ... | \| Honeycomb adds LISP Mapping \| ${nodes['DUT1']} \| ${data} \|
76 | | [Arguments] | ${node} | ${data}
78 | | Configure LISP Mapping | ${node} | ${data}
80 | Honeycomb removes all LISP mappings
81 | | [Documentation] | Uses Honeycomb API to clear the eid-table.
83 | | ... | *Arguments:*
84 | | ... | - node - Information about a DUT node. Type: dictionary
88 | | ... | \| Honeycomb removes all LISP mappings \| ${nodes['DUT1']} \|
90 | | [Arguments] | ${node}
92 | | Configure LISP mapping | ${node} | ${NONE}
94 | LISP should not be configured
95 | | [Documentation] | Retrieves LISP configuration from Honeycomb operational\
96 | | ... | data, and expects an empty dictionary.
98 | | ... | *Arguments:*
99 | | ... | - node - Information about a DUT node. Type: dictionary
103 | | ... | \| LISP should not be configured \| ${nodes['DUT1']} \|
105 | | [Arguments] | ${node}
107 | | Run keyword and Expect Error | KeyError: 'lisp-feature-data'
108 | | ... | Get LISP operational data | ${node}
110 | LISP state from Honeycomb should be
111 | | [Documentation] | Retrieves LISP state from Honeycomb operational\
112 | | ... | data, and compares LISP state with expected value.
114 | | ... | *Arguments:*
115 | | ... | - node - Information about a DUT node. Type: dictionary
116 | | ... | - state - Expected LISP state. Type: string
120 | | ... | \| LISP state from Honeycomb should be \| ${nodes['DUT1']} \
121 | | ... | \| enabled \|
123 | | [Arguments] | ${node} | ${state}
124 | | ${data}= | Get LISP operational data | ${node}
126 | | Run keyword if | $state == 'enabled'
127 | | ... | Should be equal as strings
128 | | ... | ${data['lisp-state']['enable']} | ${True}
129 | | Run keyword if | $state == 'disabled'
130 | | ... | Should be equal as strings
131 | | ... | ${data['lisp-state']['enable']} | ${False}
133 | LISP state from VAT should be
134 | | [Documentation] | Retrieves LISP state from VAT,\
135 | | ... | and compares LISP state with expected value.
137 | | ... | *Arguments:*
138 | | ... | - node - Information about a DUT node. Type: dictionary
139 | | ... | - state - Expected LISP state. Type: string
143 | | ... | \| LISP state from VAT should be \| ${nodes['DUT1']} \| enabled \|
145 | | [Arguments] | ${node} | ${state}
147 | | ${status}= | VPP show LISP State | ${node}
148 | | Should match | ${status['feature_status']} | ${state}
150 | LISP mapping from Honeycomb should be
151 | | [Documentation] | Retrieves LISP mapping from Honeycomb operational\
152 | | ... | data, and compares with expected data.
154 | | ... | *Arguments:*
155 | | ... | - node - Information about a DUT node. Type: dictionary
156 | | ... | - settings - Expected LISP mapping data. Type: dictionary
160 | | ... | \| LISP mapping from Honeycomb should be \| ${nodes['DUT1']} \
161 | | ... | \| ${settings} \|
163 | | [Arguments] | ${node} | ${settings}
165 | | ${data}= | Get LISP operational data | ${node}
166 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
167 | | ${data}= | Set Variable | ${data['eid-table']['vni-table'][0]}
168 | | Compare data structures | ${data} | ${settings}
170 | LISP mapping from VAT should be
171 | | [Documentation] | Retrieves LISP mapping from VAT,\
172 | | ... | and compares with expected data.
174 | | ... | *Arguments:*
175 | | ... | - node - Information about a DUT node. Type: dictionary
176 | | ... | - settings - Expected LISP mapping data. Type: dictionary
180 | | ... | \| LISP mapping from VAT should be \| ${nodes['DUT1']} \
181 | | ... | \| ${settings} \|
183 | | [Arguments] | ${node} | ${settings}
185 | | ${data}= | VPP show LISP eid table | ${node}
186 | | Compare data structures | ${data[0]} | ${settings}
188 | LISP mappings from Honeycomb should not exist
189 | | [Documentation] | Retrieves LISP mappings from operational\
190 | | ... | data, and expects to find none.
192 | | ... | *Arguments:*
193 | | ... | - node - Information about a DUT node. Type: dictionary
197 | | ... | \| LISP mappings from Honeycomb should not exist \
198 | | ... | \| ${nodes['DUT1']} \|
200 | | [Arguments] | ${node}
202 | | ${data}= | Get LISP operational data | ${node}
203 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
204 | | Should be empty | ${data['eid-table']['vni-table']}
206 | LISP mappings from VAT should not exist
207 | | [Documentation] | Retrieves LISP mappings from VAT,\
208 | | ... | and expects to receive an empty list.
210 | | ... | *Arguments:*
211 | | ... | - node - Information about a DUT node. Type: dictionary
215 | | ... | \| LISP mappings from VAT should not exist \| ${nodes['DUT1']} \|
217 | | [Arguments] | ${node}
219 | | ${data}= | VPP show LISP eid table | ${node}
220 | | Should be empty | ${data}
222 | Locator set from Honeycomb should be
223 | | [Documentation] | Retrieves LISP locator set from Honeycomb operational\
224 | | ... | data, and compares with expected data.
226 | | ... | *Arguments:*
227 | | ... | - node - Information about a DUT node. Type: dictionary
228 | | ... | - interface - Interface that should be referenced by locator.\
229 | | ... | Type: dictionary
230 | | ... | - locator_set - Expected locator set name. Type: string
234 | | ... | \| Locator set From Honeycomb Should Be \| ${nodes['DUT1']} \
235 | | ... | \| GigabitEthernet0/8/0 \| loc01 \|
237 | | [Arguments] | ${node} | ${interface} | ${locator_set}
239 | | ${data}= | Get LISP operational data | ${node}
240 | | ${loc_data}= | Set Variable
241 | | ... | ${data['lisp-state']['lisp-feature-data']['locator-sets']}
243 | | ... | ${loc_data['locator-set'][0]['name']}
244 | | ... | ${locator_set}
246 | | ... | ${loc_data['locator-set'][0]['interface'][0]['interface-ref']}
247 | | ... | ${interface}
249 | Honeycomb adds LISP adjacency
250 | | [Documentation] | Uses Honeycomb API to configure LISP adjacency.
252 | | ... | *Arguments:*
253 | | ... | - node - Information about a DUT node. Type: dictionary
254 | | ... | - vni - Virtual network identifier number. Type: integer
255 | | ... | - map - Name of an existing remote mapping. Type: string
256 | | ... | - adjacency - Name for the new adjacency. Type: string
257 | | ... | - data - LISP adjacency settings to use. Type: dictionary
261 | | ... | \| Honeycomb adds LISP adjacency \| ${nodes['DUT1']} \| ${1} \| map1\
262 | | ... | \| adj1 \| ${data} \|
264 | | [Arguments] | ${node} | ${vni} | ${map} | ${adjacency} | ${data}
266 | | Add LISP adjacency
267 | | ... | ${node} | ${vni} | ${map} | ${adjacency} | ${data}
269 | Honeycomb adds LISP map resolver
270 | | [Documentation] | Uses Honeycomb API to configure LISP map resolver.
272 | | ... | *Arguments:*
273 | | ... | - node - Information about a DUT node. Type: dictionary
274 | | ... | - ip_address - IP address for the map resolver. Type: string
278 | | ... | \| Honeycomb adds LISP map resolver \| ${nodes['DUT1']} \
279 | | ... | \| 192.168.0.2 \|
281 | | [Arguments] | ${node} | ${ip_address}
283 | | Add map resolver | ${node} | ${ip_address}
285 | Honeycomb adds LISP Map register
286 | | [Documentation] | Uses Honeycomb API to configure LISP map register.
288 | | ... | *Arguments:*
289 | | ... | - node - Information about a DUT node. Type: dictionary
290 | | ... | - add_map_register - Set boolean value of map register. Type: bool
294 | | ... | \| Honeycomb adds LISP Map register \| ${nodes['DUT1']} \
295 | | ... | \| ${True} \|
297 | | [Arguments] | ${node} | ${add_map_register}
299 | | Set Map Register | ${node} | ${add_map_register}
301 | Honeycomb sets LISP Map request Mode
302 | | [Documentation] | Uses Honeycomb API to configure LISP map request mode.
304 | | ... | *Arguments:*
305 | | ... | - node - Information about a DUT node. Type: dictionary
306 | | ... | - set_map_request - Set boolean value of map request mode. Type: bool
310 | | ... | \| Honeycomb adds LISP Map Request Mode \| ${nodes['DUT1']} \
311 | | ... | \| ${True} \|
313 | | [Arguments] | ${node} | ${set_map_request}
315 | | Set Map Request Mode | ${node} | ${set_map_request}
317 | Map resolver from Honeycomb should be
318 | | [Documentation] | Retrieves LISP map resolver from Honeycomb operational\
319 | | ... | data, and compares with expected data.
321 | | ... | *Arguments:*
322 | | ... | - node - Information about a DUT node. Type: dictionary
323 | | ... | - ip_address - IP address that should be referenced in map resolver.\
324 | | ... | Type: string
328 | | ... | \| Map resolver From Honeycomb Should Be \| ${nodes['DUT1']} \
329 | | ... | \| 192.168.1.2 \|
331 | | [Arguments] | ${node} | ${ip_address}
333 | | ${data}= | Get LISP operational data | ${node}
334 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
335 | | ${data}= | Set Variable | ${data['map-resolvers']['map-resolver'][0]}
336 | | Should be equal | ${data['ip-address']} | ${ip_address}
338 | Map resolver from VAT should be
339 | | [Documentation] | Retrieves LISP mapping from VAT,\
340 | | ... | and compares with expected data.
342 | | ... | *Arguments:*
343 | | ... | - node - Information about a DUT node. Type: dictionary
344 | | ... | - ip_address - IP address that should be referenced in map resolver.\
345 | | ... | Type: string
349 | | ... | \| Map resolver From VAT Should Be \| ${nodes['DUT1']} \
350 | | ... | \| 192.168.1.2 \|
352 | | [Arguments] | ${node} | ${ip_address}
354 | | ${data}= | Vpp show LISP map resolver | ${node}
355 | | Should be equal | ${data[0]['map resolver']} | ${ip_address}
357 | Honeycomb adds LISP Map Server
358 | | [Documentation] | Uses Honeycomb API to configure LISP Map Server.
360 | | ... | *Arguments:*
361 | | ... | - node - Information about a DUT node. Type: dictionary
362 | | ... | - ip_addresses - IP addresses for the Map Server.\
363 | | ... | Type: any number of strings
367 | | ... | \| Honeycomb adds LISP Map Server \| ${nodes['DUT1']} \
368 | | ... | \| 192.168.0.2 \| 192.168.0.3 \|
370 | | [Arguments] | ${node} | @{ip_addresses}
372 | | Add Map Server | ${node} | @{ip_addresses}
374 | Map Register from Honeycomb should be
375 | | [Documentation] | Retrieves LISP Map Register from Honeycomb operational\
376 | | ... | data, and compares with expected data.
378 | | ... | *Arguments:*
379 | | ... | - node - Information about a DUT node. Type: dictionary
380 | | ... | - state - Desired state - True. Type: bool
384 | | ... | \| Map Register From Honeycomb Should Be \| ${nodes['DUT1']} \
385 | | ... | \| ${True} \|
387 | | [Arguments] | ${node} | ${state}
389 | | ${data}= | Get LISP operational data | ${node}
390 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
391 | | ${data}= | Set Variable | ${data['map-register']}
392 | | Should be equal | ${data['enabled']} | ${state}
394 | Map Server from Honeycomb should be
395 | | [Documentation] | Retrieves LISP Map Server from Honeycomb operational\
396 | | ... | data, and compares with expected data.
398 | | ... | *Arguments:*
399 | | ... | - node - Information about a DUT node. Type: dictionary
400 | | ... | - ip_addresses - IP addresses that should be referenced\
401 | | ... | in Map Server. Type: any number of strings
405 | | ... | \| Map Server From Honeycomb Should Be \| ${nodes['DUT1']} \
406 | | ... | \| 192.168.1.2 \| 192.168.1.7 \|
408 | | [Arguments] | ${node} | @{ip_addresses}
410 | | ${data}= | Get LISP operational data | ${node}
411 | | Verify Map Server Data from Honeycomb | ${data} | ${ip_addresses}
414 | Map Server from VAT should be
415 | | [Documentation] | Retrieves LISP mapping from VAT,\
416 | | ... | and compares with expected data.
418 | | ... | *Arguments:*
419 | | ... | - node - Information about a DUT node. Type: dictionary
420 | | ... | - ip_addresses - IP addresses that should be referenced\
421 | | ... | in Map Server. Type: any number of strings
425 | | ... | \| Map Server From VAT Should Be \| ${nodes['DUT1']} \
426 | | ... | \| 192.168.1.2 \| 192.168.1.7 \|
428 | | [Arguments] | ${node} | @{ip_addresses}
430 | | ${data}= | Vpp show LISP Map Server | ${node}
431 | | Verify Map Server Data from VAT | ${data} | ${ip_addresses}
433 | Map Register from VAT should be
434 | | [Documentation] | Retrieves LISP mapping from VAT,\
435 | | ... | and compares with expected data.
437 | | ... | *Arguments:*
438 | | ... | - node - Information about a DUT node. Type: dictionary
439 | | ... | - state - Desired state - "enabled". Type: string
443 | | ... | \| Map Register From VAT Should Be \| ${nodes['DUT1']} \
444 | | ... | \| enabled \|
446 | | [Arguments] | ${node} | ${state}
448 | | ${data}= | Vpp show LISP Map Register | ${node}
449 | | Should be equal | ${data['state']} | ${state}
451 | Map Request Mode from VAT should be
452 | | [Documentation] | Retrieves LISP Request Mode from VAT,\
453 | | ... | and compares with expected data.
455 | | ... | *Arguments:*
456 | | ... | - node - Information about a DUT node. Type: dictionary
457 | | ... | - destination - Source or Destination in Map\
458 | | ... | Request Mode. Type: string
462 | | ... | \| Map Request Mode From VAT Should Be \| ${nodes['DUT1']} \
463 | | ... | \| src-dst \|
465 | | [Arguments] | ${node} | ${destination}
467 | | ${data}= | Vpp show LISP Map Request Mode | ${node}
468 | | Should be equal | ${data['map_request_mode']} | ${destination}
470 | Honeycomb enables LISP PITR feature
471 | | [Documentation] | Uses Honeycomb API to configure LISP PITR feature.
473 | | ... | *Arguments:*
474 | | ... | - node - Information about a DUT node. Type: dictionary
475 | | ... | - locator_set - Name of an existing locator set. Type: string
479 | | ... | \| Honeycomb enables LISP PITR feature \| ${nodes['DUT1']} \| loc1 \|
481 | | [Arguments] | ${node} | ${locator_set}
483 | | Configure PITR | ${node} | ${locator_set}
485 | Honeycomb enables LISP PETR feature
486 | | [Documentation] | Uses Honeycomb API to configure LISP PETR feature.
488 | | ... | *Arguments:*
489 | | ... | - node - Information about a DUT node. Type: dictionary
490 | | ... | - ip_address - IP address. Type: string
494 | | ... | \| Honeycomb enables LISP PETR feature \| ${nodes['DUT1']}\
495 | | ... | \| 192.168.0.1 \|
497 | | [Arguments] | ${node} | ${ip_address}
499 | | Configure PETR | ${node} | ${ip_address}
501 | Honeycomb enables LISP RLOC feature
502 | | [Documentation] | Uses Honeycomb API to enable the LISP RLOC feature.
504 | | ... | *Arguments:*
505 | | ... | - node - Information about a DUT node. Type: dictionary
509 | | ... | \| Honeycomb enables LISP RLOC feature\
510 | | ... | \| ${nodes['DUT1']} \|
512 | | [Arguments] | ${node}
514 | | Set RLOC probe state | ${node} | ${TRUE}
516 | PITR config from Honeycomb should be
517 | | [Documentation] | Retrieves PITR config from Honeycomb operational\
518 | | ... | data, and compares with expected data.
520 | | ... | *Arguments:*
521 | | ... | - node - Information about a DUT node. Type: dictionary
522 | | ... | - locator_set - Name of locator set that should be referenced\
523 | | ... | in PITR config. Type: string
527 | | ... | \| PITR config from Honeycomb should be \| ${nodes['DUT1']} \
528 | | ... | \| loc01 \|
530 | | [Arguments] | ${node} | ${locator_set}
532 | | ${data}= | Get LISP operational data | ${node}
533 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
534 | | ${data}= | Set Variable | ${data['pitr-cfg']}
535 | | Should be equal | ${data['locator-set']} | ${locator_set}
537 | PETR configuration from Honeycomb should be
538 | | [Documentation] | Retrieves PETR config from Honeycomb operational\
539 | | ... | data, and compares with expected data.
541 | | ... | *Arguments:*
542 | | ... | - node - Information about a DUT node. Type: dictionary
543 | | ... | - ip_address - IP address for PETR config. Type: string
547 | | ... | \| PETR config from Honeycomb should be \| ${nodes['DUT1']} \
548 | | ... | \| 192.168.0.1 \|
550 | | [Arguments] | ${node} | ${ip_address}
552 | | ${data}= | Get LISP operational data | ${node}
553 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
554 | | ${data}= | Set Variable | ${data['petr-cfg']['petr-address']}
555 | | Should be equal | ${data} | ${ip_address}
557 | Map Request Mode from Honeycomb should be
558 | | [Documentation] | Retrieves List Map Request Mode from Honeycomb\
559 | | ... | operational data, and compares with expected data.
561 | | ... | *Arguments:*
562 | | ... | - node - Information about a DUT node. Type: dictionary
563 | | ... | - destination - source-destination. Type: string
567 | | ... | \| List Map Request Mode from Honeycomb should be \| ${nodes['DUT1']}\
568 | | ... | \| 192.168.0.1 \|
570 | | [Arguments] | ${node} | ${destination}
572 | | ${data}= | Get LISP operational data | ${node}
573 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
574 | | ${data}= | Set Variable | ${data['map-request-mode']['mode']}
575 | | Should be equal | ${data} | ${destination}
577 | RLOC probing from Honeycomb should be
578 | | [Documentation] | Retrieves RLOC config from Honeycomb operational\
579 | | ... | data, and compares with expected data.
581 | | ... | *Arguments:*
582 | | ... | - node - Information about a DUT node. Type: dictionary
583 | | ... | - state - desired state -True/False. Type: bool
587 | | ... | \| RLOC probing from Honeycomb should be \| ${nodes['DUT1']} \
588 | | ... | \| ${True} \|
590 | | [Arguments] | ${node} | ${state}
592 | | ${data}= | Get LISP operational data | ${node}
593 | | ${data}= | Set Variable | ${data['lisp-state']['lisp-feature-data']}
594 | | ${data}= | Set Variable | ${data['rloc-probe']['enabled']}
595 | | Should be equal | ${data} | ${state}
597 | PETR configuration from VAT should be
598 | | [Documentation] | Retrieves LISP mapping from VAT,\
599 | | ... | and compares with expected data.
601 | | ... | *Arguments:*
602 | | ... | - node - Information about a DUT node. Type: dictionary
603 | | ... | - state - state of PETR config - enabled/disabled.\
604 | | ... | Type: string
608 | | ... | \| PETR configuration From VAT Should Be \| ${nodes['DUT1']} \
609 | | ... | \| enabled \|
611 | | [Arguments] | ${node} | ${state}
613 | | ${data}= | Vpp show LISP PETR config | ${node}
614 | | Should be equal | ${data['status']} | ${state}
616 | RLOC probing from VAT should be
617 | | [Documentation] | Retrieves LISP mapping from VAT,\
618 | | ... | and compares with expected data.
620 | | ... | *Arguments:*
621 | | ... | - node - Information about a DUT node. Type: dictionary
622 | | ... | - state - state of RLOC config - enabled/disabled.\
623 | | ... | Type: string
627 | | ... | \| RLOC configuration From VAT Should Be \| ${nodes['DUT1']} \
628 | | ... | \| enabled \|
630 | | [Arguments] | ${node} | ${state}
632 | | ${data}= | Vpp show LISP RLOC config | ${node}
633 | | Should be equal | ${data['state']} | ${state}
635 | PITR config from VAT should be
636 | | [Documentation] | Retrieves PITR config from VAT,\
637 | | ... | and compares with expected data.
639 | | ... | *Arguments:*
640 | | ... | - node - Information about a DUT node. Type: dictionary
641 | | ... | - locator_set - Name of locator set that should be referenced\
642 | | ... | in PITR config. Type: string
646 | | ... | \| PITR config from VAT should be \| ${nodes['DUT1']} \
647 | | ... | \| loc01 \|
649 | | [Arguments] | ${node} | ${locator_set}
651 | | ${data}= | VPP show LISP PITR | ${node}
652 | | Should be equal | ${data['status']} | enabled
653 | | Should be equal | ${data['locator_set']} | ${locator_set}
655 | Honeycomb disables all LISP features
656 | | [Documentation] | Uses Honeycomb API to remove all LISP configuration.
658 | | ... | *Arguments:*
659 | | ... | - node - Information about a DUT node. Type: dictionary
663 | | ... | \| Honeycomb disables all LISP features \| ${nodes['DUT1']} \|
665 | | [Arguments] | ${node}
667 | | Disable LISP | ${node}
669 | Send packet and verify LISP encap
670 | | [Documentation] | Send ICMP packet to DUT out one interface and receive\
671 | | ... | a LISP encapsulated packet on the other interface.
673 | | ... | *Arguments:*
675 | | ... | _NOTE:_ Arguments are based on topology:
676 | | ... | TG(if1)->(if1)DUT(if2)->TG(if2)
678 | | ... | - tg_node - Node to execute scripts on (TG). Type: dictionary
679 | | ... | - src_ip - IP of source interface (TG-if1). Type: string
680 | | ... | - dst_ip - IP of destination interface (TG-if2). Type: string
681 | | ... | - tx_src_port - Interface of TG-if1. Type: string
682 | | ... | - tx_src_mac - MAC address of TG-if1. Type: string
683 | | ... | - tx_dst_mac - MAC address of DUT-if1. Type: string
684 | | ... | - rx_port - Interface of TG-if1. Type: string
685 | | ... | - rx_src_mac - MAC address of DUT1-if2. Type: string
686 | | ... | - rx_dst_mac - MAC address of TG-if2. Type: string
687 | | ... | - src_rloc - configured RLOC source address. Type: string
688 | | ... | - dst_rloc - configured RLOC destination address. Type: string
691 | | ... | - No value returned
695 | | ... | \| Send packet and verify LISP encap \| ${nodes['TG']} \| 10.0.0.1 \
696 | | ... | \| 32.0.0.1 \| eth2 \| 08:00:27:ee:fd:b3 \| 08:00:27:a2:52:5b \
697 | | ... | \| eth3 \| 08:00:27:4d:ca:7a \| 08:00:27:7d:fd:10 \| 10.0.1.1 \
698 | | ... | \| 10.0.1.2 \|
700 | | [Arguments] | ${tg_node} | ${src_ip} | ${dst_ip} | ${tx_src_port}
701 | | ... | ${tx_src_mac} | ${tx_dst_mac} | ${rx_port} | ${rx_src_mac}
702 | | ... | ${rx_dst_mac} | ${src_rloc} | ${dst_rloc}
704 | | ${tx_port_name}= | Get interface name | ${tg_node} | ${tx_src_port}
705 | | ${rx_port_name}= | Get interface name | ${tg_node} | ${rx_port}
706 | | ${args}= | Catenate | --tg_src_mac | ${tx_src_mac} | --tg_dst_mac
707 | | ... | ${rx_dst_mac} | --dut_if1_mac | ${tx_dst_mac} | --dut_if2_mac
708 | | ... | ${rx_src_mac} | --src_ip | ${src_ip} | --dst_ip | ${dst_ip}
709 | | ... | --tx_if | ${tx_port_name} | --rx_if | ${rx_port_name}
710 | | ... | --src_rloc | ${src_rloc} | --dst_rloc | ${dst_rloc}
711 | | Run Traffic Script On Node | lisp/lisp_check.py | ${tg_node}
714 | LISP Functional Traffic Test Teardown
715 | | [Documentation] | Teardown for LISP functional traffic test.
716 | | Show Packet Trace on all DUTs | ${nodes}
717 | | VPP Show LISP EID Table | ${node}
718 | | Disable LISP | ${node}