LibMec_Functions.ttcn

module LibMec_Functions {
  
  // Libcommon
  import from LibCommon_Sync all;
  
  // LibMec
  import from LibMec_Pixits all;
  import from LibMec_Pics all;
  
   // LibMec_UEidentityAPI
  import from UEidentityAPI_TypesAndValues all;
  import from UEidentityAPI_Templates all;
  import from UEidentityAPI_Pixits all;
  
  // LibHttp
  import from LibItsHttp_TypesAndValues all;
  import from LibItsHttp_JsonMessageBodyTypes all;
  import from LibItsHttp_Templates all;
  import from LibItsHttp_TestSystem all;
  import from LibItsHttp_Templates all;
  import from LibItsHttp_JsonTemplates all;
  
  group preambles {
    
    /**
     * @desc Setup HTTP pprotocol port
     */
    function f_cf_01_http_up() runs on HttpComponent {
      
      // Map ports
      map(self:httpPort, system:httpPort);
      
      // Connect
      f_connect4SelfOrClientSync();
      
      activate(a_cf_01_http_down());
      activate(a_default_requests());
      activate(a_default_responses());
      
    } // End of function f_cf_01_http_up
    
    /**
     * @desc Setup HTTP pprotocol port
     */
    function f_cf_01_http_notif_up() runs on HttpComponent {
      
      // Map ports
      map(self:httpPort_notif, system:httpPort_notif);
      
      // Connect
      f_connect4SelfOrClientSync();
      
      activate(a_cf_01_http_notif_down());
      activate(a_default_requests());
      activate(a_default_responses());
      
    } // End of function f_cf_01_http_notif_up
    
  } // End of group preambles
  
  group postambles {
    
    /**
     * @desc Shutdown HTTP pprotocol port
     */
    function f_cf_01_http_down() runs on HttpComponent {
      
      // Unmap ports
      unmap(self:httpPort, system:httpPort);
      
      // Disconnect ports
      f_disconnect4SelfOrClientSync();
      
      deactivate;
    } // End of function f_cf_01_http_down
    
    /**
     * @desc Shutdown HTTP pprotocol port
     */
    function f_cf_01_http_notif_down() runs on HttpComponent {
      
      // Unmap ports
      unmap(self:httpPort_notif, system:httpPort_notif);
      
      // Disconnect ports
      f_disconnect4SelfOrClientSync();
      
      deactivate;
    } // End of function f_cf_01_http_notif_down
    
    /**
     * @desc Default handling cf01 de-initialisation.
     */
    altstep a_cf_01_http_down() runs on HttpComponent {
      [] a_shutdown() {
        f_cf_01_http_down();
        log("*** a_cf_01_http_down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
        stop;
      }
    } // End of altstep a_cf_01_http_down
    
    /**
     * @desc Default handling cf01 de-initialisation.
     */
    altstep a_cf_01_http_notif_down() runs on HttpComponent {
      [] a_shutdown() {
        f_cf_01_http_notif_down();
        log("*** a_cf_01_http_notif_down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
        stop;
      }
    } // End of altstep a_cf_01_http_notif_down
    
  } // End of group postambles
  
  group helpers {
    
    /**
     * @desc Check HTTP response headers
     * @param p_headers The HTTP headers
     * @param p_value the expected va;ue
     * @return true on success, false otherwise
     */
    function f_check_headers(
                             in HeaderLines p_headers,
                             in charstring p_header_name := "Location",
                             in template (present) charstring p_value := ?
    ) return boolean {
      // Local variables
      var boolean v_header_matched := false;
      
      for (var integer v_idx := 0; v_idx < lengthof(p_headers); v_idx := v_idx + 1) {
        if (p_headers[v_idx].header_name == p_header_name) {
          if (match(p_headers[v_idx].header_value[0], p_value) == true) { 
            v_header_matched := true;
          } // else, nothing to do
          break;
        }
      } // End of 'for' statement
      
      return v_header_matched;
    }
    
    /**
     * @desc Check if the user is registered or not
     * @param p_ue_identity_tag The UE identity tag
     * @param p_headers The HTTP headers
     * @return 0 if unregistered, 1 if registered, -1 otherwise
     */
    function f_check_user_register_state(
                                         in UeIdentityTag p_ue_identity_tag := PX_UE_IDENTITY_TAG,
                                         in HeaderLines p_headers
    ) runs on HttpComponent return integer {
      var HttpMessage v_response;
      var integer v_result := -1;
      
      // Send request
      httpPort.send(
                    m_http_request(
                                   m_http_request_get(
                                                      "/" & PICS_ROOT_API & PX_ME_APP_Q_UE_IDENTITY_ID_URI & oct2char(unichar2oct(PX_APP_INSTANCE_ID, "UTF-8")) & "/ue_identity_tag_info?ueIdentityTag=" & oct2char(unichar2oct(p_ue_identity_tag, "UTF-8")),
                                                      p_headers
                                                      )
                                   )
                    );
      // Await for the response
      tc_ac.start;
      alt {
        [] httpPort.receive(
                            mw_http_response(
                                             mw_http_response_ok(
                                                                 mw_http_message_body_json(
                                                                                           mw_body_json_ue_identity_tag_info(
                                                                                                                             mw_ue_identity_tag_info(
                                                                                                                                                     { *, mw_ue_identity_tag_item(PX_UE_IDENTITY_TAG), * }
                                                                                                                                                     )))))) -> value v_response {
          tc_ac.stop;
          
          for (var integer v_i := 0; v_i < lengthof(v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags); v_i := v_i + 1) {
            if (v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].ueIdentityTag == p_ue_identity_tag) {
              //log("Processing ", v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].ueIdentityTag);
              //log("State      ", v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].state);
              if (v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].state == UNREGISTERED) {
                v_result := 0;
              } else if (v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].state == REGISTERED) {
                v_result := 1;
              } else if (v_response.response.body.json_body.ueIdentityTagInfo.ueIdentityTags[v_i].state == INVALID_STATE) {
                v_result := 2;
              }
              break;
            }
          }
        }
        [] tc_ac.timeout {
        }
      } // End of 'alt' statement
      
      //log("<<< f_check_user_register_state: v_result: ", v_result);
      return v_result;
    } // End of function f_check_user_register_state
    
  } // End of group helpers 
  
  group registration {
    
    function f_register_for_notification(
                                         in charstring p_uri,
                                         in HeaderLines p_headers,
                                         in template (value) JsonBody p_json_body,
                                         out JsonBody p_notification
    ) runs on HttpComponent return integer {
      var integer v_result := -1;
      var HttpMessage v_response;
      
      // Send the request
      httpPort.send(
                    m_http_request(
                                   m_http_request_get(
                                                      p_uri,
                                                      p_headers,
                                                      m_http_message_body_json(p_json_body)
                    )));
      // Await for the response
      tc_ac.start;
      alt {
        [] httpPort.receive(
                            mw_http_response(
                                             mw_http_response_201_created(
                                                                          mw_http_message_body_json
                            ))) -> value v_response {
          tc_ac.stop;
          
          p_notification := v_response.response.body.json_body;
          v_result := 0;
          log("*** f_register_for_notification: INFO: Regustration for notification succeed ***");
        }
        [] tc_ac.timeout {
          log("*** f_register_for_notification: INCONC: Expected message not received ***");
        }
      } // End of 'alt' statement
      
      //log("<<< f_register_for_notification: v_result: ", v_result);
      return v_result;
    } // End of fiunction f_register_for_notification

    function f_unregister_for_notification(
                                           in charstring p_uri,
                                           in HeaderLines p_headers
    ) runs on HttpComponent return integer {
      var HttpMessage v_response;
      var integer v_result := -1;
      
      // Send the request
      httpPort.send(
                    m_http_request(
                                   m_http_request_delete(
                                                         p_uri,
                                                         p_headers
                    )));
      // Await for the response
      tc_ac.start;
      alt {
        [] httpPort.receive(
                            mw_http_response(
                                             mw_http_response_ok
                                             )) -> value v_response {
          tc_ac.stop;
          
          v_result := 0;
          log("*** f_unregister_for_notification: INFO: Regustration for notification succeed ***");
        }
        [] tc_ac.timeout {
          log("*** f_unregister_for_notification: INCONC: Expected message not received ***");
        }
      } // End of 'alt' statement
      
      //log("<<< f_unregister_for_notification: v_result: ", v_result);
      return v_result;
    } // End of fiunction f_unregister_for_notification
    
  } // End of group registration 
  
  group altsteps {

    altstep a_default_requests() runs on HttpComponent {
      [] httpPort.receive(mw_http_request) {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: Receive request instead of response on httpPort ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort_notif.receive(mw_http_request) {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: Receive unsollicited request on httpPort_notif ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
    } // End of altstep a_default_requests
    
    altstep a_default_responses() runs on HttpComponent {
      var HttpMessage v_response;
      
      [] httpPort.receive(
                          mw_http_response(
                                           mw_http_response_ok(
                                                               mw_http_message_body_xml
                                                               ))) {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Unexpected XML response ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort.receive(
                          mw_http_response(
                                           mw_http_response_ok(
                                                               mw_http_message_body_json
                                                               ))) {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Unexpected JSON response ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort.receive(
                          mw_http_response(
                                           mw_http_response_ok(
                                                               mw_http_message_body_binary
                                                               ))) {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Unexpected binary response ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort.receive(
                          mw_http_response(
                                           mw_http_response_ko
                                           ))  -> value v_response {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: " & int2str(v_response.response.statuscode) & "/" & v_response.response.statustext & " ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort.receive(mw_http_response) -> value v_response {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: " & int2str(v_response.response.statuscode) & "/" & v_response.response.statustext & " ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort.receive {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: Receive unsollicited message on httpPort ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort_notif.receive(mw_http_response) -> value v_response {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: " & int2str(v_response.response.statuscode) & "/" & v_response.response.statustext & " on httpPort_notif ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
      [] httpPort_notif.receive {
        tc_ac.stop;
        log("*** " & testcasename() & ": FAIL: Server error: Receive unsollicited message on httpPort_notif ***");
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
      }
    } // End of altstep a_default_responses
    
  } // end of group altsteps
  
} // End of module LibMec_Functions