Commit fb0761a9 authored by YannGarcia's avatar YannGarcia
Browse files

Adding typing for Dequeue registration support; Implement PSAP Dequeue TPs

parent 85477df9
Loading
Loading
Loading
Loading
+52 −7108

File changed.

Preview size limit exceeded, changes collapsed.

+73 −43
Original line number Diff line number Diff line
module AtsPSAP_Pics {
  
  // LibCommon
  import from LibCommon_BasicTypesAndValues all;
  
  /**
   * @desc Does IUT configured to use TLS?
   */
@@ -40,4 +43,31 @@ module AtsPSAP_Pics {
   */
  modulepar boolean PICS_PSAP_S_SIP_REGISTRATION := true;
  
  /**
   * @desc Does the IUT support HTTP Dequeue Registration
   */
  modulepar boolean PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION := true;
  
  /**
   * @desc URI to ESRP Dequeue Registration web service
   */
  modulepar charstring PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_URI := "";
  
  /**
   * @desc SIP URI of queue to register on
   */
  modulepar charstring PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_NUMBER := "";
  modulepar charstring PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_HOST := "";
  
  /**
   * @desc SIP URI of dequeuer (where to send calls)
   */
  modulepar charstring PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_NUMBER := "";
  modulepar charstring PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_HOST := "";
  
  /**
   * @desc Requested time in seconds this registration will expire 
   */
  modulepar UInt32 PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_EXPIRATION_TIME := 10;
  
} // End of module AtsPSAP_Pics 
+2830 −2465
Original line number Diff line number Diff line
@@ -108,7 +108,7 @@ module AtsPSAP_TestCases {
  import from AtsPSAP_Steps all;
  import from AtsPSAP_Pics all;
  
  group psap_role {
  group Invite {
    
    /**
     * @desc "IUT successfully handles SIP INVITE with different service urn and ULAW via UDP, with no SIP registration"
@@ -1225,6 +1225,9 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_INVITE_BV_08
    
  } // End of group Invite
  
  group Ack {
    /**
     * @desc "IUT after sending 200 OK INVITE successfully handles an incoming SIP ACK to accept the emergency call"
     */
@@ -1377,6 +1380,9 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_ACK_BV_01
    
  } // End of group Ack
  
  group Bye {
    /**
     * @desc "IUT successfully handles an incoming SIP BYE"
     */
@@ -1624,6 +1630,10 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_BYE_BV_02
    
  } // End of group Bye
  
  group Message {
    
    /**
     * @desc "IUT successfully handles an incoming SIP MESSAGE"
     */
@@ -1854,6 +1864,8 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_MESSAGE_BV_02
    
  } // End of group Message
  
//    /**   Test from the previous version of test suite
//     * @desc "IUT successfully handles an incoming SIP NOTIFY"
//     */
@@ -1960,6 +1972,8 @@ module AtsPSAP_TestCases {
//      
//    } // End of group f_TC_PSAP_SIP_NOTIFY_BV_01
  
  group Options {
    
    /**
     * @desc "IUT successfully handles an incoming SIP OPTIONS"
     */
@@ -2066,6 +2080,10 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_OPTIONS_BV_01
    
  } // End of group Options
  
  group Cancel {
    
    /**
     * @desc "Check that IUT successfully handles an incoming SIP CANCEL, release the call with 200 OK CANCEL and 487"
     */
@@ -2215,6 +2233,10 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_CANCEL_BV_01
    
  } // End of group Cancel
  
  group Info {
    
    /**
     * @desc "IUT rejects requests without a certificate"
     */
@@ -2373,6 +2395,349 @@ module AtsPSAP_TestCases {
      
    } // End of group f_TC_PSAP_SIP_INFO_BV_01
    
  } // End of group Info
  
  group Dequeue {
    
    /**
     * @desc "Check that the IUT registers properly to an ESRP Dequeue"
     */
    testcase TC_PSAP_DEQUEUE_BV_01() runs on HttpComponent system TestAdapter {
        // Local variables
        var Headers v_headers;
        var HttpMessage v_response;
        var charstring v_params;

        // Test control
        if ((not PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION)) {
            log("*** " & testcasename() & ": PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION required for executing the TC ***");
            setverdict(inconc);
            stop;
        }
        
        // Test component configuration
        f_cf_01_http_up();
        
        // Test adapter configuration
        
        // Preamble
        f_init_default_headers_list(-, -, v_headers);
        f_remove_headers_list({ c_header_accept }, v_headers);
        httpPort.send(
                      m_http_request(
                                     m_http_request_get(
                                                        PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_URI,
                                                        v_headers,
                                                        m_http_message_body_xml(
                                                                                m_body_xml_dequeue_registration_request(
                                                                                                                        m_dequeue_registration_request(
                                                                                                                                                       m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_HOST), 
                                                                                                                                                       m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_HOST), 
                                                                                                                                                       PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_EXPIRATION_TIME
                      ))))));
        f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);

        tc_ac.start;
        alt {
          [] httpPort.receive(
                              mw_http_response(
                                               mw_http_response_ok(
                                                                   mw_http_message_body_xml(
                                                                                            mw_body_xml_dequeue_registration_response(
                                                                                                                                      mw_dequeue_response_ok
                                                                                            ))))) -> value v_response {
            tc_ac.stop;

            log("*** " & testcasename() & ": INFO: IUT successfully registers to ESRP dequeue successfully ***");
            f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_success);
          }
          [] tc_ac.timeout {
            log("*** " & testcasename() & ": INCONC: Expected message not received ***");
            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
          }
        } // End of 'alt' statement
        
        // Postamble
        f_cf_01_http_down();
    } // End of testcase TC_PSAP_DEQUEUE_BV_01
    
    /**
     * @desc "Check that the IUT registers properly to an ESRP Dequeue"
     */
    testcase TC_PSAP_DEQUEUE_BV_02(
                                   in CSeq p_cSeq_s
                                   ) runs on HttpImsComponent system TestAdapter {
        // Local variables
        var HttpComponent v_dequeue;
        var ImsComponent v_caller;
        var ImsComponent v_call_taker;
        var CSeq v_cSeq_s := p_cSeq_s;
        
        // Test control
        if ((not PICS_PSAP_USE_TLS) or (not PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION) or PICS_PSAP_S_SIP_REGISTRATION) {
          log("*** " & testcasename() & ": PICS_PSAP_USE_TLS and PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION and NOT PICS_PSAP_S_SIP_REGISTRATION required for executing the TC ***");
          setverdict(inconc);
          stop;
        }
        
        // Test component configuration
        f_cf_03_up(v_dequeue, v_caller, v_call_taker);
        
        // Test adapter configuration
        
        // Preamble
        
        // Test Body
        v_dequeue.start(f_TC_PSAP_DEQUEUE_BV_02_dequeue());
        if (not(PICS_PSAP_CALL_TAKER)) {
          f_incCSeq(v_cSeq_s); v_caller.start(f_TC_PSAP_DEQUEUE_BV_02_caller(v_cSeq_s));
          f_serverSyncNClientsAndStop(2, {c_prDone, c_uPlane, c_tbDone, c_poDone});
        } else {
          f_incCSeq(v_cSeq_s); v_caller.start(f_TC_PSAP_DEQUEUE_BV_02_caller(v_cSeq_s));
          f_incCSeq(v_cSeq_s); v_call_taker.start(f_TC_PSAP_DEQUEUE_BV_02_call_taker(v_cSeq_s));
          f_serverSyncNClientsAndStop(3, {c_prDone, c_uPlane, c_tbDone, c_poDone});
        }
        
        // Postamble
        f_cf_03_down(v_dequeue, v_caller, v_call_taker);
      
    } // End of testcase TC_PSAP_DEQUEUE_BV_02
    
    group f_TC_PSAP_DEQUEUE_BV_02 {
      
      function f_TC_PSAP_DEQUEUE_BV_02_dequeue() runs on HttpComponent system TestAdapter {
          // Local variables
          var Headers v_headers;
          var HttpMessage v_response;
          var charstring v_params;
  
          // Test control
          if ((not PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION)) {
              log("*** " & testcasename() & ": PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION required for executing the TC ***");
              setverdict(inconc);
              stop;
          }
          
          // Test component configuration
          f_cf_01_http_up();
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, -, v_headers);
          f_remove_headers_list({ c_header_accept }, v_headers);
          httpPort.send(
                        m_http_request(
                                       m_http_request_get(
                                                          PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_URI,
                                                          v_headers,
                                                          m_http_message_body_xml(
                                                                                  m_body_xml_dequeue_registration_request(
                                                                                                                          m_dequeue_registration_request(
                                                                                                                                                         m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_HOST), 
                                                                                                                                                         m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_HOST), 
                                                                                                                                                         PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_EXPIRATION_TIME
                        ))))));
          f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
          f_selfOrClientSyncAndVerdictPreamble(c_uPlane, e_success);

          tc_ac.start;
          alt {
            [] httpPort.receive(
                                mw_http_response(
                                                 mw_http_response_ok(
                                                                     mw_http_message_body_xml(
                                                                                              mw_body_xml_dequeue_registration_response(
                                                                                                                                        mw_dequeue_response_ok
                                                                                              ))))) -> value v_response {
              tc_ac.stop;
  
              log("*** " & testcasename() & ": INFO: IUT successfully registers to ESRP dequeue successfully ***");
              f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_success);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
          
          // Postamble
          f_cf_01_http_down();
          f_clientSyncAndVerdictPostamble(c_poDone, e_success);
      } // End of testcase f_TC_PSAP_DEQUEUE_BV_02
      
      function f_TC_PSAP_DEQUEUE_BV_02_caller(
                                              in CSeq p_cSeq_s
                                              ) runs on ImsComponent {
        // Local variables
        var template INVITE_Request v_invite;
        
        // Test control
        
        // Test component configuration
        f_init_userprofile(c_userProfile_UE1atSUThome);
        f_initSipUrl(c_userProfile_UE1atSUThome);
        f_init_interfaceprofile(c_interfaceProfile_IMS_SUT_PCSCF1);
        
        // Test adapter configuration
        
        // Preamble
        f_IMS_preamble_woRegistration(p_cSeq_s);
        LibIms_Steps.f_setHeadersINVITE(vc_cSeq, f_initSipUrl(c_serviceProfile_EMERGENCY), f_initSipUrl(c_userProfile_UE1atSUThome));
        f_init_sdp_userprofile(vc_sdp_local, c_userProfile_UE1atSUThome, c_userProfile_Huawei);
        v_invite := m_INVITE_Request_IMS_Ng112(vc_requestUri,
                                                vc_callId,
                                                vc_cSeq,
                                                vc_from,
                                                vc_to,
                                                vc_via,
                                                vc_contact,
                                                m_Require_100rel,
                                                -, -,
                                                m_Supported_100rel,
                                                -,
                                                m_MBody_SDP(vc_sdp_local),
                                               /*m_MBody_MIMESdpXml_Emergency(
                                                                             vc_sdp_local,
                                                                             m_XmlBody_Presence(
                                                                                                m_presence(
                                                                                                           PX_PRESENCE_USER,
                                                                                                           { m_tuple(
                                                                                                                     "fclnzj22sbtoxpj",
                                                                                                                     { basic := omit, elem_list := { v_location_info } }
                                                                                                                     )
                                                                                                             }
                                                                                                           )
                                                                                                )
                                                                                                ),*/
                                               m_geolocation({ scheme:= "https", components := {other := "//lis1.gridgears.plugtests.net/locref?ref=660bc838-882e-4683-8241-af26bb5960d8" }, urlParameters := omit, headers := omit }, omit), // TODO Add a LIS component to do a request for location by reference
                                                m_geolocation_routing,
                                                { fieldName := USER_AGENT_E, userAgentBody := { "ETSI_Conf_testing" } }
                                                );
        //v_invite.msgHeader.contentType := m_contentType(m_mimeMultipart);
        f_SendINVITE(v_invite);
        f_awaitingResponseIgnore100Trying(mw_Response_Base(c_statusLine200, vc_callId, vc_cSeq));
        LibSip_Steps.f_setHeadersACK();
        f_SendACK(m_ACK_Request_route(vc_requestUri, vc_callId, vc_response.msgHeader.cSeq, vc_from, vc_to, vc_via, vc_route));
        f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
        
        // Test Body
        f_sleep(10.0);
        f_check_Conversation(PX_CHECK_CONVERSATION);
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
        
        // Postamble
        f_terminateCall_UE(vc_requestUri, valueof(vc_callId), vc_cSeq, vc_caller_From, vc_caller_To);
        f_clientSyncAndVerdictPostamble(c_poDone, e_success);
      } // End of function f_TC_PSAP_DEQUEUE_BV_02_caller
      
      function f_TC_PSAP_DEQUEUE_BV_02_call_taker(
                                                  in CSeq p_cSeq_s
                                                  ) runs on ImsComponent {
        // Local variables
        var template REGISTER_Request v_register;
        
        // Test control
        f_init_userprofile(c_userProfile_UE1atSUThome);
        f_initSipUrl(c_serviceProfile_EMERGENCY);
        f_init_interfaceprofile(c_interfaceProfile_IMS_SUT_PCSCF1);
        
        // Test component configuration
        
        // Test adapter configuration
        
        // Preamble
        f_IMS_preamble_woRegistration(p_cSeq_s);
        LibIms_Steps.f_setHeadersINVITE(p_cSeq_s, f_initSipUrl(c_serviceProfile_EMERGENCY), f_initSipUrl(c_userProfile_UE1atSUThome));
        f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
        
        // Test Body
        f_awaitingINVITE(mw_INVITE_Request_RequestURI(vc_requestUri));
        f_sendResponse(m_Response_2xxonINVITE_UE(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via,
                                                 vc_contact, f_recordroute(), valueof(m_MBody_SDP(vc_sdp_local))));
        f_awaitingACK(mw_ACK_Request_Base(vc_callId));
        
        f_check_Conversation(PX_CHECK_CONVERSATION);
        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
        
        // Postamble
        f_awaitingBYE_sendReply();
        f_clientSyncAndVerdictPostamble(c_poDone, e_success);
      } // End of function f_TC_PSAP_DEQUEUE_BV_02_call_taker
      
    } // End of group f_TC_PSAP_DEQUEUE_BV_02
    
    /**
     * @desc "Check that the IUT registers properly to an ESRP Dequeue"
     */
    testcase TC_PSAP_DEQUEUE_BV_03() runs on HttpComponent system TestAdapter {
        // Local variables
        var Headers v_headers;
        var HttpMessage v_response;
        var charstring v_params;

        // Test control
        if ((not PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION)) {
            log("*** " & testcasename() & ": PICS_PSAP_S_HTTP_DEQUEUE_REGISTRATION required for executing the TC ***");
            setverdict(inconc);
            stop;
        }
        
        // Test component configuration
        f_cf_01_http_up();
        
        // Test adapter configuration
        
        // Preamble
        f_init_default_headers_list(-, -, v_headers);
        f_remove_headers_list({ c_header_accept }, v_headers);
        httpPort.send(
                      m_http_request(
                                     m_http_request_get(
                                                        PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_URI,
                                                        v_headers,
                                                        m_http_message_body_xml(
                                                                                m_body_xml_dequeue_registration_request(
                                                                                                                        m_dequeue_deregistration_request(
                                                                                                                                                       m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUE_REGISTRATION_HOST), 
                                                                                                                                                       m_SipUrl_NumberHostHeader(PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_NUMBER, PICS_PSAP_ESRP_DEQUEUER_REGISTRATION_HOST)
                      ))))));
        tc_ac.start;
        alt {
          [] httpPort.receive(
                              mw_http_response(
                                               mw_http_response_ok(
                                                                   mw_http_message_body_xml(
                                                                                            mw_body_xml_dequeue_registration_response(
                                                                                                                                      mw_dequeue_response_ok
                                                                                            ))))) -> value v_response {
            tc_ac.stop;

            log("*** " & testcasename() & ": INFO: IUT successfully de-registers from ESRP dequeue successfully ***");
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
          }
          [] tc_ac.timeout {
            log("*** " & testcasename() & ": INCONC: Expected message not received ***");
            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
          }
        } // End of 'alt' statement
        
        // Postamble
        f_cf_01_http_down();
    } // End of testcase TC_PSAP_DEQUEUE_BV_03
    
  } // End of group Dequeue
  
  group HELD {
    
  } // End of group HELD
  
  group LoST {
    
  } // End of group LoST
  
  group Security {
    
    /**
     * @desc "IUT successfully handles an incoming SIP MESSAGE"
     */
@@ -2460,6 +2825,6 @@ module AtsPSAP_TestCases {
      
    } // End of testcase TC_PSAP_TLS_BI_01
    
  } // End of group psap_role 
  } // End of group Security 
  
} // End of module AtsPSAP_TestCases 
+517 −432

File changed.

Preview size limit exceeded, changes collapsed.

+49 −3
Original line number Diff line number Diff line
module LibNg112_TypesAndValues {
  
  // LibCommon
  import from LibCommon_BasicTypesAndValues all;
  
  // LibSip
  import from LibSip_SIPTypesAndValues all;
  
  group dequeue_register {
    
    /**
     * @desc Dequeue Registration/Deregistrationrequest data structure
     * @member registrationQueueUri SIP URI of queue to register on
     * @member registrationDequeuer SIP URI of dequeuer (where to send calls)
     * @member registrationExpirationTime Requested time in seconds this registration will expire
     * @member registrationDequeuePreference Integer from 1 - 5 indicating queuing preference. 5 indicating highest preference
     * @see ETSI TS 103 479 Table 5: DequeueRegistrationRequest
     */
    type record DequeueRegistrationRequest {
      DequeueRegistrationQueueUri registrationQueueUri,
      DequeueRegistrationDequeuer registrationDequeuer,
      DequeueRegistrationExpirationTime registrationExpirationTime,
      DequeueRegistrationDequeuePreference registrationDequeuePreference optional
    } // End of type DequeueRegistrationRequest
    
    /**
     * @desc Dequeue Registration/Deregistration response data structure
     * @member registrationExpirationTime Requested time in seconds this registration will expire
     * @member registrationStatusCode Integer from 1 - 5 indicating queuing preference. 5 indicating highest preference
     * @see ETSI TS 103 479 Table 5: DequeueRegistrationRequest
     */
    type record DequeueRegistrationResponse {
      DequeueRegistrationExpirationTime registrationExpirationTime,
      DequeueRegistrationStatusCode registrationStatusCode
    } // End of type DequeueRegistrationResponse
    
    type SipUrl DequeueRegistrationQueueUri;
    
    type SipUrl DequeueRegistrationDequeuer;
    
    type UInt32 DequeueRegistrationExpirationTime;
    
    type UInt32 DequeueRegistrationDequeuePreference;
    
    type UInt32 DequeueRegistrationStatusCode;
    
  } // End of group dequeue_register
  
} // End of module LibNg112_TypesAndValues
Loading