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