Commit c10f1cf1 authored by Yann Garcia's avatar Yann Garcia
Browse files

Emhance meep-iot_test

parent 144f2851

docs/meepctl/meepctl_lint.md

+1 −0
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ Valid Targets: 
  * meep-iot

  * meep-sss

  * meep-iot-mgr

  * meep-sss-mgr

  * meep-wais

  * meep-watchdog

  * meep-webhook

go-apps/meep-iot/server/meep-iot.go

+3 −8
Original line number Diff line number Diff line
@@ -932,20 +932,15 @@ func registereddevicesPOST(w http.ResponseWriter, r *http.Request) { 
	log.Debug(">>> registereddevicesPOST: ", r)



	// Read JSON input stream provided in the Request, and stores it in the bodyBytes as bytes

	var registeredDevicesRegisteredDeviceIdBody RegisteredDevicesRegisteredDeviceIdBody

	var deviceInfo DeviceInfo

	bodyBytes, _ := ioutil.ReadAll(r.Body)

	// Unmarshal function to converts a JSON-formatted string into a SubscriptionCommon struct and store it in extractSubType

	err := json.Unmarshal(bodyBytes, &registeredDevicesRegisteredDeviceIdBody)

	err := json.Unmarshal(bodyBytes, &deviceInfo)

	if err != nil {

		log.Error(err.Error())

		errHandlerProblemDetails(w, err.Error(), http.StatusInternalServerError)

		return

	} else if registeredDevicesRegisteredDeviceIdBody.DeviceInfo == nil {

		err = errors.New("Failed to decode body")

		errHandlerProblemDetails(w, err.Error(), http.StatusInternalServerError)

		return

	}

	deviceInfo := *registeredDevicesRegisteredDeviceIdBody.DeviceInfo

	log.Info("registereddevicesPOST: ", deviceInfo)



	// Sanity checks
@@ -981,7 +976,7 @@ func registereddevicesPOST(w http.ResponseWriter, r *http.Request) { 
	}

	log.Info("registereddevicesPOST: jsonResponse: ", string(jsonResponse))



	w.WriteHeader(http.StatusOK)

	w.WriteHeader(http.StatusCreated)

	fmt.Fprint(w, string(jsonResponse))

}

go-apps/meep-iot/server/meep-iot_test.go

+557 −24
Original line number Diff line number Diff line
@@ -656,7 +656,7 @@ func TestRegisterediotplatformsPOST(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegisterediotplatformsPOST)

	rr, err := sendRequest(http.MethodPost, "/registered_iot_platforms", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegisterediotplatformsPOST)

	if err != nil {

		t.Fatalf(err.Error())

	}
@@ -667,7 +667,7 @@ func TestRegisterediotplatformsPOST(t *testing.T) { 
		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if !validateIotPlatformInfo(resp, iotPlatformInfo) {

	if !validate_iot_platform_info(resp, iotPlatformInfo) {

		t.Errorf("handler returned unexpected body: got %v want %v", rr, expected_iotPlatformInfo_str)

	}
@@ -675,7 +675,7 @@ func TestRegisterediotplatformsPOST(t *testing.T) { 
	/******************************

	 * back to initial state section

	 ******************************/

	_ = deleteRegisterediotplatforms(resp.IotPlatformId)

	_ = delete_registered_iot_platforms(resp.IotPlatformId)

	terminateScenario()

}
@@ -761,7 +761,7 @@ func TestRegisterediotplatformsPOSTFail_1(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	_, err = sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	_, err = sendRequest(http.MethodPost, "/registered_iot_platforms", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	if err != nil {

		t.Fatalf("Shall received 400 Bad Request due to Security missing field")

	}
@@ -855,7 +855,7 @@ func TestRegisterediotplatformsPOSTFail_2(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	_, err = sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	_, err = sendRequest(http.MethodPost, "/registered_iot_platforms", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	if err != nil {

		t.Fatalf("Shall received 400 Bad Request due to ImplSpecificInfo missing field")

	}
@@ -949,7 +949,7 @@ func TestRegisterediotplatformsPOSTFail_3(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	_, err = sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	_, err = sendRequest(http.MethodPost, "/registered_iot_platforms", bytes.NewBuffer(body), nil, nil, nil, http.StatusBadRequest, RegisterediotplatformsPOST)

	if err != nil {

		t.Fatalf("Shall received 400 Bad Request due to TransportType missing field")

	}
@@ -980,7 +980,7 @@ func TestRegisterediotplatformsGET(t *testing.T) { 
	/******************************

	 * expected response section

	 ******************************/

	expected_iotPlatformInfo, err := createRegisterediotplatforms()

	expected_iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}
@@ -993,7 +993,7 @@ func TestRegisterediotplatformsGET(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodGet, "/registered_devices", nil, nil, nil, nil, http.StatusOK, RegisterediotplatformsGET)

	rr, err := sendRequest(http.MethodGet, "/registered_iot_platforms", nil, nil, nil, nil, http.StatusOK, RegisterediotplatformsGET)

	if err != nil {

		t.Fatalf(err.Error())

	}
@@ -1007,7 +1007,7 @@ func TestRegisterediotplatformsGET(t *testing.T) { 
	if len(resp) != 1 {

		t.Fatalf("Invalid response length")

	}

	if !validateIotPlatformInfo(resp[0], expected_iotPlatformInfo) {

	if !validate_iot_platform_info(resp[0], expected_iotPlatformInfo) {

		t.Errorf("Response mismatch")

	}
@@ -1015,7 +1015,7 @@ func TestRegisterediotplatformsGET(t *testing.T) { 
	/******************************

	 * back to initial state section

	 ******************************/

	_ = deleteRegisterediotplatforms(expected_iotPlatformInfo.IotPlatformId)

	_ = delete_registered_iot_platforms(expected_iotPlatformInfo.IotPlatformId)

	terminateScenario()

}
@@ -1039,7 +1039,7 @@ func TestRegisterediotplatformsByIdGET(t *testing.T) { 
	/******************************

	 * expected response section

	 ******************************/

	expected_iotPlatformInfo, err := createRegisterediotplatforms()

	expected_iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}
@@ -1058,7 +1058,7 @@ func TestRegisterediotplatformsByIdGET(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodGet, "/registered_devices", nil, vars, nil, nil, http.StatusOK, RegisterediotplatformsByIdGET)

	rr, err := sendRequest(http.MethodGet, "/registered_iot_platforms", nil, vars, nil, nil, http.StatusOK, RegisterediotplatformsByIdGET)

	if err != nil {

		t.Fatalf(err.Error())

	}
@@ -1069,7 +1069,7 @@ func TestRegisterediotplatformsByIdGET(t *testing.T) { 
		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if !validateIotPlatformInfo(resp, expected_iotPlatformInfo) {

	if !validate_iot_platform_info(resp, expected_iotPlatformInfo) {

		t.Errorf("Response mismatch")

	}
@@ -1077,7 +1077,7 @@ func TestRegisterediotplatformsByIdGET(t *testing.T) { 
	/******************************

	 * back to initial state section

	 ******************************/

	_ = deleteRegisterediotplatforms(expected_iotPlatformInfo.IotPlatformId)

	_ = delete_registered_iot_platforms(expected_iotPlatformInfo.IotPlatformId)

	terminateScenario()

}
@@ -1101,7 +1101,7 @@ func TestRegisterediotplatformsDelete(t *testing.T) { 
	/******************************

	 * expected response section

	 ******************************/

	expected_iotPlatformInfo, err := createRegisterediotplatforms()

	expected_iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}
@@ -1120,7 +1120,7 @@ func TestRegisterediotplatformsDelete(t *testing.T) { 
	/******************************

	 * request execution section

	 ******************************/

	_, err = sendRequest(http.MethodDelete, "/registered_devices", nil, vars, nil, nil, http.StatusNoContent, RegisterediotplatformsByIdDELETE)

	_, err = sendRequest(http.MethodDelete, "/registered_iot_platforms", nil, vars, nil, nil, http.StatusNoContent, RegisterediotplatformsByIdDELETE)

	if err != nil {

		t.Fatalf(err.Error())

	}
@@ -1132,7 +1132,348 @@ func TestRegisterediotplatformsDelete(t *testing.T) { 
	terminateScenario()

}



func createRegisterediotplatforms() (resp IotPlatformInfo, err error) {

func TestRegistereddevicesPOST(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")



	iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}

	fmt.Println("iotPlatformInfo: ", iotPlatformInfo)



	/******************************

	 * expected response section

	 ******************************/

	expected_requestedIotPlatformId := iotPlatformInfo.IotPlatformId

	expected_deviceMetadata := make([]KeyValuePair, 2)

	expected_deviceMetadata[0] = KeyValuePair{

		Key:   "Key1",

		Value: "Value1",

	}

	expected_deviceMetadata[1] = KeyValuePair{

		Key:   "Key2",

		Value: "Value2",

	}

	var expected_device = DeviceInfo{

		DeviceMetadata:         expected_deviceMetadata,

		RequestedIotPlatformId: expected_requestedIotPlatformId,

		DeviceId:               expected_requestedIotPlatformId,

		Imsi:                   "12345",

		Enabled:                true,

	}

	expected_device_str, err := json.Marshal(expected_device)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("expected_device: ", string(expected_device_str))



	/******************************

	 * request body section

	 ******************************/

	var device = DeviceInfo{

		RequestedIotPlatformId: expected_requestedIotPlatformId,

		DeviceId:               expected_requestedIotPlatformId,

		Enabled:                true,

	}

	fmt.Println("Create a device: ", device)

	body, err := json.Marshal(device)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("body: ", string(body))



	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegistereddevicesPOST)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: rr: ", rr)

	var resp DeviceInfo

	err = json.Unmarshal([]byte(rr), &resp)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if !validate_device_info(resp, expected_device) {

		t.Errorf("Response mismatch")

	}



	fmt.Println("Received expected response")

	/******************************

	 * back to initial state section

	 ******************************/

	_ = delete_device(expected_device.DeviceId)

	_ = delete_registered_iot_platforms(iotPlatformInfo.IotPlatformId)

	terminateScenario()

}



func TestRegistereddevicesDELETE(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")



	iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}

	fmt.Println("iotPlatformInfo: ", iotPlatformInfo)



	/******************************

	 * expected response section

	 ******************************/

	device, err := create_device(iotPlatformInfo)

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}



	/******************************

	 * request vars section

	 ******************************/

	vars := make(map[string]string)

	vars["registeredDeviceId"] = device.DeviceId



	/******************************

	 * request body section

	 ******************************/



	/******************************

	 * request execution section

	 ******************************/

	_, err = sendRequest(http.MethodDelete, "/registered_devices", nil, vars, nil, nil, http.StatusNoContent, RegistereddevicesByIdDELETE)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Received expected response")

	/******************************

	 * back to initial state section

	 ******************************/

	_ = delete_registered_iot_platforms(iotPlatformInfo.IotPlatformId)

	terminateScenario()

}



func TestRegistereddevicesGET(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")



	iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}

	fmt.Println("iotPlatformInfo: ", iotPlatformInfo)



	/******************************

	 * expected response section

	 ******************************/

	expected_device, err := create_device(iotPlatformInfo)

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}



	/******************************

	 * request body section

	 ******************************/



	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodGet, "/registered_devices", nil, nil, nil, nil, http.StatusOK, RegistereddevicesGET)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: rr: ", rr)

	var resp []DeviceInfo

	err = json.Unmarshal([]byte(rr), &resp)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if len(resp) != 1 {

		t.Errorf("Response length mismatch")

	}

	if !validate_device_info(resp[0], expected_device) {

		t.Errorf("Response mismatch")

	}



	fmt.Println("Received expected response")

	/******************************

	 * back to initial state section

	 ******************************/

	_ = delete_device(expected_device.DeviceId)

	_ = delete_registered_iot_platforms(iotPlatformInfo.IotPlatformId)

	terminateScenario()

}



func TestRegistereddevicesGET_withFiltering(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")



	iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}

	fmt.Println("iotPlatformInfo: ", iotPlatformInfo)



	/******************************

	 * expected response section

	 ******************************/

	expected_devices, err := create_set_of_devices(iotPlatformInfo)

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}



	// Filter on RequestedUserTransportId and its complement

	queryParam := make(map[string]string)

	queryParam["filter"] = "(eq," + expected_devices[2].RequestedUserTransportId + ", requestedUserTransportId)"

	rr, err := sendRequest(http.MethodGet, "/registered_devices", nil, nil, queryParam, nil, http.StatusOK, RegistereddevicesGET)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: rr: ", rr)

	var resp []DeviceInfo

	err = json.Unmarshal([]byte(rr), &resp)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if len(resp) != 1 {

		t.Errorf("Response length mismatch")

	}

	if !validate_device_info(resp[0], expected_device[2]) {

		t.Errorf("Response mismatch")

	}



	fmt.Println("Received expected response")

	/******************************

	 * back to initial state section

	 ******************************/

	_ = delete_device(expected_device.DeviceId)

	_ = delete_registered_iot_platforms(iotPlatformInfo.IotPlatformId)

	terminateScenario()

}



func TestRegistereddevicesByIdGET(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")



	iotPlatformInfo, err := create_registered_iot_platforms()

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}

	fmt.Println("iotPlatformInfo: ", iotPlatformInfo)



	/******************************

	 * expected response section

	 ******************************/

	expected_device, err := create_device(iotPlatformInfo)

	if err != nil {

		t.Fatalf("unexpected error: %v", err)

	}



	/******************************

	 * request vars section

	 ******************************/

	vars := make(map[string]string)

	vars["registeredDeviceId"] = expected_device.DeviceId



	/******************************

	 * request body section

	 ******************************/



	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodGet, "/registered_devices", nil, vars, nil, nil, http.StatusOK, RegistereddevicesByIdGET)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: rr: ", rr)

	var resp DeviceInfo

	err = json.Unmarshal([]byte(rr), &resp)

	if err != nil {

		t.Fatalf(err.Error())

	}

	fmt.Println("Respone: resp: ", resp)

	if !validate_device_info(resp, expected_device) {

		t.Errorf("Response mismatch")

	}



	fmt.Println("Received expected response")

	/******************************

	 * back to initial state section

	 ******************************/

	_ = delete_device(expected_device.DeviceId)

	_ = delete_registered_iot_platforms(iotPlatformInfo.IotPlatformId)

	terminateScenario()

}



func create_registered_iot_platforms() (resp IotPlatformInfo, err error) {

	var mb_transportInfo TransportType

	mb_transportInfo = MB_TOPIC_BASED

	var security = SecurityInfo{}
@@ -1191,7 +1532,7 @@ func createRegisterediotplatforms() (resp IotPlatformInfo, err error) { 
	}

	fmt.Println("body: ", string(body))



	rr, err := sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegisterediotplatformsPOST)

	rr, err := sendRequest(http.MethodPost, "/registered_iot_platforms", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegisterediotplatformsPOST)

	if err != nil {

		return resp, err

	}
@@ -1204,10 +1545,10 @@ func createRegisterediotplatforms() (resp IotPlatformInfo, err error) { 
	return resp, nil

}



func deleteRegisterediotplatforms(iotPlatformId string) (err error) {

func delete_registered_iot_platforms(iotPlatformId string) (err error) {

	vars := make(map[string]string)

	vars["registeredIotPlatformId"] = iotPlatformId

	_, err = sendRequest(http.MethodDelete, "/registered_devices", nil, vars, nil, nil, http.StatusNoContent, RegisterediotplatformsByIdDELETE)

	_, err = sendRequest(http.MethodDelete, "/registered_iot_platforms", nil, vars, nil, nil, http.StatusNoContent, RegisterediotplatformsByIdDELETE)

	if err != nil {

		return err

	}
@@ -1215,9 +1556,9 @@ func deleteRegisterediotplatforms(iotPlatformId string) (err error) { 
	return nil

}



func validateIotPlatformInfo(received IotPlatformInfo, expected IotPlatformInfo) bool {

	fmt.Println("validateIotPlatformInfo: received: ", received)

	fmt.Println("validateIotPlatformInfo: expected: ", expected)

func validate_iot_platform_info(received IotPlatformInfo, expected IotPlatformInfo) bool {

	fmt.Println("validate_iot_platform_info: received: ", received)

	fmt.Println("validate_iot_platform_info: expected: ", expected)



	if received.IotPlatformId != expected.IotPlatformId {

		fmt.Println("received.IotPlatformId != IotPlatformId")
@@ -1241,7 +1582,199 @@ func validateIotPlatformInfo(received IotPlatformInfo, expected IotPlatformInfo) 
		return false

	}



	fmt.Println("validateIotPlatformInfo: succeed")

	fmt.Println("validate_iot_platform_info: succeed")

	return true

}



func create_device(iotPlatformInfo IotPlatformInfo) (device DeviceInfo, err error) {

	requestedIotPlatformId := iotPlatformInfo.IotPlatformId

	deviceMetadata := make([]KeyValuePair, 2)

	deviceMetadata[0] = KeyValuePair{

		Key:   "Key1",

		Value: "Value1",

	}

	deviceMetadata[1] = KeyValuePair{

		Key:   "Key2",

		Value: "Value2",

	}

	device = DeviceInfo{

		DeviceMetadata:         deviceMetadata,

		RequestedIotPlatformId: requestedIotPlatformId,

		DeviceId:               requestedIotPlatformId,

		Imsi:                   "12345",

		Enabled:                true,

	}

	body, err := json.Marshal(device)

	if err != nil {

		return device, err

	}



	/******************************

	 * request execution section

	 ******************************/

	rr, err := sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegistereddevicesPOST)

	if err != nil {

		return device, err

	}

	fmt.Println("Respone: rr: ", rr)

	var resp DeviceInfo

	err = json.Unmarshal([]byte(rr), &resp)

	if err != nil {

		return device, err

	}



	return device, nil

}



func create_set_device(iotPlatformInfo IotPlatformInfo) (devices []DeviceInfo, err error) {

	requestedIotPlatformId := iotPlatformInfo.IotPlatformId

	deviceMetadata := make([]KeyValuePair, 2)

	deviceMetadata[0] = KeyValuePair{

		Key:   "Key1",

		Value: "Value1",

	}

	deviceMetadata[1] = KeyValuePair{

		Key:   "Key2",

		Value: "Value2",

	}

	devices = make([]DeviceInfo, 3)

	devices[0] = DeviceInfo{

		DeviceMetadata:         deviceMetadata,

		RequestedIotPlatformId: requestedIotPlatformId,

		DeviceId:               "0",

		Gpsi:                   "12345",

		Enabled:                true,

	}

	deviceMetadata[0].Key = "Key11"

	devices[1] = DeviceInfo{

		DeviceMetadata:         deviceMetadata,

		RequestedIotPlatformId: requestedIotPlatformId,

		DeviceId:               "1",

		Msisdn:                 "345",

		Enabled:                true,

	}

	deviceMetadata[0].Key = "Key12"

	devices[2] = DeviceInfo{

		DeviceMetadata:           deviceMetadata,

		RequestedIotPlatformId:   requestedIotPlatformId,

		DeviceId:                 "2",

		RequestedUserTransportId: "987",

		Imsi:                     "12345",

		Enabled:                  true,

	}



	/******************************

	 * request execution section

	 ******************************/

	resp_devices := devices // Same format

	for i, val := range devices {

		body, err := json.Marshal(val)

		if err != nil {

			return nil, err

		}

		rr, err := sendRequest(http.MethodPost, "/registered_devices", bytes.NewBuffer(body), nil, nil, nil, http.StatusCreated, RegistereddevicesPOST)

		if err != nil {

			return nil, err

		}

		fmt.Println("Respone: rr: ", rr)

		var resp DeviceInfo

		err = json.Unmarshal([]byte(rr), &resp)

		if err != nil {

			return nil, err

		}

		resp_devices[i] = resp

	} // End of 'for' statement



	return resp_devices, nil

}



func delete_device(deviceId string) (err error) {

	vars := make(map[string]string)

	vars["registeredDeviceId"] = deviceId

	_, err = sendRequest(http.MethodDelete, "/registered_devices", nil, vars, nil, nil, http.StatusNoContent, RegistereddevicesByIdDELETE)

	return err

}



func validate_device_info(expected_device DeviceInfo, received_deviceResp DeviceInfo) bool {

	if expected_device.DeviceId != received_deviceResp.DeviceId {

		fmt.Println("received_deviceResp.DeviceId != DeviceId")

		return false

	}

	if expected_device.Enabled != received_deviceResp.Enabled {

		fmt.Println("received_deviceResp.Enabled != Enabled")

		return false

	}

	if expected_device.DeviceAuthenticationInfo != received_deviceResp.DeviceAuthenticationInfo {

		fmt.Println("received_deviceResp.DeviceAuthenticationInfo != DeviceAuthenticationInfo")

		return false

	}

	if expected_device.Gpsi != received_deviceResp.Gpsi {

		fmt.Println("received_deviceResp.Gpsi != Gpsi")

		return false

	}

	if expected_device.Pei != received_deviceResp.Pei {

		fmt.Println("received_deviceResp.Pei != Pei")

		return false

	}

	if expected_device.Supi != received_deviceResp.Supi {

		fmt.Println("received_deviceResp.Supi != Supi")

		return false

	}

	if expected_device.Msisdn != received_deviceResp.Msisdn {

		fmt.Println("received_deviceResp.Msisdn != Msisdn")

		return false

	}

	if expected_device.Imei != received_deviceResp.Imei {

		fmt.Println("received_deviceResp.Imei != Imei")

		return false

	}

	if expected_device.Imsi != received_deviceResp.Imsi {

		fmt.Println("received_deviceResp.Imsi != Imsi")

		return false

	}

	if expected_device.Iccid != received_deviceResp.Iccid {

		fmt.Println("received_deviceResp.Iccid != Iccid")

		return false

	}

	if expected_device.RequestedIotPlatformId != received_deviceResp.RequestedIotPlatformId {

		fmt.Println("received_deviceResp.RequestedIotPlatformId != RequestedIotPlatformId")

		return false

	}

	if expected_device.RequestedUserTransportId != received_deviceResp.RequestedUserTransportId {

		fmt.Println("received_deviceResp.RequestedUserTransportId != RequestedUserTransportId")

		return false

	}

	if expected_device.ClientCertificate != received_deviceResp.ClientCertificate {

		fmt.Println("received_deviceResp.ClientCertificate != ClientCertificate")

		return false

	}

	if len(expected_device.DeviceMetadata) != len(received_deviceResp.DeviceMetadata) {

		fmt.Println("received_deviceResp.DeviceMetadata != DeviceMetadata")

		return false

	} else {

		for i, val := range expected_device.DeviceMetadata {

			if val.Key != received_deviceResp.DeviceMetadata[i].Key {

				fmt.Println("item #", i, ":received_deviceResp.DeviceMetadata.Key != DeviceMetadata.Key")

				return false

			}

			if val.Value != received_deviceResp.DeviceMetadata[i].Value {

				fmt.Println("item #", i, ":received_deviceResp.DeviceMetadata.Value != DeviceMetadata.Value")

				return false



			}

		} // End of 'for' statement

	}

	if len(expected_device.RequestedMecTrafficRule) != len(received_deviceResp.RequestedMecTrafficRule) {

		fmt.Println("received_deviceResp.RequestedMecTrafficRule != RequestedMecTrafficRule")

		return false

	} else {

		// for i, val := range expected_device.RequestedMecTrafficRule {

		// } // End of 'for' statement

		// TODO To be continued

		//RequestedMecTrafficRule  []TrafficRuleDescriptor

	}

	// TODO To be continued



	return true

}