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