gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 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.sdc.vendorsoftwareproduct.impl;
  18
  19
  20 import org.mockito.InjectMocks;
  21 import org.mockito.Mock;
  22 import org.mockito.MockitoAnnotations;
  23 import org.mockito.Spy;
  24 import org.openecomp.sdc.common.errors.CoreException;
  25 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  26 import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  29 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  30 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  32 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  33 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  35 import org.openecomp.sdc.versioning.dao.types.Version;
  36 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  37 import org.testng.Assert;
  38 import org.testng.annotations.AfterMethod;
  39 import org.testng.annotations.BeforeMethod;
  40 import org.testng.annotations.Test;
  41
  42 import java.util.Arrays;
  43 import java.util.Collection;
  44
  45 import static org.mockito.Matchers.anyObject;
  46 import static org.mockito.Mockito.doReturn;
  47 import static org.mockito.Mockito.never;
  48 import static org.mockito.Mockito.verify;
  49
  50 public class NetworkManagerImplTest {
  51
  52   private static final String VSP_ID = "vsp";
  53   private static final String USER_ID = "test_user1";
  54   private static final Version VERSION = new Version("version_id");
  55   private static final String NETWORK1_ID = "network1";
  56   private static final String NETWORK2_ID = "network2";
  57   private static final String tenant = "dox";
  58
  59   @Mock
  60   private NetworkDao networkDaoMock;
  61   @Mock
  62   private CompositionEntityDataManager compositionEntityDataManagerMock;
  63   @Mock
  64   private VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao;
  65
  66   @InjectMocks
  67   @Spy
  68   private NetworkManagerImpl networkManager;
  69
  70   static NetworkEntity createNetwork(String vspId, Version version, String networkId) {
  71     NetworkEntity networkEntity = new NetworkEntity(vspId, version, networkId);
  72     Network networkData = new Network();
  73     networkData.setName(networkId + " name");
  74     networkData.setDhcp(true);
  75     networkEntity.setNetworkCompositionData(networkData);
  76     return networkEntity;
  77   }
  78
  79   @BeforeMethod
  80   public void setUp() throws Exception {
  81     MockitoAnnotations.initMocks(this);
  82     SessionContextProviderFactory.getInstance().createInterface().create(USER_ID, tenant);
  83   }
  84
  85   @AfterMethod
  86   public void tearDown() {
  87     networkManager = null;
  88     SessionContextProviderFactory.getInstance().createInterface().close();
  89   }
  90
  91   @Test
  92   public void testListWhenNone() {
  93     Collection<NetworkEntity> networks =
  94         networkManager.listNetworks(VSP_ID, null);
  95     Assert.assertEquals(networks.size(), 0);
  96   }
  97
  98   @Test
  99   public void testList() {
 100     doReturn(Arrays.asList(
 101         createNetwork(VSP_ID, VERSION, NETWORK1_ID),
 102         createNetwork(VSP_ID, VERSION, NETWORK2_ID)))
 103         .when(networkDaoMock).list(anyObject());
 104
 105     Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, VERSION);
 106     Assert.assertEquals(actual.size(), 2);
 107   }
 108
 109   @Test
 110   public void testCreateOnUploadVsp_negative() {
 111     testCreate_negative(new NetworkEntity(VSP_ID, VERSION, null),
 112         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 113   }
 114
 115   @Test
 116   public void testUpdateNonExistingNetworkId_negative() {
 117     testUpdate_negative(VSP_ID, VERSION, NETWORK1_ID,
 118         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 119   }
 120
 121   @Test
 122   public void testIllegalUpdateOnUploadVsp() {
 123     doReturn(createNetwork(VSP_ID, VERSION, NETWORK1_ID))
 124         .when(networkDaoMock).get(anyObject());
 125
 126     CompositionEntityValidationData toBeReturned =
 127         new CompositionEntityValidationData(CompositionEntityType.network, NETWORK1_ID);
 128     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 129     doReturn(toBeReturned)
 130         .when(compositionEntityDataManagerMock)
 131         .validateEntity(anyObject(), anyObject(), anyObject());
 132     doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
 133
 134     NetworkEntity networkEntity = new NetworkEntity(VSP_ID, VERSION, NETWORK1_ID);
 135     Network networkData = new Network();
 136     networkData.setName(NETWORK1_ID + " name updated");
 137     networkData.setDhcp(false);
 138     networkEntity.setNetworkCompositionData(networkData);
 139
 140     CompositionEntityValidationData validationData =
 141         networkManager.updateNetwork(networkEntity);
 142     Assert.assertNotNull(validationData);
 143     Assert.assertEquals(validationData.getErrors().size(), 2);
 144
 145     verify(networkDaoMock, never()).update(networkEntity);
 146   }
 147
 148   @Test
 149   public void testGetNonExistingNetworkId_negative() {
 150     testGet_negative(VSP_ID, VERSION, NETWORK1_ID,
 151         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 152   }
 153
 154   @Test
 155   public void testGet() {
 156     NetworkEntity network = createNetwork(VSP_ID, VERSION, NETWORK1_ID);
 157     doReturn(network)
 158         .when(networkDaoMock).get(anyObject());
 159     doReturn("schema string").when(networkManager).getCompositionSchema(anyObject());
 160     doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
 161
 162     CompositionEntityResponse<Network> response =
 163         networkManager.getNetwork(VSP_ID, VERSION, NETWORK1_ID);
 164     Assert.assertEquals(response.getId(), network.getId());
 165     Assert.assertEquals(response.getData(), network.getNetworkCompositionData());
 166     Assert.assertNotNull(response.getSchema());
 167   }
 168
 169   @Test(dependsOnMethods = "testList")
 170   public void testDeleteOnUploadVsp_negative() {
 171     testDelete_negative(VSP_ID, VERSION, NETWORK1_ID,
 172         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 173   }
 174
 175   private void testCreate_negative(NetworkEntity network, String expectedErrorCode) {
 176     try {
 177       doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
 178       networkManager.createNetwork(network);
 179       Assert.fail();
 180     } catch (CoreException exception) {
 181       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 182     }
 183   }
 184
 185   private void testGet_negative(String vspId, Version version, String networkId,
 186                                 String expectedErrorCode) {
 187     try {
 188       networkManager.getNetwork(vspId, version, networkId);
 189       Assert.fail();
 190     } catch (CoreException exception) {
 191       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 192     }
 193   }
 194
 195   private void testUpdate_negative(String vspId, Version version, String networkId,
 196                                    String expectedErrorCode) {
 197     try {
 198       networkManager.updateNetwork(new NetworkEntity(vspId, version, networkId));
 199       Assert.fail();
 200     } catch (CoreException exception) {
 201       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 202     }
 203   }
 204
 205   private void testList_negative(String vspId, Version version, String expectedErrorCode) {
 206     try {
 207       networkManager.listNetworks(vspId, version);
 208       Assert.fail();
 209     } catch (CoreException exception) {
 210       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 211     }
 212   }
 213
 214   private void testDelete_negative(String vspId, Version version, String networkId,
 215                                    String expectedErrorCode) {
 216     try {
 217       doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
 218       networkManager.deleteNetwork(vspId, version, networkId);
 219       Assert.fail();
 220     } catch (CoreException exception) {
 221       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 222     }
 223   }
 224 }