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