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

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