gerrit.onap Code Review - sdc.git/blob

   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.openecomp.activityspec.be.impl;
  18
  19 import java.util.Arrays;
  20 import java.util.Collection;
  21 import org.mockito.InjectMocks;
  22 import org.mockito.Mock;
  23 import org.mockito.MockitoAnnotations;
  24 import org.mockito.Spy;
  25 import org.openecomp.activityspec.api.rest.types.ActivitySpecAction;
  26 import org.openecomp.activityspec.be.dao.ActivitySpecDao;
  27 import org.openecomp.activityspec.be.dao.types.ActivitySpecEntity;
  28 import org.openecomp.activityspec.be.datatypes.ActivitySpecParameter;
  29 import org.openecomp.activityspec.errors.ActivitySpecNotFoundException;
  30 import org.openecomp.core.dao.UniqueValueDao;
  31 import org.openecomp.sdc.common.errors.CoreException;
  32 import org.openecomp.sdc.common.errors.SdcRuntimeException;
  33 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  34 import org.openecomp.sdc.versioning.ItemManager;
  35 import org.openecomp.sdc.versioning.VersioningManager;
  36 import org.openecomp.sdc.versioning.dao.types.Version;
  37 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  38 import org.openecomp.sdc.versioning.types.Item;
  39 import org.testng.Assert;
  40 import org.testng.annotations.AfterMethod;
  41 import org.testng.annotations.BeforeMethod;
  42 import org.testng.annotations.Test;
  43
  44 import java.util.ArrayList;
  45 import java.util.List;
  46
  47 import static org.mockito.Matchers.anyObject;
  48 import static org.mockito.Mockito.doReturn;
  49 import static org.mockito.Mockito.doThrow;
  50 import static org.mockito.Mockito.verify;
  51 import static org.openecomp.activityspec.utils.ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND;
  52 import static org.openecomp.activityspec.utils.ActivitySpecConstant.INVALID_STATE;
  53 import static org.openecomp.activityspec.utils.ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE;
  54
  55 public class ActivitySpecManagerImplTest {
  56
  57   private static final String STRING_TYPE = "String";
  58   private static final String TEST_ERROR_MSG = "Test Error";
  59   private ActivitySpecEntity input;
  60   private static final Version VERSION01 = new Version("12345");
  61   private static final String ID = "ID1";
  62
  63   @Spy
  64   @InjectMocks
  65   private ActivitySpecManagerImpl activitySpecManager;
  66
  67   @Mock
  68   private ItemManager itemManagerMock;
  69
  70   @Mock
  71   private VersioningManager versionManagerMock;
  72
  73   @Mock
  74   private ActivitySpecDao activitySpecDaoMock;
  75
  76   //This is used to mock UniqueValueUtil. This should not be removed.
  77   @Mock
  78   private UniqueValueDao uniqueValueDaoMock;
  79
  80   @BeforeMethod
  81   public void setUp() throws Exception {
  82     MockitoAnnotations.initMocks(this);
  83   }
  84
  85   @AfterMethod
  86   public void tearDown() {
  87     activitySpecManager = null;
  88   }
  89
  90   @Test
  91   public void testCreate() {
  92
  93     SessionContextProviderFactory.getInstance().createInterface().create("testUser", "testTenant");
  94
  95     ActivitySpecEntity activitySpecToCreate = new ActivitySpecEntity();
  96     activitySpecToCreate.setName("startserver");
  97     activitySpecToCreate.setDescription("start the server");
  98     activitySpecToCreate.setVersion(VERSION01);
  99
 100     List<String> categoryList = new ArrayList<>();
 101     categoryList.add("category1");
 102     categoryList.add("category2");
 103     activitySpecToCreate.setCategoryList(categoryList);
 104
 105     ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", STRING_TYPE);
 106     inputParams.setValue("localhost");
 107     ActivitySpecParameter inputParams1 = new ActivitySpecParameter("dbname", STRING_TYPE);
 108     inputParams.setValue("prod");
 109     List<ActivitySpecParameter> inputs = new ArrayList<>();
 110     inputs.add(inputParams);
 111     inputs.add(inputParams1);
 112     activitySpecToCreate.setInputs(inputs);
 113
 114     ActivitySpecParameter outputParams = new ActivitySpecParameter("status", STRING_TYPE);
 115     outputParams.setValue("started");
 116     List<ActivitySpecParameter> outputs = new ArrayList<>();
 117     outputs.add(outputParams);
 118     activitySpecToCreate.setOutputs(outputs);
 119
 120     activitySpecToCreate.setId("ID1");
 121     activitySpecToCreate.setVersion(VERSION01);
 122
 123     Item item = new Item();
 124     doReturn(item).when(itemManagerMock).create(anyObject());
 125
 126     ActivitySpecEntity activitySpec = activitySpecManager.createActivitySpec
 127         (activitySpecToCreate);
 128
 129     Assert.assertNotNull(activitySpec);
 130     activitySpec.setId("ID1");
 131     activitySpec.setStatus(VersionStatus.Draft.name());
 132     assertActivitySpecEquals(activitySpec, activitySpecToCreate);
 133   }
 134
 135
 136
 137   @Test
 138   public void testList () {
 139     ActivitySpecEntity activitySpec = new ActivitySpecEntity();
 140     activitySpec.setName("stopServer");
 141     doReturn(Arrays.asList(
 142         activitySpec))
 143         .when(itemManagerMock).list(anyObject());
 144     final Collection<Item> activitySpecs = activitySpecManager.list("Certified");
 145     Assert.assertEquals(activitySpecs.size(), 1);
 146   }
 147
 148   @Test
 149   public void testListInvalidFilter () {
 150     final Collection<Item> activitySpecs = activitySpecManager.list("invalid_status");
 151     Assert.assertEquals(activitySpecs.size(), 0);
 152   }
 153
 154   @Test
 155   public void testListNoFilter () {
 156     final Collection<Item> activitySpecs = activitySpecManager.list(null);
 157     Assert.assertEquals(activitySpecs.size(), 0);
 158   }
 159
 160   @Test
 161   public void testGet () {
 162     input = new ActivitySpecEntity();
 163     input.setId(ID);
 164     input.setVersion(VERSION01);
 165
 166     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 167     doReturn(input).when(activitySpecDaoMock).get(anyObject());
 168     VERSION01.setStatus(VersionStatus.Draft);
 169     doReturn(VERSION01).when(versionManagerMock).get(anyObject(), anyObject());
 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   @Test
 182   public void testGetActivitySpecDaoFail () {
 183     input = new ActivitySpecEntity();
 184     input.setId(ID);
 185     input.setVersion(VERSION01);
 186     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 187     doReturn(input).when(activitySpecDaoMock).get(anyObject());
 188     doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(activitySpecDaoMock).get(anyObject());
 189     try {
 190       activitySpecManager.get(input);
 191       Assert.fail();
 192     } catch (ActivitySpecNotFoundException exception) {
 193       Assert.assertEquals(exception.getMessage(), ACTIVITY_SPEC_NOT_FOUND);
 194     }
 195   }
 196
 197   @Test
 198   public void testListVersionFail () {
 199     input = new ActivitySpecEntity();
 200     input.setId(ID);
 201     input.setVersion(VERSION01);
 202     input.getVersion().setId(VERSION_ID_DEFAULT_VALUE);
 203     doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(versionManagerMock).list(anyObject());
 204     try {
 205       activitySpecManager.get(input);
 206       Assert.fail();
 207     } catch (ActivitySpecNotFoundException exception) {
 208       Assert.assertEquals(exception.getMessage(), ACTIVITY_SPEC_NOT_FOUND);
 209     }
 210   }
 211
 212   @Test
 213   public void testInvalidDeprecate () {
 214     try {
 215       activitySpecManager.actOnAction(ID,
 216           VERSION01.getId(), ActivitySpecAction.DEPRECATE);
 217     }
 218     catch (CoreException exception) {
 219       Assert.assertEquals(exception.getMessage(), INVALID_STATE);
 220     }
 221   }
 222
 223   @Test
 224   public void testInvalidDelete () {
 225     try {
 226       activitySpecManager.actOnAction(ID,
 227           VERSION01.getId(), ActivitySpecAction.DELETE);
 228     }
 229     catch (CoreException exception) {
 230       Assert.assertEquals(exception.getMessage(), INVALID_STATE);
 231     }
 232   }
 233
 234   @Test
 235   public void testCertify () {
 236     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 237     doReturn(VERSION01).when(versionManagerMock).get(anyObject(), anyObject());
 238     activitySpecManager.actOnAction(ID,
 239         VERSION01.getId(), ActivitySpecAction.CERTIFY);
 240
 241     verify(versionManagerMock).updateVersion(ID, VERSION01);
 242     verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Certified,
 243         VersionStatus.Draft);
 244     verify(versionManagerMock).publish(anyObject(), anyObject(), anyObject());
 245   }
 246
 247   @Test
 248   public void testInvalidCertify () {
 249     try {
 250       activitySpecManager.actOnAction(ID,
 251           VERSION01.getId(), ActivitySpecAction.CERTIFY);
 252     }
 253     catch (CoreException exception) {
 254       Assert.assertEquals(exception.getMessage(), INVALID_STATE);
 255     }
 256   }
 257
 258   @Test
 259   public void testGetVersionFailOnStatusChangeAction () {
 260     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 261     doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(versionManagerMock).get(anyObject(), anyObject());
 262     try {
 263       activitySpecManager.actOnAction(ID,
 264           VERSION01.getId(), ActivitySpecAction.CERTIFY);
 265       Assert.fail();
 266     } catch (ActivitySpecNotFoundException exception) {
 267       Assert.assertEquals(exception.getMessage(), ACTIVITY_SPEC_NOT_FOUND);
 268     }
 269   }
 270
 271   @Test
 272   public void testDeprecate () {
 273     VERSION01.setStatus(VersionStatus.Certified);
 274     Version retrivedVersion = new Version("12");
 275     retrivedVersion.setStatus(VersionStatus.Certified);
 276     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 277     doReturn(retrivedVersion).when(versionManagerMock).get(anyObject(), anyObject());
 278     activitySpecManager.actOnAction(ID,
 279         VERSION_ID_DEFAULT_VALUE, ActivitySpecAction.DEPRECATE);
 280
 281     verify(versionManagerMock).updateVersion(ID, retrivedVersion);
 282     verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Deprecated,
 283         VersionStatus.Certified);
 284     verify(versionManagerMock).publish(anyObject(), anyObject(), anyObject());
 285   }
 286
 287   @Test
 288   public void testDelete () {
 289     ActivitySpecEntity activitySpec = new ActivitySpecEntity();
 290     VERSION01.setStatus(VersionStatus.Deprecated);
 291     activitySpec.setName("stopServer");
 292     activitySpec.setVersion(VERSION01);
 293
 294     Version retrivedVersion = new Version("12");
 295     retrivedVersion.setStatus(VersionStatus.Deprecated);
 296
 297     doReturn(Arrays.asList(VERSION01)).when(versionManagerMock).list(anyObject());
 298     doReturn(retrivedVersion).when(versionManagerMock).get(anyObject(), anyObject());
 299     doReturn(activitySpec).when(activitySpecDaoMock).get(anyObject());
 300     activitySpecManager.actOnAction(ID,
 301         VERSION_ID_DEFAULT_VALUE, ActivitySpecAction.DELETE);
 302
 303     verify(versionManagerMock).updateVersion(ID, VERSION01);
 304     verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Deleted,
 305         VersionStatus.Deprecated);
 306     verify(versionManagerMock).publish(anyObject(), anyObject(), anyObject());
 307   }
 308
 309   private void assertActivitySpecEquals(ActivitySpecEntity actual, ActivitySpecEntity expected) {
 310     Assert.assertEquals(actual.getId(), expected.getId());
 311     Assert.assertEquals(actual.getName(), expected.getName());
 312     Assert.assertEquals(actual.getDescription(), expected.getDescription());
 313     Assert.assertEquals(actual.getCategoryList(), expected.getCategoryList());
 314     Assert.assertEquals(actual.getInputs(), expected.getInputs());
 315     Assert.assertEquals(actual.getOutputs(), expected.getOutputs());
 316   }
 317
 318 }