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