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.mockito.ArgumentMatchers.argThat;
   5 import static org.mockito.ArgumentMatchers.eq;
   6 import static org.mockito.ArgumentMatchers.any;
   7 import static org.mockito.Mockito.doReturn;
   8 import static org.mockito.Mockito.doThrow;
   9 import static org.mockito.Mockito.times;
  10 import static org.mockito.Mockito.verify;
  11 import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED;
  12 import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.DRAFT;
  13
  14 import java.io.IOException;
  15 import java.io.InputStream;
  16 import java.util.Arrays;
  17 import java.util.Collections;
  18 import java.util.Date;
  19 import java.util.List;
  20 import java.util.Optional;
  21 import org.apache.commons.io.IOUtils;
  22 import org.junit.Test;
  23 import org.junit.runner.RunWith;
  24 import org.mockito.ArgumentCaptor;
  25 import org.mockito.ArgumentMatcher;
  26 import org.mockito.InjectMocks;
  27 import org.mockito.Mock;
  28 import org.mockito.junit.MockitoJUnitRunner;
  29 import org.onap.sdc.workflow.api.types.VersionRequestDto;
  30 import org.onap.sdc.workflow.persistence.ArtifactRepository;
  31 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
  32 import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
  33 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
  34 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  35 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
  36 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
  37 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  38 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  39 import org.openecomp.sdc.versioning.VersioningManager;
  40 import org.openecomp.sdc.versioning.dao.types.Version;
  41 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  42 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  43 import org.springframework.mock.web.MockMultipartFile;
  44
  45 @RunWith(MockitoJUnitRunner.class)
  46 public class WorkflowVersionManagerImplTest {
  47
  48     private static final String ITEM1_ID = "item_id_1";
  49     private static final String VERSION1_ID = "version_id_1";
  50     private static final String VERSION2_ID = "version_id_2";
  51
  52     @Mock
  53     private VersioningManager versioningManagerMock;
  54     @Mock
  55     private ArtifactRepository artifactRepositoryMock;
  56     @Mock
  57     private VersionMapper versionMapperMock;
  58     @Mock
  59     private VersionStateMapper versionStateMapperMock;
  60     @InjectMocks
  61     private WorkflowVersionManagerImpl workflowVersionManager;
  62
  63     @Test(expected = EntityNotFoundException.class)
  64     public void shouldThrowExceptionWhenVersionDontExist() {
  65         Version nonExistingVersion = new Version(VERSION1_ID);
  66         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion);
  67         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
  68     }
  69
  70     @Test
  71     public void shouldReturnWorkflowVersionWhenExist() {
  72         Version version = new Version(VERSION1_ID);
  73         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, version);
  74         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
  75         verify(versioningManagerMock).get(ITEM1_ID, version);
  76     }
  77
  78     @Test
  79     public void shouldReturnWorkflowVersionList() {
  80         List<Version> versionList = Arrays.asList(new Version(VERSION1_ID), new Version(VERSION2_ID));
  81         versionList.forEach(version -> {
  82             version.setBaseId("baseVersionId");
  83             version.setDescription("Version description");
  84             version.setName("name");
  85             version.setCreationTime(new Date());
  86             version.setModificationTime(new Date());
  87         });
  88         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
  89         workflowVersionManager.list(ITEM1_ID);
  90         verify(versioningManagerMock).list(ITEM1_ID);
  91         verify(versionMapperMock, times(2)).versionToWorkflowVersion(any(Version.class));
  92     }
  93
  94     @Test
  95     public void shouldUpdateWorkflowVersion() {
  96         Version retrievedVersion = new Version(VERSION1_ID);
  97         retrievedVersion.setName("1.0");
  98         retrievedVersion.setDescription("WorkflowVersion description");
  99         retrievedVersion.setStatus(VersionStatus.Draft);
 100         doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 101         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
 102
 103         WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID);
 104         inputVersion.setName("1.0");
 105         inputVersion.setDescription("WorkflowVersion description updated");
 106
 107         Version mappedInputVersion = new Version(VERSION1_ID);
 108         mappedInputVersion.setName("1.0");
 109         mappedInputVersion.setDescription("WorkflowVersion description updated");
 110         doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion);
 111
 112         ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
 113         workflowVersionManager.update(ITEM1_ID, inputVersion);
 114
 115         verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture());
 116         Version captorVersion = versionArgCaptor.getValue();
 117         assertEquals("1.0", captorVersion.getName());
 118         assertEquals("WorkflowVersion description updated", captorVersion.getDescription());
 119         assertEquals(VersionStatus.Draft, captorVersion.getStatus());
 120         verify(versioningManagerMock).publish(ITEM1_ID, mappedInputVersion, "Update version");
 121     }
 122
 123     @Test
 124     public void shouldCreateWorkflowVersion() {
 125         Version version = new Version(VERSION1_ID);
 126         version.setDescription("version desc");
 127         doReturn(version).when(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
 128         VersionRequestDto workflowVersion = new VersionRequestDto();
 129         workflowVersion.setDescription("version desc");
 130         workflowVersionManager.create(ITEM1_ID, workflowVersion);
 131         verify(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
 132
 133     }
 134
 135     @Test(expected = VersionCreationException.class)
 136     public void shouldTrowExceptionWhenDraftVersionExists() {
 137         VersionRequestDto versionRequestDto = new VersionRequestDto();
 138         versionRequestDto.setBaseVersionId(VERSION2_ID);
 139
 140         Version baseVersion = new Version(VERSION2_ID);
 141         baseVersion.setStatus(VersionStatus.Draft);
 142         List<Version> versions = Collections.singletonList(baseVersion);
 143         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 144
 145         workflowVersionManager.create(ITEM1_ID, versionRequestDto);
 146     }
 147
 148     @Test(expected = EntityNotFoundException.class)
 149     public void getStateOfNonExisting() {
 150         doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 151         workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 152     }
 153
 154     @Test
 155     public void getState() {
 156         Version version = new Version(VERSION1_ID);
 157         version.setStatus(VersionStatus.Certified);
 158         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 159         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 160
 161         WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 162         assertEquals(CERTIFIED, state);
 163     }
 164
 165     @Test(expected = EntityNotFoundException.class)
 166     public void updateStateOfNonExisting() {
 167         doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 168         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 169     }
 170
 171     @Test(expected = VersionStateModificationException.class)
 172     public void updateStateToCurrentState() {
 173         Version version = new Version(VERSION1_ID);
 174         version.setStatus(VersionStatus.Draft);
 175         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 176         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 177
 178         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
 179     }
 180
 181     @Test(expected = VersionStateModificationException.class)
 182     public void updateStateWhenCertified() {
 183         Version version = new Version(VERSION1_ID);
 184         version.setStatus(VersionStatus.Certified);
 185         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 186         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 187
 188         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 189     }
 190
 191     @Test
 192     public void updateState() {
 193         Version retrievedVersion = new Version(VERSION1_ID);
 194         retrievedVersion.setStatus(VersionStatus.Draft);
 195         doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 196         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
 197         doReturn(VersionStatus.Certified).when(versionStateMapperMock).workflowVersionStateToVersionStatus(CERTIFIED);
 198
 199         ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
 200         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 201
 202         verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture());
 203         assertEquals(VersionStatus.Certified, versionArgCaptor.getValue().getStatus());
 204         verify(versioningManagerMock)
 205                 .publish(eq(ITEM1_ID), eqVersion(VERSION1_ID), eq("Update version state from DRAFT to CERTIFIED"));
 206     }
 207
 208     @Test
 209     public void shouldUploadArtifact() {
 210         Version version = new Version(VERSION1_ID);
 211         version.setStatus(VersionStatus.Draft);
 212         doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 213         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 214
 215         MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
 216         workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
 217
 218         verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
 219     }
 220
 221     @Test(expected = EntityNotFoundException.class)
 222     public void shouldThrowExceptionWhenArtifactNotFound() {
 223         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 224
 225         doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 226         workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 227     }
 228
 229     @Test
 230     public void shouldReturnArtifact() throws IOException {
 231         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
 232
 233         InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
 234         ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock);
 235         doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 236         ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 237         assertEquals(artifactMock, returnedArtifact);
 238     }
 239
 240     private static Version eqVersion(String versionId) {
 241         return argThat(new EqVersion(versionId));
 242     }
 243
 244     private static class EqVersion implements ArgumentMatcher<Version> {
 245
 246         private final String versionId;
 247
 248         EqVersion(String versionId) {
 249             this.versionId = versionId;
 250         }
 251
 252         @Override
 253         public boolean matches(Version version) {
 254             return versionId.equals(version.getId());
 255         }
 256     }
 257
 258 }