diff options
author | Ofir Sonsino <os0695@intl.att.com> | 2018-08-12 12:20:55 +0000 |
---|---|---|
committer | Gerrit Code Review <gerrit@onap.org> | 2018-08-12 12:20:55 +0000 |
commit | 91b057331b92ecf7f3c2d495681b05295dc8346c (patch) | |
tree | 0ce3f821ada8ad518784f7f9869db4b537ba3237 /vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java | |
parent | 9152b2ae03c4751b492a219993d85d522c58b383 (diff) | |
parent | 4a4dcc5185f8ba5a28c7f9fef509f32c0c2389e6 (diff) |
Merge "vid-automation selenium tests"
Diffstat (limited to 'vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java')
-rw-r--r-- | vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java | 431 |
1 files changed, 431 insertions, 0 deletions
diff --git a/vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java b/vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java new file mode 100644 index 00000000..65b0253b --- /dev/null +++ b/vid-automation/src/test/java/org/opencomp/vid/api/OperationalEnvironmentControllerApiTest.java @@ -0,0 +1,431 @@ +package org.opencomp.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")); + } +} |