workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java

   1 package org.onap.sdc.workflow.services.impl;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertTrue;
   5 import static org.mockito.ArgumentMatchers.any;
   6 import static org.mockito.ArgumentMatchers.anyString;
   7 import static org.mockito.ArgumentMatchers.argThat;
   8 import static org.mockito.ArgumentMatchers.eq;
   9 import static org.mockito.Mockito.doReturn;
  10 import static org.mockito.Mockito.doThrow;
  11 import static org.mockito.Mockito.times;
  12 import static org.mockito.Mockito.verify;
  13 import static org.onap.sdc.workflow.services.types.WorkflowVersionState.CERTIFIED;
  14 import static org.onap.sdc.workflow.services.types.WorkflowVersionState.DRAFT;
  15
  16 import java.io.IOException;
  17 import java.io.InputStream;
  18 import java.util.ArrayList;
  19 import java.util.Arrays;
  20 import java.util.Collection;
  21 import java.util.Collections;
  22 import java.util.List;
  23 import java.util.Optional;
  24 import java.util.Set;
  25 import org.apache.commons.io.IOUtils;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.ArgumentCaptor;
  29 import org.mockito.InjectMocks;
  30 import org.mockito.Mock;
  31 import org.mockito.Spy;
  32 import org.mockito.junit.MockitoJUnitRunner;
  33 import org.onap.sdc.workflow.persistence.ArtifactRepository;
  34 import org.onap.sdc.workflow.persistence.ParameterRepository;
  35 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
  36 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
  37 import org.onap.sdc.workflow.persistence.types.ParameterRole;
  38 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  39 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
  40 import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
  41 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
  42 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  43 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  44 import org.onap.sdc.workflow.services.types.WorkflowVersion;
  45 import org.onap.sdc.workflow.services.types.WorkflowVersionState;
  46 import org.openecomp.sdc.versioning.VersioningManager;
  47 import org.openecomp.sdc.versioning.dao.types.Version;
  48 import org.openecomp.sdc.versioning.dao.types.VersionState;
  49 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  50 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  51 import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
  52 import org.springframework.mock.web.MockMultipartFile;
  53
  54 @RunWith(MockitoJUnitRunner.class)
  55 public class WorkflowVersionManagerImplTest {
  56
  57     private static final String ITEM1_ID = "item_id_1";
  58     private static final String VERSION1_ID = "version_id_1";
  59     private static final String VERSION2_ID = "version_id_2";
  60
  61     @Mock
  62     private VersioningManager versioningManagerMock;
  63     @Mock
  64     private ParameterRepository parameterRepositoryMock;
  65     @Mock
  66     private ArtifactRepository artifactRepositoryMock;
  67     @Mock
  68     private VersionMapper versionMapperMock;
  69     @Mock
  70     private VersionStateMapper versionStateMapperMock;
  71     @Spy
  72     @InjectMocks
  73     private WorkflowVersionManagerImpl workflowVersionManager;
  74
  75     @Test(expected = EntityNotFoundException.class)
  76     public void shouldThrowExceptionWhenVersionDontExist() {
  77         Version nonExistingVersion = new Version(VERSION1_ID);
  78         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion);
  79         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
  80     }
  81
  82     @Test
  83     public void shouldReturnWorkflowVersionWhenExist() {
  84         Version version = new Version(VERSION1_ID);
  85         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
  86         doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(any(Version.class));
  87         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), any(Version.class));
  88         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
  89                 .list(eq(ITEM1_ID), eq(VERSION1_ID), any(ParameterRole.class));
  90         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
  91         verify(versioningManagerMock).get(ITEM1_ID, version);
  92     }
  93
  94     @Test
  95     public void shouldReturnWorkflowVersionList() {
  96         Version version1 = new Version(VERSION1_ID);
  97         Version version2 = new Version(VERSION2_ID);
  98         List<Version> versionList = Arrays.asList(version1,version2);
  99         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
 100         WorkflowVersion workflowVersion1 = new WorkflowVersion();
 101         workflowVersion1.setId(VERSION1_ID);
 102         workflowVersion1.setName(VERSION1_ID);
 103         WorkflowVersion workflowVersion2 = new WorkflowVersion();
 104         workflowVersion2.setId(VERSION2_ID);
 105         workflowVersion2.setName(VERSION2_ID);
 106         doReturn(workflowVersion2).when(versionMapperMock).versionToWorkflowVersion(version2);
 107         doReturn(Collections.emptyList()).when(parameterRepositoryMock).list(eq(ITEM1_ID),anyString(),eq(ParameterRole.INPUT));
 108         doReturn(Collections.emptyList()).when(parameterRepositoryMock).list(eq(ITEM1_ID),anyString(),eq(ParameterRole.OUTPUT));
 109         workflowVersionManager.list(ITEM1_ID, null);
 110         verify(versioningManagerMock).list(ITEM1_ID);
 111         verify(versionMapperMock, times(2)).versionToWorkflowVersion(any(Version.class));
 112     }
 113
 114     @Test
 115     public void shouldReturnCertifiedWorkflowVersionList() {
 116         Version version1 = new Version(VERSION1_ID);
 117         version1.setStatus(VersionStatus.Certified);
 118         Version version2 = new Version(VERSION2_ID);
 119         version2.setStatus(VersionStatus.Draft);
 120         List<Version> versionList = Arrays.asList(version1, version2);
 121         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
 122         WorkflowVersion workflowVersion1 = new WorkflowVersion();
 123         workflowVersion1.setId(VERSION1_ID);
 124         workflowVersion1.setName(VERSION1_ID);
 125         WorkflowVersion workflowVersion2 = new WorkflowVersion();
 126         workflowVersion2.setId(VERSION2_ID);
 127         workflowVersion2.setName(VERSION2_ID);
 128         doReturn(workflowVersion1).when(versionMapperMock).versionToWorkflowVersion(version1);
 129         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 130                                    .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.INPUT));
 131         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 132                                    .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.OUTPUT));
 133         doReturn(VersionStatus.Certified).when(versionStateMapperMock)
 134                                                                 .workflowVersionStateToVersionStatus(
 135                                                                        WorkflowVersionState.CERTIFIED);
 136
 137         assertEquals(1,  workflowVersionManager.list(ITEM1_ID, Collections.singleton(WorkflowVersionState.CERTIFIED)).size());
 138         verify(versioningManagerMock).list(ITEM1_ID);
 139         verify(versionMapperMock, times(1)).versionToWorkflowVersion(any(Version.class));
 140
 141     }
 142
 143     @Test
 144     public void shouldUpdateWorkflowVersion() {
 145         String updatedDescription = "WorkflowVersion description updated";
 146         Version retrievedVersion = new Version(VERSION1_ID);
 147         retrievedVersion.setName("1.0");
 148         retrievedVersion.setDescription("WorkflowVersion description");
 149         retrievedVersion.setStatus(VersionStatus.Draft);
 150         VersionState versionState = new VersionState();
 151         versionState.setDirty(true);
 152         retrievedVersion.setState(versionState);
 153         doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 154         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
 155
 156         WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID);
 157         inputVersion.setName("1.0");
 158         inputVersion.setDescription(updatedDescription);
 159         ParameterEntity toBeCreated = new ParameterEntity("Input1");
 160         inputVersion.setInputs(Collections.singleton(toBeCreated));
 161         ParameterEntity toBeUpdated = new ParameterEntity("Output1");
 162         inputVersion.setOutputs(Collections.singleton(toBeUpdated));
 163         doReturn(Collections.emptyList()).when(parameterRepositoryMock).list(ITEM1_ID,VERSION1_ID,ParameterRole.INPUT);
 164         ParameterEntity toBeDeleted = new ParameterEntity("Output2");
 165         toBeDeleted.setId("parameter_id_1");
 166         Collection<ParameterEntity> currentOutputs = Arrays.asList(toBeDeleted, toBeUpdated);
 167         doReturn(currentOutputs).when(parameterRepositoryMock).list(ITEM1_ID,VERSION1_ID,ParameterRole.OUTPUT);
 168
 169         Version mappedInputVersion = new Version(VERSION1_ID);
 170         mappedInputVersion.setName("1.0");
 171         mappedInputVersion.setDescription(updatedDescription);
 172         doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion);
 173
 174         ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
 175         workflowVersionManager.update(ITEM1_ID, inputVersion);
 176
 177         verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture());
 178         Version captorVersion = versionArgCaptor.getValue();
 179         assertEquals("1.0", captorVersion.getName());
 180         assertEquals(updatedDescription, captorVersion.getDescription());
 181         assertEquals(VersionStatus.Draft, captorVersion.getStatus());
 182         verify(versioningManagerMock).publish(ITEM1_ID, mappedInputVersion, "Update version");
 183
 184         verify(parameterRepositoryMock).delete(ITEM1_ID,VERSION1_ID,"parameter_id_1");
 185         verify(parameterRepositoryMock).create(ITEM1_ID,VERSION1_ID,ParameterRole.INPUT,toBeCreated);
 186         verify(parameterRepositoryMock).update(ITEM1_ID,VERSION1_ID,ParameterRole.OUTPUT,toBeUpdated);
 187
 188     }
 189
 190
 191     @Test
 192     public void shouldCreateWorkflowVersion() {
 193         Version version = new Version(VERSION1_ID);
 194         version.setDescription("version desc");
 195         doReturn(version).when(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
 196         WorkflowVersion versionRequest = new WorkflowVersion();
 197         versionRequest.setDescription("version desc");
 198         versionRequest.setInputs(Collections.emptyList());
 199         versionRequest.setOutputs(Collections.emptyList());
 200         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 201         doReturn(workflowVersion).when(workflowVersionManager).get(ITEM1_ID, VERSION1_ID);
 202         workflowVersionManager.create(ITEM1_ID, null, versionRequest);
 203         verify(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
 204     }
 205
 206     @Test(expected = VersionCreationException.class)
 207     public void shouldTrowExceptionWhenDraftVersionExists() {
 208         WorkflowVersion versionRequestDto = new WorkflowVersion();
 209
 210         Version baseVersion = new Version(VERSION2_ID);
 211         baseVersion.setStatus(VersionStatus.Draft);
 212         List<Version> versions = Collections.singletonList(baseVersion);
 213         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 214
 215         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
 216     }
 217
 218     @Test(expected = VersionCreationException.class)
 219     public void shouldTrowExceptionWhenInputsSupplied() {
 220         WorkflowVersion versionRequestDto = new WorkflowVersion();
 221         versionRequestDto.setInputs(Collections.singleton(new ParameterEntity()));
 222         Version baseVersion = new Version(VERSION2_ID);
 223         baseVersion.setStatus(VersionStatus.Draft);
 224         List<Version> versions = Collections.singletonList(baseVersion);
 225         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 226
 227         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
 228     }
 229
 230     @Test(expected = EntityNotFoundException.class)
 231     public void getStateOfNonExisting() {
 232         doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 233         workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 234     }
 235
 236     @Test
 237     public void getState() {
 238         Version version = new Version(VERSION1_ID);
 239         version.setStatus(VersionStatus.Certified);
 240         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 241         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 242
 243         WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 244         assertEquals(CERTIFIED, state);
 245     }
 246
 247     @Test(expected = EntityNotFoundException.class)
 248     public void updateStateOfNonExisting() {
 249         doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 250         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 251     }
 252
 253     @Test(expected = VersionStateModificationException.class)
 254     public void updateStateToCurrentState() {
 255         Version version = new Version(VERSION1_ID);
 256         version.setStatus(VersionStatus.Draft);
 257         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 258         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 259
 260         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
 261     }
 262
 263     @Test(expected = VersionStateModificationException.class)
 264     public void updateStateWhenCertified() {
 265         Version version = new Version(VERSION1_ID);
 266         version.setStatus(VersionStatus.Certified);
 267         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 268         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 269         doThrow(new RuntimeException()).when(versioningManagerMock)
 270                 .submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
 271
 272         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 273     }
 274
 275     @Test
 276     public void updateState() {
 277         Version retrievedVersion = new Version(VERSION1_ID);
 278         retrievedVersion.setStatus(VersionStatus.Draft);
 279         doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 280         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
 281
 282         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 283
 284         verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
 285     }
 286
 287     @Test
 288     public void shouldUploadArtifact() {
 289         Version version = new Version(VERSION1_ID);
 290         version.setStatus(VersionStatus.Draft);
 291         VersionState versionState = new VersionState();
 292         versionState.setDirty(false);
 293         version.setState(versionState);
 294         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 295         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 296
 297         MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
 298         workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
 299
 300         verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
 301     }
 302
 303     @Test(expected = EntityNotFoundException.class)
 304     public void shouldThrowExceptionWhenArtifactNotFound() {
 305         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 306
 307         doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 308         workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 309     }
 310
 311     @Test
 312     public void shouldReturnArtifact() throws IOException {
 313         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 314
 315         InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
 316         ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock);
 317         doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 318         ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 319         assertEquals(artifactMock, returnedArtifact);
 320     }
 321
 322     @Test(expected = VersionModificationException.class)
 323     public void shouldThrowExceptionInDeleteArtifactWhenVersionIsCertified() {
 324         Version version = new Version(VERSION1_ID);
 325         doReturn(version).when(versioningManagerMock).get(ITEM1_ID,version);
 326         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 327         workflowVersion.setState(WorkflowVersionState.CERTIFIED);
 328         doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(version);
 329         workflowVersionManager.deleteArtifact(ITEM1_ID,VERSION1_ID);
 330     }
 331
 332     @Test
 333     public void shouldDeleteArtifact() {
 334         Version version = new Version(VERSION1_ID);
 335         doReturn(version).when(versioningManagerMock).get(ITEM1_ID,version);
 336         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 337         doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(version);
 338         workflowVersionManager.deleteArtifact(ITEM1_ID,VERSION1_ID);
 339         verify(artifactRepositoryMock).delete(ITEM1_ID,VERSION1_ID);
 340         verify(versioningManagerMock).publish(ITEM1_ID,version,"Delete Artifact");
 341     }
 342
 343     private static Version eqVersion(String versionId) {
 344         return argThat(version -> versionId.equals(version.getId()));
 345     }
 346 }