1 files changed, 367 insertions, 0 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java
new file mode 100644
index 0000000000..f756e44776
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java
@@ -0,0 +1,367 @@
+package org.openecomp.sdc.vendorsoftwareproduct.impl;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.openecomp.sdc.activityLog.ActivityLogManager;
+import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessType;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.eq;
+
+public class ProcessManagerImplTest {
+
+
+  private static final String USER1 = "processesTestUser";
+  private static final String VSP_ID = "vsp";
+  private static final Version VERSION = new Version(0, 1);
+  private static final String COMPONENT_ID = "component";
+  private static final String PROCESS1_ID = "process1";
+  private static final String PROCESS2_ID = "process2";
+  private static final String ARTIFACT_NAME = "artifact.sh";
+
+  @Mock
+  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
+  @Mock
+  private ActivityLogManager activityLogManagerMock;
+
+  @InjectMocks
+  @Spy
+  private ProcessManagerImpl processManager;
+  @Captor
+  private ArgumentCaptor<ActivityLogEntity> activityLogEntityArg;
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testListWhenNone() {
+    Collection<ProcessEntity> processes =
+        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+    Assert.assertEquals(processes.size(), 0);
+  }
+
+  @Test
+  public void testList() {
+    doReturn(Arrays.asList(
+        createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID),
+        createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID)))
+        .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
+
+    Collection<ProcessEntity> actual =
+        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+    Assert.assertEquals(actual.size(), 2);
+  }
+
+  @Test
+  public void testDeleteListWhenNone() {
+    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+    verify(vendorSoftwareProductDaoMock, never()).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
+  }
+
+  @Test
+  public void testDeleteList() {
+    ProcessEntity process1 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    ProcessEntity process2 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID);
+    doReturn(Arrays.asList(process1, process2))
+        .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
+    doNothing().when(processManager)
+        .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
+    doNothing().when(processManager)
+        .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process2.getName());
+
+    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+
+    verify(vendorSoftwareProductDaoMock).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
+    verify(processManager)
+        .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
+    verify(processManager)
+        .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process2.getName());
+  }
+
+  @Test
+  public void testCreate() {
+    ProcessEntity processToCreate = createProcess(VSP_ID, VERSION, COMPONENT_ID, null);
+    processToCreate.setName("proc name");
+
+    doNothing().when(processManager)
+        .validateUniqueName(VSP_ID, VERSION, COMPONENT_ID, processToCreate.getName());
+    doNothing().when(processManager)
+        .createUniqueName(VSP_ID, VERSION, COMPONENT_ID, processToCreate.getName());
+
+    ProcessEntity process = processManager.createProcess(processToCreate, USER1);
+    Assert.assertNotNull(process);
+    process.setId(process.getId());
+
+    Assert.assertEquals(process, processToCreate);
+  }
+
+  @Test(expectedExceptions = CoreException.class)
+  public void testCreateWithExistingName_negative() {
+    ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, null);
+    process.setName("p1 name");
+
+    doThrow(new CoreException(
+        new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
+        .when(processManager).validateUniqueName(VSP_ID, VERSION, COMPONENT_ID, process.getName());
+
+    processManager.createProcess(process, USER1);
+  }
+
+  @Test
+  public void testUpdateNonExistingProcessId_negative() {
+    doReturn(null).when(vendorSoftwareProductDaoMock)
+        .getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test(expectedExceptions = CoreException.class)
+  public void testUpdateWithExistingName_negative() {
+    ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(existingProcess).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doThrow(new CoreException(
+        new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
+        .when(processManager)
+        .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
+            processToUpdate.getName());
+
+    processManager.updateProcess(processToUpdate, USER1);
+  }
+
+  @Test
+  public void testUpdate() {
+    ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(existingProcess).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doNothing().when(processManager)
+        .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
+            processToUpdate.getName());
+
+    processManager.updateProcess(processToUpdate, USER1);
+    verify(vendorSoftwareProductDaoMock).updateProcess(processToUpdate);
+  }
+
+
+  @Test
+  public void testGetNonExistingProcessId_negative() {
+    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testGet() {
+    ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(process).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    ProcessEntity actual =
+        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    Assert.assertEquals(actual, process);
+    Assert.assertNull(actual.getArtifactName());
+  }
+
+  @Test
+  public void testGetAfterUploadArtifact() {
+    ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    process.setArtifactName(ARTIFACT_NAME);
+    doReturn(process).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    ProcessEntity actual =
+        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    Assert.assertEquals(actual, process);
+    Assert.assertEquals(actual.getArtifactName(), ARTIFACT_NAME);
+  }
+
+  @Test(expectedExceptions = CoreException.class)
+  public void testDeleteNonExistingProcessId_negative() {
+    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+  }
+
+  @Test
+  public void testDelete() {
+    ProcessEntity processToDelete = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(processToDelete).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doNothing().when(processManager).deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID,
+        processToDelete.getName());
+
+    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    verify(vendorSoftwareProductDaoMock).deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    verify(processManager)
+        .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, processToDelete.getName());
+  }
+
+  @Test
+  public void testUploadArtifactNonExistingProcessId_negative() {
+    testUploadArtifact_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testUploadArtifact() {
+    ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(process).when
+        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    byte[] artifactBytes = "bla bla".getBytes();
+    processManager
+        .uploadProcessArtifact(new ByteArrayInputStream(artifactBytes), ARTIFACT_NAME,
+            VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    verify(vendorSoftwareProductDaoMock)
+        .uploadProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, artifactBytes,
+            ARTIFACT_NAME);
+
+    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
+    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
+    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION.getMajor()+1));
+    Assert.assertTrue(activityLogEntity.isSuccess());
+  }
+
+  @Test
+  public void testGetArtifactWhenNone_negative() {
+    testGetFile_negative(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID, USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testGetArtifactNonExistingProcessId_negative() {
+    testGetFile_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testGetArtifact() {
+    ProcessEntity processArtifact =
+        new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
+    doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
+        .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    File actual =
+        processManager.getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    Assert.assertNotNull(actual);
+  }
+
+  @Test
+  public void testDeleteArtifactWhenNone_negative() {
+    testDeleteArtifact_negative(VSP_ID, COMPONENT_ID, PROCESS2_ID, USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testDeleteArtifactNonExistingProcessId_negative() {
+    testDeleteArtifact_negative(VSP_ID, COMPONENT_ID, "non existing process id", USER1,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
+
+  @Test
+  public void testDeleteArtifact() {
+    ProcessEntity processArtifact =
+        new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
+    doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
+        .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+
+    processManager.deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    verify(vendorSoftwareProductDaoMock)
+        .deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+  }
+
+
+  private ProcessEntity createProcess(String vspId, Version version, String componentId,
+                                      String processId) {
+    ProcessEntity process = new ProcessEntity(vspId, version, componentId, processId);
+    process.setName(processId + " name");
+    process.setDescription(processId + " desc");
+    process.setType(ProcessType.Other);
+    return process;
+  }
+
+  private void testGet_negative(String vspId, Version version, String componentId, String processId,
+                                String user, String expectedErrorCode) {
+    try {
+      processManager.getProcess(vspId, version, componentId, processId, user);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+    }
+  }
+
+  private void testUpdate_negative(String vspId, Version version, String componentId,
+                                   String processId, String user,
+                                   String expectedErrorCode) {
+    try {
+      processManager
+          .updateProcess(new ProcessEntity(vspId, version, componentId, processId), user);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+    }
+  }
+
+  private void testGetFile_negative(String vspId, Version version, String componentId,
+                                    String processId, String user, String expectedErrorCode) {
+    try {
+      processManager.getProcessArtifact(vspId, version, componentId, processId, user);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+    }
+  }
+
+  private void testUploadArtifact_negative(String vspId, Version version, String componentId,
+                                           String processId, String user,
+                                           String expectedErrorCode) {
+    try {
+      processManager
+          .uploadProcessArtifact(new ByteArrayInputStream("bla bla".getBytes()), "artifact.sh",
+              vspId, version, componentId, processId, user);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+    }
+  }
+
+  private void testDeleteArtifact_negative(String vspId, String componentId, String processId,
+                                           String user, String expectedErrorCode) {
+    try {
+      processManager.deleteProcessArtifact(vspId, VERSION, componentId, processId, user);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+    }
+  }
+
+}