Bug fixed in go-apps/meep-app-enablement/server/app-support/app-support.go (69de4cc5) · Commits · MEC - Multi-access Edge Computing / ETSI MEC Sandbox

go-apps/meep-app-enablement/server/app-support/app-support.go

+45 −25

Original line number	Diff line number	Diff line
		@@ -648,7 +648,7 @@ func timingCurrentTimeGET(w http.ResponseWriter, r *http.Request) {
		}

		func registerAppPost(w http.ResponseWriter, r *http.Request) {
		log.Info(">>> applicationsRegistrationPOST")
		log.Info(">>> applicationsRegistrationPOST: ", r)

		w.Header().Set("Content-Type", "application/json; charset=UTF-8")

		@@ -660,6 +660,7 @@ func registerAppPost(w http.ResponseWriter, r *http.Request) {
		errHandlerProblemDetails(w, err.Error(), http.StatusBadRequest)
		return
		}
		log.Info("applicationsRegistrationPOST: appInfo: ", appInfo)

		// Validation of mandatory parameters
		if appInfo.AppName == "" {
		@@ -675,11 +676,14 @@ func registerAppPost(w http.ResponseWriter, r *http.Request) {
		}

		// Get App instance
		log.Info("applicationsRegistrationPOST: appInfo.AppInstanceId: ", appInfo.AppInstanceId)
		appId, err := getAppInfo(appInfo.AppInstanceId)
		if err != nil {
		log.Error(err.Error())
		errHandlerProblemDetails(w, err.Error(), http.StatusNotFound)
		return
		}
		log.Info("applicationsRegistrationPOST: appId: ", appId)

		// Validate App info
		code, problemDetails, err := validateAppInfo(appId)
		@@ -695,7 +699,6 @@ func registerAppPost(w http.ResponseWriter, r *http.Request) {
		}

		var jsonResponse []byte

		jsonResponse, err = setApplicationInfo(appInfo)
		if err != nil {
		log.Error("Unable to store new Registration in redis")
		@@ -703,24 +706,30 @@ func registerAppPost(w http.ResponseWriter, r *http.Request) {
		return
		}

		// Create a unique link for every subscription and concatenate subscription to it
		resourceURI := hostUrl.String() + basePath + "registrations/" + appInfo.AppInstanceId
		log.Info("applicationsRegistrationPOST: resourceUDI: ", resourceURI)
		w.Header().Set("Location", resourceURI)

		// On successful registration, return 201 Created with the response body
		w.WriteHeader(http.StatusCreated)
		fmt.Fprint(w, string(jsonResponse))
		}

		func appRegistrationGET(w http.ResponseWriter, r *http.Request) {
		log.Info(">>> appRegistrationGET")
		log.Info(">>> appRegistrationGET: ", r)

		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		vars := mux.Vars(r)
		appInstanceId := vars["appInstanceId"]
		log.Info("appRegistrationGET: appInstanceId: ", appInstanceId)

		mutex.Lock()
		defer mutex.Unlock()

		keyName := baseKey + "Ins_Id:" + appInstanceId
		keyName := baseKey + "appInfo:" + appInstanceId
		log.Info("appRegistrationGET: keyName: ", keyName)
		jsonAppInfo, err := rc.JSONGetEntry(keyName, ".")

		if err != nil {
		err = errors.New("appInfo not found against the provided appInstanceId")
		log.Error(err.Error())
		@@ -735,6 +744,7 @@ func appRegistrationGET(w http.ResponseWriter, r *http.Request) {
		errHandlerProblemDetails(w, err.Error(), http.StatusInternalServerError)
		return
		}
		log.Info("appRegistrationGET: appInfo: ", appInfo)

		// Marshal the AppInfo struct to JSON format
		jsonResponse := convertAppInfoToJson(&appInfo)
		@@ -760,14 +770,17 @@ func deleteAppInstance(appId string) {
		_ = sm.DeleteServices(appId)

		// Flush App instance data
		key := baseKey + "app:" + appId
		_ = rc.DBFlush(key)
		keyName := baseKey + "app:" + appId
		log.Info("deleteAppInstance: keyName: ", keyName)
		_ = rc.DBFlush(keyName)

		// Confirm App removal
		sendAppRemoveCnf(appId)
		}

		func getAppList() ([]map[string]string, error) {
		log.Info(">>> getAppList")

		var appInfoList []map[string]string

		// Get all applications from DB
		@@ -794,18 +807,6 @@ func populateAppInfo(key string, entry map[string]string, userData interface{})
		return nil
		}

		// func getApp(appId string) (map[string]string, error) {
		// var appInfo map[string]string

		// // Get app instance from local MEP only
		// key := baseKey + "app:" + appId + ":info"
		// appInfo, err := rc.GetEntry(key)
		// if err != nil \|\| len(appInfo) == 0 {
		// return nil, errors.New("App Instance not found")
		// }
		// return appInfo, nil
		// }

		func validateAppInfo(appInfo map[string]string) (int, string, error) {
		// Make sure App is in ready state
		if appInfo[fieldState] != APP_STATE_READY {
		@@ -818,6 +819,8 @@ func validateAppInfo(appInfo map[string]string) (int, string, error) {
		}

		func newAppInfo(app *apps.Application) (map[string]string, error) {
		log.Info(">>> newAppInfo: ", app)

		// Validate app
		if app == nil {
		return nil, errors.New("nil application")
		@@ -835,6 +838,8 @@ func newAppInfo(app *apps.Application) (map[string]string, error) {
		}

		func setAppInfo(appInfo map[string]string) error {
		log.Info(">>> setAppInfo: ", appInfo)

		appId, found := appInfo[fieldAppId]
		if !found \|\| appId == "" {
		return errors.New("Missing app instance id")
		@@ -847,8 +852,9 @@ func setAppInfo(appInfo map[string]string) error {
		}

		// Store entry
		key := baseKey + "app:" + appId + ":info"
		err := rc.SetEntry(key, entry)
		keyName := baseKey + "app:" + appId + ":info"
		log.Info("setAppInfo: keyName: ", keyName)
		err := rc.SetEntry(keyName, entry)
		if err != nil {
		return err
		}
		@@ -956,6 +962,8 @@ func refreshApps() error {
		}

		func getApp(appId string) (map[string]string, error) {
		log.Info(">>> getApp: ", appId)

		appInfo, found := appInfoMap[appId]
		if !found {
		return nil, errors.New("app instance not found")
		@@ -964,6 +972,8 @@ func getApp(appId string) (map[string]string, error) {
		}

		func updateApp(appId string) (map[string]string, error) {
		log.Info(">>> updateApp: ", appId)

		// Get App information from app store
		app, err := appStore.Get(appId)
		if err != nil {
		@@ -1144,22 +1154,32 @@ func sendAppRemoveCnf(id string) {
		* @return {error} err It returns error if there is no information associated with this appId
		*/
		func getAppInfo(appId string) (map[string]string, error) {
		log.Info(">>> getAppInfo: ", appId)

		var appInfo map[string]string

		// Get app instance from local MEP only
		baseKeyAppEn := dkm.GetKeyRoot(sandboxName) + appEnablementKey + ":mep:" + mepName + ":"
		key := baseKeyAppEn + "app:" + appId + ":info"
		appInfo, err := rc.GetEntry(key)
		if err != nil \|\| len(appInfo) == 0 {
		keyName := baseKey + "app:" + appId + ":info"
		log.Info("getAppInfo: keyName: ", keyName)
		appInfo, err := rc.GetEntry(keyName)
		if err != nil {
		log.Error(err.Error())
		return nil, err
		} else if len(appInfo) == 0 {
		return nil, errors.New("App Instance not found")
		}
		log.Info("getAppInfo: appInfo: ", appInfo)

		return appInfo, nil
		}

		func setApplicationInfo(appInfo AppInfo) ([]byte, error) {
		log.Info(">>> setApplicationInfo: ", appInfo)

		var jsonResponse []byte
		appInstanceId := appInfo.AppInstanceId
		keyName := baseKey + "appInfo:" + appInstanceId
		log.Info("setApplicationInfo: keyName: ", keyName)
		_ = rc.JSONSetEntry(keyName, ".", convertAppInfoToJson(&appInfo))
		jsonResponse, err := json.Marshal(appInfo)

go-apps/meep-app-enablement/server/mae_test.go

+395 −108

Original line number	Diff line number	Diff line
		@@ -5903,101 +5903,6 @@ const deltaSeconds = float64(2.0)

		var appStore *apps.ApplicationStore

		// func TestRegisterAppPOST(t *testing.T) {
		// fmt.Println("--- ", t.Name())
		// log.MeepTextLogInit(t.Name())

		// initializeVars()

		// err := Init()
		// if err != nil {
		// t.Fatalf("Error initializing test basic procedure")
		// }

		// err = Run()
		// if err != nil {
		// t.Fatalf("Error running test basic procedure")
		// }

		// fmt.Println("Set a scenario")
		// initialiseScenario(testScenario)

		// time.Sleep(1000 * time.Millisecond)
		// updateScenario("mobility1")

		// /******************************
		// * expected response section
		// ******************************/
		// appDId := uuid.New().String()
		// appInstanceId := uuid.New().String()
		// expectedAppInfo := as.AppInfo{
		// AppName: "MyAppName",
		// AppProvider: "MyAppProvider",
		// AppDId: appDId,
		// AppInstanceId: appInstanceId,
		// }

		// /******************************
		// * request vars section
		// ******************************/

		// /******************************
		// * request body section
		// ******************************/

		// /******************************
		// * request queries section
		// ******************************/

		// /******************************
		// * request execution section
		// ******************************/

		// appInfo := as.AppInfo{
		// AppName: "MyAppName",
		// AppProvider: "MyAppProvider",
		// AppDId: appDId,
		// AppInstanceId: appInstanceId,
		// }
		// body, err := json.Marshal(appInfo)
		// if err != nil {
		// t.Fatalf(err.Error())
		// }
		// fmt.Println("body: ", string(body))

		// rr, err := sendRequest(http.MethodPost, "/mec_app_support/v2/registrations", bytes.NewBuffer(body), nil, nil, nil, http.StatusOK, as.RegisterMecAppPOST)
		// if err != nil {
		// t.Fatalf(err.Error())
		// }
		// fmt.Println("sendRequest done")

		// var respBody as.AppInfo
		// err = json.Unmarshal([]byte(rr), &respBody)
		// if err != nil {
		// t.Fatalf("Failed to get expected response")
		// }
		// fmt.Println("respBody: ", respBody)

		// if !validateAppInfo(respBody, expectedAppInfo) {
		// t.Fatalf("Invalid delta seconds")
		// }

		// /******************************
		// * back to initial state section
		// ******************************/

		// terminateScenario()

		// }

		// func validateAppInfo(received as.AppInfo, expected as.AppInfo) bool {
		// fmt.Println("validateAppInfo: received: ", received)
		// fmt.Println("validateAppInfo: expected: ", expected)

		// fmt.Println("validateAppInfo: succeed")
		// return true
		// }

		func createNewApp() string {
		appInstanceId := uuid.New().String()
		app := &apps.Application{
		@@ -6097,6 +6002,8 @@ func TestApplicationsConfirmPOST(t *testing.T) {
		/******************************
		* request vars section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId

		/******************************
		* request body section
		@@ -6115,8 +6022,6 @@ func TestApplicationsConfirmPOST(t *testing.T) {
		t.Fatalf(err.Error())
		}
		fmt.Println("body: ", string(body))
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		_, err = sendRequest(http.MethodPost, "/mec_app_support/v2/applications/"+appInstanceId+"/confirm_ready", bytes.NewBuffer(body), vars, nil, nil, http.StatusNoContent, as.ApplicationsConfirmReadyPOST)
		if err != nil {
		t.Fatalf(err.Error())
		@@ -6288,6 +6193,8 @@ func TestSubscriptionGET(t *testing.T) {
		/******************************
		* request vars section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId

		/******************************
		* request body section
		@@ -6305,6 +6212,7 @@ func TestSubscriptionGET(t *testing.T) {
		subscriptionId_1, _ /expectedGetResponse_1/ := testSubscriptionPost(t, appInstanceId, false, false, true)
		subscriptionId_2, _ /expectedGetResponse_2/ := testSubscriptionPost(t, appInstanceId, false, false, true)

		// GET Subscriptions
		var expected_mecAppSuptApiSubscriptionLinkListLinks as.MecAppSuptApiSubscriptionLinkListLinks
		expected_mecAppSuptApiSubscriptionLinkListLinks.Self = &as.LinkType{
		Href: "/mec_app_support/v2/applications/" + appInstanceId + "/subscriptions",
		@@ -6322,9 +6230,6 @@ func TestSubscriptionGET(t *testing.T) {
		Links: &expected_mecAppSuptApiSubscriptionLinkListLinks,
		}

		// GET Subscriptions
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		rr, err := sendRequest(http.MethodGet, "/mec_app_support/v2/applications/"+appInstanceId+"/subscriptions", nil, vars, nil, nil, http.StatusOK, as.ApplicationsSubscriptionsGET)
		if err != nil {
		t.Fatalf(err.Error())
		@@ -6488,7 +6393,7 @@ func testSubscriptionPost(t *testing.T, appInstanceId string, requestTestNotific
		******************************/
		// Initialize the data structure for the POST request
		expected_callbackReference := "http://localhost:8080/callback"
		expected_href := as.LinkType{Href: "http://localhost/testScenario/mec_app_support/v2/applications/" + appInstanceId + "subscriptions/"}
		expected_href := as.LinkType{Href: "/testScenario/mec_app_support/v2/applications/" + appInstanceId + "/subscriptions/"}
		expected_self := as.Self{Self: &expected_href}
		var expected_appTermNotifSub = as.AppTerminationNotificationSubscription{
		SubscriptionType: "AppTerminationNotificationSubscription",
		@@ -6501,6 +6406,11 @@ func testSubscriptionPost(t *testing.T, appInstanceId string, requestTestNotific
		t.Fatalf(err.Error())
		}
		fmt.Println("expectedResponseStr: ", string(expectedResponseStr))
		/******************************
		* request vars section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		/******************************
		* request body section
		******************************/
		@@ -6518,8 +6428,6 @@ func testSubscriptionPost(t *testing.T, appInstanceId string, requestTestNotific
		/******************************
		* request execution section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		if expectSuccess {
		rr, err := sendRequest(http.MethodPost, "/mec_app_support/v2/applications/"+appInstanceId+"/subscriptions", bytes.NewBuffer(body), vars, nil, &expected_href.Href, http.StatusCreated, as.ApplicationsSubscriptionsPOST)
		if err != nil {
		@@ -6614,13 +6522,13 @@ func testIndividualSubscriptionDelete(t *testing.T, appInstanceId string, subscr
		/******************************
		* request vars section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		vars["subscriptionId"] = subscriptionId

		/******************************
		* request execution section
		******************************/
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		vars["subscriptionId"] = subscriptionId
		if expectSuccess {
		_, err := sendRequest(http.MethodDelete, "/mec_app_support/v2/applications/"+appInstanceId+"/subscriptions/"+subscriptionId, nil, vars, nil, nil, http.StatusNoContent, as.ApplicationsSubscriptionDELETE)
		if err != nil {
		@@ -6653,7 +6561,7 @@ func validateAppTerminationNotificationSubscription(received as.AppTerminationNo
		if received.Links != nil && expected.Links != nil {
		if received.Links.Self != nil && expected.Links.Self != nil {
		fmt.Println("AppTerminationNotificationSubscription.Links.Self.Href: ", received.Links.Self)
		if strings.Contains(received.Links.Self.Href, expected.Links.Self.Href) {
		if strings.Contains(expected.Links.Self.Href, received.Links.Self.Href) {
		fmt.Println("AppTerminationNotificationSubscription.Links.Self.Href mismatch")
		return false
		}
		@@ -6721,7 +6629,7 @@ func validateMecAppSuptApiSubscriptionLinkListSubscription(received as.MecAppSup
		fmt.Println("validateMecAppSuptApiSubscriptionLinkListSubscription: received: ", received)
		fmt.Println("validateMecAppSuptApiSubscriptionLinkListSubscription: expected: ", expected)

		if received.Href != expected.Href {
		if !strings.Contains(expected.Href, received.Href) {
		fmt.Println("MecAppSuptApiSubscriptionLinkListSubscription.Href mismatch")
		return false
		}
		@@ -6734,6 +6642,385 @@ func validateMecAppSuptApiSubscriptionLinkListSubscription(received as.MecAppSup
		return true
		}

		func TestRegisterAppPOST(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())
		initializeVars()
		err := Init()
		if err != nil {
		t.Fatalf("Error initializing test basic procedure")
		}
		err = Run()
		if err != nil {
		t.Fatalf("Error running test basic procedure")
		}

		fmt.Println("Set a scenario")
		initialiseScenario(testScenario)

		time.Sleep(1000 * time.Millisecond)
		updateScenario("mobility1")

		// Set application
		appInstanceId := createNewAppWithConfirmReady()

		/******************************
		* expected response section
		******************************/

		/******************************
		* request vars section
		******************************/

		/******************************
		* request body section
		******************************/

		/******************************
		* request queries section
		******************************/

		/******************************
		* request execution section
		******************************/

		// POST
		/subscriptionId, expectedGetResponse :=/
		testRegisterAppPOST(t, appInstanceId, true)

		// TODO Delete
		//testRegisterAppDELETE(t, appInstanceId, subscriptionId, true)

		deleteApp(appInstanceId)

		/******************************
		* back to initial state section
		******************************/

		terminateScenario()
		}

		func testRegisterAppPOST(t *testing.T, appInstanceId string, expectSuccess bool) (string, string) {
		fmt.Println(">>> testRegisterAppPOST")

		/******************************
		* expected response section
		******************************/
		expected_href := as.LinkType{Href: "http://localhost/testScenario/mec_app_support/v2/registrations/" + appInstanceId}
		appDId := uuid.New().String()
		expectedAppInfo := as.AppInfo{
		AppName: "MyAppName",
		AppProvider: "MyAppProvider",
		AppDId: appDId,
		AppInstanceId: appInstanceId,
		}
		expectedResponseStr, err := json.Marshal(expectedAppInfo)
		if err != nil {
		t.Fatalf(err.Error())
		}
		fmt.Println("expectedResponseStr: ", string(expectedResponseStr))

		/******************************
		* request vars section
		******************************/

		/******************************
		* request body section
		******************************/

		/******************************
		* request queries section
		******************************/

		/******************************
		* request execution section
		******************************/
		appInfo := as.AppInfo{
		AppName: "MyAppName",
		AppProvider: "MyAppProvider",
		AppDId: appDId,
		AppInstanceId: appInstanceId,
		}
		body, err := json.Marshal(appInfo)
		if err != nil {
		t.Fatalf(err.Error())
		}
		fmt.Println("body: ", string(body))
		if expectSuccess {
		rr, err := sendRequest(http.MethodPost, "/mec_app_support/v2/registrations", bytes.NewBuffer(body), nil, nil, &expected_href.Href, http.StatusCreated, as.RegisterMecAppPOST)
		if err != nil {
		t.Fatalf(err.Error())
		}
		fmt.Println("sendRequest done")
		var respBody as.AppInfo
		err = json.Unmarshal([]byte(rr), &respBody)
		if err != nil {
		t.Fatalf("Failed to get expected response")
		}
		fmt.Println("respBody: ", respBody)
		if !validateAppInfo(respBody, expectedAppInfo) {
		t.Fatalf("Invalid delta seconds")
		}

		subscriptionId := strings.Split(expected_href.Href, "/")
		cleanSubscriptionId := subscriptionId[len(subscriptionId)-1]
		return cleanSubscriptionId, string(expectedResponseStr)
		} else {
		_, err := sendRequest(http.MethodPost, "/mec_app_support/v2/registrations", bytes.NewBuffer(body), nil, nil, nil, http.StatusNotFound, as.RegisterMecAppPOST)
		if err != nil {
		t.Fatalf(err.Error())
		}
		fmt.Println("sendRequest done")
		return "", ""
		}
		}

		// FIXME xFLOW Missimg Update ETSI GS MEC 011 V3.1.1 (2022-09) Clause 7.2.14.3.2 PUT

		// FIXME xFLOW Missimg Delete ETSI GS MEC 011 V3.1.1 (2022-09) Clause 7.2.14.3.5 DELETE
		// func testRegistrationDelete(t *testing.T, appInstanceId string, subscriptionId string, expectSuccess bool) {
		// fmt.Println(">>> testRegistrationDelete")

		// /******************************
		// * request vars section
		// ******************************/
		// var vars = make(map[string]string)
		// vars["appInstanceId"] = appInstanceId
		// vars["subscriptionId"] = subscriptionId
		// /******************************
		// * request execution section
		// ******************************/

		// if expectSuccess {
		// _, err := sendRequest(http.MethodDelete, "/mec_app_support/v2/registrations/"+appInstanceId, nil, vars, nil, nil, http.StatusNoContent, as.ApplicationsSubscriptionDELETE)
		// if err != nil {
		// fmt.Println("testIndividualSubscriptionDelete: ", err.Error())
		// t.Fatalf("Failed to get expected response")
		// }
		// } else {
		// _, err := sendRequest(http.MethodDelete, "/vis/v2/subscriptions/"+subscriptionId, nil, vars, nil, nil, http.StatusNotFound, as.ApplicationsSubscriptionDELETE)
		// if err != nil {
		// fmt.Println("testIndividualSubscriptionDelete: ", err.Error())
		// t.Fatalf("Failed to get expected response")
		// }
		// }
		// }

		func TestRegisterAppGET(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())
		initializeVars()
		err := Init()
		if err != nil {
		t.Fatalf("Error initializing test basic procedure")
		}
		err = Run()
		if err != nil {
		t.Fatalf("Error running test basic procedure")
		}

		fmt.Println("Set a scenario")
		initialiseScenario(testScenario)

		time.Sleep(1000 * time.Millisecond)
		updateScenario("mobility1")

		// Set application
		appInstanceId := createNewAppWithConfirmReady()

		/******************************
		* expected response section
		******************************/

		/******************************
		* request vars section
		******************************/

		/******************************
		* request body section
		******************************/

		/******************************
		* request queries section
		******************************/

		/******************************
		* request execution section
		******************************/

		// POST
		_ /subscriptionId/, expectedGetResponse := testRegisterAppPOST(t, appInstanceId, true)
		var expectedAppInfo as.AppInfo
		err = json.Unmarshal([]byte(expectedGetResponse), &expectedAppInfo)
		if err != nil {
		t.Fatalf("Failed to get expected response")
		}

		// GET
		var vars = make(map[string]string)
		vars["appInstanceId"] = appInstanceId
		rr, err := sendRequest(http.MethodGet, "/mec_app_support/v2/registrations/"+appInstanceId, nil, vars, nil, nil, http.StatusOK, as.AppRegistrationGET)
		if err != nil {
		t.Fatalf(err.Error())
		}
		fmt.Println("sendRequest done")
		var respBody as.AppInfo
		err = json.Unmarshal([]byte(rr), &respBody)
		if err != nil {
		t.Fatalf("Failed to get expected response")
		}

		fmt.Println("respBody: ", respBody)
		if !validateAppInfo(respBody, expectedAppInfo) {
		t.Fatalf("Invalid delta seconds")
		}

		// TODO Delete
		//testRegisterAppDELETE(t, appInstanceId, subscriptionId, true)

		deleteApp(appInstanceId)

		/******************************
		* back to initial state section
		******************************/

		terminateScenario()
		}

		func TestFailRegisterAppPOST(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())
		initializeVars()
		err := Init()
		if err != nil {
		t.Fatalf("Error initializing test basic procedure")
		}
		err = Run()
		if err != nil {
		t.Fatalf("Error running test basic procedure")
		}

		fmt.Println("Set a scenario")
		initialiseScenario(testScenario)

		time.Sleep(1000 * time.Millisecond)
		updateScenario("mobility1")

		// Set application
		appInstanceId := uuid.New().String()

		/******************************
		* expected response section
		******************************/

		/******************************
		* request vars section
		******************************/

		/******************************
		* request body section
		******************************/

		/******************************
		* request queries section
		******************************/

		/******************************
		* request execution section
		******************************/

		// POST
		testRegisterAppPOST(t, appInstanceId, false)

		/******************************
		* back to initial state section
		******************************/

		terminateScenario()
		}

		func validateAppInfo(received as.AppInfo, expected as.AppInfo) bool {
		fmt.Println("validateAppInfo: received: ", received)
		fmt.Println("validateAppInfo: expected: ", expected)

		if received.AppName != expected.AppName {
		fmt.Println("validateAppInfo: AppInfo.AppName mismatch")
		return false
		}

		if received.AppProvider != expected.AppProvider {
		fmt.Println("validateAppInfo: AppInfo.AppProvider mismatch")
		return false
		}

		if received.AppCategory != nil && expected.AppCategory != nil {
		// TODO FSCOM
		} else if received.AppCategory != nil \|\| expected.AppCategory != nil {
		fmt.Println("validateAppInfo: AppInfo.AppCategory mismatch")
		return false
		}

		if received.AppDId != expected.AppDId {
		fmt.Println("validateAppInfo: AppInfo.AppDId mismatch")
		return false
		}

		if received.AppInstanceId != expected.AppInstanceId {
		fmt.Println("validateAppInfo: AppInfo.AppInstanceId mismatch")
		return false
		}

		if received.Endpoint != nil && expected.Endpoint != nil {
		// TODO FSCOM
		} else if received.Endpoint != nil \|\| expected.Endpoint != nil {
		fmt.Println("validateAppInfo: AppInfo.Endpoint mismatch")
		return false
		}

		if len(received.AppServiceRequired) == len(expected.AppServiceRequired) {
		// TODO FSCOM
		} else {
		fmt.Println("validateAppInfo: AppInfo.AppServiceRequired mismatch")
		return false
		}

		if len(received.AppServiceOptional) == len(expected.AppServiceOptional) {
		// TODO FSCOM
		} else {
		fmt.Println("validateAppInfo: AppInfo.AppServiceOptional mismatch")
		return false
		}

		if len(received.AppFeatureRequired) == len(expected.AppFeatureRequired) {
		// TODO FSCOM
		} else {
		fmt.Println("validateAppInfo: AppInfo.AppFeatureRequired mismatch")
		return false
		}

		if len(received.AppFeatureOptional) == len(expected.AppFeatureOptional) {
		// TODO FSCOM
		} else {
		fmt.Println("validateAppInfo: AppInfo.AppFeatureOptional mismatch")
		return false
		}

		if received.IsInsByMec != expected.IsInsByMec {
		fmt.Println("validateAppInfo: AppInfo.IsInsByMec mismatch")
		return false
		}

		if received.AppProfile != nil && expected.AppProfile != nil {
		// TODO FSCOM
		} else if received.AppProfile != nil \|\| expected.AppProfile != nil {
		fmt.Println("validateAppInfo: AppInfo.AppProfile mismatch")
		return false
		}

		fmt.Println("validateAppInfo: succeed")
		return true
		}

		func TestTimingCapsGET(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())