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