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