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