gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  22
  23 import org.mockito.InjectMocks;
  24 import org.mockito.Mock;
  25 import org.mockito.MockitoAnnotations;
  26 import org.mockito.Spy;
  27 import org.openecomp.sdc.common.errors.CoreException;
  28 import org.openecomp.sdc.logging.api.Logger;
  29 import org.openecomp.sdc.logging.api.LoggerFactory;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  32 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  33 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  38 import org.openecomp.sdc.versioning.dao.types.Version;
  39 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  40 import org.testng.Assert;
  41 import org.testng.annotations.BeforeMethod;
  42 import org.testng.annotations.Test;
  43
  44 import java.util.Arrays;
  45 import java.util.Collection;
  46
  47 import static org.mockito.Matchers.anyObject;
  48 import static org.mockito.Mockito.doReturn;
  49 import static org.mockito.Mockito.never;
  50 import static org.mockito.Mockito.verify;
  51
  52 public class NetworkManagerImplTest {
  53
  54   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
  55
  56   private static final String USER1 = "networksTestUser1";
  57   private static final String USER2 = "networksTestUser2";
  58   private static final String VSP_ID = "vsp";
  59   private static final Version VERSION = new Version(0, 1);
  60   private static final String NETWORK1_ID = "network1";
  61   private static final String NETWORK2_ID = "network2";
  62
  63   @Mock
  64   private NetworkDao networkDaoMock;
  65   @Mock
  66   private CompositionEntityDataManager compositionEntityDataManagerMock;
  67   @InjectMocks
  68   @Spy
  69   private NetworkManagerImpl networkManager;
  70
  71   static NetworkEntity createNetwork(String vspId, Version version, String networkId) {
  72     NetworkEntity networkEntity = new NetworkEntity(vspId, version, networkId);
  73     Network networkData = new Network();
  74     networkData.setName(networkId + " name");
  75     networkData.setDhcp(true);
  76     networkEntity.setNetworkCompositionData(networkData);
  77     return networkEntity;
  78   }
  79
  80   @BeforeMethod
  81   public void setUp() throws Exception {
  82     MockitoAnnotations.initMocks(this);
  83   }
  84
  85   @Test
  86   public void testListWhenNone() {
  87     Collection<NetworkEntity> networks =
  88         networkManager.listNetworks(VSP_ID, null, USER1);
  89     Assert.assertEquals(networks.size(), 0);
  90   }
  91
  92   @Test
  93   public void testList() {
  94     doReturn(Arrays.asList(
  95         createNetwork(VSP_ID, VERSION, NETWORK1_ID),
  96         createNetwork(VSP_ID, VERSION, NETWORK2_ID)))
  97         .when(networkDaoMock).list(anyObject());
  98
  99     Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, VERSION, USER1);
 100     Assert.assertEquals(actual.size(), 2);
 101   }
 102
 103 /*    @Test(dependsOnMethods = "testListWhenNone")
 104     public void testCreate() {
 105         NETWORK1_ID = testCreate(VSP_ID);
 106     }
 107
 108     private String testCreate(String vspId) {
 109         NetworkEntity expected = new NetworkEntity(vspId, null, null);
 110         Network networkData = new Network();
 111         networkData.setName("network1 name");
 112         networkData.setDhcp(true);
 113         expected.setNetworkCompositionData(networkData);
 114
 115
 116         NetworkEntity created = networkManager.createNetwork(expected, USER1);
 117         Assert.assertNotNull(created);
 118         expected.setId(created.getId());
 119         expected.setVersion(VERSION01);
 120
 121         NetworkEntity actual = networkDaoMock.getNetwork(vspId, VERSION01, created.getId());
 122
 123         Assert.assertEquals(actual, expected);
 124         return created.getId();
 125     }
 126
 127     @Test(dependsOnMethods = {"testCreate"})
 128     public void testCreateWithExistingName_negative() {
 129         NetworkEntity network = new NetworkEntity(VSP_ID, null, null);
 130         Network networkData = new Network();
 131         networkData.setName("network1 name");
 132         networkData.setDhcp(true);
 133         network.setNetworkCompositionData(networkData);
 134         testCreate_negative(network, USER1, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 135     }*/
 136
 137   @Test
 138   public void testCreateOnUploadVsp_negative() {
 139     testCreate_negative(new NetworkEntity(VSP_ID, VERSION, null), USER1,
 140         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 141   }
 142
 143   /*    @Test(dependsOnMethods = {"testCreate"})
 144       public void testCreateWithExistingNameUnderOtherVsp() {
 145           testCreate(vsp2Id);
 146       }
 147   */
 148
 149   @Test
 150   public void testUpdateNonExistingNetworkId_negative() {
 151     testUpdate_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
 152         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 153   }
 154
 155   @Test
 156   public void testIllegalUpdateOnUploadVsp() {
 157     doReturn(createNetwork(VSP_ID, VERSION, NETWORK1_ID))
 158         .when(networkDaoMock).get(anyObject());
 159
 160     CompositionEntityValidationData toBeReturned =
 161         new CompositionEntityValidationData(CompositionEntityType.network, NETWORK1_ID);
 162     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 163     doReturn(toBeReturned)
 164         .when(compositionEntityDataManagerMock)
 165         .validateEntity(anyObject(), anyObject(), anyObject());
 166
 167     NetworkEntity networkEntity = new NetworkEntity(VSP_ID, VERSION, NETWORK1_ID);
 168     Network networkData = new Network();
 169     networkData.setName(NETWORK1_ID + " name updated");
 170     networkData.setDhcp(false);
 171     networkEntity.setNetworkCompositionData(networkData);
 172
 173     CompositionEntityValidationData validationData =
 174         networkManager.updateNetwork(networkEntity, USER1);
 175     Assert.assertNotNull(validationData);
 176     Assert.assertEquals(validationData.getErrors().size(), 2);
 177
 178     verify(networkDaoMock, never()).update(networkEntity);
 179   }
 180
 181   @Test
 182   public void testGetNonExistingNetworkId_negative() {
 183     testGet_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
 184         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 185   }
 186
 187   @Test
 188   public void testGet() {
 189     NetworkEntity network = createNetwork(VSP_ID, VERSION, NETWORK1_ID);
 190     doReturn(network)
 191         .when(networkDaoMock).get(anyObject());
 192     doReturn("schema string").when(networkManager).getCompositionSchema(anyObject());
 193
 194     CompositionEntityResponse<Network> response =
 195         networkManager.getNetwork(VSP_ID, VERSION, NETWORK1_ID, USER1);
 196     Assert.assertEquals(response.getId(), network.getId());
 197     Assert.assertEquals(response.getData(), network.getNetworkCompositionData());
 198     Assert.assertNotNull(response.getSchema());
 199   }
 200
 201     /*
 202            @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 203            public void testCreateWithERemovedName() {
 204                testCreate(VSP_ID);
 205            }
 206
 207     @Test(dependsOnMethods = "testList")
 208     public void testDeleteNonExistingNetworkId_negative() {
 209         testDelete_negative(VSP_ID, "non existing network id", USER1, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 210     }*/
 211
 212 /*
 213            @Test(dependsOnMethods = "testList")
 214            public void testDelete() {
 215                networkManager.deleteNetwork(VSP_ID, NETWORK1_ID, USER1);
 216                NetworkEntity actual = networkDaoMock.getNetwork(VSP_ID, VERSION01, NETWORK1_ID);
 217                Assert.assertNull(actual);
 218            }
 219
 220
 221
 222            @Test(dependsOnMethods = "testDelete")
 223            public void testDeleteList() {
 224                NetworkEntity network3 = new NetworkEntity(VSP_ID, null, null);
 225                network3.setName("network3 name");
 226                network3.setDescription("network3 desc");
 227                networkManager.createNetwork(network3, USER1);
 228
 229                networkManager.deleteNetworks(VSP_ID, USER1);
 230
 231                Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, null, USER1);
 232                Assert.assertEquals(actual.size(), 0);
 233            }*/
 234
 235   @Test(dependsOnMethods = "testList")
 236   public void testDeleteOnUploadVsp_negative() {
 237     testDelete_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
 238         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 239   }
 240
 241   private void testCreate_negative(NetworkEntity network, String user, String expectedErrorCode) {
 242     try {
 243       networkManager.createNetwork(network, user);
 244       Assert.fail();
 245     } catch (CoreException exception) {
 246       log.debug("",exception);
 247       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 248     }
 249   }
 250
 251   private void testGet_negative(String vspId, Version version, String networkId, String user,
 252                                 String expectedErrorCode) {
 253     try {
 254       networkManager.getNetwork(vspId, version, networkId, user);
 255       Assert.fail();
 256     } catch (CoreException exception) {
 257       log.debug("",exception);
 258       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 259     }
 260   }
 261
 262   private void testUpdate_negative(String vspId, Version version, String networkId, String user,
 263                                    String expectedErrorCode) {
 264     try {
 265       networkManager.updateNetwork(new NetworkEntity(vspId, version, networkId), user);
 266       Assert.fail();
 267     } catch (CoreException exception) {
 268       log.debug("",exception);
 269       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 270     }
 271   }
 272
 273   private void testList_negative(String vspId, Version version, String user,
 274                                  String expectedErrorCode) {
 275     try {
 276       networkManager.listNetworks(vspId, version, user);
 277       Assert.fail();
 278     } catch (CoreException exception) {
 279       log.debug("",exception);
 280       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 281     }
 282   }
 283
 284   private void testDelete_negative(String vspId, Version version, String networkId, String user,
 285                                    String expectedErrorCode) {
 286     try {
 287       networkManager.deleteNetwork(vspId, version, networkId, user);
 288       Assert.fail();
 289     } catch (CoreException exception) {
 290       log.debug("",exception);
 291       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 292     }
 293   }
 294 }