1 files changed, 431 insertions, 0 deletions
diff --git a/vid-automation/src/test/java/org/onap/vid/api/OperationalEnvironmentControllerApiTest.java b/vid-automation/src/test/java/org/onap/vid/api/OperationalEnvironmentControllerApiTest.java
new file mode 100644
index 000000000..222b0f5fb
--- /dev/null
+++ b/vid-automation/src/test/java/org/onap/vid/api/OperationalEnvironmentControllerApiTest.java
@@ -0,0 +1,431 @@
+package org.onap.vid.api;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import org.apache.commons.text.StringEscapeUtils;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpClientErrorException;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import vid.automation.test.services.SimulatorApi;
+import vid.automation.test.services.SimulatorApi.RegistrationStrategy;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.METHOD_NOT_ALLOWED;
+
+public class OperationalEnvironmentControllerApiTest extends BaseMsoApiTest {
+    private static final String UUID = "927befca-e32c-4f7d-be8d-b4107e0ac31e";
+    public static final String GET_STATUS_REQUEST_UUID = "3212b08c-0dcd-4d20-8c84-51e4f325c14a";
+    private static final String BASIC_DEACTIVATE_REQUEST_BODY = "{}";
+    private static final String BASIC_ACTIVATE_REQUEST_BODY = getResourceAsString("operationalEnvironmentController/activateOperationalEnvironment.json");
+    private static final String BASIC_CREATE_REQUEST_BODY = getResourceAsString("operationalEnvironmentController/createOperationalEnvironment.json");
+    private final String MSO_OK_RESPONSE_FOR_DEACTIVATE = "mso_ok_response_for_deactivate.json";
+    public static final String GET_CLOUD_RESOURCES_REQUEST_STATUS = "get_cloud_resources_request_status.json";
+    private final String MSO_ERROR_RESPONSE_FOR_DEACTIVATE = "mso_error_response_for_deactivate.json";
+    private final String MSO_ERROR_RESPONSE_FOR_STATUS = "mso_error_response_for_status.json";
+    private final String MSO_OK_RESPONSE_FOR_POST_OPERATIONAL_ENVIRONMENT = "mso_ok_response_for_post_operational_environmnet.json";
+    private final String MSO_ERROR_RESPONSE_FOR_POST_OPERATIONAL_ENVIRONMENT = "mso_error_response_for_post_operational_environmnet.json";
+    private final String missingParamErrorText = "Required String parameter 'operationalEnvironment' is not present";
+
+    /*
+    # DEACTIVATION
+
+    ## Tests
+    [x]  -  Try all methods: only POST is working
+    [x]  -  Send wrong requests; all are responded with 400 and nice description
+    [x]      -  missing param
+    [x]      -  missing body
+    [x]      -  operationalEnvironment value is empty
+         -  Simulate MSO responses (status and body); verify all are propagated inside a VID's 200 OK
+    [x]      -  [ 200, 202, 400, 404, 500 ]
+
+         -  Positive cases
+    [x]      - Request body is just '{}'
+    [x]      - Request body is with some fields
+    [x]      - URI with more query params
+
+    ### Always verify
+    [x]  -  Payload to MSO is the valid schema and values
+    [ ]  -  RequestorId is ok
+
+     */
+
+    @Override
+    @BeforeClass
+    public void login() {
+        super.login();
+    }
+
+
+    @Test(dataProvider = "wrongHttpMethodsForAllUris")
+    public void tryAllWrongMethods(HttpMethod httpMethod, String uri) throws IOException {
+        try {
+            ResponseEntity<String> responseEntity = restTemplate.exchange(uri, httpMethod, new HttpEntity<ImmutableMap>(ImmutableMap.of()), String.class);
+            assertThat("Response should be method not allowed => " + responseEntity, responseEntity.getBody(), containsString("Request method '" + httpMethod + "' not supported"));
+        } catch (HttpClientErrorException e) {
+            assertThat("Response should be method not allowed (by error code)", e.getStatusCode(), is(METHOD_NOT_ALLOWED));
+        }
+
+    }
+
+
+    @Test
+    public void activateWithAdditionalQueryParam() throws IOException {
+        doWithFineRequest(BASIC_ACTIVATE_REQUEST_BODY, getActivationTargetUri(ACTIVATION_URI_UUID_MODE.EXTENDED), "/activate\"");
+    }
+
+    @Test(expectedExceptions = { HttpClientErrorException.class })
+    public void activateWithMissingOperationalEnvironmentParam() throws IOException {
+        doWithBadRequest(BASIC_ACTIVATE_REQUEST_BODY, missingParamErrorText, getActivationTargetUri(ACTIVATION_URI_UUID_MODE.MISSING));
+    }
+
+    @Test(expectedExceptions = { HttpClientErrorException.class })
+    public void activateWithNoValueForOperationalEnvironmentParam() throws IOException {
+        doWithBadRequest(BASIC_ACTIVATE_REQUEST_BODY, missingParamErrorText, getActivationTargetUri(ACTIVATION_URI_UUID_MODE.NO_VALUE));
+    }
+
+    @Test
+    public void deactivateWithAdditionalQueryParam() throws IOException {
+        doWithFineRequest(BASIC_DEACTIVATE_REQUEST_BODY, getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.EXTENDED), "/deactivate\"");
+    }
+
+    @Test(expectedExceptions = { HttpClientErrorException.class })
+    public void deactivateWithMissingOperationalEnvironmentParam() throws IOException {
+        doWithBadRequest(BASIC_DEACTIVATE_REQUEST_BODY, missingParamErrorText, getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.MISSING));
+    }
+
+    @Test(expectedExceptions = { HttpClientErrorException.class })
+    public void deactivateWithNoValueForOperationalEnvironmentParam() throws IOException {
+        doWithBadRequest(BASIC_DEACTIVATE_REQUEST_BODY, missingParamErrorText, getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.NO_VALUE));
+    }
+
+    @Test(dataProvider = "requestPayloads")
+    public void activateWithBody(String requestBody) throws IOException {
+        doWithFineRequest(requestBody, getActivationTargetUri(ACTIVATION_URI_UUID_MODE.OK), "/activate\"");
+    }
+
+    @Test(dataProvider = "requestPayloads")
+    public void deactivateWithBody(String requestBody) throws IOException {
+        doWithFineRequest(requestBody, getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.OK), "/deactivate\"");
+    }
+
+
+    private void doWithFineRequest(String requestBody, String targetUri, String v1) throws IOException {
+        final String expectedResult = "" +
+                "{" +
+                "  \"requestReferences\": {" +
+                "     \"requestId\": \"dbe54591-c8ed-46d3-abc7-d3a24873dfbd\"," +
+                "     \"instanceId\": \"" + UUID + "\"" +
+                "  }" +
+                "}";
+        callMsoWithFineRequest(MSO_OK_RESPONSE_FOR_DEACTIVATE, ImmutableMap.of(
+                    "/deactivate\"", v1,
+                    "UUID", UUID)
+                ,targetUri,requestBody,HttpStatus.ACCEPTED.value(),expectedResult, HttpMethod.POST);
+       }
+
+    @Test(dataProvider = "errorCodes")
+    public void deactivateWithErrorResponse(int errorCode) throws IOException {
+        doWithSimulatedErrorResponse(errorCode, getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.OK), BASIC_DEACTIVATE_REQUEST_BODY, "/deactivate\"", MSO_ERROR_RESPONSE_FOR_DEACTIVATE, HttpMethod.POST);
+    }
+
+    @Test(dataProvider = "errorCodes")
+    public void activateWithErrorResponse(int errorCode) throws IOException {
+        doWithSimulatedErrorResponse(errorCode, getActivationTargetUri(ACTIVATION_URI_UUID_MODE.OK), BASIC_ACTIVATE_REQUEST_BODY, "/activate\"", MSO_ERROR_RESPONSE_FOR_DEACTIVATE, HttpMethod.POST);
+    }
+
+    @Test(dataProvider = "errorCodes")
+    public void testStatusWithErrorResponse(int errorCode) throws IOException {
+        doWithSimulatedErrorResponse(errorCode, getStatusTargetUri(STATUS_URI_UUID_MODE.OK), "", "", MSO_ERROR_RESPONSE_FOR_STATUS, HttpMethod.GET);
+    }
+
+    private void doWithSimulatedErrorResponse(int errorCode, String targetUri, String basicRequestBody, String msoPathSuffix, String expectationTemplateFilename, HttpMethod method) throws IOException {
+        final String expectedResult = "" +
+                "<head>Huston, you have a problem<head>";
+        callMsoWithSimulatedErrorResponse(expectationTemplateFilename, ImmutableMap.of(
+                    "/deactivate\"", msoPathSuffix,
+                    "UUID", UUID,
+                    "500", errorCode,
+                    "ERROR_PAYLOAD", StringEscapeUtils.escapeJson(expectedResult)
+                    ),targetUri,basicRequestBody,errorCode, expectedResult, method);
+    }
+
+    @Test(
+            dataProvider = "requestPayloads",
+            expectedExceptions = { HttpClientErrorException.class }
+    )
+    public void activateWithBadRequest(String requestBody) throws IOException {
+        doWithBadRequest(requestBody, "HttpMessageNotReadableException", getActivationTargetUri(ACTIVATION_URI_UUID_MODE.OK));
+    }
+
+    @Test(
+            dataProvider = "activateBadHalfBakedPayloads",
+            expectedExceptions = { HttpClientErrorException.class }
+    )
+    public void activateWithBadHalfBakedPayload(String requestBody) throws IOException {
+        doWithBadRequest(requestBody, "HttpMessageNotReadableException", getActivationTargetUri(ACTIVATION_URI_UUID_MODE.OK));
+    }
+
+    @Test(
+            dataProvider = "requestPayloads",
+            expectedExceptions = { HttpClientErrorException.class }
+    )
+    public void deactivateWithBadRequest(String requestBody) throws IOException {
+        doWithBadRequest(requestBody, "HttpMessageNotReadableException", getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.OK));
+    }
+
+    private void doWithBadRequest(String requestBody, String httpMessageNotReadableException, String targetUri) throws IOException {
+        SimulatorApi.registerExpectation(MSO_OK_RESPONSE_FOR_DEACTIVATE, ImmutableMap.of("UUID", UUID), RegistrationStrategy.CLEAR_THEN_SET);
+
+        try {
+            ResponseEntity<String> responseEntity = restTemplate.postForEntity(targetUri, requestBody, String.class);
+        } catch (HttpClientErrorException e) {
+            assertThat("Response should be Bad Request (by error code)", e.getStatusCode(), is(BAD_REQUEST));
+            assertThat("Response should be Bad Request (by body)", e.getResponseBodyAsString(), containsString(httpMessageNotReadableException));
+            throw e;
+        }
+
+    }
+
+
+    @DataProvider
+    public Object[][] wrongHttpMethodsForAllUris() {
+        ImmutableList<String> uris = ImmutableList.of(
+                getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE.OK),
+                getActivationTargetUri(ACTIVATION_URI_UUID_MODE.OK)
+        );
+        
+        return Arrays.stream(HttpMethod.values())
+                .filter(Streams.not(ImmutableList.of(
+                        HttpMethod.POST,    // because POST *should* work
+                        HttpMethod.PATCH,   // because PATCH is invalid method for Java.net
+                        HttpMethod.OPTIONS, // because OPTIONS is somehow valid...  :-(  => Allow=[GET, HEAD, POST, PUT, DELETE, OPTIONS, PATCH]
+                        HttpMethod.HEAD     // because HEAD is like POST/GET but without body, so error is hidden
+                )::contains))
+                .flatMap(httpMethod -> uris.stream()
+                        .map(uri -> new Object[]{ httpMethod, uri})  // pair given method for each of the URIs
+                ) 
+                .collect(Collectors.toList())
+                .toArray(new Object[][] {});
+    }
+
+    @DataProvider
+    public static Object[][] requestPayloads(Method test) {
+        switch (test.getName()) {
+            case "deactivateWithBody":
+                return new Object[][]{
+                        {BASIC_DEACTIVATE_REQUEST_BODY}
+                        , {"{ \"a\": \"b\" }"}
+                        , {"{ \"a\": [ 55 ] }"}
+                };
+            case "activateWithBody":
+                return new Object[][]{
+                        {BASIC_ACTIVATE_REQUEST_BODY}
+                };
+            default: // bad payloads
+                return new Object[][]{
+                        {null}
+                        , {""}
+                        , {"{"}
+                        , {"foo"}
+                };
+        }
+    }
+
+    @DataProvider
+    public static Object[][] activateBadHalfBakedPayloads(Method test) {
+        final ImmutableList<String> strings = ImmutableList.of(
+                "\"relatedInstanceId\": \"1117887f-068f-46d7-9e43-9b73bef17af8\"",
+                "\"relatedInstanceName\": \"managing ECOMP Operational Environment\"",
+                "\"workloadContext\": \"VNF_E2E-IST\"",
+                "\"manifest\": {" +
+                        "  \"serviceModelList\": [" +
+                        "    {" +
+                        "      \"serviceModelVersionId\": \"uuid2\"," +
+                        "      \"recoveryAction\": \"retry\"" +
+                        "    }" +
+                        "  ]" +
+                        "}"
+        );
+
+        final LinkedList<String> tests = new LinkedList<>();
+        for (int i = 0; i < strings.size(); i++) {
+            final ArrayList<String> aCase = new ArrayList<>(strings);
+            aCase.remove(i);
+            tests.add("{" + String.join(", ", aCase) + "}");
+        }
+
+        return tests.stream().map(o -> new Object[] { o }).collect(Collectors.toList()).toArray(new Object[][]{});
+    }
+
+    @DataProvider
+    public static Object[][] errorCodes(Method test) {
+        return new Object[][]{
+                {500}, {505}, {400}, {401}, {405}
+        };
+    }
+
+    @DataProvider
+    public static Object[][] statusLegitUri(Method test) {
+        return new Object[][]{
+                {STATUS_URI_UUID_MODE.OK}, {STATUS_URI_UUID_MODE.EXTENDED}
+        };
+    }
+
+    @DataProvider
+    public static Object[][] statusNotLegitUri(Method test) {
+        return new Object[][]{
+                {STATUS_URI_UUID_MODE.MISSING}, {STATUS_URI_UUID_MODE.NO_VALUE}
+        };
+    }
+
+    private enum ACTIVATION_URI_UUID_MODE {
+        MISSING(""),
+        NO_VALUE("?operationalEnvironment="),
+        OK(NO_VALUE.val + UUID),
+        EXTENDED(OK.val + "&anotherParam=6");
+
+        final String val;
+
+        ACTIVATION_URI_UUID_MODE(String val) {
+            this.val = val;
+        }
+    }
+
+    private enum STATUS_URI_UUID_MODE {
+        MISSING(""),
+        NO_VALUE("?requestId="),
+        OK(NO_VALUE.val + GET_STATUS_REQUEST_UUID),
+        EXTENDED(OK.val + "&anotherParam=6");
+
+        final String val;
+
+        STATUS_URI_UUID_MODE(String val) {
+            this.val = val;
+        }
+    }
+
+    private String getDeactivationTargetUri(ACTIVATION_URI_UUID_MODE uriUuidMode) {
+        return uri.toASCIIString() + "/operationalEnvironment/deactivate" + uriUuidMode.val;
+    }
+
+    private String getActivationTargetUri(ACTIVATION_URI_UUID_MODE uriUuidMode) {
+        return uri.toASCIIString() + "/operationalEnvironment/activate" + uriUuidMode.val;
+    }
+
+    private String getStatusTargetUri(STATUS_URI_UUID_MODE uriUuidMode) {
+        return uri.toASCIIString() + "/operationalEnvironment/requestStatus" + uriUuidMode.val;
+    }
+
+    private String getCreateOperationEnvironmentUri() {
+        return uri.toASCIIString() + "/operationalEnvironment/create";
+    }
+
+    @Test
+    public void createWithSimplestBody()throws IOException {
+
+        final String expectedResult = "" +
+                "{" +
+                "  \"requestReferences\": {" +
+                "     \"requestId\": \"dbe54591-c8ed-46d3-abc7-d3a24873dfbd\","+
+                "     \"instanceId\": \"" + UUID + "\"" +
+                "  }" +
+                "}";
+        callMsoWithFineRequest(MSO_OK_RESPONSE_FOR_POST_OPERATIONAL_ENVIRONMENT, ImmutableMap.of(
+                "UUID", UUID), getCreateOperationEnvironmentUri(), BASIC_CREATE_REQUEST_BODY, HttpStatus.ACCEPTED.value(), expectedResult, HttpMethod.POST);
+   }
+
+    @Test(dataProvider = "errorCodes")
+    public void createWithErrorResponse(int errorCode) throws IOException {
+        final String expectedResult = "" +
+                "<head>Huston, you have a problem<head>";
+        callMsoWithSimulatedErrorResponse(MSO_ERROR_RESPONSE_FOR_POST_OPERATIONAL_ENVIRONMENT,ImmutableMap.of(
+                "500", errorCode,
+                "ERROR_PAYLOAD", StringEscapeUtils.escapeJson(expectedResult)
+        ),  getCreateOperationEnvironmentUri(), BASIC_CREATE_REQUEST_BODY, errorCode,expectedResult, HttpMethod.POST);
+    }
+
+
+
+
+    @Test(dataProvider = "statusLegitUri")
+    public void testStatusWithLegitUri(STATUS_URI_UUID_MODE statusUriMode) throws IOException {
+
+        String uri = getStatusTargetUri(statusUriMode);
+
+        final String expectedResult = "" +
+                "{" +
+                "  \"request\": {" +
+                "    \"requestId\": \"3212b08c-0dcd-4d20-8c84-51e4f325c14a\"," +
+                "    \"startTime\": \"Thu, 02 Jun 2017 02:51:59 GMT\"," +
+                "    \"instanceReferences\": {" +
+                "      \"operationalEnvironmentInstanceId\": \"bc305d54-75b4-431b-adb2-eb6b9e546014\"" +
+                "    }," +
+                "    \"requestScope\": \"operationalEnvironment\"," +
+                "    \"requestType\": \"deactivate\"," +
+                "    \"requestDetails\": {" +
+                "      \"requestInfo\": {" +
+                "        \"resourceType\": \"operationalEnvironment\"," +
+                "        \"source\": \"VID\"," +
+                "        \"requestorId\": \"az2017\"" +
+                "      }," +
+                "      \"requestParameters\": {" +
+                "        \"operationalEnvironmentType\": \"VNF\"" +
+                "      }" +
+                "    }," +
+                "    \"requestStatus\": {" +
+                "      \"timestamp\": \"Thu, 02 Jun 2017 02:53:39 GMT\"," +
+                "      \"requestState\": \"COMPLETE\"," +
+                "      \"statusMessage\": \"Operational Environment successfully deactivated\"," +
+                "      \"percentProgress\": \"100\"" +
+                "    }" +
+                "  }" +
+                "}";
+
+        callMsoWithFineRequest(GET_CLOUD_RESOURCES_REQUEST_STATUS, ImmutableMap.of()
+                ,uri,"",HttpStatus.OK.value(),expectedResult, HttpMethod.GET);
+
+    }
+
+    @Test(
+            expectedExceptions = {HttpClientErrorException.class},
+            dataProvider = "statusNotLegitUri"
+    )
+    public void testStatusWithBadRequest(STATUS_URI_UUID_MODE statusUriMode) throws IOException {
+        SimulatorApi.registerExpectation(GET_CLOUD_RESOURCES_REQUEST_STATUS, RegistrationStrategy.CLEAR_THEN_SET);
+
+        String uri = getStatusTargetUri(statusUriMode);
+
+        try {
+            ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
+        } catch (HttpClientErrorException e) {
+            assertThat("Response should be Bad Request (by error code)", e.getStatusCode(), is(BAD_REQUEST));
+            assertThat("Response should be Bad Request (by body)", e.getResponseBodyAsString(), containsString("'requestId' is not present"));
+            throw e;
+        }
+    }
+
+    @Test
+    public void testStatusWithWrongMethodPost() throws IOException {
+        SimulatorApi.registerExpectation(GET_CLOUD_RESOURCES_REQUEST_STATUS, RegistrationStrategy.CLEAR_THEN_SET);
+
+        String myUri = getStatusTargetUri(STATUS_URI_UUID_MODE.OK);
+
+        String response = restTemplate.postForObject(myUri, "", String.class);
+        assertThat("Response should be method not allowed => " + response, response, containsString("Request method '" + HttpMethod.POST + "' not supported"));
+    }
+}