*** Settings ***
Documentation     The main interface for interacting with DCAE. It handles low level stuff like managing the http request library and DCAE required fields
Library 	      RequestsLibrary
Library	          DcaeLibrary
Library           OperatingSystem
Library           Collections
Library           CertsLibrary
Variables         ../resources/DcaeVariables.py
Resource          ../../../common.robot
Resource          ../resources/dcae_properties.robot

*** Keywords ***
Create sessions
    [Documentation]  Create all required sessions
    ${auth}=  Create List  ${VESC_HTTPS_USER}   ${VESC_HTTPS_PD}
    ${wrong_auth}=  Create List  ${VESC_HTTPS_WRONG_USER}  ${VESC_HTTPS_WRONG_PD}
    ${certs}=  Create List  ${VESC_CERT}  ${VESC_KEY}
    ${wrong_certs}=  Create List  ${VESC_WRONG_CERT}  ${VESC_WRONG_KEY}
    ${outdated_certs}=  Create List  ${VESC_OUTDATED_CERT}  ${VESC_OUTDATED_KEY}
    Create Session    dcae_vesc_url    ${VESC_URL}
    Set Global Variable    ${http_session}    dcae_vesc_url
    Create Session    dcae_vesc_url_https    ${VESC_URL_HTTPS}  auth=${auth}  disable_warnings=1
    Set Global Variable    ${https_basic_auth_session}    dcae_vesc_url_https
    Create Session  dcae_vesc_url_https_wrong_auth  ${VESC_URL_HTTPS}  auth=${wrong_auth}  disable_warnings=1
    Set Global Variable  ${https_wrong_auth_session}  dcae_vesc_url_https_wrong_auth
    Create Client Cert Session  dcae_vesc_url_https_cert  ${VESC_URL_HTTPS}  client_certs=${certs}  disable_warnings=1
    Set Global Variable  ${https_valid_cert_session}  dcae_vesc_url_https_cert
    Create Client Cert Session  dcae_vesc_url_https_wrong_cert  ${VESC_URL_HTTPS}  client_certs=${wrong_certs}  disable_warnings=1  verify=${False}
    Set Global Variable  ${https_invalid_cert_session}  dcae_vesc_url_https_wrong_cert
    Create Client Cert Session  dcae_vesc_url_https_outdated_cert  ${VESC_URL_HTTPS}  client_certs=${outdated_certs}  disable_warnings=1  verify=${False}
    Set Global Variable  ${https_outdated_cert_session}  dcae_vesc_url_https_outdated_cert
    Create Session  dcae_vesc_url_https_wo_auth  ${VESC_URL_HTTPS}  disable_warnings=1
    Set Global Variable  ${https_no_cert_no_auth_session}  dcae_vesc_url_https_wo_auth

Create header
    ${headers}=    Create Dictionary    Content-Type=application/json
    Set Global Variable    ${suite_headers}    ${headers}

Get DCAE Nodes
    [Documentation]    Get DCAE Nodes from Consul Catalog
    ${session}=    Create Session 	dcae 	${GLOBAL_DCAE_CONSUL_URL}
    ${uuid}=    Generate UUID
    ${headers}=  Create Dictionary     Accept=application/json    Content-Type=application/json  X-Consul-Token=abcd1234  X-TransactionId=${GLOBAL_APPLICATION_ID}-${uuid}    X-FromAppId=${GLOBAL_APPLICATION_ID}
    ${resp}= 	Get Request 	dcae 	/v1/catalog/nodes        headers=${headers}
    Log    Received response from dcae consul: ${resp.json()}
    Should Be Equal As Strings 	${resp.status_code} 	200
    ${NodeList}=   Get Json Value List   ${resp.text}   Node
    ${NodeListLength}=  Get Length  ${NodeList}
    ${len}=  Get Length   ${NodeList}
    Should Not Be Equal As Integers   ${len}   0
    [Return]    ${NodeList}

DCAE Node Health Check
    [Documentation]    Perform DCAE Node Health Check
    [Arguments]    ${NodeName}
    ${session}=    Create Session 	dcae-${NodeName} 	${GLOBAL_DCAE_CONSUL_URL}
    ${uuid}=    Generate UUID
    ${headers}=  Create Dictionary     Accept=application/json    Content-Type=application/json  X-Consul-Token=abcd1234  X-TransactionId=${GLOBAL_APPLICATION_ID}-${uuid}    X-FromAppId=${GLOBAL_APPLICATION_ID}
    ${hcpath}=   Catenate  SEPARATOR=    /v1/health/node/    ${NodeName}
    ${resp}= 	Get Request 	dcae-${NodeName} 	${hcpath}        headers=${headers}
    Log    Received response from dcae consul: ${resp.json()}
    Should Be Equal As Strings 	${resp.status_code} 	200
    ${StatusList}=  Get Json Value List   ${resp.text}    Status
    ${len}=  Get Length  ${StatusList}
    Should Not Be Equal As Integers   ${len}   0
    DCAE Check Health Status    ${NodeName}   ${StatusList[0]}    Serf Health Status

DCAE Check Health Status
    [Arguments]    ${NodeName}    ${ItemStatus}   ${CheckType}
    Should Be Equal As Strings    ${ItemStatus}    passing
    Log   Node: ${NodeName} ${CheckType} check pass ok

VES Collector Suite Setup DMaaP
    [Documentation]   Start DMaaP Mockup Server
    ${ret}=  Setup DMaaP Server
    Should Be Equal As Strings     ${ret}    true

VES Collector Suite Shutdown DMaaP
    [Documentation]   Shutdown DMaaP Mockup Server
    ${ret}=  Shutdown DMaap
    Should Be Equal As Strings     ${ret}    true

Check DCAE Results
    [Documentation]    Parse DCAE JSON response and make sure all rows have healthTestStatus=GREEN
    [Arguments]    ${json}
    @{rows}=    Get From Dictionary    ${json['returns']}    rows
    @{headers}=    Get From Dictionary    ${json['returns']}    columns
    # Retrieve column names from headers
    ${columns}=    Create List
    :for    ${header}    IN    @{headers}
    \    ${colName}=    Get From Dictionary    ${header}    colName
    \    Append To List    ${columns}    ${colName}
    # Process each row making sure status=GREEN
    :for    ${row}    IN    @{rows}
    \    ${cells}=    Get From Dictionary    ${row}    cells
    \    ${dict}=    Make A Dictionary    ${cells}    ${columns}
    \    Dictionary Should Contain Item    ${dict}    healthTestStatus    GREEN

Make A Dictionary
    [Documentation]    Given a list of column names and a list of dictionaries, map columname=value
    [Arguments]     ${columns}    ${names}    ${valuename}=value
    ${dict}=    Create Dictionary
    ${collength}=    Get Length    ${columns}
    ${namelength}=    Get Length    ${names}
    :for    ${index}    IN RANGE    0   ${collength}
    \    ${name}=    Evaluate     ${names}[${index}]
    \    ${valued}=    Evaluate     ${columns}[${index}]
    \    ${value}=    Get From Dictionary    ${valued}    ${valueName}
    \    Set To Dictionary    ${dict}   ${name}    ${value}
    [Return]     ${dict}

Json String To Dictionary
    [Arguments]  ${json_string}
    ${json_dict}=  evaluate    json.loads('''${json_string}''')    json
    [Return]   ${json_dict}

Dictionary To Json String
    [Arguments]  ${json_dict}
    ${json_string}=    evaluate    json.dumps(${json_dict})    json
    [Return]    ${json_string}

Get DCAE Service Component Status
    [Documentation]   Get the status of a DCAE Service Component
    [Arguments]    ${url}    ${urlpath}     ${usr}    ${passwd}
    ${auth}=  Create List  ${usr}  ${passwd}
    ${session}=    Create Session 	dcae-service-component 	${url}    auth=${auth}
    ${resp}= 	Get Request 	dcae-service-component 	${urlpath}
    [Return]    ${resp}

Publish Event To VES Collector
    [Documentation]    Send an event to VES Collector
    [Arguments]     ${session}  ${evtpath}   ${evtdata}
    ${resp}= 	Post Request 	${session}  	${evtpath}     data=${evtdata}   headers=${suite_headers}
    [Return] 	${resp}

Publish Event To VES Collector With Put Method
    [Documentation]    Send an event to VES Collector
    [Arguments]     ${session}  ${evtpath}   ${evtdata}
    ${resp}= 	Put Request 	${session}  	${evtpath}     data=${evtdata}   headers=${suite_headers}
    [Return] 	${resp}

Send Request And Validate Response
    [Documentation]  Post singel event to passed url with passed data and validate received response
    [Arguments]  ${keyword}  ${session}  ${evtpath}  ${evtjson}  ${resp_code}  ${msg_code}=None  ${topic}=None
    ${evtdata}=  Get Data From File  ${evtjson}
    ${resp}=  Run Keyword  ${keyword}  ${session}  ${evtpath}  ${evtdata}
    Log    Receive HTTPS Status code ${resp.status_code}
    Should Be Equal As Strings 	${resp.status_code} 	${resp_code}
    ${isEmpty}=   Is Json Empty    ${resp}
    Run Keyword If   '${isEmpty}' == False   Log  ${resp.json()}
    Run Keyword If  '${msg_code}' != 'None'  Check Whether Message Received  ${msg_code}  ${topic}

Check Whether Message Received
    [Documentation]  Validare if message has been received
    [Arguments]  ${msg_code}  ${topic}
    ${ret}=  Run Keyword If  '${topic}' != 'None'  DMaaP Message Receive On Topic  ${msg_code}  ${topic}
    ...  ELSE  DMaaP Message Receive  ${msg_code}
    Should Be Equal As Strings    ${ret}    true

Send Request And Expect Error
    [Documentation]  Post singel event to passed url with passed data and expect error
    [Arguments]  ${keyword}  ${session}  ${evtpath}  ${evtjson}  ${error_type}  @{error_content}
    ${evtdata}=  Get Data From File  ${evtjson}
    ${err_msg}=  Run Keyword And Expect Error  ${error_type}  ${keyword}  ${session}  ${evtpath}  ${evtdata}
    :FOR    ${content}    IN    @{error_content}
    \    Should Contain   ${err_msg}  ${content}
    Log  Recieved error message ${err_msg}

Run Healthcheck
    [Documentation]  Run Healthcheck
    [Arguments]  ${session}
    ${uuid}=    Generate UUID
    ${headers}=  Create Dictionary     Accept=*/*     X-TransactionId=${GLOBAL_APPLICATION_ID}-${uuid}    X-FromAppId=${GLOBAL_APPLICATION_ID}
    ${resp}= 	Get Request 	${session} 	/healthcheck        headers=${headers}
    Should Be Equal As Strings 	${resp.status_code} 	200