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