Unique identifier for test execution

Issue-ID: SDC-2584
Co-authored-by: nikhil.soni@vodafone.com
Signed-off-by: atulpurohit <atul.purohit1@vodafone.com>
Change-Id: I3e7f1a84935cbcd26f8a42a6e2d2dbcb7533cb19
Signed-off-by: atulpurohit <atul.purohit1@vodafone.com>

4 files changed, 534 insertions, 394 deletions

diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/pom.xml b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/pom.xml
index d7b40a33c5..52011ab651 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/pom.xml
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/pom.xml
@@ -119,19 +119,47 @@
             <scope>provided</scope>
         </dependency>
         <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-common-rest</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
-          <groupId>org.mockito</groupId>
-          <artifactId>mockito-core</artifactId>
-          <scope>test</scope>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-module-junit4-common</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
         </dependency>
         <dependency>
-          <groupId>org.openecomp.sdc</groupId>
-          <artifactId>openecomp-sdc-externaltesting-impl</artifactId>
-          <version>${project.version}</version>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito2</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-module-junit4</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-externaltesting-impl</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <scope>provided</scope>
         </dependency>
     </dependencies>
 
diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/ExternalTesting.java b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/ExternalTesting.java
index c25456f1ae..5f70570429 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/ExternalTesting.java
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/ExternalTesting.java
@@ -18,17 +18,23 @@ package org.openecomp.sdcrests.externaltesting.rest;
 
 import io.swagger.v3.oas.annotations.OpenAPIDefinition;
 import io.swagger.v3.oas.annotations.info.Info;
+import java.util.List;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.apache.cxf.jaxrs.ext.multipart.Attachment;
+import org.apache.cxf.jaxrs.ext.multipart.Multipart;
 import org.openecomp.core.externaltesting.api.ClientConfiguration;
 import org.openecomp.core.externaltesting.api.RemoteTestingEndpointDefinition;
-import org.openecomp.core.externaltesting.api.VtpTestExecutionRequest;
 import org.springframework.validation.annotation.Validated;
 
-import javax.ws.rs.*;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import java.util.List;
-
-
 @Path("/v1.0/externaltesting")
 @Produces(MediaType.APPLICATION_JSON)
 @Consumes(MediaType.APPLICATION_JSON)
@@ -37,55 +43,58 @@ import java.util.List;
 
 public interface ExternalTesting {
 
-  @GET
-  @Path("/config")
-  Response getConfig();
+    @GET
+    @Path("/config")
+    Response getConfig();
 
-  @PUT
-  @Path("/config")
-  Response setConfig(ClientConfiguration config);
+    @PUT
+    @Path("/config")
+    Response setConfig(ClientConfiguration config);
 
-  @GET
-  @Path("/testcasetree")
-  Response getTestCasesAsTree();
+    @GET
+    @Path("/testcasetree")
+    Response getTestCasesAsTree();
 
-  @GET
-  @Path("/endpoints")
-  Response getEndpoints();
+    @GET
+    @Path("/endpoints")
+    Response getEndpoints();
 
-  @PUT
-  @Path("/endpoints")
-  Response setEndpoints(List<RemoteTestingEndpointDefinition> endpoints);
+    @PUT
+    @Path("/endpoints")
+    Response setEndpoints(List<RemoteTestingEndpointDefinition> endpoints);
 
-  @GET
-  @Path("/endpoints/{endpointId}/scenarios")
-  Response getScenarios(@PathParam("endpointId") String endpointId);
+    @GET
+    @Path("/endpoints/{endpointId}/scenarios")
+    Response getScenarios(@PathParam("endpointId") String endpointId);
 
-  @GET
-  @Path("/endpoints/{endpointId}/scenarios/{scenario}/testsuites")
-  Response getTestsuites(@PathParam("endpointId") String endpointId, @PathParam("scenario") String scenario);
+    @GET
+    @Path("/endpoints/{endpointId}/scenarios/{scenario}/testsuites")
+    Response getTestsuites(@PathParam("endpointId") String endpointId, @PathParam("scenario") String scenario);
 
-  @GET
-  @Path("/endpoints/{endpointId}/scenarios/{scenario}/testcases")
-  Response getTestcases(@PathParam("endpointId") String endpointId,
-                        @PathParam("scenario") String scenario);
+    @GET
+    @Path("/endpoints/{endpointId}/scenarios/{scenario}/testcases")
+    Response getTestcases(@PathParam("endpointId") String endpointId, @PathParam("scenario") String scenario);
 
-  @GET
-  @Path("/endpoints/{endpointId}/scenarios/{scenario}/testsuites/{testsuite}/testcases/{testcase}")
-  Response getTestcase(@PathParam("endpointId") String endpointId,
-                       @PathParam("scenario") String scenario,
-                       @PathParam("testsuite") String testsuite,
-                       @PathParam("testcase") String testcase);
+    @GET
+    @Path("/endpoints/{endpointId}/scenarios/{scenario}/testsuites/{testsuite}/testcases/{testcase}")
+    Response getTestcase(@PathParam("endpointId") String endpointId, @PathParam("scenario") String scenario,
+            @PathParam("testsuite") String testsuite, @PathParam("testcase") String testcase);
 
-  @POST
-  @Path("/endpoints/{endpointId}/executions/{executionId}")
-  Response getExecution(@PathParam("endpointId") String endpointId,
-                        @PathParam("executionId") String executionId);
+    @POST
+    @Path("/endpoints/{endpointId}/executions/{executionId}")
+    Response getExecution(@PathParam("endpointId") String endpointId, @PathParam("executionId") String executionId);
 
 
-  @POST
-  @Path("/executions")
-  Response execute(List<VtpTestExecutionRequest> req,
-                   @QueryParam("requestId") String requestId);
+    @POST
+    @Path("/executions")
+    @Consumes(MediaType.MULTIPART_FORM_DATA)
+    Response execute(@QueryParam("vspId") String vspId, @QueryParam("vspVersionId") String vspVersionId,
+            @QueryParam("requestId") String requestId,
+            @Multipart(value = "files", required = false) List<Attachment> files,
+            @Multipart(value = "testdata", required = false) String testData);
 
+    @GET
+    @Path("/executions")
+    Response getValidationResult(@QueryParam("requestId") String requestId,
+            @QueryParam("endPoint") List<String> endPoints);
 }
diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/services/ExternalTestingImpl.java b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/services/ExternalTestingImpl.java
index 1ce89b6748..7e8e98837e 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/services/ExternalTestingImpl.java
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/main/java/org/openecomp/sdcrests/externaltesting/rest/services/ExternalTestingImpl.java
@@ -19,179 +19,240 @@
 
 package org.openecomp.sdcrests.externaltesting.rest.services;
 
-
-import org.openecomp.core.externaltesting.api.*;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.inject.Named;
+import javax.ws.rs.core.Response;
+import org.apache.commons.io.IOUtils;
+import org.apache.cxf.jaxrs.ext.multipart.Attachment;
+import org.openecomp.core.externaltesting.api.ClientConfiguration;
+import org.openecomp.core.externaltesting.api.ExternalTestingManager;
+import org.openecomp.core.externaltesting.api.RemoteTestingEndpointDefinition;
+import org.openecomp.core.externaltesting.api.TestErrorBody;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionOutput;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionRequest;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionResponse;
 import org.openecomp.core.externaltesting.errors.ExternalTestingException;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
 import org.openecomp.sdcrests.externaltesting.rest.ExternalTesting;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Scope;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
-import javax.inject.Named;
-import javax.ws.rs.core.Response;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
 @SuppressWarnings("unused")
 @Named
 @Service("externaltesting")
 @Scope(value = "prototype")
 public class ExternalTestingImpl implements ExternalTesting {
 
-  private final ExternalTestingManager testingManager;
-
-  private static final Logger logger =
-      LoggerFactory.getLogger(ExternalTestingImpl.class);
+    private final ExternalTestingManager testingManager;
+    private static final int REQUEST_ID_LENGTH = 8;
+    private static final String TESTING_INTERNAL_ERROR = "SDC-TEST-005";
+    private final VendorSoftwareProductManager vendorSoftwareProductManager =
+            VspManagerFactory.getInstance().createInterface();
+    private static final Logger logger = LoggerFactory.getLogger(ExternalTestingImpl.class);
 
-  public ExternalTestingImpl(@Autowired ExternalTestingManager testingManager) {
-    this.testingManager = testingManager;
-  }
-
-  /**
-   * Return the configuration of the feature to the client.
-   * @return JSON response content.
-   */
-  @Override
-  public Response getConfig() {
-    try {
-      return Response.ok(testingManager.getConfig()).build();
-    }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+    public ExternalTestingImpl(@Autowired ExternalTestingManager testingManager) {
+        this.testingManager = testingManager;
     }
-  }
 
-  /**
-   * To enable automated functional testing, allow
-   * a put for the client configuration.
-   * @return JSON response content.
-   */
-  @Override
-  public Response setConfig(ClientConfiguration config) {
-    try {
-      return Response.ok(testingManager.setConfig(config)).build();
+    /**
+     * Return the configuration of the feature to the client.
+     *
+     * @return JSON response content.
+     */
+    @Override
+    public Response getConfig() {
+        try {
+            return Response.ok(testingManager.getConfig()).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    /**
+     * To enable automated functional testing, allow
+     * a put for the client configuration.
+     *
+     * @return JSON response content.
+     */
+    @Override
+    public Response setConfig(ClientConfiguration config) {
+        try {
+            return Response.ok(testingManager.setConfig(config)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-  }
 
 
-  /**
-   * Return the test tree structure created by the testing manager.
-   * @return JSON response content.
-   */
-  @Override
-  public Response getTestCasesAsTree() {
-    try {
-      return Response.ok(testingManager.getTestCasesAsTree()).build();
+    /**
+     * Return the test tree structure created by the testing manager.
+     *
+     * @return JSON response content.
+     */
+    @Override
+    public Response getTestCasesAsTree() {
+        try {
+            return Response.ok(testingManager.getTestCasesAsTree()).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
-    }
-  }
 
-  @Override
-  public Response getEndpoints() {
-    try {
-      return Response.ok(testingManager.getEndpoints()).build();
+    @Override
+    public Response getEndpoints() {
+        try {
+            return Response.ok(testingManager.getEndpoints()).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    /**
+     * To enable automated functional testing, allow a put of the endpoints.
+     *
+     * @return JSON response content.
+     */
+    @Override
+    public Response setEndpoints(List<RemoteTestingEndpointDefinition> endpoints) {
+        try {
+            return Response.ok(testingManager.setEndpoints(endpoints)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-  }
 
-  /**
-   * To enable automated functional testing, allow a put of the endpoints.
-   * @return JSON response content.
-   */
-  @Override
-  public Response setEndpoints(List<RemoteTestingEndpointDefinition> endpoints) {
-    try {
-      return Response.ok(testingManager.setEndpoints(endpoints)).build();
+    @Override
+    public Response getScenarios(String endpoint) {
+        try {
+            return Response.ok(testingManager.getScenarios(endpoint)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
+
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    @Override
+    public Response getTestsuites(String endpoint, String scenario) {
+        try {
+            return Response.ok(testingManager.getTestSuites(endpoint, scenario)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-  }
 
-  @Override
-  public Response getScenarios(String endpoint) {
-    try {
-      return Response.ok(testingManager.getScenarios(endpoint)).build();
+    @Override
+    public Response getTestcases(String endpoint, String scenario) {
+        try {
+            return Response.ok(testingManager.getTestCases(endpoint, scenario)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    @Override
+    public Response getTestcase(String endpoint, String scenario, String testsuite, String testcase) {
+        try {
+            return Response.ok(testingManager.getTestCase(endpoint, scenario, testsuite, testcase)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
 
-  }
+    @Override
+    public Response execute(String vspId, String vspVersionId, String requestId, List<Attachment> files,
+            String testDataString) {
+        try {
+            List<VtpTestExecutionRequest> req = getVtpTestExecutionRequestObj(testDataString);
+            Map<String, byte[]> fileMap = getFileMap(files);
+            List<VtpTestExecutionResponse> vtpTestExecutionResponses =
+                    testingManager.execute(req, vspId, vspVersionId, requestId, fileMap);
+            return Response.status(HttpStatus.OK.value()).entity(vtpTestExecutionResponses).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
 
-  @Override
-  public Response getTestsuites(String endpoint, String scenario) {
-    try {
-      return Response.ok(testingManager.getTestSuites(endpoint, scenario)).build();
-    }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
     }
-  }
 
-  @Override
-  public Response getTestcases(String endpoint, String scenario) {
-    try {
-      return Response.ok(testingManager.getTestCases(endpoint, scenario)).build();
-    }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+    @Override
+    public Response getValidationResult(String requestId, List<String> endPoints) {
+        try {
+            List<VtpTestExecutionResponse> resultsFromVtp = new ArrayList<>();
+            for (String endPoint : endPoints) {
+                List<VtpTestExecutionOutput> vtpTestExecutionOutput =
+                        testingManager.getExecutionIds(endPoint, requestId);
+                List<String> execIds = vtpTestExecutionOutput.stream().map(VtpTestExecutionOutput::getExecutionId)
+                                               .collect(Collectors.toList());
+                List<VtpTestExecutionResponse> resultFromVtp = getVtpResultbyExecutionId(execIds, endPoint);
+                resultsFromVtp.addAll(resultFromVtp);
+            }
+            return Response.status(HttpStatus.OK.value()).entity(resultsFromVtp).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-  }
 
-  @Override
-  public Response getTestcase(String endpoint, String scenario, String testsuite, String testcase) {
-    try {
-      return Response.ok(testingManager.getTestCase(endpoint, scenario, testsuite, testcase)).build();
-    }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
-    }
-  }
+    private List<VtpTestExecutionRequest> getVtpTestExecutionRequestObj(String testDataString) {
+        try {
+            return new ObjectMapper().configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true).reader()
+                           .forType(new TypeReference<List<VtpTestExecutionRequest>>() { }).readValue(testDataString);
+        } catch (IOException e) {
+            throw new ExternalTestingException(TESTING_INTERNAL_ERROR, 500, e.getMessage(), e);
 
-  @Override
-  public Response execute(List<VtpTestExecutionRequest> req, String requestId) {
-    try {
-      List<VtpTestExecutionResponse> responses = testingManager.execute(req, requestId);
-      List<Integer> statuses = responses.stream().map(r-> Optional.ofNullable(r.getHttpStatus()).orElse(HttpStatus.OK.value())).distinct().collect(Collectors.toList());
-      if (statuses.size() == 1) {
-        return Response.status(HttpStatus.OK.value()).entity(responses).build();
-      }
-      else {
-        return Response.status(HttpStatus.MULTI_STATUS.value()).entity(responses).build();
-      }
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    private List<VtpTestExecutionResponse> getVtpResultbyExecutionId(List<String> executionIds, String endPoint) {
+        List<VtpTestExecutionResponse> vtpTestExecutionResponses = new ArrayList<>();
+        executionIds.stream().forEach(executionId -> {
+            VtpTestExecutionResponse executionResult = testingManager.getExecution(endPoint, executionId);
+            vtpTestExecutionResponses.add(executionResult);
+        });
+        return vtpTestExecutionResponses;
     }
-  }
 
-  @Override
-  public Response getExecution(String endpoint, String executionId) {
-    try {
-      return Response.ok(testingManager.getExecution(endpoint, executionId)).build();
+
+    @Override
+    public Response getExecution(String endpoint, String executionId) {
+        try {
+            return Response.ok(testingManager.getExecution(endpoint, executionId)).build();
+        } catch (ExternalTestingException e) {
+            return convertTestingException(e);
+        }
     }
-    catch (ExternalTestingException e) {
-      return convertTestingException(e);
+
+    private Map<String, byte[]> getFileMap(List<Attachment> files) {
+        if (files != null && !files.isEmpty()) {
+
+            return files.stream().collect(
+                    Collectors.toMap(attachment -> attachment.getDataHandler().getName(), attachment -> {
+                        try {
+                            return IOUtils.toByteArray(attachment.getDataHandler().getInputStream());
+                        } catch (IOException e) {
+                            throw new ExternalTestingException(TESTING_INTERNAL_ERROR, 500, e.getMessage(), e);
+                        }
+                    }));
+        }
+
+        return null;
     }
-  }
 
-  private Response convertTestingException(ExternalTestingException e) {
-    if (logger.isErrorEnabled()) {
-      logger.error("testing exception {} {} {}", e.getMessageCode(), e.getHttpStatus(), e.getDetail(), e);
+    private Response convertTestingException(ExternalTestingException e) {
+        if (logger.isErrorEnabled()) {
+            logger.error("testing exception {} {} {}", e.getMessageCode(), e.getHttpStatus(), e.getDetail(), e);
+        }
+        TestErrorBody body = new TestErrorBody(e.getMessageCode(), e.getHttpStatus(), e.getDetail());
+        return Response.status(e.getHttpStatus()).entity(body).build();
     }
-    TestErrorBody body = new TestErrorBody(e.getMessageCode(), e.getHttpStatus(), e.getDetail());
-    return Response.status(e.getHttpStatus()).entity(body).build();
-  }
 }
diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/test/java/org/openecomp/sdcrests/externaltesting/rest/services/ApiTest.java b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/test/java/org/openecomp/sdcrests/externaltesting/rest/services/ApiTest.java
index 5f302bebc6..883b89a16e 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/test/java/org/openecomp/sdcrests/externaltesting/rest/services/ApiTest.java
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/externaltesting-rest/externaltesting-rest-services/src/test/java/org/openecomp/sdcrests/externaltesting/rest/services/ApiTest.java
@@ -16,245 +16,287 @@
 
 package org.openecomp.sdcrests.externaltesting.rest.services;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.openecomp.core.externaltesting.api.*;
-import org.openecomp.core.externaltesting.errors.ExternalTestingException;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
 
-import javax.ws.rs.core.Response;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
+import javax.ws.rs.core.Response;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.openecomp.core.externaltesting.api.ClientConfiguration;
+import org.openecomp.core.externaltesting.api.ExternalTestingManager;
+import org.openecomp.core.externaltesting.api.RemoteTestingEndpointDefinition;
+import org.openecomp.core.externaltesting.api.TestTreeNode;
+import org.openecomp.core.externaltesting.api.VtpNameDescriptionPair;
+import org.openecomp.core.externaltesting.api.VtpTestCase;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionOutput;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionRequest;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionResponse;
+import org.openecomp.core.externaltesting.errors.ExternalTestingException;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
 
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({VspManagerFactory.class})
 public class ApiTest {
 
-  private static final String EP = "ep";
-  private static final String EXEC = "exec";
-  private static final String SC = "sc";
-  private static final String TS = "ts";
-  private static final String TC = "tc";
-  private static final String EXPECTED = "Expected";
-
-
-  @Mock
-  private ExternalTestingManager testingManager;
-
-  /**
-   * At the API level, test that the code does not throw
-   * exceptions but there's not much to test.
-   */
-  @Test
-  public void testApi() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingImpl testing = new ExternalTestingImpl(testingManager);
-    Assert.assertNotNull(testing.getConfig());
-    Assert.assertNotNull(testing.getEndpoints());
-    Assert.assertNotNull(testing.getExecution(EP, EXEC));
-    Assert.assertNotNull(testing.getScenarios(EP));
-    Assert.assertNotNull(testing.getTestcase(EP, SC, TS, TC));
-    Assert.assertNotNull(testing.getTestcases(EP, SC));
-    Assert.assertNotNull(testing.getTestsuites(EP, SC));
-    Assert.assertNotNull(testing.getTestCasesAsTree());
-
-    List<VtpTestExecutionRequest> requests =
-        Arrays.asList(new VtpTestExecutionRequest(), new VtpTestExecutionRequest());
-    Assert.assertNotNull(testing.execute(requests, "requestId"));
-
-
-    ClientConfiguration cc = new ClientConfiguration();
-    Assert.assertNotNull(testing.setConfig(cc));
-
-    ArrayList<RemoteTestingEndpointDefinition> lst = new ArrayList<>();
-    Assert.assertNotNull(testing.setEndpoints(lst));
-  }
-
-  class ApiTestExternalTestingManager implements ExternalTestingManager {
-    @Override
-    public ClientConfiguration getConfig() {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    private static final String EP = "ep";
+    private static final String EXEC = "exec";
+    private static final String SC = "sc";
+    private static final String TS = "ts";
+    private static final String TC = "tc";
+    private static final String EXPECTED = "Expected";
+
+    @Mock
+    private ExternalTestingManager testingManager;
+    @Mock
+    private VspManagerFactory vspManagerFactory;
+    @Mock
+    VendorSoftwareProductManager vendorSoftwareProductManager;
+
+    @Before
+    public void setUp() {
+        try {
+            initMocks(this);
+            mockStatic(VspManagerFactory.class);
+            when(VspManagerFactory.getInstance()).thenReturn(vspManagerFactory);
+            when(vspManagerFactory.createInterface()).thenReturn(vendorSoftwareProductManager);
+            when(vspManagerFactory.getInstance().createInterface()).thenReturn(vendorSoftwareProductManager);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 
-    @Override
-    public ClientConfiguration setConfig(ClientConfiguration config) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+
+    /**
+     * At the API level, test that the code does not throw
+     * exceptions but there's not much to test.
+     */
+    @Test
+    public void testApi() {
+
+
+        ExternalTestingImpl testing = new ExternalTestingImpl(testingManager);
+        Assert.assertNotNull(testing.getConfig());
+        Assert.assertNotNull(testing.getEndpoints());
+        Assert.assertNotNull(testing.getExecution(EP, EXEC));
+        Assert.assertNotNull(testing.getScenarios(EP));
+        Assert.assertNotNull(testing.getTestcase(EP, SC, TS, TC));
+        Assert.assertNotNull(testing.getTestcases(EP, SC));
+        Assert.assertNotNull(testing.getTestsuites(EP, SC));
+        Assert.assertNotNull(testing.getTestCasesAsTree());
+
+        List<VtpTestExecutionRequest> requests =
+                Arrays.asList(new VtpTestExecutionRequest(), new VtpTestExecutionRequest());
+        Assert.assertNotNull(testing.execute("vspId", "vspVersionId", "abc", null, "[]"));
+
+
+        ClientConfiguration cc = new ClientConfiguration();
+        Assert.assertNotNull(testing.setConfig(cc));
+
+        ArrayList<RemoteTestingEndpointDefinition> lst = new ArrayList<>();
+        Assert.assertNotNull(testing.setEndpoints(lst));
     }
 
-    @Override
-    public List<RemoteTestingEndpointDefinition> setEndpoints(List<RemoteTestingEndpointDefinition> endpoints) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    class ApiTestExternalTestingManager implements ExternalTestingManager {
+
+        @Override
+        public ClientConfiguration getConfig() {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public ClientConfiguration setConfig(ClientConfiguration config) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<RemoteTestingEndpointDefinition> setEndpoints(List<RemoteTestingEndpointDefinition> endpoints) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public TestTreeNode getTestCasesAsTree() {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<RemoteTestingEndpointDefinition> getEndpoints() {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<VtpNameDescriptionPair> getScenarios(String endpoint) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<VtpNameDescriptionPair> getTestSuites(String endpoint, String scenario) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<VtpTestCase> getTestCases(String endpoint, String scenario) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public VtpTestCase getTestCase(String endpoint, String scenario, String testSuite, String testCaseName) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<VtpTestExecutionResponse> execute(List<VtpTestExecutionRequest> requests, String vspId,
+                String vspVersionId, String requestId, Map<String, byte[]> fileMap) {
+
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public VtpTestExecutionResponse getExecution(String endpoint, String executionId) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
+        @Override
+        public List<VtpTestExecutionOutput> getExecutionIds(String endpoint, String requestId) {
+            throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+        }
+
     }
 
-    @Override
-    public TestTreeNode getTestCasesAsTree() {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for configuration get/set.
+     */
+    @Test()
+    public void testConfigExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response getResponse = testingF.getConfig();
+        Assert.assertEquals(500, getResponse.getStatus());
+
+        Response setResponse = testingF.setConfig(new ClientConfiguration());
+        Assert.assertEquals(500, setResponse.getStatus());
     }
 
-    @Override
-    public List<RemoteTestingEndpointDefinition> getEndpoints() {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for endpoint get/set.
+     */
+    @Test()
+    public void testEndpointExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response getResponse = testingF.getEndpoints();
+        Assert.assertEquals(500, getResponse.getStatus());
+
+        Response setResponse = testingF.setEndpoints(new ArrayList<>());
+        Assert.assertEquals(500, setResponse.getStatus());
     }
 
-    @Override
-    public List<VtpNameDescriptionPair> getScenarios(String endpoint) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for executions (invocation and query).
+     */
+    @Test()
+    public void testExecutionExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response invokeResponse = testingF.execute("vspId", "vspVersionId", "abc", null, "[]");
+        Assert.assertEquals(500, invokeResponse.getStatus());
+
+        Response getResponse = testingF.getExecution(EP, EXEC);
+        Assert.assertEquals(500, getResponse.getStatus());
     }
 
-    @Override
-    public List<VtpNameDescriptionPair> getTestSuites(String endpoint, String scenario) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+
+    /**
+     * Test the exception handler logic for the cases when the
+     * testing manager throws an accessing the scenarios.
+     */
+    @Test()
+    public void testScenarioExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response response = testingF.getScenarios(EP);
+        Assert.assertEquals(500, response.getStatus());
     }
 
-    @Override
-    public List<VtpTestCase> getTestCases(String endpoint, String scenario) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for the cases when the
+     * testing manager throws an accessing a test case.
+     */
+    @Test()
+    public void testTestCaseExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response response = testingF.getTestcase(EP, SC, TS, TC);
+        Assert.assertEquals(500, response.getStatus());
     }
 
-    @Override
-    public VtpTestCase getTestCase(String endpoint, String scenario, String testSuite, String testCaseName) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for the cases when the
+     * testing manager throws an accessing the test cases.
+     */
+    @Test()
+    public void testTestCasesExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response response = testingF.getTestcases(EP, SC);
+        Assert.assertEquals(500, response.getStatus());
     }
 
-    @Override
-    public List<VtpTestExecutionResponse> execute(List<VtpTestExecutionRequest> requests, String requestId) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for the cases when the
+     * testing manager throws an accessing the test suites.
+     */
+    @Test()
+    public void testTestSuitesExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response response = testingF.getTestsuites(EP, SC);
+        Assert.assertEquals(500, response.getStatus());
     }
 
-    @Override
-    public VtpTestExecutionResponse getExecution(String endpoint, String executionId) {
-      throw new ExternalTestingException(EXPECTED, 500, EXPECTED);
+    /**
+     * Test the exception handler logic for the cases when the
+     * testing manager throws an accessing the test tree.
+     */
+    @Test()
+    public void testTreeExceptions() {
+        initMocks(this);
+
+        ExternalTestingManager m = new ApiTestExternalTestingManager();
+        ExternalTestingImpl testingF = new ExternalTestingImpl(m);
+
+        Response response = testingF.getTestCasesAsTree();
+        Assert.assertEquals(500, response.getStatus());
     }
-  }
-
-  /**
-   * Test the exception handler logic for configuration get/set.
-   */
-  @Test()
-  public void testConfigExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response getResponse = testingF.getConfig();
-    Assert.assertEquals(500, getResponse.getStatus());
-
-    Response setResponse = testingF.setConfig(new ClientConfiguration());
-    Assert.assertEquals(500, setResponse.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for endpoint get/set.
-   */
-  @Test()
-  public void testEndpointExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response getResponse = testingF.getEndpoints();
-    Assert.assertEquals(500, getResponse.getStatus());
-
-    Response setResponse = testingF.setEndpoints(new ArrayList<>());
-    Assert.assertEquals(500, setResponse.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for executions (invocation and query).
-   */
-  @Test()
-  public void testExecutionExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    List<VtpTestExecutionRequest> requests =
-        Arrays.asList(new VtpTestExecutionRequest(), new VtpTestExecutionRequest());
-
-    Response invokeResponse = testingF.execute(requests, null);
-    Assert.assertEquals(500, invokeResponse.getStatus());
-
-    Response getResponse = testingF.getExecution(EP, EXEC);
-    Assert.assertEquals(500, getResponse.getStatus());
-  }
-
-
-  /**
-   * Test the exception handler logic for the cases when the
-   * testing manager throws an accessing the scenarios.
-   */
-  @Test()
-  public void testScenarioExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response response = testingF.getScenarios(EP);
-    Assert.assertEquals(500, response.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for the cases when the
-   * testing manager throws an accessing a test case.
-   */
-  @Test()
-  public void testTestCaseExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response response = testingF.getTestcase(EP, SC, TS, TC);
-    Assert.assertEquals(500, response.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for the cases when the
-   * testing manager throws an accessing the test cases.
-   */
-  @Test()
-  public void testTestCasesExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response response = testingF.getTestcases(EP, SC);
-    Assert.assertEquals(500, response.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for the cases when the
-   * testing manager throws an accessing the test suites.
-   */
-  @Test()
-  public void testTestSuitesExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response response = testingF.getTestsuites(EP, SC);
-    Assert.assertEquals(500, response.getStatus());
-  }
-
-  /**
-   * Test the exception handler logic for the cases when the
-   * testing manager throws an accessing the test tree.
-   */
-  @Test()
-  public void testTreeExceptions() {
-    MockitoAnnotations.initMocks(this);
-
-    ExternalTestingManager m = new ApiTestExternalTestingManager();
-    ExternalTestingImpl testingF = new ExternalTestingImpl(m);
-
-    Response response = testingF.getTestCasesAsTree();
-    Assert.assertEquals(500, response.getStatus());
-  }
 }