diff --git a/ttcn/AtsMec/AtsMec_MepmPkgm_TestCases.ttcn b/ttcn/AtsMec/AtsMec_MepmPkgm_TestCases.ttcn new file mode 100644 index 0000000000000000000000000000000000000000..30e28090c8ef24464a865dffded71e539a26b9ca --- /dev/null +++ b/ttcn/AtsMec/AtsMec_MepmPkgm_TestCases.ttcn @@ -0,0 +1,937 @@ +/** +* @author ETSI / STF569 +* @version $URL:$ +* $ID:$ +* @desc This module provides the MEC test cases. +* @copyright ETSI Copyright Notification +* No part may be reproduced except as authorized by written permission. +* The copyright and the foregoing restriction extend to reproduction in all media. +* All rights reserved. +* @see ETSI GS MEC 003, Draft ETSI GS MEC 013 V2.0.3 (2018-10) +*/ +module AtsMec_PkgMgmt_mm3_TestCases { + + // Libcommon + import from LibCommon_Sync all; + + // LibHttp + import from LibItsHttp_TypesAndValues all; + import from LibItsHttp_Functions all; + import from LibItsHttp_Templates all; + import from LibItsHttp_JsonTemplates all; + import from LibItsHttp_TestSystem all; + + + import from MepmPkgm_Templates all; + import from MepmPkgm_Pics all; + import from MepmPkgm_Pixits all; + + // LibMec + import from LibMec_Functions all; + import from LibMec_Pics all; + import from LibMec_Pixits all; + + group appPackageManagement { + + /** + * @desc: Check that MEPM returns the list of App Packages when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.1.3.2, + * ETSI GS MEC 010-2 2.0.10, Table 6.2.3.3.2-1, //OnboardedAppPkgInfo + */ + testcase TP_MEC_MEPM_PKGM_001_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI, + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + mw_http_message_body_json( + mw_body_json_mepm_pkg_mgmt_response_list( + { + *, + mw_package_management( + PX_ON_BOARDED_APP_PKG_ID, + PX_APP_D_ID, + -, + -, + -, + - + ), + * + } + ))))) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with a Onboarded App Package list***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_001_OK + + + + /** + * @desc: Check that MEPM responds with an error when it receives a malformed request for requesting the list of existing App Packages + * ETSI GS MEC 010-2 2.0.10, clause 7.4.1.3.2 + * ETSI GS MEC 010-2 2.0.10, Table 6.2.3.3.2-1 //OnboardedAppPkgInfo + */ + testcase TP_MEC_MEPM_PKGM_001_BR() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & "?operationalStatus=ENABLED", //query prameter should be operationalState + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_400_bad_request( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a Bad response ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEO_PKGM_001_BR + + + + /** + * @desc: Check that MEPM returns the an App Package when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.2.3.2 + * ETSI GS MEC 010-2 2.0.10, Table 6.2.3.3.2-1 //OnboardedAppPkgInfo + */ + testcase TP_MEC_MEPM_PKGM_002_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & oct2char(unichar2oct(PX_ON_BOARDED_APP_PKG_ID, "UTF-8")), + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + mw_http_message_body_json( + mw_body_json_mepm_pkg_mgmt_response( + mw_package_management( + PX_ON_BOARDED_APP_PKG_ID, + -, -, -, -, -, - + ) + ) + ) + ) + )) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with an Onboarded App Package info and 200 status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_002_OK + + + /** + * @desc: Check that MEPM responds with an error when it receives + * a request for returning a App Package referred with a wrong ID + * @see: ETSI GS MEC 010-2 2.0.10, clause 7.4.2.3.2 + */ + testcase TP_MEC_MEPM_PKGM_002_NF() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & oct2char(unichar2oct(PX_NON_EXISTENT_APP_PKG_ID, "UTF-8")), + v_headers, + - + + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_404_not_found( + ))) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with a 404 not found status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEO_PKGM_003_NF + + + /** + * @desc: Check that MEPM returns the Application Descriptor contained on a on-boarded Application Package when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.4.3.2 + */ + testcase TP_MEC_MEPM_PKGM_003_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & "/" & oct2char(unichar2oct(PX_ON_BOARDED_APP_PKG_ID, "UTF-8")) & "/app_descriptor", + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + //@TODO: How to check if a file is present in the body? + ))) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with the app descriptor contained in the app pkg ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_003_OK + + + /** + * @desc: Check that MEPM responds with an error when it receives + * a request for returning a App Descriptor referred with a wrong App Package ID + * @see: ETSI GS MEC 010-2 2.0.10, clause 7.4.4.3.2 + */ + testcase TP_MEC_MEPM_PKGM_003_NF() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & oct2char(unichar2oct(PX_NON_EXISTENT_APP_PKG_ID, "UTF-8")) &"/app_descriptor", + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_404_not_found( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a 404 not found status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_003_NF + + + /** + * @desc: Check that MEPM returns the content on a on-boarded Application Package when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.3.3.2 + */ + testcase TP_MEC_MEPM_PKGM_004_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_put( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & oct2char(unichar2oct(PX_ON_BOARDED_APP_PKG_ID, "UTF-8")) & "/appPkgContent", + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + //@TODO: How to check if a file is present in the body? + ))) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with and APP Descriptor and a 200 ok status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_004_OK + + /** + * @desc: Check that MEPM responds with an error when it receives + * a request for returning a App Descriptor referred with a wrong App Package ID + * @see: ETSI GS MEC 010-2 2.0.10, clause 7.4.4.3.2 + */ + testcase TP_MEC_MEPM_PKGM_004_NF() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_URI & oct2char(unichar2oct(PX_NON_EXISTENT_APP_PKG_ID, "UTF-8")) & "/appPkgContent", + v_headers + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_404_not_found( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a 404 not found status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_004_NF + +} // End of packageManagement + +group pkg_mgmt_subscriptions { + + /** + * @desc: Check that MEPM service returns an application package subscription when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.5.3.1 + */ + testcase TP_MEC_MEPM_PKGM_005_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_post( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS, + v_headers, + m_http_message_body_json( + m_body_json_mepm_pkgm_subscription( + m_app_package_subscription( + PX_CALLBACK_URI, + PX_SUBSCRIPTION_TYPE + ) + ) + ) + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + mw_http_message_body_json( + mw_body_json_mepm_pkgm_subscription_info( + mw_app_package_subscription_info( + -, + PX_SUBSCRIPTION_TYPE, + PX_CALLBACK_URI + ) + ))))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a App Package Subscription Info ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_005_OK + + /** + * @desc: Check that MEPM service sends an error when it receives a + * malformed request for creating a new subscription on AppPackages + * ETSI GS MEC 010-2 2.0.10, clause 7.4.5.3.1 + */ + testcase TP_MEC_MEPM_PKGM_005_BR() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_post( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS, + v_headers, + m_http_message_body_json( + m_body_json_mepm_pkgm_subscription_with_error( + m_app_package_subscription_with_error( + PX_CALLBACK_URI, + PX_SUBSCRIPTION_TYPE_WITH_ERROR + ) + ) + ) + + ))); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_400_bad_request( + ))) -> value v_response { + tc_ac.stop; + log("*** " & testcasename() & ": PASS: IUT successfully responds with a 400 Bad Request status code ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_005_BR + + /** + * @desc: Check that MEPM service returns the list of Application Package Subscriptions when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.5.3.2 + */ + testcase TP_MEC_MEPM_PKGM_006_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS, + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + mw_http_message_body_json( + mw_body_json_mepm_pkgm_subscription_info_list( + { + *, + mw_app_package_subscription_info( + -, + PX_SUBSCRIPTION_TYPE, + PX_CALLBACK_URI + ), + * + } + ))))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a App Package Subscription Info List ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_006_OK + + + /** + * @desc: Check that MEPM service returns an Application Package Subscription when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.6.3.2 + */ + testcase TP_MEC_MEPM_PKGM_007_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS & "/" & oct2char(unichar2oct(PX_SUBSCRIPTION_ID, "UTF-8")), + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_ok( + mw_http_message_body_json( + mw_body_json_mepm_pkgm_subscription_info( + mw_app_package_subscription_info( + PX_SUBSCRIPTION_ID, + PX_SUBSCRIPTION_TYPE, + PX_CALLBACK_URI + ) + ))))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with a App Package Subscription Info identified by the given ID ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_007_OK + + + /** + * @desc: Check that MEPM service sends an error when it receives a query + * for a subscription on AppPackages with a wrong identifier + * ETSI GS MEC 010-2 2.0.10, clause 7.4.6.3.2 + */ + testcase TP_MEC_MEPM_PKGM_007_NF() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_get( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS & "/" & oct2char(unichar2oct(PX_NON_EXISTENT_SUBSCRIPTION_ID, "UTF-8")), + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_404_not_found( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with 404 not found ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_007_NF + + /** + * @desc: Check that MEPM service deletes an Application Package Subscription when requested + * ETSI GS MEC 010-2 2.0.10, clause 7.4.6.3.4 + */ + testcase TP_MEC_MEPM_PKGM_008_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_delete( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS & "/" & oct2char(unichar2oct(PX_SUBSCRIPTION_ID, "UTF-8")), + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_204_no_content( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds 204 No Content removing the AppPkgSubscription identified by the given ID ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEPM_PKGM_008_OK + + + /** + * @desc: Check that MEPM service sends an error when it receives a deletion request + * for a subscription on AppPackages with a wrong identifier + * ETSI GS MEC 010-2 2.0.10, clause 7.4.6.3.4 + */ + testcase TP_MEC_MEPM_PKGM_008_NF() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + var HttpMessage v_response; + + // Test control + if (not(PIC_APP_PACKAGE_MANAGEMENT)){ + log("*** " & testcasename() & ": PIC_APP_PACKAGE_MANAGEMENT required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_up(); + + // Preamble + f_init_default_headers_list(-, -, v_headers); + httpPort.send( + m_http_request( + m_http_request_delete( + "/" & PICS_ROOT_API & PX_MEPM_PKGM_SUBS & "/" & oct2char(unichar2oct(PX_NON_EXISTENT_SUBSCRIPTION_ID, "UTF-8")), + v_headers + ) + )); + + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_ac.start; + alt { + [] httpPort.receive( + mw_http_response( + mw_http_response_404_not_found( + ))) -> value v_response { + tc_ac.stop; + + log("*** " & testcasename() & ": PASS: IUT successfully responds with 404 not found ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_ac.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + } // End of testcase TP_MEC_MEO_PKGM_010_NF + +} // end of group pkg_mgmt_subscriptions + +group mepm_pkg_management_notification { + + /** + * @desc Check that the MEPM service sends a application package notification if + * the MEPM service has an associated subscription and the event is generated + * @see ETSI GS MEC 010-2 2.0.10, clause 7.4.7.3.1 + */ + testcase TP_MEC_MEPM_PKGM_009_OK() runs on HttpComponent system HttpTestAdapter { + // Local variables + var HeaderLines v_headers; + + // Test control + if (not(PIC_APP_PACKAGE_NOTIFICATIONS)) { + log("*** " & testcasename() & ": PIC_APP_PACKAGE_NOTIFICATIONS required for executing the TC ***"); + setverdict(inconc); + stop; + } + + // Test component configuration + f_cf_01_http_notif_up(); + + // Test adapter configuration + + // Preamble + f_init_default_headers_list(-, -, v_headers); + action("Trigger a expire notification event"); + f_selfOrClientSyncAndVerdict(c_prDone, e_success); + + // Test Body + tc_wait.start; + alt { + [] httpPort_notif.receive( + mw_http_request( + mw_http_request_post( + unichar2char(PX_CALLBACK_URI), + -, + mw_http_message_body_json( + mw_body_json_mepm_app_package_notification( + mw_app_package_notification( + -, + PX_NOTIFICATION_TYPE, + PX_SUBSCRIPTION_ID, + PX_CALLBACK_URI) + ) + ) + ) + ) + ) { + tc_wait.stop; + log("*** " & testcasename() & ": INFO: IUT successfully sends notification ***"); + + // Send 204 No Content + httpPort_notif.send(m_http_response(m_http_response_204_no_content(v_headers))); + + log("*** " & testcasename() & ": PASS: IUT successfully sends notification ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_success); + } + [] tc_wait.timeout { + log("*** " & testcasename() & ": INCONC: Expected message not received ***"); + f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout); + } + } // End of 'alt' statement + + // Postamble + f_cf_01_http_notif_down(); + } + + +} // end of group pkg_management_notification + + +} // End of module AtsMec_PkgMgmt_mm1_TestCases + + + + + + + diff --git a/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pics.ttcn b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pics.ttcn new file mode 100644 index 0000000000000000000000000000000000000000..0bd4a56eb1a299bf88eab13853d499c5b1cf688d --- /dev/null +++ b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pics.ttcn @@ -0,0 +1,8 @@ +module MepmPkgm_Pics { + + /** + * @desc Does the IUT support LocationAPI? + */ + modulepar boolean PICS_PKGMGMT_API_SUPPORTED := true; + +} // End of module LocationAPI_Pics diff --git a/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pixits.ttcn b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pixits.ttcn new file mode 100644 index 0000000000000000000000000000000000000000..34dcc5a59881a4cc967cb96909429faedfc77926 --- /dev/null +++ b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Pixits.ttcn @@ -0,0 +1,52 @@ +module MepmPkgm_Pixits { + + // JSON + import from JSON all; + + // LibMec/LocationAPI + import from MepmPkgm_TypesAndValues all; + + modulepar JSON.String PX_APP_PKG_NAME := "APP_PKG_NAME" + + modulepar JSON.String PX_APP_PKG_VERSION := "APP_PKG_VERSION" + + modulepar JSON.String PX_CHECKSUM := "CHECKSUM" + + modulepar JSON.String PX_APP_PKG_PATH := "APP_PKG_PATH" + + modulepar OperationalState PX_OPERATIONAL_STATE := ENABLED + + modulepar UsageState PX_USAGE_STATE := NOT_IN_USE + + modulepar JSON.String PX_ON_BOARDED_APP_PKG_ID := "5abe4782-2c70-4e47-9a4e-0ee3a1a0fd1f" + + modulepar JSON.String PX_NON_EXISTENT_APP_PKG_ID := "NON_EXISTENT_APP_PKG_ID" + + modulepar JSON.AnyURI PX_CALLBACK_URI := "http://127.0.0.1/callback" + + modulepar SubscriptionType PX_SUBSCRIPTION_TYPE := ON_BOARDING + + modulepar SubscriptionTypeWithError PX_SUBSCRIPTION_TYPE_WITH_ERROR := ONBOARDING + + modulepar JSON.String PX_SUBSCRIPTION_ID := "e0deee2b-6e50-4f33-ab09-8bf0585025d3" + + modulepar JSON.String PX_NON_EXISTENT_SUBSCRIPTION_ID := "NON_EXISTENT_SUBSCRIPTION_ID" + + modulepar NotificationType PX_NOTIFICATION_TYPE := ON_BOARDING + + modulepar JSON.String PX_APP_D_ID := "5lkj4782-2c70-4e47-9a4e-0ee3a1a0fd1f" + + +// modulepar JSON.String PX_APP_MOBILITY_SERVICE_ID := "KtRGymNQ84dG3mQfRepa" +// +// +// modulepar SubscriptionType PX_SUBSCRIPTION_TYPE := MobilityProcedureSubscription +// +// +// +// modulepar JSON.String PX_CALLBACK_REFERENCE := "http://127.0.0.1/callback" +// +// +// modulepar JSON.String PX_MEP_ID := ""; + +} // End of module LocationAPI_Pixits diff --git a/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Templates.ttcn b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Templates.ttcn new file mode 100644 index 0000000000000000000000000000000000000000..15a25142bb3427988689376eecefb3525124c522 --- /dev/null +++ b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_Templates.ttcn @@ -0,0 +1,95 @@ +module MepmPkgm_Templates { + + // JSON + import from JSON all; + + // LibCommon + import from LibCommon_BasicTypesAndValues all; + + import from MepmPkgm_TypesAndValues all; + import from MepmPkgm_Pixits all; + + template AppPkg m_package_management ( + in String p_appPkgName, + in String p_appPkgVersion, + in String p_checksum, + in String p_appPkgPath + ) := { + appPkgName := p_appPkgName, + appPkgVersion := p_appPkgVersion, + checksum := p_checksum, + appPkgPath := p_appPkgPath + } + + + template AppPkgWithError m_package_management_with_error ( + in String p_appPkgVersion, + in String p_checksum, + in String p_appPkgPath + ) := { + appPkgVersion := p_appPkgVersion, + checksum := p_checksum, + appPkgPath := p_appPkgPath + } + + template (present) OnboardedAppPkgInfo mw_package_management ( + in template (present) String p_appPkgId := ?, + in template (present) String p_appName := ?, + in template (present) String p_appDId := ?, + in template (present) String p_appDVersion := ?, + in template (present) String p_checksum := ?, + in template (present) OperationalState p_operationalState := ?, + in template (present) UsageState p_usageState := ? + ) := { + appPkgId := p_appPkgId , + appName := p_appName, + appDId := p_appDId , + appDVersion := p_appDVersion, + checksum := p_checksum , + operationalState := p_operationalState, + usageState := p_usageState + + } + + + template (omit) AppPkgSubscription m_app_package_subscription ( + in template (omit) AnyURI p_callbackUri := omit, + in template(omit) SubscriptionType p_subscription_type := omit + ) := { + callbackUri := p_callbackUri, + subscriptionType := p_subscription_type + } + + template (omit) AppPkgSubscriptionWithError m_app_package_subscription_with_error ( + in template (omit) AnyURI p_callbackUri := omit, + in template(omit) SubscriptionTypeWithError p_subscription_type := omit + ) := { + callbackUri := p_callbackUri, + subscriptionType := p_subscription_type + } + + + template (present) AppPkgSubscriptionInfo mw_app_package_subscription_info ( + in template (present) String p_subscriptionId := ?, + in template (present) SubscriptionType p_subscription_type := ?, + in template (present) AnyURI p_callbackUri := ? + ) := { + subscriptionId := p_subscriptionId ifpresent, + subscriptionType := p_subscription_type, + callbackUri := p_callbackUri + } + + template (present) AppPkgNotification mw_app_package_notification ( + in template (present) String p_notificationId := ?, + in template (present) NotificationType p_notificationType := ?, + in template (present) String p_subscriptionId := ?, + in template (present) AnyURI p_links := ? + ) := { + notificationType := p_notificationType, + subscriptionId := p_subscriptionId, + links := p_links + } + + + +} // End of module LocationAPI_Templates diff --git a/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_TypesAndValues.ttcn b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_TypesAndValues.ttcn new file mode 100644 index 0000000000000000000000000000000000000000..4d6c6bbc8b6b70896156324f918033dc0f48523a --- /dev/null +++ b/ttcn/LibMec/MepmPkgm/ttcn/MepmPkgm_TypesAndValues.ttcn @@ -0,0 +1,259 @@ +module MepmPkgm_TypesAndValues { + +// JSON +import from JSON all; + +// LibCommon +import from LibCommon_BasicTypesAndValues all; + + +type record AppPkg { + JSON.String appPkgName, + JSON.String appPkgVersion, + JSON.String checksum, + JSON.String appPkgPath +} + +type record AppPkgWithError { + JSON.String appPkgVersion, + JSON.String checksum, + JSON.String appPkgPath +} + +type record of OnboardedAppPkgInfo OnboardedAppPkgInfoList; +type record OnboardedAppPkgInfo { + JSON.String appPkgId, + JSON.String appDId, + JSON.String appName, + JSON.String appDVersion, + JSON.String checksum, + OperationalState operationalState, + UsageState usageState +} + +type enumerated AppPkgOperation { + DISABLE, + ENABLE, + ABORT +} + +type enumerated OperationalState { + ENABLED, + DISABLED, + DELETION_PENDING +} + +type enumerated UsageState { + IN_USE, + NOT_IN_USE +} + + +type enumerated SubscriptionType { + ON_BOARDING, + OP_CHANGE +} + +type enumerated SubscriptionTypeWithError { + ONBOARDING, + OP_CHANGE +} + + +type record of AppPkgSubscriptionInfo AppPkgSubscriptionInfoList; +type record AppPkgSubscriptionInfo { + JSON.String subscriptionId, + SubscriptionType subscriptionType, + JSON.AnyURI callbackUri +} + +type record AppPkgSubscription { + JSON.AnyURI callbackUri, + SubscriptionType subscriptionType +} + +type record AppPkgSubscriptionWithError { + JSON.AnyURI callbackUri, + SubscriptionTypeWithError subscriptionType +} + + +type enumerated NotificationType { + ON_BOARDING, + OP_CHANGE +} + + +type record AppPkgNotification { + NotificationType notificationType, + JSON.String subscriptionId, + //@TODO: links should be named _links but getting error. + //@TODO: links shuld be a record, but cannot contain self cause self is a key for ttnc + JSON.AnyURI links +} + + +// +// +//type record of AppMobilityServiceInfo AppMobilityServiceInfos; +//type record AppMobilityServiceInfo { +// RegistrationInfos registeredAppMobilityService , +// String appMobilityServiceId +//} +// +//type record of RegistrationInfo RegistrationInfos; +//type record RegistrationInfo { +// ServiceConsumerId serviceConsumerId, +// DeviceInformations deviceInformation optional, +// UInt32 expiryTime optional +//} +// +// +// +// +// +//type record of ServiceConsumerId ServiceConsumerIds; +//type record ServiceConsumerId { +// String appInstanceId optional, +// String mepId optional +//} +// +//// Erroneous parameter: appInstance should be appInstanceId +//type record of ServiceConsumer ServiceConsumers; +//type record ServiceConsumer { +// String appInstance optional, +// String mepId optional +//} +// +//type record of DeviceInformation DeviceInformations; +//type record DeviceInformation { +// String associateId +//} +// +// +//type JSON.AnyURI links; +// +//type enumerated SubscriptionType { +// MobilityProcedureSubscription, +// AdjacentAppInfoSubscription +//} +// +//type record Subscription { +// JSON.AnyURI href, +// SubscriptionType subscriptionType +//} +// +// +//type record of AmsSubscriptionLinkList AmsSubscriptionLinkLists; +//type record AmsSubscriptionLinkList { +// JSON.AnyURI links, +// Subscription subscription +//} +// +// +//type record MobilityProcedureSubscriptionError { +// SubscriptionType subscriptionType, +// JSON.AnyURI callbackReference, +// JSON.AnyURI links optional, +// FilterCriteria filterCriteria, +// TimeStamp expiryDeadline optional +//} +// +// +// +// +//type record of MobilityProcedureSubscription MobilityProcedureSubscriptions; +//type record MobilityProcedureSubscription { +// SubscriptionType subscriptionType, +// JSON.AnyURI callbackReference, +// JSON.AnyURI links optional, +// FilterCriteria filterCriteria, +// TimeStamp expiryDeadline optional +//} +// +//type enumerated MobilityStatusType { +// INTERHOST_MOVEOUT_TRIGGERED, +// TARGET_APPINST_CONFIRMED, +// TARGET_TRAFFIC_RULE_ACTIVATED, +// INTERHOST_MOVEOUT_COMPLETED, +// INTERHOST_MOVEOUT_FAILED +//} +// +//type record AssociateIdList { +// String associateId +//} +// +//type record of FilterCriteria FilterCriterias; +//type record FilterCriteria { +// String appInstanceId optional, +// AssociateIdList associateId optional, +// MobilityStatusType mobilityStatus +//} +// +// +// +//type record AdjacentFilterCriteria { +// String appInstanceId optional +//} +// +// +//type record of ExpiryNotification ExpiryNotifications; +//type record ExpiryNotification { +// TimeStamp timeStamp, +// JSON.AnyURI links optional, +// TimeStamp expiryDeadline +//} +// +//type record of AdjacentAppInfoSubscription AdjacentAppInfoSubscriptions; +//type record AdjacentAppInfoSubscription { +// SubscriptionType subscriptionType, +// JSON.AnyURI callbackReference, +// JSON.AnyURI links optional, +// AdjacentFilterCriteria filterCriteria, +// TimeStamp expiryDeadline optional +//} + + /** + * @desc + * @member seconds The seconds part of the time. Time is defined as Unix-time since January 1, 1970, 00:00:00 UTC + * @member nanoSeconds The nanoseconds part of the time. Time is defined as Unix-time since January 1, 1970, 00:00:00 UTC + */ + type record TimeStamp { + Seconds seconds, + NanoSeconds nanoSeconds + } + + + /** + * @desc The seconds part of the Time. Time is defined as Unix-time since January 1, 1970, 00:00:00 UTC + */ + type UInt32 Seconds; + + /** + * @desc The nanoseconds part of the Time. Time is defined as Unix-time since January 1, 1970, 00:00:00 UTC + */ + type UInt32 NanoSeconds; + +/** +* @desc Problem Details for HTTP APIs +* @member type_ A URI reference according to IETF RFC 3986 that identifies the problem type +* @member title A short, human-readable summary of the problem type +* @member status The HTTP status code for this occurrence of the problem +* @member detail A human-readable explanation specific to this occurrence of the problem +* @member instance A URI reference that identifies the specific occurrence of the problem +* @see IETF RFC 7807 Clause 3. The Problem Details JSON Object +*/ +type record ProblemDetails { + JSON.String type_, + JSON.String title, + UInt32 status, + JSON.String detail, + JSON.String instance +} with { + variant (type_) "name as 'type'"; +} + + +} with { +encode "JSON" +}