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.eq;
   5 import static org.mockito.Matchers.any;
   6 import static org.mockito.Mockito.doReturn;
   7 import static org.mockito.Mockito.doThrow;
   8 import static org.mockito.Mockito.times;
   9 import static org.mockito.Mockito.verify;
  10 import static org.onap.sdc.workflow.persistence.types.WorkflowVersionStatus.*;
  11
  12 import java.io.IOException;
  13 import java.io.InputStream;
  14 import java.util.Arrays;
  15 import java.util.Collections;
  16 import java.util.Date;
  17 import java.util.List;
  18 import java.util.Optional;
  19 import org.apache.commons.io.IOUtils;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.InjectMocks;
  23 import org.mockito.Mock;
  24 import org.mockito.Spy;
  25 import org.mockito.junit.MockitoJUnitRunner;
  26 import org.onap.sdc.workflow.api.types.VersionRequestDto;
  27 import org.onap.sdc.workflow.persistence.ArtifactRepository;
  28 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
  29 import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
  30 import org.onap.sdc.workflow.persistence.types.WorkflowVersionStatus;
  31 import org.onap.sdc.workflow.services.exceptions.CreateVersionException;
  32 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  33 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  34 import org.openecomp.sdc.versioning.VersioningManager;
  35 import org.openecomp.sdc.versioning.dao.types.Version;
  36 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  37 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  38 import org.springframework.mock.web.MockMultipartFile;
  39
  40 @RunWith(MockitoJUnitRunner.class)
  41 public class WorkflowVersionManagerTest {
  42
  43
  44     private static final String ITEM1_ID = "item_id_1";
  45     private static final String VERSION1_ID = "version_id_1";
  46     private static final String VERSION2_ID = "version_id_2";
  47
  48     @Mock
  49     private VersionMapper versionMapperMock;
  50
  51     @Mock
  52     private VersioningManager versioningManagerMock;
  53
  54     @Mock
  55     private ArtifactRepository artifactRepositoryMock;
  56
  57     @Spy
  58     @InjectMocks
  59     private WorkflowVersionManagerImpl workflowVersionManager;
  60
  61
  62     @Test(expected = EntityNotFoundException.class)
  63     public void shouldThrowExceptionWhenVersionDontExist(){
  64         Version nonExistingVersion = new Version(VERSION1_ID);
  65         doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion);
  66         workflowVersionManager.get(ITEM1_ID, VERSION1_ID);
  67     }
  68
  69     @Test
  70     public void shouldReturnWorkflowVersionWhenExist(){
  71         Version version = new Version(VERSION1_ID);
  72         doReturn(version).when(versioningManagerMock).get(ITEM1_ID,version);
  73         workflowVersionManager.get(ITEM1_ID,VERSION1_ID);
  74         verify(versioningManagerMock).get(ITEM1_ID,version);
  75     }
  76
  77     @Test
  78     public void shouldReturnWorkflowVersionList(){
  79         List<Version> versionList =
  80                 Arrays.asList(new Version(VERSION1_ID), new Version(VERSION2_ID));
  81         versionList.forEach(version -> {
  82             version.setBaseId("baseVersionId");
  83             version.setDescription("Version description");
  84             version.setName("name");
  85             version.setCreationTime(new Date());
  86             version.setModificationTime(new Date());
  87         });
  88         doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID);
  89         workflowVersionManager.list(ITEM1_ID);
  90         verify(versioningManagerMock).list(ITEM1_ID);
  91         verify(versionMapperMock ,times(2)).versionToWorkflowVersion(any(Version.class));
  92     }
  93
  94     @Test
  95     public void shouldUpdateWorkflowVersion(){
  96         Version version = new Version(VERSION1_ID);
  97         version.setName("1.0");
  98         version.setDescription("WorkflowVersion description");
  99         WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID);
 100         workflowVersion.setName("1.0");
 101         workflowVersion.setDescription("WorkflowVersion description");
 102         doReturn(version).when(workflowVersionManager).mapVersionInfo(ITEM1_ID,workflowVersion);
 103         workflowVersionManager.update(ITEM1_ID,workflowVersion);
 104         verify(versioningManagerMock).updateVersion(ITEM1_ID,version);
 105     }
 106
 107     @Test
 108     public void shouldCreateWorkflowVersion(){
 109         Version version = new Version(VERSION1_ID);
 110         version.setDescription("version desc");
 111         doReturn(version).when(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major);
 112         VersionRequestDto workflowVersion = new VersionRequestDto();
 113         workflowVersion.setDescription("version desc");
 114         workflowVersionManager.create(ITEM1_ID,workflowVersion);
 115         verify(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major);
 116
 117     }
 118
 119     @Test(expected = CreateVersionException.class)
 120     public void shouldTrowExceptionWhenDraftVersionExists(){
 121         VersionRequestDto versionRequestDto = new VersionRequestDto();
 122         versionRequestDto.setBaseVersionId(VERSION2_ID);
 123
 124         Version baseVersion = new Version(VERSION2_ID);
 125         baseVersion.setStatus(VersionStatus.Draft);
 126         List<Version> versions = Collections.singletonList(baseVersion);
 127         doReturn(versions).when(versioningManagerMock).list(ITEM1_ID);
 128
 129         workflowVersionManager.create(ITEM1_ID,versionRequestDto);
 130     }
 131
 132     @Test
 133     public void shouldUploadArtifact() throws IOException {
 134
 135         String mockFileName = "filename.txt";
 136         MockMultipartFile mockFile =
 137                 new MockMultipartFile("data", mockFileName, "text/plain", "some xml".getBytes());
 138         WorkflowVersion version = new WorkflowVersion(VERSION1_ID);
 139         version.setStatus(WorkflowVersionStatus.DRAFT);
 140         doReturn(version).when(workflowVersionManager).get(ITEM1_ID,VERSION1_ID);
 141         workflowVersionManager.uploadArtifact(ITEM1_ID,version,mockFile);
 142
 143         verify(artifactRepositoryMock).update(eq(ITEM1_ID),eq(VERSION1_ID),any(ArtifactEntity.class));
 144     }
 145
 146     @Test(expected = EntityNotFoundException.class)
 147     public void shouldThrowExceptionWhenArtifactNotFound(){
 148         WorkflowVersion version = new WorkflowVersion(VERSION1_ID);
 149         version.setStatus(DRAFT);
 150         doReturn(version).when(workflowVersionManager).get(ITEM1_ID,VERSION1_ID);
 151         doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID,VERSION1_ID);
 152         workflowVersionManager.getArtifact(ITEM1_ID,version);
 153     }
 154
 155     @Test
 156     public void shouldReturnArtifact() throws IOException {
 157         WorkflowVersion version = new WorkflowVersion(VERSION1_ID);
 158         doReturn(version).when(workflowVersionManager).get(ITEM1_ID,VERSION1_ID);
 159
 160         InputStream inputStreamMock =
 161                 IOUtils.toInputStream("some test data for my input stream", "UTF-8");
 162         ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt",inputStreamMock);
 163         doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID,VERSION1_ID);
 164         ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, new WorkflowVersion(VERSION1_ID));
 165         assertEquals(artifactMock,returnedArtifact);
 166     }
 167
 168 }