openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import org.mockito.InjectMocks;
   4 import org.mockito.Mock;
   5 import org.mockito.MockitoAnnotations;
   6 import org.mockito.Spy;
   7 import org.mockito.ArgumentCaptor;
   8 import org.mockito.Captor;
   9 import org.openecomp.sdc.activityLog.ActivityLogManager;
  10 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
  11 import org.openecomp.sdc.common.errors.CoreException;
  12 import org.openecomp.sdc.common.errors.ErrorCategory;
  13 import org.openecomp.sdc.common.errors.ErrorCode;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessType;
  17 import org.openecomp.sdc.versioning.dao.types.Version;
  18 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  19 import org.testng.Assert;
  20 import org.testng.annotations.BeforeMethod;
  21 import org.testng.annotations.Test;
  22
  23 import java.io.ByteArrayInputStream;
  24 import java.io.File;
  25 import java.nio.ByteBuffer;
  26 import java.util.Arrays;
  27 import java.util.Collection;
  28
  29 import static org.mockito.Mockito.doNothing;
  30 import static org.mockito.Mockito.doReturn;
  31 import static org.mockito.Mockito.doThrow;
  32 import static org.mockito.Mockito.never;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Matchers.eq;
  35
  36 public class ProcessManagerImplTest {
  37
  38
  39   private static final String USER1 = "processesTestUser";
  40   private static final String VSP_ID = "vsp";
  41   private static final Version VERSION = new Version(0, 1);
  42   private static final String COMPONENT_ID = "component";
  43   private static final String PROCESS1_ID = "process1";
  44   private static final String PROCESS2_ID = "process2";
  45   private static final String ARTIFACT_NAME = "artifact.sh";
  46
  47   @Mock
  48   private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
  49   @Mock
  50   private ActivityLogManager activityLogManagerMock;
  51
  52   @InjectMocks
  53   @Spy
  54   private ProcessManagerImpl processManager;
  55   @Captor
  56   private ArgumentCaptor<ActivityLogEntity> activityLogEntityArg;
  57
  58   @BeforeMethod
  59   public void setUp() throws Exception {
  60     MockitoAnnotations.initMocks(this);
  61   }
  62
  63   @Test
  64   public void testListWhenNone() {
  65     Collection<ProcessEntity> processes =
  66         processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
  67     Assert.assertEquals(processes.size(), 0);
  68   }
  69
  70   @Test
  71   public void testList() {
  72     doReturn(Arrays.asList(
  73         createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID),
  74         createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID)))
  75         .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
  76
  77     Collection<ProcessEntity> actual =
  78         processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
  79     Assert.assertEquals(actual.size(), 2);
  80   }
  81
  82   @Test
  83   public void testDeleteListWhenNone() {
  84     processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
  85     verify(vendorSoftwareProductDaoMock, never()).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
  86   }
  87
  88   @Test
  89   public void testDeleteList() {
  90     ProcessEntity process1 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
  91     ProcessEntity process2 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID);
  92     doReturn(Arrays.asList(process1, process2))
  93         .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
  94     doNothing().when(processManager)
  95         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
  96     doNothing().when(processManager)
  97         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process2.getName());
  98
  99     processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
 100
 101     verify(vendorSoftwareProductDaoMock).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
 102     verify(processManager)
 103         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
 104     verify(processManager)
 105         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process2.getName());
 106   }
 107
 108   @Test
 109   public void testCreate() {
 110     ProcessEntity processToCreate = createProcess(VSP_ID, VERSION, COMPONENT_ID, null);
 111     processToCreate.setName("proc name");
 112
 113     doNothing().when(processManager)
 114         .validateUniqueName(VSP_ID, VERSION, COMPONENT_ID, processToCreate.getName());
 115     doNothing().when(processManager)
 116         .createUniqueName(VSP_ID, VERSION, COMPONENT_ID, processToCreate.getName());
 117
 118     ProcessEntity process = processManager.createProcess(processToCreate, USER1);
 119     Assert.assertNotNull(process);
 120     process.setId(process.getId());
 121
 122     Assert.assertEquals(process, processToCreate);
 123   }
 124
 125   @Test(expectedExceptions = CoreException.class)
 126   public void testCreateWithExistingName_negative() {
 127     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, null);
 128     process.setName("p1 name");
 129
 130     doThrow(new CoreException(
 131         new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
 132         .when(processManager).validateUniqueName(VSP_ID, VERSION, COMPONENT_ID, process.getName());
 133
 134     processManager.createProcess(process, USER1);
 135   }
 136
 137   @Test
 138   public void testUpdateNonExistingProcessId_negative() {
 139     doReturn(null).when(vendorSoftwareProductDaoMock)
 140         .getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 141
 142     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1,
 143         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 144   }
 145
 146   @Test(expectedExceptions = CoreException.class)
 147   public void testUpdateWithExistingName_negative() {
 148     ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 149     doReturn(existingProcess).when
 150         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 151
 152     ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 153     doThrow(new CoreException(
 154         new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
 155         .when(processManager)
 156         .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
 157             processToUpdate.getName());
 158
 159     processManager.updateProcess(processToUpdate, USER1);
 160   }
 161
 162   @Test
 163   public void testUpdate() {
 164     ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 165     doReturn(existingProcess).when
 166         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 167
 168     ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 169     doNothing().when(processManager)
 170         .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
 171             processToUpdate.getName());
 172
 173     processManager.updateProcess(processToUpdate, USER1);
 174     verify(vendorSoftwareProductDaoMock).updateProcess(processToUpdate);
 175   }
 176
 177
 178   @Test
 179   public void testGetNonExistingProcessId_negative() {
 180     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
 181         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 182   }
 183
 184   @Test
 185   public void testGet() {
 186     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 187     doReturn(process).when
 188         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 189     ProcessEntity actual =
 190         processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 191     Assert.assertEquals(actual, process);
 192     Assert.assertNull(actual.getArtifactName());
 193   }
 194
 195   @Test
 196   public void testGetAfterUploadArtifact() {
 197     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 198     process.setArtifactName(ARTIFACT_NAME);
 199     doReturn(process).when
 200         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 201     ProcessEntity actual =
 202         processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 203     Assert.assertEquals(actual, process);
 204     Assert.assertEquals(actual.getArtifactName(), ARTIFACT_NAME);
 205   }
 206
 207   @Test(expectedExceptions = CoreException.class)
 208   public void testDeleteNonExistingProcessId_negative() {
 209     processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 210   }
 211
 212   @Test
 213   public void testDelete() {
 214     ProcessEntity processToDelete = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 215     doReturn(processToDelete).when
 216         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 217     doNothing().when(processManager).deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID,
 218         processToDelete.getName());
 219
 220     processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 221     verify(vendorSoftwareProductDaoMock).deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 222     verify(processManager)
 223         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, processToDelete.getName());
 224   }
 225
 226   @Test
 227   public void testUploadArtifactNonExistingProcessId_negative() {
 228     testUploadArtifact_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
 229         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 230   }
 231
 232   @Test
 233   public void testUploadArtifact() {
 234     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 235     doReturn(process).when
 236         (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 237
 238     byte[] artifactBytes = "bla bla".getBytes();
 239     processManager
 240         .uploadProcessArtifact(new ByteArrayInputStream(artifactBytes), ARTIFACT_NAME,
 241             VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 242     verify(vendorSoftwareProductDaoMock)
 243         .uploadProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, artifactBytes,
 244             ARTIFACT_NAME);
 245
 246     verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
 247     ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
 248     Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION.getMajor()+1));
 249     Assert.assertTrue(activityLogEntity.isSuccess());
 250   }
 251
 252   @Test
 253   public void testGetArtifactWhenNone_negative() {
 254     testGetFile_negative(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID, USER1,
 255         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 256   }
 257
 258   @Test
 259   public void testGetArtifactNonExistingProcessId_negative() {
 260     testGetFile_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing process id", USER1,
 261         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 262   }
 263
 264   @Test
 265   public void testGetArtifact() {
 266     ProcessEntity processArtifact =
 267         new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 268     processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
 269     doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
 270         .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 271
 272     File actual =
 273         processManager.getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 274     Assert.assertNotNull(actual);
 275   }
 276
 277   @Test
 278   public void testDeleteArtifactWhenNone_negative() {
 279     testDeleteArtifact_negative(VSP_ID, COMPONENT_ID, PROCESS2_ID, USER1,
 280         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 281   }
 282
 283   @Test
 284   public void testDeleteArtifactNonExistingProcessId_negative() {
 285     testDeleteArtifact_negative(VSP_ID, COMPONENT_ID, "non existing process id", USER1,
 286         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 287   }
 288
 289   @Test
 290   public void testDeleteArtifact() {
 291     ProcessEntity processArtifact =
 292         new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 293     processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
 294     doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
 295         .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 296
 297     processManager.deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
 298     verify(vendorSoftwareProductDaoMock)
 299         .deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
 300   }
 301
 302
 303   private ProcessEntity createProcess(String vspId, Version version, String componentId,
 304                                       String processId) {
 305     ProcessEntity process = new ProcessEntity(vspId, version, componentId, processId);
 306     process.setName(processId + " name");
 307     process.setDescription(processId + " desc");
 308     process.setType(ProcessType.Other);
 309     return process;
 310   }
 311
 312   private void testGet_negative(String vspId, Version version, String componentId, String processId,
 313                                 String user, String expectedErrorCode) {
 314     try {
 315       processManager.getProcess(vspId, version, componentId, processId, user);
 316       Assert.fail();
 317     } catch (CoreException exception) {
 318       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 319     }
 320   }
 321
 322   private void testUpdate_negative(String vspId, Version version, String componentId,
 323                                    String processId, String user,
 324                                    String expectedErrorCode) {
 325     try {
 326       processManager
 327           .updateProcess(new ProcessEntity(vspId, version, componentId, processId), user);
 328       Assert.fail();
 329     } catch (CoreException exception) {
 330       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 331     }
 332   }
 333
 334   private void testGetFile_negative(String vspId, Version version, String componentId,
 335                                     String processId, String user, String expectedErrorCode) {
 336     try {
 337       processManager.getProcessArtifact(vspId, version, componentId, processId, user);
 338       Assert.fail();
 339     } catch (CoreException exception) {
 340       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 341     }
 342   }
 343
 344   private void testUploadArtifact_negative(String vspId, Version version, String componentId,
 345                                            String processId, String user,
 346                                            String expectedErrorCode) {
 347     try {
 348       processManager
 349           .uploadProcessArtifact(new ByteArrayInputStream("bla bla".getBytes()), "artifact.sh",
 350               vspId, version, componentId, processId, user);
 351       Assert.fail();
 352     } catch (CoreException exception) {
 353       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 354     }
 355   }
 356
 357   private void testDeleteArtifact_negative(String vspId, String componentId, String processId,
 358                                            String user, String expectedErrorCode) {
 359     try {
 360       processManager.deleteProcessArtifact(vspId, VERSION, componentId, processId, user);
 361       Assert.fail();
 362     } catch (CoreException exception) {
 363       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 364     }
 365   }
 366
 367 }