New bulkomatic performance test single instance
[integration/test.git] / csit / libraries / Utils.robot
1 *** Settings ***
2 Documentation     General Utils library. This library has broad scope, it can be used by any robot system tests.
3 Library           SSHLibrary
4 Library           String
5 Library           DateTime
6 Library           Process
7 Library           Collections
8 Library           RequestsLibrary
9 Library           ./UtilLibrary.py
10 Resource          KarafKeywords.robot
11 Resource          TemplatedRequests.robot
12 Variables         ../variables/Variables.py
13
14 *** Variables ***
15 # TODO: Introduce ${tree_size} and use instead of 1 in the next line.
16 ${start}          sudo mn --controller=remote,ip=${ODL_SYSTEM_IP} --topo tree,1 --switch ovsk,protocols=OpenFlow13
17
18 *** Keywords ***
19 Start Suite
20     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${timeout}=30s
21     [Documentation]    Basic setup/cleanup work that can be done safely before any system
22     ...    is run.
23     Log    Start the test on the base edition
24     Clean Mininet System
25     ${mininet_conn_id}=    Open Connection    ${system}    prompt=${prompt}    timeout=${timeout}
26     Set Suite Variable    ${mininet_conn_id}
27     Flexible Mininet Login    user=${user}    password=${password}
28     Execute Command    sudo ovs-vsctl set-manager ptcp:6644
29     Write    ${start}
30     Read Until    mininet>
31
32 Start Mininet
33     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}    ${cmd}=${start}    ${custom}=    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}
34     ...    ${prompt_timeout}=30s
35     [Documentation]    Basic setup to start mininet with custom topology
36     Log    Start the test on the base edition
37     Clean Mininet System
38     ${mininet_conn_id}=    Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
39     Set Suite Variable    ${mininet_conn_id}
40     Flexible Mininet Login    user=${user}    password=${password}
41     Put File    ${custom}
42     Write    ${cmd}
43     Read Until    mininet>
44     [Return]    ${mininet_conn_id}
45
46 Stop Mininet
47     [Arguments]    ${mininet_conn_id}    ${prompt}=${DEFAULT_LINUX_PROMPT}
48     [Documentation]    Basic setup to stop/clean mininet
49     Switch Connection    ${mininet_conn_id}
50     SSHLibrary.Write    exit
51     Read Until    ${prompt}
52     Close Connection
53
54 Stop Suite
55     [Arguments]    ${prompt}=${DEFAULT_LINUX_PROMPT}
56     [Documentation]    Cleanup/Shutdown work that should be done at the completion of all
57     ...    tests
58     Log    Stop the test on the base edition
59     Switch Connection    ${mininet_conn_id}
60     Read
61     Write    exit
62     Read Until    ${prompt}
63     Close Connection
64
65 Report_Failure_Due_To_Bug
66     [Arguments]    ${number}
67     [Documentation]    Report that a test failed due to a known Bugzilla bug whose
68     ...    number is provided as an argument.
69     ...    Not FAILED (incl. SKIPPED) test are not reported.
70     ...    This keyword must be used in the [Teardown] setting of the affected test
71     ...    or as the first line of the test if FastFail module is not being
72     ...    used. It reports the URL of the bug on console and also puts it
73     ...    into the Robot log file.
74     ${test_skipped}=    BuiltIn.Evaluate    len(re.findall('SKIPPED', """${TEST_MESSAGE}""")) > 0    modules=re
75     BuiltIn.Return From Keyword If    ('${TEST_STATUS}' != 'FAIL') or ${test_skipped}
76     ${newline}=    BuiltIn.Evaluate    chr(10)
77     ${msg}=    BuiltIn.Set_Variable    This test fails due to https://bugs.opendaylight.org/show_bug.cgi?id=${number}
78     BuiltIn.Set Test Message    ${msg}${newline}${newline}${TEST_MESSAGE}
79     BuiltIn.Log    ${msg}
80
81 Report_Failure_And_Point_To_Linked_Bugs
82     [Documentation]    Report that a test failed and point to linked Bugzilla bug(s).
83     ...    Linked bugs must contain the ${reference} inside comments (workaround
84     ...    becasue of currently missing suitable field for external references and
85     ...    not correctly working the CONTENT MATCHES filter).
86     ...    Not FAILED (incl. SKIPPED) test are not reported.
87     ...    This keyword must be used in the [Teardown] setting of the affected test
88     ...    or as the first line of the test if FastFail module is not being
89     ...    used. It reports the URL of the bug on console and also puts it
90     ...    into the Robot log file.
91     ${test_skipped}=    BuiltIn.Evaluate    len(re.findall('SKIPPED', """${TEST_MESSAGE}""")) > 0    modules=re
92     BuiltIn.Return From Keyword If    ('${TEST_STATUS}' != 'FAIL') or ${test_skipped}
93     ${newline}=    BuiltIn.Evaluate    chr(10)
94     ${reference}=    String.Replace_String_Using_Regexp    ${SUITE_NAME}_${TEST_NAME}    [ /\.-]    _
95     ${reference}=    String.Convert_To_Lowercase    ${reference}
96     ${msg}=    BuiltIn.Set_Variable    ... click for list of related bugs or create a new one if needed (with the${newline}"${reference}"${newline}reference somewhere inside)
97     ${bugs}=    BuiltIn.Set_Variable    "https://bugs.opendaylight.org/buglist.cgi?f1=cf_external_ref&o1=substring&v1=${reference}&order=bug_status"
98     BuiltIn.Set Test Message    ${msg}${newline}${bugs}${newline}${newline}${TEST_MESSAGE}
99     BuiltIn.Log    ${msg}${newline}${bugs}
100
101 Ensure All Nodes Are In Response
102     [Arguments]    ${URI}    ${node_list}
103     [Documentation]    A GET is made to the supplied ${URI} and every item in the ${node_list}
104     ...    is verified to exist in the repsonse. This keyword currently implies that it's node
105     ...    specific but any list of strings can be given in ${node_list}. Refactoring of this
106     ...    to make it more generic should be done. (see keyword "Check For Elements At URI")
107     : FOR    ${node}    IN    @{node_list}
108     \    ${resp}    RequestsLibrary.Get Request    session    ${URI}
109     \    Should Be Equal As Strings    ${resp.status_code}    200
110     \    Should Contain    ${resp.content}    ${node}
111
112 Check Nodes Stats
113     [Arguments]    ${node}
114     [Documentation]    A GET on the /node/${node} API is made and specific flow stat
115     ...    strings are checked for existence.
116     ${resp}    RequestsLibrary.Get Request    session    ${OPERATIONAL_NODES_API}/node/${node}
117     Should Be Equal As Strings    ${resp.status_code}    200
118     Should Contain    ${resp.content}    flow-capable-node-connector-statistics
119     Should Contain    ${resp.content}    flow-table-statistics
120
121 Check That Port Count Is Ok
122     [Arguments]    ${node}    ${count}
123     [Documentation]    A GET on the /port API is made and the specified port ${count} is
124     ...    verified. A more generic Keyword "Check For Specific Number Of Elements At URI"
125     ...    also does this work and further consolidation should be done.
126     ${resp}    RequestsLibrary.Get Request    session    ${REST_CONTEXT}/${CONTAINER}/port
127     Log    ${resp.content}
128     Should Be Equal As Strings    ${resp.status_code}    200
129     Should Contain X Times    ${resp.content}    ${node}    ${count}
130
131 Check For Specific Number Of Elements At URI
132     [Arguments]    ${uri}    ${element}    ${expected_count}
133     [Documentation]    A GET is made to the specified ${URI} and the specific count of a
134     ...    given element is done (as supplied by ${element} and ${expected_count})
135     ${resp}    RequestsLibrary.Get Request    session    ${uri}
136     Log    ${resp.content}
137     Should Be Equal As Strings    ${resp.status_code}    200
138     Should Contain X Times    ${resp.content}    ${element}    ${expected_count}
139
140 Check For Elements At URI
141     [Arguments]    ${uri}    ${elements}
142     [Documentation]    A GET is made at the supplied ${URI} and every item in the list of
143     ...    ${elements} is verified to exist in the response
144     ${resp}    RequestsLibrary.Get Request    session    ${uri}
145     Log    ${resp.content}
146     Should Be Equal As Strings    ${resp.status_code}    200
147     : FOR    ${i}    IN    @{elements}
148     \    Should Contain    ${resp.content}    ${i}
149
150 Check For Elements Not At URI
151     [Arguments]    ${uri}    ${elements}
152     [Documentation]    A GET is made at the supplied ${URI} and every item in the list of
153     ...    ${elements} is verified to NOT exist in the response
154     ${resp}    RequestsLibrary.Get Request    session    ${uri}
155     Log    ${resp.content}
156     Should Be Equal As Strings    ${resp.status_code}    200
157     : FOR    ${i}    IN    @{elements}
158     \    Should Not Contain    ${resp.content}    ${i}
159
160 Clean Mininet System
161     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}
162     Run Command On Mininet    ${system}    sudo mn -c
163     Run Command On Mininet    ${system}    sudo ps -elf | egrep 'usr/local/bin/mn' | egrep python | awk '{print "sudo kill -9",$4}' | sh
164
165 Clean Up Ovs
166     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}
167     [Documentation]    Cleans up the OVS instance and remove any existing common known bridges.
168     ${output}=    Run Command On Mininet    ${system}    sudo ovs-vsctl list-br
169     Log    ${output}
170     : FOR    ${i}    IN    ${output}
171     \    Run Command On Mininet    ${system}    sudo ovs-vsctl --if-exists del-br ${i}
172     Run Command On Mininet    ${system}    sudo ovs-vsctl del-manager
173
174 Extract Value From Content
175     [Arguments]    ${content}    ${index}    ${strip}=nostrip
176     [Documentation]    Will take the given response content and return the value at the given index as a string
177     ${value}=    Get Json Value    ${content}    ${index}
178     ${value}=    Convert To String    ${value}
179     ${value}=    Run Keyword If    '${strip}' == 'strip'    Strip Quotes    ${value}
180     [Return]    ${value}
181
182 Get Process ID Based On Regex On Remote System
183     [Arguments]    ${system}    ${regex_string_to_match_on}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
184     [Documentation]    Uses ps to find a process that matches the supplied regex. Returns the PID of that process
185     ...    The ${regex_string_to_match_on} should produce a unique process otherwise the PID returned may not be
186     ...    the expected PID
187     # doing the extra -v grep in this command to exclude the grep process itself from the output
188     ${cmd}=    Set Variable    ps -elf | grep -v grep | grep ${regex_string_to_match_on} | awk '{print $4}'
189     ${output}=    Run Command On Remote System    ${system}    ${cmd}    user=${user}    password=${password}    prompt=${prompt}
190     ...    prompt_timeout=${prompt_timeout}
191     # ${output} contains the system prompt and all we want is the value of the number
192     ${pid}=    Fetch From Left    ${output}    \r
193     # TODO: Get Process * keywords have perhaps non-standard default credentials.
194     # ...    Should there be * On Mininet and * On Controller specializations?
195     [Return]    ${pid}
196
197 Get Process Thread Count On Remote System
198     [Arguments]    ${system}    ${pid}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
199     [Documentation]    Executes the ps command to retrieve the lightweight process (aka thread) count.
200     ${cmd}=    Set Variable    ps --no-headers -o nlwp ${pid}
201     ${output}=    Run Command On Remote System    ${system}    ${cmd}    user=${user}    password=${password}    prompt=${prompt}
202     ...    prompt_timeout=${prompt_timeout}
203     # ${output} contains the system prompt and all we want is the value of the number
204     ${thread_count}=    Fetch From Left    ${output}    \r
205     [Return]    ${thread_count}
206
207 Strip Quotes
208     [Arguments]    ${string_to_strip}
209     [Documentation]    Will strip ALL quotes from given string and return the new string
210     ${string_to_return}=    Replace String    ${string_to_strip}    "    \    count=-1
211     [Return]    ${string_to_return}
212
213 Flexible SSH Login
214     [Arguments]    ${user}    ${password}=${EMPTY}    ${delay}=0.5s
215     [Documentation]    On active SSH session: if given non-empty password, do Login, else do Login With Public Key.
216     ${pwd_length} =    BuiltIn.Get Length    ${password}
217     # ${pwd_length} is guaranteed to be an integer, so we are safe to evaluate it as Python expression.
218     BuiltIn.Run Keyword And Return If    ${pwd_length} > 0    SSHLibrary.Login    ${user}    ${password}    delay=${delay}
219     BuiltIn.Run Keyword And Return    SSHLibrary.Login With Public Key    ${user}    ${USER_HOME}/.ssh/${SSH_KEY}    ${KEYFILE_PASS}    delay=${delay}
220
221 Flexible Mininet Login
222     [Arguments]    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${delay}=0.5s
223     [Documentation]    Call Flexible SSH Login, but with default values suitable for Mininet machine.
224     BuiltIn.Run Keyword And Return    Flexible SSH Login    user=${user}    password=${password}    delay=${delay}
225
226 Flexible Controller Login
227     [Arguments]    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${delay}=0.5s
228     [Documentation]    Call Flexible SSH Login, but with default values suitable for Controller machine.
229     BuiltIn.Run Keyword And Return    Flexible SSH Login    user=${user}    password=${password}    delay=${delay}
230
231 Run Command On Remote System
232     [Arguments]    ${system}    ${cmd}    ${user}=${DEFAULT_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=${DEFAULT_TIMEOUT}
233     [Documentation]    Reduces the common work of running a command on a remote system to a single higher level
234     ...    robot keyword, taking care to log in with a public key and. The command given is written
235     ...    and the output returned. No test conditions are checked.
236     ${current_ssh_connection}=    SSHLibrary.Get Connection
237     Log    Attempting to execute command "${cmd}" on remote system "${system}" by user "${user}" with keyfile pass "${keyfile_pass}" and prompt "${prompt}"
238     ${conn_id}=    SSHLibrary.Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
239     Flexible SSH Login    ${user}    ${password}
240     ${stdout}    ${stderr}    SSHLibrary.Execute Command    ${cmd}    return_stderr=True
241     SSHLibrary.Close Connection
242     Log    ${stderr}
243     [Teardown]    KarafKeywords.Restore_Current_SSH_Connection_From_Index    ${current_ssh_connection.index}
244     [Return]    ${stdout}
245
246 Write_Bare_Ctrl_C
247     [Documentation]    Construct ctrl+c character and SSH-write it (without endline) to the current SSH connection.
248     ...    Do not read anything yet.
249     ${ctrl_c}=    BuiltIn.Evaluate    chr(int(3))
250     SSHLibrary.Write_Bare    ${ctrl_c}
251
252 Write Bare Ctrl D
253     [Documentation]    Construct ctrl+d character and SSH-write it (without endline) to the current SSH connection.
254     ...    Do not read anything yet.
255     ${ctrl_d}=    BuiltIn.Evaluate    chr(int(4))
256     SSHLibrary.Write Bare    ${ctrl_d}
257
258 Run Command On Mininet
259     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}    ${cmd}=echo    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${TOOLS_SYSTEM_PROMPT}
260     [Documentation]    Call Run Comand On Remote System, but with default values suitable for Mininet machine.
261     BuiltIn.Run Keyword And Return    Run Command On Remote System    ${system}    ${cmd}    ${user}    ${password}    prompt=${prompt}
262
263 Run Command On Controller
264     [Arguments]    ${system}=${ODL_SYSTEM_IP}    ${cmd}=echo    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
265     [Documentation]    Call Run Comand On Remote System, but with default values suitable for Controller machine.
266     BuiltIn.Run Keyword And Return    Run Command On Remote System    ${system}    ${cmd}    ${user}    ${password}    prompt=${prompt}
267
268 Verify File Exists On Remote System
269     [Arguments]    ${system}    ${file}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=5s
270     [Documentation]    Will create connection with public key and will PASS if the given ${file} exists,
271     ...    otherwise will FAIL
272     ${conn_id}=    Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
273     Flexible SSH Login    ${user}    ${password}
274     SSHLibrary.File Should Exist    ${file}
275     Close Connection
276
277 Verify Controller Is Not Dead
278     [Arguments]    ${controller_ip}=${ODL_SYSTEM_IP}
279     [Documentation]    Will execute any tests to verify the controller is not dead. Some checks are
280     ...    Out Of Memory Execptions.
281     Check Karaf Log File Does Not Have Messages    ${controller_ip}    java.lang.OutOfMemoryError
282     # TODO: Should Verify Controller * keywords also accept user, password, prompt and karaf_log arguments?
283
284 Verify Controller Has No Null Pointer Exceptions
285     [Arguments]    ${controller_ip}=${ODL_SYSTEM_IP}
286     [Documentation]    Will execute any tests to verify the controller is not having any null pointer eceptions.
287     Check Karaf Log File Does Not Have Messages    ${controller_ip}    java.lang.NullPointerException
288
289 Get Epoch Time
290     [Arguments]    ${time}
291     [Documentation]    Get the Epoc time from MM/DD/YYYY HH:MM:SS
292     ${epoch_time}=    Convert Date    ${time}    epoch    exclude_milles=True    date_format=%m/%d/%Y %H:%M:%S
293     ${epoch_time}=    Convert To Integer    ${epoch_time}
294     [Return]    ${epoch_time}
295
296 Remove Space on String
297     [Arguments]    ${str}    ${count}=-1
298     [Documentation]    Remove the empty space from given string.count is optional,if its given
299     ...    that many occurence of space will be removed from left
300     ${x}=    Convert To String    ${str}
301     ${x}=    Replace String    ${str}    ${SPACE}    ${EMPTY}    count=${count}
302     [Return]    ${x}
303
304 Split Value from String
305     [Arguments]    ${str}    ${splitter}
306     [Documentation]    Split the String based on given splitter and return as list
307     @{x}=    Split String    ${str}    ${splitter}
308     [Return]    @{x}
309
310 Concatenate the String
311     [Arguments]    ${str1}    ${str2}
312     [Documentation]    Catenate the two non-string objects and return as String
313     ${str1}=    Convert to String    ${str1}
314     ${str2}=    Convert to String    ${str2}
315     ${output}=    Catenate    ${str1}    ${str2}
316     [Return]    ${output}
317
318 Post Elements To URI
319     [Arguments]    ${rest_uri}    ${data}    ${headers}=${headers}    ${session}=session
320     [Documentation]    Perform a POST rest operation, using the URL and data provided
321     ${resp} =    RequestsLibrary.Post Request    ${session}    ${rest_uri}    data=${data}    headers=${headers}
322     Log    ${resp.content}
323     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
324
325 Remove All Elements At URI
326     [Arguments]    ${uri}
327     ${resp}    RequestsLibrary.Delete Request    session    ${uri}
328     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
329
330 Remove All Elements At URI And Verify
331     [Arguments]    ${uri}
332     ${resp}    RequestsLibrary.Delete Request    session    ${uri}
333     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
334     ${resp}    RequestsLibrary.Get Request    session    ${uri}
335     Should Be Equal As Strings    ${resp.status_code}    404
336
337 Add Elements To URI From File
338     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}
339     ${body}    OperatingSystem.Get File    ${data_file}
340     ${resp}    RequestsLibrary.Put Request    session    ${dest_uri}    data=${body}    headers=${headers}
341     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
342
343 Add Elements To URI From File And Verify
344     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}
345     ${body}    OperatingSystem.Get File    ${data_file}
346     ${resp}    RequestsLibrary.Put Request    session    ${dest_uri}    data=${body}    headers=${headers}
347     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
348     ${resp}    RequestsLibrary.Get Request    session    ${dest_uri}
349     Should Not Be Equal    ${resp.status_code}    404
350
351 Add Elements To URI And Verify
352     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}
353     ${resp}    RequestsLibrary.Put Request    session    ${dest_uri}    ${data_file}    headers=${headers}
354     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
355     ${resp}    RequestsLibrary.Get Request    session    ${dest_uri}
356     Should Not Be Equal    ${resp.status_code}    404
357
358 Post Elements To URI From File
359     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}
360     ${body}    OperatingSystem.Get File    ${data_file}
361     ${resp}    RequestsLibrary.Post Request    session    ${dest_uri}    data=${body}    headers=${headers}
362     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
363
364 Run Process With Logging And Status Check
365     [Arguments]    @{proc_args}
366     [Documentation]    Execute an OS command, log STDOUT and STDERR output and check exit code to be 0
367     ${result}=    Run Process    @{proc_args}
368     Log    ${result.stdout}
369     Log    ${result.stderr}
370     Should Be Equal As Integers    ${result.rc}    0
371     [Return]    ${result}
372
373 Get Data From URI
374     [Arguments]    ${session}    ${uri}    ${headers}=${NONE}
375     [Documentation]    Issue a GET request and return the data obtained or on error log the error and fail.
376     ...    Issues a GET request for ${uri} in ${session} using headers from
377     ...    ${headers}. If the request returns a HTTP error, fails. Otherwise
378     ...    returns the data obtained by the request.
379     ${response}=    RequestsLibrary.Get Request    ${session}    ${uri}    ${headers}
380     Builtin.Return_From_Keyword_If    ${response.status_code} == 200    ${response.text}
381     Builtin.Log    ${response.text}
382     Builtin.Fail    The request failed with code ${response.status_code}
383
384 No Content From URI
385     [Arguments]    ${session}    ${uri}    ${headers}=${NONE}
386     [Documentation]    Issue a GET request and return on error 404 (No content) or will fail and log the content.
387     ...    Issues a GET request for ${uri} in ${session} using headers from
388     ...    ${headers}. If the request returns a HTTP error, fails. Otherwise
389     ...    returns the data obtained by the request.
390     ${response}=    RequestsLibrary.Get Request    ${session}    ${uri}    ${headers}
391     Builtin.Return_From_Keyword_If    ${response.status_code} == 404
392     Builtin.Log    ${response.text}
393     Builtin.Fail    The request failed with code ${response.status_code}
394
395 Get Index From List Of Dictionaries
396     [Arguments]    ${dictionary_list}    ${key}    ${value}
397     [Documentation]    Extract index for the dictionary in a list that contains a key-value pair. Returns -1 if key-value is not found.
398     ${length}=    Get Length    ${dictionary_list}
399     ${index}=    Set Variable    -1
400     : FOR    ${i}    IN RANGE    ${length}
401     \    ${dictionary}=    Get From List    ${dictionary_list}    ${i}
402     \    Run Keyword If    '&{dictionary}[${key}]' == '${value}'    Set Test Variable    ${index}    ${i}
403     [Return]    ${index}
404
405 Check Item Occurrence
406     [Arguments]    ${string}    ${dictionary_item_occurrence}
407     [Documentation]    Check string for occurrences of items expressed in a list of dictionaries {item=occurrences}. 0 occurences means item is not present.
408     : FOR    ${item}    IN    @{dictionary_item_occurrence}
409     \    Should Contain X Times    ${string}    ${item}    &{dictionary_item_occurrence}[${item}]
410
411 Post Log Check
412     [Arguments]    ${uri}    ${body}    ${status_code}=200
413     [Documentation]    Post body to ${uri}, log response content, and check status
414     ${resp}=    RequestsLibrary.Post Request    session    ${uri}    ${body}
415     Log    ${resp.content}
416     Should Be Equal As Strings    ${resp.status_code}    ${status_code}
417     [Return]    ${resp}
418
419 Get Log File Name
420     [Arguments]    ${testtool}    ${testcase}=${EMPTY}
421     [Documentation]    Get the name of the suite sanitized to be usable as a part of filename.
422     ...    These names are used to constructs names of the log files produced
423     ...    by the testing tools so two suites using a tool wont overwrite the
424     ...    log files if they happen to run in one job.
425     ${name}=    BuiltIn.Evaluate    """${SUITE_NAME}""".replace(" ","-").replace("/","-").replace(".","-")
426     ${suffix}=    BuiltIn.Set_Variable_If    '${testcase}' != ''    --${testcase}    ${EMPTY}
427     [Return]    ${testtool}--${name}${suffix}.log
428
429 Set_User_Configurable_Variable_Default
430     [Arguments]    ${name}    ${value}
431     [Documentation]    Set a default value for an user configurable variable.
432     ...    This keyword is needed if your default value is calculated using
433     ...    a complex expression which needs BuiltIn.Evaluate or even more
434     ...    complex keywords. It sets the variable ${name} (the name of the
435     ...    variable MUST be specified WITHOUT the ${} syntactic sugar due
436     ...    to limitations of Robot Framework) to ${value} but only if the
437     ...    variable ${name} was not set previously. This keyword is intended
438     ...    for user configurable variables which are supposed to be set only
439     ...    with pybot -v; calling this keyword on a variable that was already
440     ...    set by another keyword will silently turn the call into a NOP and
441     ...    thus is a bug in the suite or resource trying to call this
442     ...    keyword.
443     # TODO: Figure out how to make the ${value} evaluation "lazy" (meaning
444     #    evaluating it only when the user did not set anything and thus the
445     #    default is needed). This might be needed to avoid potentially costly
446     #    keyword invocations when they are not needed. Currently no need for
447     #    this was identified, thus leaving it here as a TODO. Based on
448     #    comments the best approach would be to create another keyword that
449     #    expects a ScalarClosure in the place of ${value} and calls the
450     #    closure to get the value but only if the value is needed).
451     #    The best idea how to implement this "laziness" would be to have the
452     #    used to define another keyword that will be responsible for getting
453     #    the default value and then passing the name of this getter keyword
454     #    to this keyword. Then this keyword would call the getter (to obtain
455     #    the expensive default value) only if it discovers that this value
456     #    is really needed (because the variable is not set yet).
457     # TODO: Is the above TODO really necessary? Right now we don't have any
458     #    examples of "expensive default values" where to obtain the default
459     #    value is so expensive on resources (e.g. need to SSH somewhere to
460     #    check something) that we would want to skip the calculation if the
461     #    variable for which it is needed has a value already provided by the
462     #    user using "pybot -v" or something. One example would be
463     #    JAVA_HOME if it would be designed as user-configurable variable
464     #    (currently it is not; users can specify "use jdk7" or "use jdk8"
465     #    but not "use the jdk over there"; and there actually is no JAVA_HOME
466     #    present in the resource, rather the Java invocation command uses the
467     #    Java invocation with a full path). The default value of JAVA_HOME
468     #    has to be obtained by issuing commands on the SSH connection where
469     #    the resulting Java invocation command will be used (to check
470     #    multiple candidate paths until one that fits is found) and we could
471     #    skip all this checking if a JAVA_HOME was supplied by the user using
472     #    "pybot -v".
473     ${value}=    BuiltIn.Get_Variable_Value    \${${name}}    ${value}
474     BuiltIn.Set_Suite_Variable    \${${name}}    ${value}
475
476 Convert_To_Minutes
477     [Arguments]    ${time}
478     [Documentation]    Convert a Robot time string to an integer expressing the time in minutes, rounded up
479     ...    This is a wrapper around DateTime.Convert_Time which does not
480     ...    provide this functionality directly nor is even able to produce
481     ...    an integer directly. It is needed for RestPerfClient which
482     ...    cannot accept floats for its --timeout parameter and interprets
483     ...    the value supplied in this parameter in minutes.
484     ${seconds}=    DateTime.Convert_Time    ${time}    result_format=number
485     ${minutes}=    BuiltIn.Evaluate    int(math.ceil(${seconds}/60.0))    modules=math
486     [Return]    ${minutes}
487
488 Write Commands Until Expected Prompt
489     [Arguments]    ${cmd}    ${prompt}    ${timeout}=30s
490     [Documentation]    quick wrapper for Write and Read Until Prompt Keywords to make test cases more readable
491     SSHLibrary.Set Client Configuration    timeout=${timeout}
492     SSHLibrary.Write    ${cmd}
493     ${output}=    SSHLibrary.Read Until    ${prompt}
494     [Return]    ${output}
495
496 Install Package On Ubuntu System
497     [Arguments]    ${package_name}    ${system}=${TOOLS_SYSTEM_IP}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
498     [Documentation]    Keyword to install packages for testing to Ubuntu Mininet VM
499     Log    Keyword to install package to Mininet Ubuntu VM
500     Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
501     Flexible Mininet Login    user=${user}    password=${password}
502     Write    sudo apt-get install -y ${package_name}
503     Read Until    ${prompt}