gerrit.onap Code Review - sdc/sdc-workflow-designer.git/blob

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