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.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 shouldDeleteArtifact() {
 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).delete(ITEM1_ID, VERSION1_ID);
 410         verify(versioningManagerMock).publish(ITEM1_ID, version, "Delete Artifact");
 411     }
 412
 413     private static Version eqVersion(String versionId) {
 414         return argThat(version -> versionId.equals(version.getId()));
 415     }
 416 }