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

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