1 package org.onap.sdc.workflow.services.impl;
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.doNothing;
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;
16 import java.io.IOException;
17 import java.io.InputStream;
18 import java.util.Arrays;
19 import java.util.Collection;
20 import java.util.Collections;
21 import java.util.List;
22 import java.util.Optional;
24 import org.apache.commons.io.IOUtils;
25 import org.junit.Rule;
26 import org.junit.Test;
27 import org.junit.rules.ExpectedException;
28 import org.junit.runner.RunWith;
29 import org.mockito.ArgumentCaptor;
30 import org.mockito.InjectMocks;
31 import org.mockito.Mock;
32 import org.mockito.Spy;
33 import org.mockito.junit.MockitoJUnitRunner;
34 import org.onap.sdc.workflow.persistence.ArtifactRepository;
35 import org.onap.sdc.workflow.persistence.ParameterRepository;
36 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
37 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
38 import org.onap.sdc.workflow.persistence.types.ParameterRole;
39 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
40 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
41 import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
42 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
43 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationMissingArtifactException;
44 import org.onap.sdc.workflow.services.exceptions.WorkflowModificationException;
45 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
46 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
47 import org.onap.sdc.workflow.services.types.WorkflowVersion;
48 import org.onap.sdc.workflow.services.types.WorkflowVersionState;
49 import org.openecomp.sdc.versioning.ItemManager;
50 import org.openecomp.sdc.versioning.VersioningManager;
51 import org.openecomp.sdc.versioning.dao.types.Version;
52 import org.openecomp.sdc.versioning.dao.types.VersionState;
53 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
54 import org.openecomp.sdc.versioning.types.Item;
55 import org.openecomp.sdc.versioning.types.ItemStatus;
56 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
57 import org.springframework.mock.web.MockMultipartFile;
59 @RunWith(MockitoJUnitRunner.class)
60 public class WorkflowVersionManagerImplTest {
62 private static final String ITEM1_ID = "item_id_1";
63 private static final String VERSION1_ID = "version_id_1";
64 private static final String VERSION2_ID = "version_id_2";
67 private ItemManager itemManagerMock;
69 private VersioningManager versioningManagerMock;
71 private ParameterRepository parameterRepositoryMock;
73 private ArtifactRepository artifactRepositoryMock;
75 private VersionMapper versionMapperMock;
77 private VersionStateMapper versionStateMapperMock;
79 public ExpectedException exceptionRule = ExpectedException.none();
82 private WorkflowVersionManagerImpl workflowVersionManager;
84 @Test(expected = EntityNotFoundException.class)
85 public void shouldThrowExceptionWhenVersionDontExist() {
86 Version nonExistingVersion = new Version(VERSION1_ID);
87 doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion);
88 workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
91 @Test(expected = WorkflowModificationException.class)
92 public void shouldThrowExceptionWhenCreatingVersionForArchivedWorkflow() {
93 Item mockItem = new Item();
94 mockItem.setId(ITEM1_ID);
95 mockItem.setStatus(ItemStatus.ARCHIVED);
96 doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
97 workflowVersionManager.create(ITEM1_ID, null, new WorkflowVersion(VERSION1_ID));
100 @Test(expected = WorkflowModificationException.class)
101 public void shouldThrowExceptionWhenUpdatingVersionForArchivedWorkflow() {
102 Item mockItem = new Item();
103 mockItem.setId(ITEM1_ID);
104 mockItem.setStatus(ItemStatus.ARCHIVED);
105 doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
106 workflowVersionManager.update(ITEM1_ID, new WorkflowVersion(VERSION1_ID));
109 @Test(expected = WorkflowModificationException.class)
110 public void shouldThrowExceptionWhenUploadingArtifactForArchivedWorkflow() {
111 Item mockItem = new Item();
112 mockItem.setId(ITEM1_ID);
113 mockItem.setStatus(ItemStatus.ARCHIVED);
114 doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
115 MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
116 workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
119 @Test(expected = WorkflowModificationException.class)
120 public void shouldThrowExceptionWhenDeletingArtifactForArchivedWorkflow() {
121 Item mockItem = new Item();
122 mockItem.setId(ITEM1_ID);
123 mockItem.setStatus(ItemStatus.ARCHIVED);
124 doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
125 workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
129 public void shouldReturnWorkflowVersionWhenExist() {
130 Version version = new Version(VERSION1_ID);
131 WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
132 doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(any(Version.class));
133 doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), any(Version.class));
134 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
135 .list(eq(ITEM1_ID), eq(VERSION1_ID), any(ParameterRole.class));
136 workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
137 verify(versioningManagerMock).get(ITEM1_ID, version);
141 public void shouldReturnWorkflowVersionList() {
142 Version version1 = new Version(VERSION1_ID);
143 Version version2 = new Version(VERSION2_ID);
144 List<Version> versionList = Arrays.asList(version1, version2);
145 doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
146 WorkflowVersion workflowVersion1 = new WorkflowVersion();
147 workflowVersion1.setId(VERSION1_ID);
148 workflowVersion1.setName(VERSION1_ID);
149 WorkflowVersion workflowVersion2 = new WorkflowVersion();
150 workflowVersion2.setId(VERSION2_ID);
151 workflowVersion2.setName(VERSION2_ID);
152 doReturn(workflowVersion2).when(versionMapperMock).versionToWorkflowVersion(version2);
153 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
154 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.INPUT));
155 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
156 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.OUTPUT));
157 workflowVersionManager.list(ITEM1_ID, null);
158 verify(versioningManagerMock).list(ITEM1_ID);
159 verify(versionMapperMock, times(2)).versionToWorkflowVersion(any(Version.class));
163 public void shouldReturnCertifiedWorkflowVersionList() {
164 Version version1 = new Version(VERSION1_ID);
165 version1.setStatus(VersionStatus.Certified);
166 Version version2 = new Version(VERSION2_ID);
167 version2.setStatus(VersionStatus.Draft);
168 List<Version> versionList = Arrays.asList(version1, version2);
169 doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
170 WorkflowVersion workflowVersion1 = new WorkflowVersion();
171 workflowVersion1.setId(VERSION1_ID);
172 workflowVersion1.setName(VERSION1_ID);
173 WorkflowVersion workflowVersion2 = new WorkflowVersion();
174 workflowVersion2.setId(VERSION2_ID);
175 workflowVersion2.setName(VERSION2_ID);
176 doReturn(workflowVersion1).when(versionMapperMock).versionToWorkflowVersion(version1);
177 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
178 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.INPUT));
179 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
180 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.OUTPUT));
181 doReturn(VersionStatus.Certified).when(versionStateMapperMock)
182 .workflowVersionStateToVersionStatus(
183 WorkflowVersionState.CERTIFIED);
186 workflowVersionManager.list(ITEM1_ID, Collections.singleton(WorkflowVersionState.CERTIFIED)).size());
187 verify(versioningManagerMock).list(ITEM1_ID);
188 verify(versionMapperMock, times(1)).versionToWorkflowVersion(any(Version.class));
193 public void shouldUpdateWorkflowVersion() {
194 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
195 String updatedDescription = "WorkflowVersion description updated";
196 Version retrievedVersion = new Version(VERSION1_ID);
197 retrievedVersion.setName("1.0");
198 retrievedVersion.setDescription("WorkflowVersion description");
199 retrievedVersion.setStatus(VersionStatus.Draft);
200 VersionState versionState = new VersionState();
201 versionState.setDirty(true);
202 retrievedVersion.setState(versionState);
203 doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
204 doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
206 WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID);
207 inputVersion.setName("1.0");
208 inputVersion.setDescription(updatedDescription);
209 ParameterEntity toBeCreated = new ParameterEntity("Input1");
210 inputVersion.setInputs(Collections.singleton(toBeCreated));
211 ParameterEntity toBeUpdated = new ParameterEntity("Output1");
212 inputVersion.setOutputs(Collections.singleton(toBeUpdated));
213 doReturn(Collections.emptyList()).when(parameterRepositoryMock)
214 .list(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
215 ParameterEntity toBeDeleted = new ParameterEntity("Output2");
216 toBeDeleted.setId("parameter_id_1");
217 Collection<ParameterEntity> currentOutputs = Arrays.asList(toBeDeleted, toBeUpdated);
218 doReturn(currentOutputs).when(parameterRepositoryMock).list(ITEM1_ID, VERSION1_ID, ParameterRole.OUTPUT);
220 Version mappedInputVersion = new Version(VERSION1_ID);
221 mappedInputVersion.setName("1.0");
222 mappedInputVersion.setDescription(updatedDescription);
223 doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion);
225 ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
226 workflowVersionManager.update(ITEM1_ID, inputVersion);
228 verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture());
229 Version captorVersion = versionArgCaptor.getValue();
230 assertEquals("1.0", captorVersion.getName());
231 assertEquals(updatedDescription, captorVersion.getDescription());
232 assertEquals(VersionStatus.Draft, captorVersion.getStatus());
233 verify(versioningManagerMock).publish(ITEM1_ID, mappedInputVersion, "Update version");
235 verify(parameterRepositoryMock).delete(ITEM1_ID, VERSION1_ID, "parameter_id_1");
236 verify(parameterRepositoryMock).create(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, toBeCreated);
237 verify(parameterRepositoryMock).update(ITEM1_ID, VERSION1_ID, ParameterRole.OUTPUT, toBeUpdated);
243 public void shouldCreateWorkflowVersion() {
244 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
245 Version version = new Version(VERSION1_ID);
246 version.setDescription("version desc");
247 doReturn(version).when(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
248 WorkflowVersion versionRequest = new WorkflowVersion();
249 versionRequest.setDescription("version desc");
250 versionRequest.setInputs(Collections.emptyList());
251 versionRequest.setOutputs(Collections.emptyList());
252 WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
253 doReturn(workflowVersion).when(workflowVersionManager).get(ITEM1_ID, VERSION1_ID);
254 workflowVersionManager.create(ITEM1_ID, null, versionRequest);
255 verify(versioningManagerMock).create(ITEM1_ID, version, VersionCreationMethod.major);
258 @Test(expected = VersionCreationException.class)
259 public void shouldTrowExceptionWhenDraftVersionExists() {
260 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
261 WorkflowVersion versionRequestDto = new WorkflowVersion();
263 Version baseVersion = new Version(VERSION2_ID);
264 baseVersion.setStatus(VersionStatus.Draft);
265 List<Version> versions = Collections.singletonList(baseVersion);
266 doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
268 workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
271 @Test(expected = VersionCreationException.class)
272 public void shouldTrowExceptionWhenInputsSupplied() {
273 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
274 WorkflowVersion versionRequestDto = new WorkflowVersion();
275 versionRequestDto.setInputs(Collections.singleton(new ParameterEntity()));
276 Version baseVersion = new Version(VERSION2_ID);
277 baseVersion.setStatus(VersionStatus.Draft);
278 List<Version> versions = Collections.singletonList(baseVersion);
279 doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
281 workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
284 @Test(expected = EntityNotFoundException.class)
285 public void getStateOfNonExisting() {
286 doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
287 workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
291 public void getState() {
292 Version version = new Version(VERSION1_ID);
293 version.setStatus(VersionStatus.Certified);
294 doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
295 doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
297 WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
298 assertEquals(CERTIFIED, state);
301 @Test(expected = EntityNotFoundException.class)
302 public void updateStateOfNonExisting() {
303 doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
304 workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
307 @Test(expected = VersionStateModificationException.class)
308 public void updateStateToCurrentState() {
309 Version version = new Version(VERSION1_ID);
310 version.setStatus(VersionStatus.Draft);
311 doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
312 doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
314 workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
317 @Test(expected = VersionStateModificationMissingArtifactException.class)
318 public void updateStateWhenCertified() {
319 Version version = new Version(VERSION1_ID);
320 version.setStatus(VersionStatus.Certified);
321 doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
322 doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
324 workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
328 public void shouldFailUpdateStateWhenNoArtifact() {
329 Version retrievedVersion = new Version(VERSION1_ID);
330 retrievedVersion.setStatus(VersionStatus.Draft);
331 doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
332 doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
334 exceptionRule.expect(VersionStateModificationMissingArtifactException.class);
335 exceptionRule.expectMessage(String.format(
336 VersionStateModificationMissingArtifactException.WORKFLOW_MODIFICATION_STATE_MISSING_ARTIFACT_TEMPLATE,
337 ITEM1_ID, VERSION1_ID, DRAFT, CERTIFIED));
338 workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
340 verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
344 public void shouldSuccessUpdateStateWhenArtifactExist() {
345 Version retrievedVersion = new Version(VERSION1_ID);
346 retrievedVersion.setStatus(VersionStatus.Draft);
347 doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
348 doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
349 doReturn(true).when(artifactRepositoryMock).isExist(ITEM1_ID, VERSION1_ID);
350 workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
351 verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
355 public void shouldUploadArtifact() {
356 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
357 Version version = new Version(VERSION1_ID);
358 version.setStatus(VersionStatus.Draft);
359 VersionState versionState = new VersionState();
360 versionState.setDirty(false);
361 version.setState(versionState);
362 doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
363 doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
365 MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
366 workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
368 verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
371 @Test(expected = EntityNotFoundException.class)
372 public void shouldThrowExceptionWhenArtifactNotFound() {
373 doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
375 doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
376 workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
380 public void shouldReturnArtifact() throws IOException {
381 doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
383 InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
384 ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock);
385 doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
386 ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
387 assertEquals(artifactMock, returnedArtifact);
390 @Test(expected = VersionModificationException.class)
391 public void shouldThrowExceptionInDeleteArtifactWhenVersionIsCertified() {
392 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
393 Version version = new Version(VERSION1_ID);
394 doReturn(version).when(versioningManagerMock).get(ITEM1_ID, version);
395 WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
396 workflowVersion.setState(WorkflowVersionState.CERTIFIED);
397 doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(version);
398 workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
402 public void shouldNotDeleteArtifactIfNotExist() {
403 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
404 Version version = new Version(VERSION1_ID);
405 doReturn(version).when(versioningManagerMock).get(ITEM1_ID, version);
406 WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
407 doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(version);
408 workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
409 verify(artifactRepositoryMock, times(0)).delete(ITEM1_ID, VERSION1_ID);
410 verify(versioningManagerMock, times(0)).publish(ITEM1_ID, version, "Delete Artifact");
414 public void shouldDeleteArtifactIfExist() {
415 doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
416 Version version = new Version(VERSION1_ID);
417 doReturn(version).when(versioningManagerMock).get(ITEM1_ID, version);
418 WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
419 doReturn(true).when(artifactRepositoryMock).isExist(ITEM1_ID, VERSION1_ID);
420 doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(version);
421 workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
422 verify(artifactRepositoryMock, times(1)).delete(ITEM1_ID, VERSION1_ID);
423 verify(versioningManagerMock, times(1)).publish(ITEM1_ID, version, "Delete Artifact");
426 private static Version eqVersion(String versionId) {
427 return argThat(version -> versionId.equals(version.getId()));