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