gerrit.onap Code Review - sdc/sdc-workflow-designer.git/blob

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