workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/ActivitySpecManagerImplTest.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.mockito.ArgumentMatchers.any;
  20 import static org.mockito.ArgumentMatchers.anyString;
  21 import static org.mockito.ArgumentMatchers.eq;
  22 import static org.mockito.ArgumentMatchers.isNull;
  23 import static org.mockito.Mockito.doReturn;
  24 import static org.mockito.Mockito.verify;
  25 import static org.onap.sdc.workflow.TestUtil.createRetrievedVersion;
  26 import static org.onap.sdc.workflow.services.ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND;
  27 import static org.onap.sdc.workflow.services.ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE;
  28
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.List;
  33 import org.junit.After;
  34 import org.junit.Assert;
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.mockito.InjectMocks;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.mockito.MockitoAnnotations;
  41 import org.mockito.Spy;
  42 import org.onap.sdc.common.versioning.persistence.types.InternalItem;
  43 import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
  44 import org.onap.sdc.common.versioning.services.ItemManager;
  45 import org.onap.sdc.common.versioning.services.VersioningManager;
  46 import org.onap.sdc.common.versioning.services.types.Item;
  47 import org.onap.sdc.common.versioning.services.types.Version;
  48 import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
  49 import org.onap.sdc.common.versioning.services.types.VersionStatus;
  50 import org.onap.sdc.workflow.api.types.activityspec.ActivitySpecAction;
  51 import org.onap.sdc.workflow.persistence.ActivitySpecRepository;
  52 import org.onap.sdc.workflow.persistence.types.ActivitySpecEntity;
  53 import org.onap.sdc.workflow.persistence.types.ActivitySpecParameter;
  54 import org.onap.sdc.workflow.services.UniqueValueService;
  55 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  56 import org.onap.sdc.workflow.services.exceptions.VersionStatusModificationException;
  57 import org.onap.sdc.workflow.services.impl.mappers.ActivitySpecMapper;
  58
  59 public class ActivitySpecManagerImplTest {
  60
  61     private static final String STRING_TYPE = "String";
  62     private static final String TEST_ERROR_MSG = "Test Error";
  63     private static final String ID = "ID1";
  64     private String version01 = "12345";
  65     private ActivitySpecEntity input;
  66
  67     @Spy
  68     @InjectMocks
  69     private ActivitySpecManagerImpl activitySpecManager;
  70     @Mock
  71     private ItemManager itemManagerMock;
  72     @Mock
  73     private VersioningManager versionManagerMock;
  74     @Mock
  75     private ActivitySpecRepository activitySpecRepositoryMock;
  76     @Mock
  77     private UniqueValueService uniqueValueServiceMock;
  78     @Mock
  79     private ActivitySpecMapper activitySpecMapperMock;
  80
  81     @Before
  82     public void setUp() {
  83         MockitoAnnotations.initMocks(this);
  84     }
  85
  86     @After
  87     public void tearDown() {
  88         activitySpecManager = null;
  89     }
  90
  91     @Test
  92     public void testCreate() {
  93         ActivitySpecEntity activitySpecToCreate = new ActivitySpecEntity();
  94         activitySpecToCreate.setName("startserver");
  95         activitySpecToCreate.setDescription("start the server");
  96         activitySpecToCreate.setVersionId(version01);
  97
  98         List<String> categoryList = new ArrayList<>();
  99         categoryList.add("category1");
 100         categoryList.add("category2");
 101         activitySpecToCreate.setCategoryList(categoryList);
 102
 103         ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", STRING_TYPE, null);
 104         inputParams.setValue("localhost");
 105         ActivitySpecParameter inputParams1 = new ActivitySpecParameter("dbname", STRING_TYPE, null);
 106         inputParams.setValue("prod");
 107         List<ActivitySpecParameter> inputs = new ArrayList<>();
 108         inputs.add(inputParams);
 109         inputs.add(inputParams1);
 110         activitySpecToCreate.setInputs(inputs);
 111
 112         ActivitySpecParameter outputParams = new ActivitySpecParameter("status", STRING_TYPE, null);
 113         outputParams.setValue("started");
 114         List<ActivitySpecParameter> outputs = new ArrayList<>();
 115         outputs.add(outputParams);
 116         activitySpecToCreate.setOutputs(outputs);
 117
 118         activitySpecToCreate.setVersionId(version01);
 119
 120         String itemId = "ID1";
 121
 122         InternalItem createdItem = new InternalItem();
 123         createdItem.setId(itemId);
 124         doReturn(createdItem).when(itemManagerMock).create(any());
 125
 126         doReturn(createRetrievedVersion(version01, VersionStatus.Draft)).when(versionManagerMock)
 127                 .create(eq(itemId), isNull(), any(Version.class), eq(VersionCreationMethod.major));
 128
 129         ActivitySpecEntity activitySpec = activitySpecManager.createActivitySpec(activitySpecToCreate);
 130
 131         Assert.assertNotNull(activitySpec);
 132         activitySpec.setId(itemId);
 133         activitySpec.setStatus(VersionStatus.Draft.name());
 134         assertActivitySpecEquals(activitySpec, activitySpecToCreate);
 135     }
 136
 137     private void assertActivitySpecEquals(ActivitySpecEntity actual, ActivitySpecEntity expected) {
 138         Assert.assertEquals(actual.getId(), expected.getId());
 139         Assert.assertEquals(actual.getName(), expected.getName());
 140         Assert.assertEquals(actual.getDescription(), expected.getDescription());
 141         Assert.assertEquals(actual.getCategoryList(), expected.getCategoryList());
 142         Assert.assertEquals(actual.getInputs(), expected.getInputs());
 143         Assert.assertEquals(actual.getOutputs(), expected.getOutputs());
 144     }
 145
 146     @Test
 147     public void testList() {
 148         Item item = new Item();
 149         doReturn(Collections.singletonList(item)).when(itemManagerMock).list(any());
 150         doReturn(new ActivitySpecEntity(ID, null)).when(activitySpecMapperMock).itemToActivitySpec(item);
 151
 152         final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list("Certified");
 153         Assert.assertEquals(1, activitySpecs.size());
 154         Assert.assertEquals(ID, activitySpecs.iterator().next().getId());
 155     }
 156
 157     @Test
 158     public void testListInvalidFilter() {
 159         final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list("invalid_status");
 160         Assert.assertEquals(0, activitySpecs.size());
 161     }
 162
 163     @Test
 164     public void testListNoFilter() {
 165         final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list(null);
 166         Assert.assertEquals(0, activitySpecs.size());
 167     }
 168
 169     @Test
 170     public void testGet() {
 171         input = new ActivitySpecEntity();
 172         input.setId(ID);
 173         input.setVersionId(version01);
 174
 175         mockListVersions();
 176         doReturn(input).when(activitySpecRepositoryMock).get(any());
 177         doReturn(createRetrievedVersion(version01,VersionStatus.Draft)).when(versionManagerMock).get(any(), any());
 178         ActivitySpecEntity retrieved = activitySpecManager.get(input);
 179         assertActivitySpecEquals(retrieved, input);
 180         Assert.assertEquals(retrieved.getStatus(), VersionStatus.Draft.name());
 181
 182
 183         retrieved = activitySpecManager.get(input);
 184         assertActivitySpecEquals(retrieved, input);
 185         Assert.assertEquals(retrieved.getStatus(), VersionStatus.Draft.name());
 186     }
 187
 188     private void mockListVersions() {
 189         doReturn(Collections.singletonList((Version)createRetrievedVersion(version01,VersionStatus.Draft))).when(versionManagerMock).list(any());
 190     }
 191
 192     @Test
 193     public void testGetActivitySpecDaoFail() {
 194         input = new ActivitySpecEntity();
 195         input.setId(ID);
 196         input.setVersionId(version01);
 197         mockListVersions();
 198         doReturn(input).when(activitySpecRepositoryMock).get(any());
 199         Mockito.doThrow(new RuntimeException(TEST_ERROR_MSG)).when(activitySpecRepositoryMock).get(any());
 200         try {
 201             activitySpecManager.get(input);
 202             Assert.fail();
 203         } catch (EntityNotFoundException exception) {
 204             Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
 205         }
 206     }
 207
 208     @Test
 209     public void testListVersionFail() {
 210         input = new ActivitySpecEntity();
 211         input.setId(ID);
 212         input.setVersionId(VERSION_ID_DEFAULT_VALUE);
 213         Mockito.doThrow(new RuntimeException(TEST_ERROR_MSG)).when(versionManagerMock).list(any());
 214         try {
 215             activitySpecManager.get(input);
 216             Assert.fail();
 217         } catch (EntityNotFoundException exception) {
 218             Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
 219         }
 220     }
 221
 222     @Test(expected = VersionStatusModificationException.class)
 223     public void testInvalidDeprecate() {
 224         InternalVersion version = createRetrievedVersion(version01, VersionStatus.Draft);
 225         doReturn(version).when(versionManagerMock).get(ID, version01);
 226         activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.DEPRECATE);
 227     }
 228
 229     @Test(expected = VersionStatusModificationException.class)
 230     public void testInvalidDelete() {
 231         mockCertifiedVersion();
 232         activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.DELETE);
 233     }
 234
 235     private void mockCertifiedVersion() {
 236         InternalVersion version = createRetrievedVersion(version01, VersionStatus.Certified);
 237         doReturn(version).when(versionManagerMock).get(ID, version01);
 238     }
 239
 240     @Test(expected = VersionStatusModificationException.class)
 241     public void testInvalidCertify() {
 242         mockCertifiedVersion();
 243         activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
 244     }
 245
 246     @Test
 247     public void testCertify() {
 248         InternalVersion retrievedVersion = createRetrievedVersion(version01, VersionStatus.Draft);
 249         doReturn(Collections.singletonList(retrievedVersion)).when(versionManagerMock).list(any());
 250         doReturn(retrievedVersion).when(versionManagerMock).get(any(), any());
 251
 252         activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
 253
 254         verify(versionManagerMock).updateStatus(eq(ID), eq(version01), eq(VersionStatus.Certified), anyString());
 255     }
 256
 257     @Test
 258     public void testGetVersionFailOnStatusChangeAction() {
 259         mockListVersions();
 260         try {
 261             activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
 262             Assert.fail();
 263         } catch (EntityNotFoundException exception) {
 264             Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
 265         }
 266     }
 267
 268     @Test
 269     public void testDeprecate() {
 270         InternalVersion retrievedVersion = createRetrievedVersion(version01, VersionStatus.Certified);
 271         mockListVersions();
 272         doReturn(retrievedVersion).when(versionManagerMock).get(any(), any());
 273         activitySpecManager
 274                 .actOnAction(new ActivitySpecEntity(ID, VERSION_ID_DEFAULT_VALUE), ActivitySpecAction.DEPRECATE);
 275
 276         verify(versionManagerMock).updateStatus(eq(ID), eq(version01), eq(VersionStatus.Deprecated), anyString());
 277     }
 278
 279     @Test
 280     public void testDelete() {
 281         ActivitySpecEntity activitySpec = new ActivitySpecEntity();
 282         activitySpec.setName("stopServer");
 283         activitySpec.setVersionId(version01);
 284
 285         mockListVersions();
 286         doReturn(createRetrievedVersion(version01, VersionStatus.Deprecated)).when(versionManagerMock).get(any(), any());
 287         doReturn(activitySpec).when(activitySpecRepositoryMock).get(any());
 288         activitySpecManager
 289                 .actOnAction(new ActivitySpecEntity(ID, VERSION_ID_DEFAULT_VALUE), ActivitySpecAction.DELETE);
 290
 291         verify(versionManagerMock).updateStatus(eq(ID), eq(version01), eq(VersionStatus.Deleted), anyString());
 292     }
 293 }