gerrit.onap Code Review - sdc.git/blob

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