workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.sdc.workflow.services.impl;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.mockito.ArgumentMatchers.any;
  21 import static org.mockito.ArgumentMatchers.anyString;
  22 import static org.mockito.ArgumentMatchers.eq;
  23 import static org.mockito.ArgumentMatchers.isNull;
  24 import static org.mockito.Mockito.doAnswer;
  25 import static org.mockito.Mockito.doNothing;
  26 import static org.mockito.Mockito.doReturn;
  27 import static org.mockito.Mockito.doThrow;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.onap.sdc.workflow.TestUtil.createRetrievedVersion;
  31 import static org.onap.sdc.workflow.services.types.WorkflowVersionState.CERTIFIED;
  32 import static org.onap.sdc.workflow.services.types.WorkflowVersionState.DRAFT;
  33
  34 import java.io.IOException;
  35 import java.io.InputStream;
  36 import java.util.Arrays;
  37 import java.util.Collection;
  38 import java.util.Collections;
  39 import java.util.List;
  40 import java.util.Optional;
  41 import org.apache.commons.io.IOUtils;
  42 import org.junit.Rule;
  43 import org.junit.Test;
  44 import org.junit.rules.ExpectedException;
  45 import org.junit.runner.RunWith;
  46 import org.mockito.ArgumentCaptor;
  47 import org.mockito.InjectMocks;
  48 import org.mockito.Mock;
  49 import org.mockito.Spy;
  50 import org.mockito.junit.MockitoJUnitRunner;
  51 import org.onap.sdc.common.versioning.persistence.types.InternalItem;
  52 import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
  53 import org.onap.sdc.common.versioning.services.ItemManager;
  54 import org.onap.sdc.common.versioning.services.VersioningManager;
  55 import org.onap.sdc.common.versioning.services.types.ItemStatus;
  56 import org.onap.sdc.common.versioning.services.types.Version;
  57 import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
  58 import org.onap.sdc.common.versioning.services.types.VersionState;
  59 import org.onap.sdc.common.versioning.services.types.VersionStatus;
  60 import org.onap.sdc.workflow.persistence.ArtifactRepository;
  61 import org.onap.sdc.workflow.persistence.ParameterRepository;
  62 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
  63 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
  64 import org.onap.sdc.workflow.persistence.types.ParameterRole;
  65 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  66 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
  67 import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
  68 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
  69 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationMissingArtifactException;
  70 import org.onap.sdc.workflow.services.exceptions.WorkflowModificationException;
  71 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  72 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  73 import org.onap.sdc.workflow.services.types.WorkflowVersion;
  74 import org.onap.sdc.workflow.services.types.WorkflowVersionState;
  75 import org.springframework.mock.web.MockMultipartFile;
  76
  77 @RunWith(MockitoJUnitRunner.class)
  78 public class WorkflowVersionManagerImplTest {
  79
  80     private static final String ITEM1_ID = "item_id_1";
  81     private static final String VERSION1_ID = "version_id_1";
  82     private static final String VERSION2_ID = "version_id_2";
  83
  84     @Mock
  85     private ItemManager itemManagerMock;
  86     @Mock
  87     private VersioningManager versioningManagerMock;
  88     @Mock
  89     private ParameterRepository parameterRepositoryMock;
  90     @Mock
  91     private ArtifactRepository artifactRepositoryMock;
  92     @Mock
  93     private VersionMapper versionMapperMock;
  94     @Mock
  95     private VersionStateMapper versionStateMapperMock;
  96     @Rule
  97     public ExpectedException exceptionRule = ExpectedException.none();
  98     @Spy
  99     @InjectMocks
 100     private WorkflowVersionManagerImpl workflowVersionManager;
 101
 102     @Test(expected = EntityNotFoundException.class)
 103     public void shouldThrowExceptionWhenVersionDontExist() {
 104         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 105         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
 106     }
 107
 108     @Test(expected = WorkflowModificationException.class)
 109     public void shouldThrowExceptionWhenCreatingVersionForArchivedWorkflow() {
 110         InternalItem mockItem = new InternalItem();
 111         mockItem.setId(ITEM1_ID);
 112         mockItem.setStatus(ItemStatus.ARCHIVED);
 113         doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
 114         workflowVersionManager.create(ITEM1_ID, null, new WorkflowVersion(VERSION1_ID));
 115     }
 116
 117     @Test(expected = WorkflowModificationException.class)
 118     public void shouldThrowExceptionWhenUpdatingVersionForArchivedWorkflow() {
 119         InternalItem mockItem = new InternalItem();
 120         mockItem.setId(ITEM1_ID);
 121         mockItem.setStatus(ItemStatus.ARCHIVED);
 122         doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
 123         workflowVersionManager.update(ITEM1_ID, new WorkflowVersion(VERSION1_ID));
 124     }
 125
 126     @Test(expected = WorkflowModificationException.class)
 127     public void shouldThrowExceptionWhenUploadingArtifactForArchivedWorkflow() {
 128         InternalItem mockItem = new InternalItem();
 129         mockItem.setId(ITEM1_ID);
 130         mockItem.setStatus(ItemStatus.ARCHIVED);
 131         doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
 132         MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
 133         workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
 134     }
 135
 136     @Test(expected = WorkflowModificationException.class)
 137     public void shouldThrowExceptionWhenDeletingArtifactForArchivedWorkflow() {
 138         InternalItem mockItem = new InternalItem();
 139         mockItem.setId(ITEM1_ID);
 140         mockItem.setStatus(ItemStatus.ARCHIVED);
 141         doReturn(mockItem).when(itemManagerMock).get(ITEM1_ID);
 142         workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
 143     }
 144
 145     @Test
 146     public void shouldReturnWorkflowVersionWhenExist() {
 147         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 148         doReturn(workflowVersion).when(versionMapperMock).fromVersion(any(Version.class));
 149         doReturn(new Version()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 150         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 151                 .list(eq(ITEM1_ID), eq(VERSION1_ID), any(ParameterRole.class));
 152         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
 153         verify(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 154     }
 155
 156     @Test
 157     public void shouldReturnWorkflowVersionList() {
 158         InternalVersion version1 = createRetrievedVersion(VERSION1_ID, VersionStatus.Certified);
 159         InternalVersion version2 = createRetrievedVersion(VERSION2_ID, VersionStatus.Draft);
 160         List<Version> versionList = Arrays.asList(version1, version2);
 161         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
 162
 163         WorkflowVersion workflowVersion1 = new WorkflowVersion();
 164         workflowVersion1.setId(VERSION1_ID);
 165         workflowVersion1.setName(VERSION1_ID);
 166         doReturn(workflowVersion1).when(versionMapperMock).fromVersion(version1);
 167
 168         WorkflowVersion workflowVersion2 = new WorkflowVersion();
 169         workflowVersion2.setId(VERSION2_ID);
 170         workflowVersion2.setName(VERSION2_ID);
 171         doReturn(workflowVersion2).when(versionMapperMock).fromVersion(version2);
 172
 173         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 174                 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.INPUT));
 175         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 176                 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.OUTPUT));
 177
 178         workflowVersionManager.list(ITEM1_ID, null);
 179         verify(versioningManagerMock).list(ITEM1_ID);
 180         verify(versionMapperMock, times(2)).fromVersion(any(Version.class));
 181     }
 182
 183     @Test
 184     public void shouldReturnCertifiedWorkflowVersionList() {
 185         InternalVersion version1 = createRetrievedVersion(VERSION1_ID, VersionStatus.Certified);
 186         InternalVersion version2 = createRetrievedVersion(VERSION2_ID, VersionStatus.Draft);
 187         List<Version> versionList = Arrays.asList(version1, version2);
 188
 189         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
 190         WorkflowVersion workflowVersion1 = new WorkflowVersion();
 191         workflowVersion1.setId(VERSION1_ID);
 192         workflowVersion1.setName(VERSION1_ID);
 193         doReturn(workflowVersion1).when(versionMapperMock).fromVersion(version1);
 194
 195         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 196                 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.INPUT));
 197         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 198                 .list(eq(ITEM1_ID), anyString(), eq(ParameterRole.OUTPUT));
 199         doReturn(VersionStatus.Certified).when(versionStateMapperMock)
 200                 .workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED);
 201
 202         assertEquals(1,
 203                 workflowVersionManager.list(ITEM1_ID, Collections.singleton(WorkflowVersionState.CERTIFIED)).size());
 204         verify(versioningManagerMock).list(ITEM1_ID);
 205         verify(versionMapperMock, times(1)).fromVersion(any(Version.class));
 206
 207     }
 208
 209     @Test
 210     public void shouldUpdateWorkflowVersion() {
 211         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 212         String updatedDescription = "WorkflowVersion description updated";
 213         InternalVersion retrievedVersion = new InternalVersion();
 214         retrievedVersion.setId(VERSION1_ID);
 215         retrievedVersion.setName("1.0");
 216         retrievedVersion.setDescription("WorkflowVersion description");
 217         retrievedVersion.setStatus(VersionStatus.Draft);
 218         VersionState versionState = new VersionState();
 219         versionState.setDirty(true);
 220         retrievedVersion.setState(versionState);
 221         doReturn(retrievedVersion).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 222         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
 223         doReturn(Collections.emptyList()).when(parameterRepositoryMock)
 224                 .list(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
 225
 226         WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID);
 227         inputVersion.setName("1.0");
 228         inputVersion.setDescription(updatedDescription);
 229         ParameterEntity toBeCreated = new ParameterEntity("Input1");
 230         inputVersion.setInputs(Collections.singleton(toBeCreated));
 231         ParameterEntity toBeUpdated = new ParameterEntity("Output1");
 232         inputVersion.setOutputs(Collections.singleton(toBeUpdated));
 233
 234         ParameterEntity toBeDeleted = new ParameterEntity("Output2");
 235         toBeDeleted.setId("parameter_id_1");
 236         Collection<ParameterEntity> currentOutputs = Arrays.asList(toBeDeleted, toBeUpdated);
 237         doReturn(currentOutputs).when(parameterRepositoryMock).list(ITEM1_ID, VERSION1_ID, ParameterRole.OUTPUT);
 238
 239         doAnswer(invocationOnMock -> {
 240             WorkflowVersion workflowVersion = invocationOnMock.getArgument(0);
 241             Version version = invocationOnMock.getArgument(1);
 242             version.setDescription(workflowVersion.getDescription());
 243             return null;
 244         }).when(versionMapperMock).toVersion(inputVersion, retrievedVersion);
 245
 246         ArgumentCaptor<Version> versionArgCaptor = ArgumentCaptor.forClass(Version.class);
 247         workflowVersionManager.update(ITEM1_ID, inputVersion);
 248
 249         verify(versioningManagerMock).update(eq(ITEM1_ID), eq(VERSION1_ID), versionArgCaptor.capture());
 250         Version captorVersion = versionArgCaptor.getValue();
 251         assertEquals("1.0", captorVersion.getName());
 252         assertEquals(updatedDescription, captorVersion.getDescription());
 253         assertEquals(VersionStatus.Draft, captorVersion.getStatus());
 254         verify(versioningManagerMock).publish(ITEM1_ID, VERSION1_ID, "Update version");
 255
 256         verify(parameterRepositoryMock).delete(ITEM1_ID, VERSION1_ID, "parameter_id_1");
 257         verify(parameterRepositoryMock).create(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, toBeCreated);
 258         verify(parameterRepositoryMock).update(ITEM1_ID, VERSION1_ID, ParameterRole.OUTPUT, toBeUpdated);
 259
 260     }
 261
 262
 263     @Test
 264     public void shouldCreateWorkflowVersion() {
 265         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 266         Version version = createRetrievedVersion(VERSION1_ID, VersionStatus.Draft);
 267         doReturn(version).when(versioningManagerMock)
 268                 .create(eq(ITEM1_ID), isNull(), any(Version.class), eq(VersionCreationMethod.major));
 269
 270         WorkflowVersion versionRequest = new WorkflowVersion();
 271         versionRequest.setDescription("version desc");
 272         versionRequest.setInputs(Collections.emptyList());
 273         versionRequest.setOutputs(Collections.emptyList());
 274         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 275         doReturn(workflowVersion).when(workflowVersionManager).get(ITEM1_ID, VERSION1_ID);
 276
 277         workflowVersionManager.create(ITEM1_ID, null, versionRequest);
 278     }
 279
 280     @Test(expected = VersionCreationException.class)
 281     public void shouldTrowExceptionWhenDraftVersionExists() {
 282         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 283         WorkflowVersion versionRequestDto = new WorkflowVersion();
 284
 285         Version baseVersion = createRetrievedVersion(VERSION2_ID, VersionStatus.Draft);
 286         List<Version> versions = Collections.singletonList(baseVersion);
 287         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 288
 289         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
 290     }
 291
 292     @Test(expected = VersionCreationException.class)
 293     public void shouldTrowExceptionWhenInputsSupplied() {
 294         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 295         WorkflowVersion versionRequestDto = new WorkflowVersion();
 296         versionRequestDto.setInputs(Collections.singleton(new ParameterEntity()));
 297         InternalVersion baseVersion = createRetrievedVersion(VERSION2_ID, VersionStatus.Draft);
 298         List<Version> versions = Collections.singletonList(baseVersion);
 299         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 300
 301         workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto);
 302     }
 303
 304
 305     @Test(expected = EntityNotFoundException.class)
 306     public void getStateOfNonExisting() {
 307         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 308         workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 309     }
 310
 311     @Test
 312     public void getState() {
 313         InternalVersion version = createRetrievedVersion(VERSION1_ID, VersionStatus.Certified);
 314         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 315         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 316
 317         WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID);
 318         assertEquals(CERTIFIED, state);
 319     }
 320
 321     @Test(expected = EntityNotFoundException.class)
 322     public void updateStateOfNonExisting() {
 323         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 324         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 325     }
 326
 327     @Test(expected = VersionStateModificationException.class)
 328     public void updateStateToCurrentState() {
 329         InternalVersion version = createRetrievedVersion(VERSION1_ID, VersionStatus.Draft);
 330         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 331         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 332
 333         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT);
 334     }
 335
 336     @Test(expected = VersionStateModificationMissingArtifactException.class)
 337     public void updateStateWhenCertified() {
 338         InternalVersion version = createRetrievedVersion(VERSION1_ID, VersionStatus.Certified);
 339         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 340         doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 341
 342         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 343     }
 344
 345     @Test
 346     public void shouldFailUpdateStateWhenNoArtifact() {
 347         InternalVersion retrievedVersion = createRetrievedVersion(VERSION1_ID, VersionStatus.Draft);
 348         doReturn(retrievedVersion).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 349         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
 350
 351         exceptionRule.expect(VersionStateModificationMissingArtifactException.class);
 352         exceptionRule.expectMessage(String.format(
 353                 VersionStateModificationMissingArtifactException.WORKFLOW_MODIFICATION_STATE_MISSING_ARTIFACT_TEMPLATE,
 354                 ITEM1_ID, VERSION1_ID, DRAFT, CERTIFIED));
 355         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 356
 357         verify(versioningManagerMock).updateStatus(ITEM1_ID, VERSION1_ID, VersionStatus.Certified, anyString());
 358     }
 359
 360     @Test
 361     public void shouldSuccessUpdateStateWhenArtifactExist() {
 362         InternalVersion retrievedVersion = createRetrievedVersion(VERSION1_ID, VersionStatus.Draft);
 363         doReturn(retrievedVersion).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 364         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft);
 365         doReturn(true).when(artifactRepositoryMock).isExist(ITEM1_ID, VERSION1_ID);
 366         workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED);
 367         verify(versioningManagerMock)
 368                 .updateStatus(eq(ITEM1_ID), eq(VERSION1_ID), eq(VersionStatus.Certified), anyString());
 369     }
 370
 371     @Test
 372     public void shouldUploadArtifact() {
 373         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 374         InternalVersion version = createRetrievedVersion(VERSION1_ID, VersionStatus.Draft);
 375         VersionState versionState = new VersionState();
 376         versionState.setDirty(false);
 377         version.setState(versionState);
 378         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 379         doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus());
 380
 381         MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes());
 382         workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile);
 383
 384         verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class));
 385     }
 386
 387     @Test(expected = EntityNotFoundException.class)
 388     public void shouldThrowExceptionWhenArtifactNotFound() {
 389         doReturn(new Version()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 390
 391         doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 392         workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 393     }
 394
 395     @Test
 396     public void shouldReturnArtifact() throws IOException {
 397         doReturn(new Version()).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 398
 399         InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8");
 400         ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock);
 401         doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID);
 402         ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID);
 403         assertEquals(artifactMock, returnedArtifact);
 404     }
 405
 406     @Test(expected = VersionModificationException.class)
 407     public void shouldThrowExceptionInDeleteArtifactWhenVersionIsCertified() {
 408         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 409         Version version = new Version();
 410         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 411         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 412         workflowVersion.setState(WorkflowVersionState.CERTIFIED);
 413         doReturn(workflowVersion).when(versionMapperMock).fromVersion(version);
 414         workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
 415     }
 416
 417     @Test
 418     public void shouldNotDeleteArtifactIfNotExist() {
 419         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 420         Version version = new Version();
 421         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 422         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 423         doReturn(workflowVersion).when(versionMapperMock).fromVersion(version);
 424         workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
 425         verify(artifactRepositoryMock, times(0)).delete(ITEM1_ID, VERSION1_ID);
 426         verify(versioningManagerMock, times(0)).publish(ITEM1_ID, VERSION1_ID, "Delete Artifact");
 427     }
 428
 429     @Test
 430     public void shouldDeleteArtifactIfExist() {
 431         doNothing().when(workflowVersionManager).validateWorkflowStatus(ITEM1_ID);
 432         Version version = new Version();
 433         doReturn(version).when(versioningManagerMock).get(ITEM1_ID, VERSION1_ID);
 434         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 435         doReturn(true).when(artifactRepositoryMock).isExist(ITEM1_ID, VERSION1_ID);
 436         doReturn(workflowVersion).when(versionMapperMock).fromVersion(version);
 437         workflowVersionManager.deleteArtifact(ITEM1_ID, VERSION1_ID);
 438         verify(artifactRepositoryMock, times(1)).delete(ITEM1_ID, VERSION1_ID);
 439         verify(versioningManagerMock, times(1)).publish(ITEM1_ID, VERSION1_ID, "Delete Artifact");
 440     }
 441 }