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