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.junit.Assert.assertTrue;
   5 import static org.mockito.ArgumentMatchers.any;
   6 import static org.mockito.Mockito.doReturn;
   7 import static org.mockito.Mockito.times;
   8 import static org.mockito.Mockito.verify;
   9 import static org.onap.sdc.workflow.TestUtil.createItem;
  10 import static org.onap.sdc.workflow.TestUtil.createWorkflow;
  11 import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
  12 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  13
  14 import java.util.ArrayList;
  15 import java.util.Arrays;
  16 import java.util.Collection;
  17 import java.util.Collections;
  18 import java.util.Iterator;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.function.Function;
  22 import java.util.stream.Collectors;
  23 import org.junit.Assert;
  24 import org.junit.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.InjectMocks;
  27 import org.mockito.Mock;
  28 import org.onap.sdc.workflow.persistence.types.Workflow;
  29 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
  30 import org.onap.sdc.workflow.services.UniqueValueService;
  31 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  32 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  33 import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper;
  34 import org.openecomp.sdc.versioning.ItemManager;
  35 import org.openecomp.sdc.versioning.types.Item;
  36 import org.openecomp.sdc.versioning.types.ItemStatus;
  37 import org.springframework.data.domain.PageRequest;
  38 import org.springframework.data.domain.Sort;
  39 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  40
  41 @RunWith(SpringJUnit4ClassRunner.class)
  42 public class WorkflowManagerImplTest {
  43
  44     private static final String ITEM1_ID = "1";
  45     private static final String WORKFLOW_TYPE = "WORKFLOW";
  46     private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME";
  47     private static final List<Item> ITEMS;
  48     private static final List<Workflow> MAPPED_WORKFLOWS;
  49
  50     static {
  51         List<Item> items = new ArrayList<>();
  52         List<Workflow> mappedWorkflows = new ArrayList<>();
  53         for (int i = 1; i < 6; i++) {
  54             items.add(createItem(i, true, true));
  55             mappedWorkflows.add(createWorkflow(i, true));
  56         }
  57         ITEMS = Collections.unmodifiableList(items);
  58         MAPPED_WORKFLOWS = Collections.unmodifiableList(mappedWorkflows);
  59     }
  60
  61     @Mock
  62     private ItemManager itemManagerMock;
  63     @Mock
  64     private UniqueValueService uniqueValueServiceMock;
  65     @Mock
  66     private WorkflowMapper workflowMapperMock;
  67     @Mock
  68     private VersionStateMapper versionStateMapperMock;
  69     @InjectMocks
  70     private WorkflowManagerImpl workflowManager;
  71
  72     @Test
  73     public void shouldReturnWorkflowVersionList() {
  74         doReturn(ITEMS).when(itemManagerMock).list(any());
  75         for (int i = 0; i < ITEMS.size(); i++) {
  76             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
  77         }
  78         Collection<Workflow> workflows =
  79                 workflowManager.list(null, createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME));
  80
  81         Map<String, Workflow> workflowById =
  82                 workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
  83         assertEquals(ITEMS.size(), workflows.size());
  84         for (int i = 1; i < ITEMS.size() + 1; i++) {
  85             assertTrue(workflowById.containsKey(String.valueOf(i)));
  86         }
  87     }
  88
  89     @Test
  90     public void listWithVersionStateFilter() {
  91         doReturn(Certified).when(versionStateMapperMock)
  92                            .workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED);
  93         doReturn(Arrays.asList(ITEMS.get(0), ITEMS.get(2))).when(itemManagerMock).list(any());
  94         doReturn(MAPPED_WORKFLOWS.get(0)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(0));
  95         doReturn(MAPPED_WORKFLOWS.get(2)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(2));
  96
  97         Collection<Workflow> workflows = workflowManager.list(Collections.singleton(WorkflowVersionState.CERTIFIED),
  98                 createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME));
  99
 100         Map<String, Workflow> workflowById =
 101                 workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
 102         assertEquals(2, workflows.size());
 103         assertTrue(workflowById.containsKey("1"));
 104         assertTrue(workflowById.containsKey("3"));
 105     }
 106
 107     @Test(expected = EntityNotFoundException.class)
 108     public void shouldThrowExceptionWhenWorkflowDontExist() {
 109         Workflow nonExistingWorkflow = new Workflow();
 110         nonExistingWorkflow.setId(ITEM1_ID);
 111         doReturn(null).when(itemManagerMock).get(ITEM1_ID);
 112         workflowManager.get(nonExistingWorkflow);
 113         verify(workflowMapperMock, times(3)).itemToWorkflow(any(Item.class));
 114     }
 115
 116     @Test
 117     public void shouldReturnWorkflow() {
 118         Item retrievedItem = createItem(1, true, true);
 119         doReturn(retrievedItem).when(itemManagerMock).get(ITEM1_ID);
 120         Workflow workflow = createWorkflow(1, true);
 121         workflowManager.get(workflow);
 122         verify(itemManagerMock).get(ITEM1_ID);
 123         verify(workflowMapperMock).itemToWorkflow(retrievedItem);
 124     }
 125
 126     @Test
 127     public void shouldCreateWorkflowItemFromWorkflow() {
 128         Workflow workflowToBeCreated = createWorkflow(1, false);
 129         Item createdWorkflowItem = createItem(1, false, true);
 130         doReturn(createdWorkflowItem).when(workflowMapperMock).workflowToItem(workflowToBeCreated);
 131         doReturn(createdWorkflowItem).when(itemManagerMock).create(createdWorkflowItem);
 132         workflowManager.create(workflowToBeCreated);
 133         verify(uniqueValueServiceMock)
 134                 .validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
 135
 136         createdWorkflowItem.setStatus(ItemStatus.ACTIVE);
 137         createdWorkflowItem.setType(WORKFLOW_TYPE);
 138         verify(itemManagerMock).create(createdWorkflowItem);
 139         verify(uniqueValueServiceMock)
 140                 .createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
 141     }
 142
 143     @Test
 144     public void shouldUpdateWorkflow() {
 145         Item workflowItem = createItem(1, true, true);
 146         doReturn(workflowItem).when(itemManagerMock).get(ITEM1_ID);
 147         Workflow workflowToBeUpdated = createWorkflow(1, true);
 148         doReturn(workflowItem).when(workflowMapperMock).workflowToItem(workflowToBeUpdated);
 149         workflowManager.update(workflowToBeUpdated);
 150         verify(itemManagerMock).update(workflowItem);
 151         verify(uniqueValueServiceMock)
 152                 .updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, workflowItem.getName(), workflowToBeUpdated.getName());
 153
 154     }
 155
 156     @Test(expected = EntityNotFoundException.class)
 157     public void shouldThrowExceptionWhenWorkflowToUpdateNotFound() {
 158         doReturn(null).when(itemManagerMock).get(ITEM1_ID);
 159         workflowManager.update(createWorkflow(1, true));
 160     }
 161
 162     @Test
 163     public void shouldListAllWorkflowsWhenLimitAndOffsetAreValid() {
 164         PageRequest pageRequest = createPageRequest(5, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
 165         doReturn(ITEMS).when(itemManagerMock).list(any());
 166         for (int i = 0; i < ITEMS.size(); i++) {
 167             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 168         }
 169         Assert.assertEquals(5, workflowManager.list(null, pageRequest).size());
 170     }
 171
 172     @Test
 173     public void shouldListLimitFilteredWorkflowsInFirstOffsetRange() {
 174         PageRequest pageRequest = createPageRequest(3, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
 175         doReturn(ITEMS).when(itemManagerMock).list(any());
 176         for (int i = 0; i < ITEMS.size(); i++) {
 177             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 178         }
 179         Assert.assertEquals(3, workflowManager.list(null, pageRequest).size());
 180     }
 181
 182     @Test
 183     public void shouldListLimitFilteredWorkflowsInSecondOffsetRange() {
 184         PageRequest pageRequest = createPageRequest(3, 1, Sort.Direction.ASC, SORT_FIELD_NAME);
 185         doReturn(ITEMS).when(itemManagerMock).list(any());
 186         for (int i = 0; i < ITEMS.size(); i++) {
 187             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 188         }
 189         Assert.assertEquals(2, workflowManager.list(null, pageRequest).size());
 190     }
 191
 192     @Test
 193     public void shouldListAllWorkflowsWhenLimitGreaterThanTotalRecordsAndOffsetInRange() {
 194         PageRequest pageRequest = createPageRequest(10, 0, Sort.Direction.ASC, SORT_FIELD_NAME);
 195         doReturn(ITEMS).when(itemManagerMock).list(any());
 196         for (int i = 0; i < ITEMS.size(); i++) {
 197             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 198         }
 199         Assert.assertEquals(5, workflowManager.list(null, pageRequest).size());
 200     }
 201
 202     @Test
 203     public void shouldNotListWorkflowsIfOffsetGreaterThanTotalRecords() {
 204         PageRequest pageRequest = createPageRequest(3, 6, Sort.Direction.ASC, SORT_FIELD_NAME);
 205         doReturn(ITEMS).when(itemManagerMock).list(any());
 206         for (int i = 0; i < ITEMS.size(); i++) {
 207             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 208         }
 209         Assert.assertEquals(0, workflowManager.list(null, pageRequest).size());
 210     }
 211
 212     @Test
 213     public void shouldNotListWorkflowsBothLimitAndOffsetGreaterThanTotalRecords() {
 214         PageRequest pageRequest = createPageRequest(10, 10, Sort.Direction.ASC, SORT_FIELD_NAME);
 215         doReturn(ITEMS).when(itemManagerMock).list(any());
 216         for (int i = 0; i < ITEMS.size(); i++) {
 217             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 218         }
 219         Assert.assertEquals(0, workflowManager.list(null, pageRequest).size());
 220     }
 221
 222     @Test
 223     public void shouldListLimitOffsetAppliedWorkflowsSortedInDescOrder() {
 224         PageRequest pageRequest = createPageRequest(2, 1, Sort.Direction.DESC, SORT_FIELD_NAME);
 225         doReturn(ITEMS).when(itemManagerMock).list(any());
 226         for (int i = 0; i < ITEMS.size(); i++) {
 227             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 228         }
 229         Collection<Workflow> workflows = workflowManager.list(null, pageRequest);
 230         Assert.assertEquals(2, workflows.size());
 231         Iterator<Workflow> workflowIterator = workflows.iterator();
 232         Assert.assertEquals("Workflow_3", workflowIterator.next().getName());
 233         Assert.assertEquals("Workflow_2", workflowIterator.next().getName());
 234     }
 235
 236     private PageRequest createPageRequest(int limit, int offset, Sort.Direction sortOrder, String sortField) {
 237         return PageRequest.of(offset, limit, sortOrder, sortField);
 238     }
 239
 240 }