openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImplTest.java

   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.junit.After;
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.mockito.InjectMocks;
  25 import org.mockito.Mock;
  26 import org.mockito.MockitoAnnotations;
  27 import org.mockito.Spy;
  28 import org.openecomp.sdc.common.errors.CoreException;
  29 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  30 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  34 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  39 import org.openecomp.sdc.versioning.dao.types.Version;
  40 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  41
  42 import java.util.Arrays;
  43 import java.util.Collection;
  44
  45 import static org.mockito.ArgumentMatchers.any;
  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   @Before
  80   public void setUp() throws Exception {
  81     MockitoAnnotations.openMocks(this);
  82     SessionContextProviderFactory.getInstance().createInterface().create(USER_ID, tenant);
  83   }
  84
  85   @After
  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(any());
 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(any());
 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(any(), any(), any());
 132     doReturn(false).when(vendorSoftwareProductInfoDao).isManual(any(),any());
 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(any());
 159     doReturn("schema string").when(networkManager).getCompositionSchema(any());
 160     doReturn(false).when(vendorSoftwareProductInfoDao).isManual(any(),any());
 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
 170   public void testDeleteOnUploadVsp_negative() {
 171     testList();
 172     testDelete_negative(VSP_ID, VERSION, NETWORK1_ID,
 173         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 174   }
 175
 176   private void testCreate_negative(NetworkEntity network, String expectedErrorCode) {
 177     try {
 178       doReturn(false).when(vendorSoftwareProductInfoDao).isManual(any(),any());
 179       networkManager.createNetwork(network);
 180       Assert.fail();
 181     } catch (CoreException exception) {
 182       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 183     }
 184   }
 185
 186   private void testGet_negative(String vspId, Version version, String networkId,
 187                                 String expectedErrorCode) {
 188     try {
 189       networkManager.getNetwork(vspId, version, networkId);
 190       Assert.fail();
 191     } catch (CoreException exception) {
 192       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 193     }
 194   }
 195
 196   private void testUpdate_negative(String vspId, Version version, String networkId,
 197                                    String expectedErrorCode) {
 198     try {
 199       networkManager.updateNetwork(new NetworkEntity(vspId, version, networkId));
 200       Assert.fail();
 201     } catch (CoreException exception) {
 202       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 203     }
 204   }
 205
 206   private void testList_negative(String vspId, Version version, String expectedErrorCode) {
 207     try {
 208       networkManager.listNetworks(vspId, version);
 209       Assert.fail();
 210     } catch (CoreException exception) {
 211       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 212     }
 213   }
 214
 215   private void testDelete_negative(String vspId, Version version, String networkId,
 216                                    String expectedErrorCode) {
 217     try {
 218       doReturn(false).when(vendorSoftwareProductInfoDao).isManual(any(),any());
 219       networkManager.deleteNetwork(vspId, version, networkId);
 220       Assert.fail();
 221     } catch (CoreException exception) {
 222       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 223     }
 224   }
 225 }