8e714f627a76e55174d60eb15f8b0d9e77ee1ad6
[sdc/sdc-workflow-designer.git] /
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.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;
15
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;
23
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;
58
59 @RunWith(MockitoJUnitRunner.class)
60 public class WorkflowVersionManagerImplTest {
61
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";
65
66     @Mock
67     private ItemManager itemManagerMock;
68     @Mock
69     private VersioningManager versioningManagerMock;
70     @Mock
71     private ParameterRepository parameterRepositoryMock;
72     @Mock
73     private ArtifactRepository artifactRepositoryMock;
74     @Mock
75     private VersionMapper versionMapperMock;
76     @Mock
77     private VersionStateMapper versionStateMapperMock;
78     @Rule
79     public ExpectedException exceptionRule = ExpectedException.none();
80     @Spy
81     @InjectMocks
82     private WorkflowVersionManagerImpl workflowVersionManager;
83
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);
89     }
90
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));
98     }
99
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));
107     }
108
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);
117     }
118
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);
126     }
127
128     @Test
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);
138     }
139
140     @Test
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));
160     }
161
162     @Test
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);
184
185         assertEquals(1,
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));
189
190     }
191
192     @Test
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());
205
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);
219
220         Version mappedInputVersion = new Version(VERSION1_ID);
221         mappedInputVersion.setName("1.0");
222         mappedInputVersion.setDescription(updatedDescription);
223         doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion);
224
225         ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
226         workflowVersionManager.update(ITEM1_ID, inputVersion);
227
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");
234
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);
238
239     }
240
241
242     @Test
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);
256     }
257
258     @Test(expected = VersionCreationException.class)
259     public void shouldTrowExceptionWhenDraftVersionExists() {
260         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
261         WorkflowVersion versionRequestDto = new WorkflowVersion();
262
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);
267
268         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
269     }
270
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);
280
281         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
282     }
283
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);
288     }
289
290     @Test
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());
296
297         WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
298         assertEquals(CERTIFIED, state);
299     }
300
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);
305     }
306
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());
313
314         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
315     }
316
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());
323
324         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
325     }
326
327     @Test
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);
333
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);
339
340         verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString());
341     }
342
343     @Test
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());
352     }
353
354     @Test
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());
364
365         MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
366         workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
367
368         verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
369     }
370
371     @Test(expected = EntityNotFoundException.class)
372     public void shouldThrowExceptionWhenArtifactNotFound() {
373         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
374
375         doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
376         workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
377     }
378
379     @Test
380     public void shouldReturnArtifact() throws IOException {
381         doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID));
382
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);
388     }
389
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);
399     }
400
401     @Test
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");
411     }
412
413     @Test
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");
424     }
425
426     private static Version eqVersion(String versionId) {
427         return argThat(version -> versionId.equals(version.getId()));
428     }
429 }