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

   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.services.types.PagingConstants.DEFAULT_LIMIT;
  12 import static org.onap.sdc.workflow.services.types.PagingConstants.DEFAULT_OFFSET;
  13 import static org.onap.sdc.workflow.services.types.PagingConstants.MAX_LIMIT;
  14 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  15
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  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.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.InjectMocks;
  27 import org.mockito.Mock;
  28 import org.onap.sdc.workflow.services.types.Workflow;
  29 import org.onap.sdc.workflow.services.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.onap.sdc.workflow.services.types.Page;
  35 import org.onap.sdc.workflow.services.types.Paging;
  36 import org.onap.sdc.workflow.services.types.PagingRequest;
  37 import org.onap.sdc.workflow.services.types.RequestSpec;
  38 import org.onap.sdc.workflow.services.types.Sort;
  39 import org.onap.sdc.workflow.services.types.SortingRequest;
  40 import org.openecomp.sdc.versioning.ItemManager;
  41 import org.openecomp.sdc.versioning.types.Item;
  42 import org.openecomp.sdc.versioning.types.ItemStatus;
  43 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  44
  45 @RunWith(SpringJUnit4ClassRunner.class)
  46 public class WorkflowManagerImplTest {
  47
  48
  49     private static final String ITEM1_ID = "1";
  50     private static final String WORKFLOW_TYPE = "WORKFLOW";
  51     private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME";
  52     private static final List<Item> ITEMS;
  53     private static final List<Workflow> MAPPED_WORKFLOWS;
  54     private static final String SORT_FIELD_NAME = "name";
  55
  56     static {
  57         List<Item> items = new ArrayList<>();
  58         List<Workflow> mappedWorkflows = new ArrayList<>();
  59         for (int i = 0; i < 5; i++) {
  60             items.add(createItem(i, true, true));
  61             mappedWorkflows.add(createWorkflow(i, true));
  62         }
  63         ITEMS = Collections.unmodifiableList(items);
  64         MAPPED_WORKFLOWS = Collections.unmodifiableList(mappedWorkflows);
  65     }
  66
  67     @Mock
  68     private ItemManager itemManagerMock;
  69     @Mock
  70     private UniqueValueService uniqueValueServiceMock;
  71     @Mock
  72     private WorkflowMapper workflowMapperMock;
  73     @Mock
  74     private VersionStateMapper versionStateMapperMock;
  75     @InjectMocks
  76     private WorkflowManagerImpl workflowManager;
  77
  78     @Test
  79     public void shouldReturnWorkflowVersionList() {
  80         doReturn(ITEMS).when(itemManagerMock).list(any());
  81         mockItemToWorkflowMaps();
  82         RequestSpec requestSpec = createRequestSpec(0, 20, true);
  83         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
  84
  85         Map<String, Workflow> workflowById =
  86                 workflows.getItems().stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
  87         assertEquals(ITEMS.size(), workflows.getItems().size());
  88         for (int i = 0; i < ITEMS.size(); i++) {
  89             assertTrue(workflowById.containsKey(String.valueOf(i)));
  90         }
  91         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
  92                 ITEMS.size());
  93     }
  94
  95     @Test
  96     public void listWithVersionStateFilter() {
  97         doReturn(Certified).when(versionStateMapperMock)
  98                            .workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED);
  99         doReturn(Arrays.asList(ITEMS.get(0), ITEMS.get(2))).when(itemManagerMock).list(any());
 100         doReturn(MAPPED_WORKFLOWS.get(0)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(0));
 101         doReturn(MAPPED_WORKFLOWS.get(2)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(2));
 102
 103         RequestSpec requestSpec = createRequestSpec(0, 20, true);
 104         Page<Workflow> workflows =
 105                 workflowManager.list(Collections.singleton(WorkflowVersionState.CERTIFIED), requestSpec);
 106
 107         Map<String, Workflow> workflowById =
 108                 workflows.getItems().stream().collect(Collectors.toMap(Workflow::getId, Function.identity()));
 109         assertEquals(2, workflows.getItems().size());
 110         assertTrue(workflowById.containsKey("0"));
 111         assertTrue(workflowById.containsKey("2"));
 112
 113         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(), 2);
 114     }
 115
 116     @Test(expected = EntityNotFoundException.class)
 117     public void shouldThrowExceptionWhenWorkflowDontExist() {
 118         Workflow nonExistingWorkflow = new Workflow();
 119         nonExistingWorkflow.setId(ITEM1_ID);
 120         doReturn(null).when(itemManagerMock).get(ITEM1_ID);
 121         workflowManager.get(nonExistingWorkflow);
 122         verify(workflowMapperMock, times(3)).itemToWorkflow(any(Item.class));
 123     }
 124
 125     @Test
 126     public void shouldReturnWorkflow() {
 127         Item retrievedItem = createItem(1, true, true);
 128         doReturn(retrievedItem).when(itemManagerMock).get(ITEM1_ID);
 129         Workflow workflow = createWorkflow(1, true);
 130         workflowManager.get(workflow);
 131         verify(itemManagerMock).get(ITEM1_ID);
 132         verify(workflowMapperMock).itemToWorkflow(retrievedItem);
 133     }
 134
 135     @Test
 136     public void shouldCreateWorkflowItemFromWorkflow() {
 137         Workflow workflowToBeCreated = createWorkflow(1, false);
 138         Item createdWorkflowItem = createItem(1, false, true);
 139         doReturn(createdWorkflowItem).when(workflowMapperMock).workflowToItem(workflowToBeCreated);
 140         doReturn(createdWorkflowItem).when(itemManagerMock).create(createdWorkflowItem);
 141         workflowManager.create(workflowToBeCreated);
 142         verify(uniqueValueServiceMock)
 143                 .validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
 144
 145         createdWorkflowItem.setStatus(ItemStatus.ACTIVE);
 146         createdWorkflowItem.setType(WORKFLOW_TYPE);
 147         verify(itemManagerMock).create(createdWorkflowItem);
 148         verify(uniqueValueServiceMock)
 149                 .createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()});
 150     }
 151
 152     @Test
 153     public void shouldUpdateWorkflow() {
 154         Item workflowItem = createItem(1, true, true);
 155         doReturn(workflowItem).when(itemManagerMock).get(ITEM1_ID);
 156         Workflow workflowToBeUpdated = createWorkflow(1, true);
 157         doReturn(workflowItem).when(workflowMapperMock).workflowToItem(workflowToBeUpdated);
 158         workflowManager.update(workflowToBeUpdated);
 159         verify(itemManagerMock).update(workflowItem);
 160         verify(uniqueValueServiceMock)
 161                 .updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, workflowItem.getName(), workflowToBeUpdated.getName());
 162
 163     }
 164
 165     @Test(expected = EntityNotFoundException.class)
 166     public void shouldThrowExceptionWhenWorkflowToUpdateNotFound() {
 167         doReturn(null).when(itemManagerMock).get(ITEM1_ID);
 168         workflowManager.update(createWorkflow(1, true));
 169     }
 170
 171     @Test
 172     public void listWhenRequestSpecIsNull() {
 173         doReturn(ITEMS).when(itemManagerMock).list(any());
 174         mockItemToWorkflowMaps();
 175         Page<Workflow> workflows = workflowManager.list(null, null);
 176
 177         assertEquals(ITEMS.size(), workflows.getItems().size());
 178         assertPaging(workflows.getPaging(), DEFAULT_OFFSET, DEFAULT_LIMIT, ITEMS.size());
 179
 180         // verify sorted ascending by name
 181         for (int i = DEFAULT_OFFSET; i < ITEMS.size(); i++) {
 182             assertEquals("Workflow_" + i, workflows.getItems().get(i).getName());
 183         }
 184     }
 185
 186     @Test
 187     public void listWhenPagingIsNull() {
 188         doReturn(ITEMS).when(itemManagerMock).list(any());
 189         mockItemToWorkflowMaps();
 190         Page<Workflow> workflows = workflowManager.list(null, new RequestSpec(null,
 191                 SortingRequest.builder().sort(new Sort(SORT_FIELD_NAME, true)).build()));
 192
 193         assertEquals(ITEMS.size(), workflows.getItems().size());
 194         assertPaging(workflows.getPaging(), DEFAULT_OFFSET, DEFAULT_LIMIT, ITEMS.size());
 195     }
 196
 197     @Test
 198     public void listWhenOffsetAndLimitAreNull() {
 199         doReturn(ITEMS).when(itemManagerMock).list(any());
 200         mockItemToWorkflowMaps();
 201         RequestSpec requestSpec = new RequestSpec(new PagingRequest(-2, -8),
 202                 SortingRequest.builder().sort(new Sort(SORT_FIELD_NAME, true)).build());
 203         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 204
 205         assertEquals(ITEMS.size(), workflows.getItems().size());
 206         assertPaging(workflows.getPaging(), DEFAULT_OFFSET, DEFAULT_LIMIT, ITEMS.size());
 207     }
 208
 209     @Test
 210     public void listWhenSortingIsNull() {
 211         doReturn(ITEMS).when(itemManagerMock).list(any());
 212         mockItemToWorkflowMaps();
 213         RequestSpec requestSpec = new RequestSpec(new PagingRequest(2, 8), null);
 214         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 215
 216         assertEquals(3, workflows.getItems().size());
 217         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 218                 ITEMS.size());
 219
 220         // verify sorted ascending by name
 221         assertEquals("Workflow_2", workflows.getItems().get(0).getName());
 222         assertEquals("Workflow_3", workflows.getItems().get(1).getName());
 223         assertEquals("Workflow_4", workflows.getItems().get(2).getName());
 224     }
 225
 226     @Test
 227     public void listWhenSortingIsEmpty() {
 228         doReturn(ITEMS).when(itemManagerMock).list(any());
 229         mockItemToWorkflowMaps();
 230         RequestSpec requestSpec = new RequestSpec(new PagingRequest(2, 8), SortingRequest.builder().build());
 231         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 232
 233         assertEquals(3, workflows.getItems().size());
 234         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 235                 ITEMS.size());
 236
 237         // verify sorted ascending by name
 238         assertEquals("Workflow_2", workflows.getItems().get(0).getName());
 239         assertEquals("Workflow_3", workflows.getItems().get(1).getName());
 240         assertEquals("Workflow_4", workflows.getItems().get(2).getName());
 241     }
 242
 243     @Test
 244     public void listWhenRequestSpecIsValid() {
 245         RequestSpec requestSpec = createRequestSpec(0, 5, true);
 246         doReturn(ITEMS).when(itemManagerMock).list(any());
 247         mockItemToWorkflowMaps();
 248         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 249
 250         assertEquals(5, workflows.getItems().size());
 251         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 252                 ITEMS.size());
 253     }
 254
 255     @Test
 256     public void listWhenLimitIsLessThanTotal() {
 257         RequestSpec requestSpec = createRequestSpec(0, 3, true);
 258         doReturn(ITEMS).when(itemManagerMock).list(any());
 259         mockItemToWorkflowMaps();
 260         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 261         assertEquals(3, workflows.getItems().size());
 262         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 263                 ITEMS.size());
 264     }
 265
 266
 267     @Test
 268     public void listWhenOffsetIsNotFirst() {
 269         RequestSpec requestSpec = createRequestSpec(3, 1, true);
 270         doReturn(ITEMS).when(itemManagerMock).list(any());
 271         mockItemToWorkflowMaps();
 272         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 273         assertEquals(1, workflows.getItems().size());
 274         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 275                 ITEMS.size());
 276     }
 277
 278     @Test
 279     public void listWhenLimitIsMoreThanTotal() {
 280         RequestSpec requestSpec = createRequestSpec(0, 10, true);
 281         doReturn(ITEMS).when(itemManagerMock).list(any());
 282         mockItemToWorkflowMaps();
 283         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 284         assertEquals(5, workflows.getItems().size());
 285         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 286                 ITEMS.size());
 287     }
 288
 289     @Test
 290     public void listWhenOffsetIsMoreThanTotal() {
 291         RequestSpec requestSpec = createRequestSpec(6, 3, true);
 292         doReturn(ITEMS).when(itemManagerMock).list(any());
 293         mockItemToWorkflowMaps();
 294         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 295         assertEquals(0, workflows.getItems().size());
 296         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 297                 ITEMS.size());
 298     }
 299
 300     @Test
 301     public void listWhenOffsetIsMoreThanMax() {
 302         doReturn(ITEMS).when(itemManagerMock).list(any());
 303         mockItemToWorkflowMaps();
 304         RequestSpec requestSpec = createRequestSpec(0, 5555, true);
 305         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 306
 307         assertEquals(ITEMS.size(), workflows.getItems().size());
 308         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), MAX_LIMIT, ITEMS.size());
 309     }
 310
 311     @Test
 312     public void listWhenOffsetAndLimitAreMoreThanTotal() {
 313         RequestSpec requestSpec = createRequestSpec(10, 10, true);
 314         doReturn(ITEMS).when(itemManagerMock).list(any());
 315         mockItemToWorkflowMaps();
 316         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 317         assertEquals(0, workflows.getItems().size());
 318         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 319                 ITEMS.size());
 320     }
 321
 322     @Test
 323     public void listWhenSortedDesc() {
 324         RequestSpec requestSpec = createRequestSpec(2, 1, false);
 325         doReturn(ITEMS).when(itemManagerMock).list(any());
 326         mockItemToWorkflowMaps();
 327         Page<Workflow> workflows = workflowManager.list(null, requestSpec);
 328         assertEquals(1, workflows.getItems().size());
 329         assertPaging(workflows.getPaging(), requestSpec.getPaging().getOffset(), requestSpec.getPaging().getLimit(),
 330                 ITEMS.size());
 331         Iterator<Workflow> workflowIterator = workflows.getItems().iterator();
 332         assertEquals("Workflow_2", workflowIterator.next().getName());
 333     }
 334
 335     private void mockItemToWorkflowMaps() {
 336         for (int i = 0; i < ITEMS.size(); i++) {
 337             doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i));
 338         }
 339     }
 340
 341     private static RequestSpec createRequestSpec(int offset, int limit, boolean isAscending) {
 342         return new RequestSpec(new PagingRequest(offset, limit),
 343                 SortingRequest.builder().sort(new Sort(SORT_FIELD_NAME, isAscending)).build());
 344     }
 345
 346     private static void assertPaging(Paging paging, int expectedOffset, int expectedLimit, int expectedTotal) {
 347         assertEquals(expectedOffset, paging.getOffset());
 348         assertEquals(expectedLimit, paging.getLimit());
 349         assertEquals(expectedTotal, paging.getTotal());
 350     }
 351 }