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