From 5fd768b457c0ec2eaf75963681fe7fcd1e69ae4e Mon Sep 17 00:00:00 2001 From: Bartosz Gardziejewski Date: Thu, 3 Sep 2020 15:01:42 +0200 Subject: Add list of errors in responce for GET request. Signed-off-by: Bartosz Gardziejewski Issue-ID: VNFSDK-594 Change-Id: I61fd4b5e514ca4185174027ff08d8908a968e404 --- .../onap/vtp/execution/VTPExecutionResource.java | 13 +- .../vtp/execution/VTPExecutionResultsSupplier.java | 85 +++++++ .../org/onap/vtp/VTPExecutionResourceTest.java | 276 ++++++++++++++++++--- .../execution/VTPExecutionResultsSupplierTest.java | 88 +++++++ .../test-01-request-id-execution-id-data/output | 6 + .../output | 1 + 6 files changed, 439 insertions(+), 30 deletions(-) create mode 100644 vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResultsSupplier.java create mode 100644 vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/execution/VTPExecutionResultsSupplierTest.java create mode 100644 vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-01-request-id-execution-id-data/output create mode 100644 vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-incorrect-request-id-execution-id-data/output diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResource.java b/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResource.java index 3bd522ff..2b06fe8f 100644 --- a/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResource.java +++ b/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResource.java @@ -1,5 +1,6 @@ /** * Copyright 2018 Huawei Technologies Co., Ltd. + * Copyright 2020 Nokia. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -87,8 +88,9 @@ public class VTPExecutionResource extends VTPResource{ private static final String PRODUCT_ARG="--product"; private static final String OPEN_CLI="open-cli"; private static final String FORMAT="--format"; + private static final Gson gson = new Gson(); - private static Gson gson = new Gson(); + protected static String pathToExecutions = "/opt/vtp/data/executions/"; public VTPTestExecutionList executeHandler(VTPTestExecutionList executions, String requestId) throws VTPException { if (requestId == null) { @@ -295,8 +297,13 @@ public class VTPExecutionResource extends VTPResource{ if (n.get(END_TIME) != null) exec.setEndTime(n.get(END_TIME).getAsString()); - if (n.get(EXECUTION_ID) != null) + if (n.get(EXECUTION_ID) != null) { exec.setExecutionId(n.get(EXECUTION_ID).getAsString()); + exec.setResults( + new VTPExecutionResultsSupplier(pathToExecutions) + .getExecutionOutputsFromFile(exec.getExecutionId()) + ); + } if (n.get(REQUEST_ID) != null) exec.setRequestId(n.get(REQUEST_ID).getAsString()); @@ -316,6 +323,7 @@ public class VTPExecutionResource extends VTPResource{ if (n.get(STATUS) != null) exec.setStatus(n.get(STATUS).getAsString()); + list.getExecutions().add(exec); } @@ -325,6 +333,7 @@ public class VTPExecutionResource extends VTPResource{ return list; } + @Path("/executions") @GET @ApiOperation(tags = "VTP Execution", value = " List test executions", response = VTPTestExecution.class, responseContainer = "List") diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResultsSupplier.java b/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResultsSupplier.java new file mode 100644 index 00000000..3f1e4c57 --- /dev/null +++ b/vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vtp/execution/VTPExecutionResultsSupplier.java @@ -0,0 +1,85 @@ +/** + * Copyright 2020 Nokia. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vtp.execution; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonParseException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Optional; + +public class VTPExecutionResultsSupplier { + + public static final Logger logger = LoggerFactory.getLogger(VTPExecutionResultsSupplier.class); + + private static final String SUB_PATH_TO_EXECUTION_OUTPUT = "/output"; + private static final Gson gson = new Gson(); + + protected String pathToExecutions; + + VTPExecutionResultsSupplier(String pathToExecutions) { + this.pathToExecutions = pathToExecutions; + } + + public JsonElement getExecutionOutputsFromFile(String executionId) { + File directoryWithExecutionFiles = new File(pathToExecutions); + return getExecutionFilesForGivenRequest(executionId, directoryWithExecutionFiles) + .map(this::getOutputOfLatestExecutionFile) + .orElse(createNoOutputFileErrorMessageInJsonFormat()); + } + + private Optional getExecutionFilesForGivenRequest(String requestId, File directoryWithExecutionsData) { + return Optional.ofNullable( + directoryWithExecutionsData.listFiles((dir, name) -> name.startsWith(requestId)) + ); + } + + private JsonElement getOutputOfLatestExecutionFile(File[] directoriesWithExecutionsData) { + return Arrays.stream(directoriesWithExecutionsData) + .max(Comparator.comparing(File::lastModified)) + .map(file -> new File(file.getAbsolutePath() + SUB_PATH_TO_EXECUTION_OUTPUT)) + .filter(File::exists) + .map(this::loadOutputJsonFromFile) + .orElse(createNoOutputFileErrorMessageInJsonFormat()); + } + + private JsonArray loadOutputJsonFromFile(File file) { + JsonArray outputJson; + try { + String executionResult = Files.readString(file.toPath()); + outputJson = gson.fromJson(executionResult, JsonArray.class); + } catch (IOException | JsonParseException e) { + logger.error(e.getMessage(),e); + String errorMessage = "" + + "[{ \"error\": \"fail to load execution result\",\"reason\":\"" + e.getMessage() + "\"}]"; + outputJson = gson.fromJson(errorMessage, JsonArray.class); + } + return outputJson; + } + + private JsonArray createNoOutputFileErrorMessageInJsonFormat() { + return gson.fromJson("[{ \"error\": \"unable to find execution results\"}]", JsonArray.class); + } +} diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/VTPExecutionResourceTest.java b/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/VTPExecutionResourceTest.java index c1a28303..1a3200ab 100644 --- a/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/VTPExecutionResourceTest.java +++ b/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/VTPExecutionResourceTest.java @@ -1,5 +1,6 @@ /** * Copyright 2019 Huawei Technologies Co., Ltd. + * Copyright 2020 Nokia. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,37 +16,66 @@ */ package org.onap.vtp; +import com.google.common.collect.Lists; +import com.google.gson.Gson; +import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonParser; import org.glassfish.jersey.media.multipart.ContentDisposition; import org.glassfish.jersey.media.multipart.FormDataBodyPart; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; +import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; +import org.onap.vtp.error.VTPError; import org.onap.vtp.execution.VTPExecutionResource; import org.onap.vtp.execution.model.VTPTestExecution; -import org.open.infc.grpc.Result; import java.io.IOException; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; @RunWith(MockitoJUnitRunner.class) public class VTPExecutionResourceTest { + static class VTPExecutionResourceForTests extends VTPExecutionResource { + public JsonElement expectedRpcResponse = null; + public List expectedArguments = null; + + VTPExecutionResourceForTests() { + VTPExecutionResource.pathToExecutions = "src/test/resources/executions"; + } + + @Override + protected JsonElement makeRpcAndGetJson(List args, int timeout) throws VTPError.VTPException { + if(expectedRpcResponse != null && expectedArguments != null) { + if (args.containsAll(expectedArguments)) { + return expectedRpcResponse; + } else { + return null; + } + } else { + return super.makeRpcAndGetJson( args, timeout); + } + } + } + @Mock FormDataBodyPart formDataBodyPart; @Mock ContentDisposition contentDisposition; String requestId; - VTPExecutionResource vtpExecutionResource; + VTPExecutionResourceForTests vtpExecutionResource; @Before - public void setUp() throws Exception { - vtpExecutionResource= new VTPExecutionResource(); + public void setUp() { + vtpExecutionResource= new VTPExecutionResourceForTests(); requestId = UUID.randomUUID().toString(); } @Test(expected = Exception.class) @@ -74,31 +104,221 @@ public class VTPExecutionResourceTest { System.out.println(executions.getExecutions()); assertNotNull(executions.getExecutions()); vtpExecutionResource.executeHandler(executions,null); - //vtpExecutionResource.executeHandler(executions,requestId); - //for handler } - @Test(expected = Exception.class) - public void testListTestExecutionsHandler() throws Exception - { - vtpExecutionResource.listTestExecutionsHandler(requestId,"VTP Scenario 1","testsuite-1","s1.ts1.testcase-1","open-cli-schema","2019-03-12T11:49:52.845","2020-03-12T11:49:52.845"); - } -// -// @Test -// public void testListTestExecutionsHandler1() throws Exception -// { VTPExecutionResource vtpExecutionResource1=mock(VTPExecutionResource.class); -// List list= new ArrayList<>(); -// list.add("abc"); -// Result result= Result.getDefaultInstance(); -// -// when(vtpExecutionResource1.makeRpc(list)).thenReturn(result); -// verify(vtpExecutionResource1).makeRpc(list); -// -// } + + @Test + public void whenListTestExecutionsHandlerIsCalledWithProperParametersThenCorrectExecutionDataIsReturned() + throws IOException, VTPError.VTPException { + // given + String testStartTime = "2019-03-12T11:49:52.845"; + String testEndTime = "2020-03-12T11:49:52.845"; + String testProduct = "VTP Scenario 1"; + String testCommand = "s1.ts1.testcase-1"; + String testSuiteName = "testsuite-1"; + String testRequestId = "test-01-request-id"; + String testExecutionId = testRequestId + "-execution-id"; + String testProfile = "open-cli-schema"; + String expectedStatus = "SUCCESS"; + JsonElement expectedResult = new Gson().fromJson("" + + "[{" + + "\"test_1\": \"error01\"," + + "\"test_2\": \"error02\" " + + "}]", JsonArray.class); + + prepareMockRpcMethods( + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus + ); + + // when + VTPTestExecution.VTPTestExecutionList testExecutionResponse = + vtpExecutionResource.listTestExecutionsHandler( + testRequestId, testProduct, testSuiteName, testCommand, testProfile, testStartTime, testEndTime + ); + + // then + assertThatListOfExecutionsContainsOneCorrectExecutionResponse( + testExecutionResponse, + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus, expectedResult + ); + } + + @Test + public void whenListTestExecutionsHandlerIsCalledWithIdThatDoesNotMatchAnyExecutionFileThenResultContainsProperInformation() + throws IOException, VTPError.VTPException { + // given + String testStartTime = "2020-08-09T08:49:52.845"; + String testEndTime = "2020-08-10T08:49:55.845"; + String testProduct = "VTP Scenario 2"; + String testCommand = "s1.ts1.testcase-2"; + String testSuiteName = "testsuite-2"; + String testRequestId = "test-02-request-id"; + String testExecutionId = testRequestId + "-execution-id"; + String testProfile = "open-cli-schema"; + String expectedStatus = "FAIL"; + JsonElement expectedResult = new Gson().fromJson("" + + "[{ \"error\": \"unable to find execution results\"}]", JsonArray.class); + + prepareMockRpcMethods( + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus + ); + + // when + VTPTestExecution.VTPTestExecutionList testExecutionResponse = + vtpExecutionResource.listTestExecutionsHandler( + testRequestId, testProduct, testSuiteName, testCommand, testProfile, testStartTime, testEndTime + ); + + // then + assertThatListOfExecutionsContainsOneCorrectExecutionResponse( + testExecutionResponse, + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus, expectedResult + ); + } + + @Test + public void whenListTestExecutionsHandlerIsCalledWithIdThatMatchIncorrectExecutionFileThenResultContainsProperInformation() + throws IOException, VTPError.VTPException { + // given + String testStartTime = "2020-08-09T08:49:52.845"; + String testEndTime = "2020-08-10T08:49:55.845"; + String testProduct = "VTP Scenario 3"; + String testCommand = "s1.ts1.testcase-3"; + String testSuiteName = "testsuite-3"; + String testRequestId = "test-incorrect-request-id"; + String testExecutionId = testRequestId + "-execution-id"; + String testProfile = "open-cli-schema"; + String expectedStatus = "FAIL"; + JsonElement expectedResult = new Gson().fromJson("" + + "[{ " + + "\"error\": \"fail to load execution result\"," + + "\"reason\":\"Expected a com.google.gson.JsonArray but was com.google.gson.JsonPrimitive\"" + + "}]", + JsonArray.class + ); + + prepareMockRpcMethods( + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus + ); + + // when + VTPTestExecution.VTPTestExecutionList testExecutionResponse = + vtpExecutionResource.listTestExecutionsHandler( + testRequestId, testProduct, testSuiteName, testCommand, testProfile, testStartTime, testEndTime + ); + + // then + assertThatListOfExecutionsContainsOneCorrectExecutionResponse( + testExecutionResponse, + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus, expectedResult + ); + } + + @Rule + public ExpectedException exceptionRule = ExpectedException.none(); + + @Test + public void whenListTestExecutionsHandlerIsCalledAndGRpcClientIsUnReachableThenExceptionShouldBeThrown() + throws IOException, VTPError.VTPException { + // given + String testStartTime = "2020-08-10T08:50:20.845"; + String testEndTime = "2020-08-11T08:51:50.845"; + String testProduct = "VTP Scenario 3"; + String testCommand = "s1.ts1.testcase-3"; + String testSuiteName = "testsuite-3"; + String testRequestId = "test-03-request-id"; + String testProfile = "open-cli-schema"; + + // when + exceptionRule.expect(VTPError.VTPException.class); + exceptionRule.expectMessage("Timed out. Please use request-id to track the progress."); + vtpExecutionResource.listTestExecutionsHandler( + testRequestId, testProduct, testSuiteName, testCommand, testProfile, testStartTime, testEndTime + ); + + } + + private void assertThatListOfExecutionsContainsOneCorrectExecutionResponse( + VTPTestExecution.VTPTestExecutionList testExecutionResponse, + String testStartTime, String testEndTime, String testProduct, String testCommand, + String testSuiteName, String testRequestId, String testExecutionId, String testProfile, + String expectedStatus, JsonElement expectedResult ) { + + assertNotNull(testExecutionResponse); + assertEquals(1, testExecutionResponse.getExecutions().size()); + VTPTestExecution vtpTestExecution = testExecutionResponse.getExecutions().get(0); + assertFieldsInExecutionResponseAreCorrect( + vtpTestExecution, + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, + testRequestId, testExecutionId, testProfile, expectedStatus, expectedResult + ); + } + + private void prepareMockRpcMethods(String testStartTime, String testEndTime, String testProduct, String testCommand, String testSuiteName, String testRequestId, String testExecutionId, String testProfile, String expectedStatus) { + vtpExecutionResource.expectedArguments = + buildListOfMockRpcArguments( + testStartTime, testEndTime, testProduct, testCommand, testRequestId, testSuiteName + ); + vtpExecutionResource.expectedRpcResponse = + buildExpectedRpcResponse( + testStartTime, testEndTime, testProduct, testCommand, testSuiteName, testRequestId, + testExecutionId, testProfile, expectedStatus + ); + } + + private JsonArray buildExpectedRpcResponse( + String testStartTime, String testEndTime, String testProduct, + String testCommand, String testSuiteName, String testRequestId, + String testExecutionId, String testProfile, String expectedStatus) { + return new Gson().fromJson("[{" + + "\"start-time\":\"" + testStartTime + "\";" + + "\"end-time\":\"" + testEndTime + "\";" + + "\"product\":\"" + testProduct + "\";" + + "\"command\":\"" + testCommand + "\";" + + "\"service\":\"" + testSuiteName + "\";" + + "\"request-id\":\"" + testRequestId + "\";" + + "\"execution-id\":\"" + testExecutionId + "\";" + + "\"profile\":\"" + testProfile + "\";" + + "\"status\":\"" + expectedStatus + "\"" + + "}]", JsonArray.class); + } + + private List buildListOfMockRpcArguments( + String testStartTime, String testEndTime, String testProduct, + String testCommand, String testRequestId, String testSuiteName) { + return Lists.newArrayList( + "--product", "open-cli", "execution-list", "--format", "json", + "--start-time", testStartTime, "--end-time", testEndTime, + "--service", testSuiteName, "--product", testProduct, + "--command", testCommand, "--request-id", testRequestId); + } + + private void assertFieldsInExecutionResponseAreCorrect( + VTPTestExecution vtpTestExecution, + String testStartTime, String testEndTime, String testProduct, + String testCommand, String testSuiteName, String testRequestId, + String testExecutionId, String testProfile, String expectedStatus, JsonElement expectedResult) { + assertEquals(testStartTime, vtpTestExecution.getStartTime()); + assertEquals(testEndTime, vtpTestExecution.getEndTime()); + assertEquals(testProduct, vtpTestExecution.getScenario()); + assertEquals(testCommand, vtpTestExecution.getTestCaseName()); + assertEquals(testSuiteName, vtpTestExecution.getTestSuiteName()); + assertEquals(testExecutionId, vtpTestExecution.getExecutionId()); + assertEquals(testRequestId, vtpTestExecution.getRequestId()); + assertEquals(testProfile, vtpTestExecution.getProfile()); + assertEquals(expectedStatus, vtpTestExecution.getStatus()); + assertEquals(expectedResult, vtpTestExecution.getResults()); + } @Test(expected = Exception.class) public void testListTestExecutions() throws Exception { - vtpExecutionResource.listTestExecutions(requestId,"abc","abc","abc","abc","123","123"); + vtpExecutionResource.listTestExecutions(requestId, "abc", "abc", "abc", "abc", "123", "123"); } @Test(expected = Exception.class) public void testGetTestExecution() throws Exception @@ -130,4 +350,4 @@ public class VTPExecutionResourceTest { public void testGetTestExecutionLogsHandler() throws Exception { assertNotNull(vtpExecutionResource.getTestExecutionLogsHandler("1234", "action")); } -} \ No newline at end of file +} diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/execution/VTPExecutionResultsSupplierTest.java b/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/execution/VTPExecutionResultsSupplierTest.java new file mode 100644 index 00000000..7be8a7d4 --- /dev/null +++ b/vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vtp/execution/VTPExecutionResultsSupplierTest.java @@ -0,0 +1,88 @@ +/** + * Copyright 2020 Nokia. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vtp.execution; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class VTPExecutionResultsSupplierTest { + + private static final String TEST_PATH_TO_EXECUTION = "src/test/resources/executions"; + + @Test + public void whenGetExecutionOutputsFromFileIsCalledWithPathToCorrectFileThenContentShouldBeLoadedAsJson() { + // given + VTPExecutionResultsSupplier vtpExecutionResultsSupplier = + new VTPExecutionResultsSupplier(TEST_PATH_TO_EXECUTION); + String pathToCorrectFile = "test-01-request-id-execution-id"; + JsonElement expectedResult = new Gson().fromJson("" + + "[{" + + "\"test_1\": \"error01\"," + + "\"test_2\": \"error02\" " + + "}]", JsonArray.class); + + // when + JsonElement executionOutputsFromFile = + vtpExecutionResultsSupplier.getExecutionOutputsFromFile(pathToCorrectFile); + + // then + assertEquals(executionOutputsFromFile, expectedResult); + } + + @Test + public void whenGetExecutionOutputsFromFileIsCalledWithPathToNonExistingFileThenProperMessageShouldBeReturned() { + // given + VTPExecutionResultsSupplier vtpExecutionResultsSupplier = + new VTPExecutionResultsSupplier(TEST_PATH_TO_EXECUTION); + String pathToCorrectFile = "test-02-request-id-execution-id"; + JsonElement expectedErrorMessage = new Gson().fromJson("" + + "[{ \"error\": \"unable to find execution results\"}]", JsonArray.class); + + // when + JsonElement executionOutputsFromFile = + vtpExecutionResultsSupplier.getExecutionOutputsFromFile(pathToCorrectFile); + + // then + assertEquals(executionOutputsFromFile, expectedErrorMessage); + } + + @Test + public void whenGetExecutionOutputsFromFileIsCalledWithPathToIncorrectFileThenProperMessageShouldBeReturned() { + // given + VTPExecutionResultsSupplier vtpExecutionResultsSupplier = + new VTPExecutionResultsSupplier(TEST_PATH_TO_EXECUTION); + String pathToCorrectFile = "test-incorrect-request-id-execution-id-data"; + JsonElement expectedErrorMessage = new Gson().fromJson("" + + "[{ " + + "\"error\": \"fail to load execution result\"," + + "\"reason\":\"Expected a com.google.gson.JsonArray but was com.google.gson.JsonPrimitive\"" + + "}]", + JsonArray.class + ); + + // when + JsonElement executionOutputsFromFile = + vtpExecutionResultsSupplier.getExecutionOutputsFromFile(pathToCorrectFile); + + // then + assertEquals(executionOutputsFromFile, expectedErrorMessage); + } +} diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-01-request-id-execution-id-data/output b/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-01-request-id-execution-id-data/output new file mode 100644 index 00000000..e52c4f4e --- /dev/null +++ b/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-01-request-id-execution-id-data/output @@ -0,0 +1,6 @@ +[ + { + "test_1": "error01", + "test_2": "error02" + } +] diff --git a/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-incorrect-request-id-execution-id-data/output b/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-incorrect-request-id-execution-id-data/output new file mode 100644 index 00000000..747c69b0 --- /dev/null +++ b/vnfmarket-be/vnf-sdk-marketplace/src/test/resources/executions/test-incorrect-request-id-execution-id-data/output @@ -0,0 +1 @@ +wrong output, not a JSON -- cgit 1.2.3-korg