openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.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 import org.junit.After;
  20 import org.junit.Assert;
  21 import org.junit.Before;
  22 import org.junit.Test;
  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.vendorsoftwareproduct.CompositionEntityDataManager;
  29 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  34 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  41 import org.openecomp.sdc.versioning.dao.types.Version;
  42 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  43
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Collection;
  47
  48 import static org.mockito.ArgumentMatchers.any;
  49 import static org.mockito.Mockito.doReturn;
  50 import static org.mockito.Mockito.never;
  51 import static org.mockito.Mockito.verify;
  52
  53 public class NicManagerImplTest {
  54
  55   private static final String NIC_NOT_EXIST_MSG =
  56       "Vendor Software Product NIC with Id nic1 does not exist for Vendor Software Product with " +
  57           "id VSP_ID and version version_id";
  58
  59   private static final String VSP_ID = "VSP_ID";
  60   private static final Version VERSION = new Version("version_id");
  61   private static final String COMPONENT_ID = "COMPONENT_ID";
  62   private static final String NIC1_ID = "nic1";
  63   private static final String NIC2_ID = "nic2";
  64   private static final String NETWORK1_ID = "network1";
  65   private static final String NETWORK2_ID = "network2";
  66
  67   @Mock
  68   private NicDao nicDao;
  69   @Mock
  70   private CompositionEntityDataManager compositionEntityDataManagerMock;
  71   @Mock
  72   private NetworkManager networkManagerMock;
  73   @Mock
  74   private VendorSoftwareProductInfoDao vspInfoDao;
  75   @InjectMocks
  76   @Spy
  77   private NicManagerImpl nicManager;
  78
  79   @Before
  80   public void setUp() throws Exception {
  81     MockitoAnnotations.initMocks(this);
  82   }
  83
  84   @After
  85   public void tearDown() {
  86     nicManager = null;
  87   }
  88
  89   @Test
  90   public void testListWhenNone() {
  91     Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
  92     Assert.assertEquals(nics.size(), 0);
  93   }
  94
  95   @Test
  96   public void testList() {
  97     doReturn(Arrays.asList(
  98         createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID),
  99         createNic(VSP_ID, VERSION, COMPONENT_ID, NIC2_ID, NETWORK2_ID)))
 100         .when(nicDao).list(any());
 101
 102     NetworkEntity network1 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK1_ID);
 103     NetworkEntity network2 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK2_ID);
 104     doReturn(Arrays.asList(network1, network2))
 105         .when(networkManagerMock).listNetworks(VSP_ID, VERSION);
 106
 107     Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
 108     Assert.assertEquals(nics.size(), 2);
 109     for (NicEntity nic : nics) {
 110       Assert.assertEquals(nic.getNicCompositionData().getNetworkName(),
 111           NIC1_ID.equals(nic.getId())
 112               ? network1.getNetworkCompositionData().getName()
 113               : network2.getNetworkCompositionData().getName());
 114     }
 115   }
 116
 117   @Test
 118   public void testCreate() {
 119     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 120     Nic nic = nicEntity.getNicCompositionData();
 121     nic.setNetworkType(NetworkType.Internal);
 122     nicEntity.setNicCompositionData(nic);
 123     doReturn(true).when(vspInfoDao).isManual(any(), any());
 124     Collection<NicEntity> nicEntities = new ArrayList<>();
 125     doReturn(nicEntities).when(nicDao).list(any());
 126     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
 127
 128     NicEntity created = nicManager.createNic(nicEntity);
 129     Assert.assertNotNull(created);
 130   }
 131
 132   @Test
 133   public void testCreateWithIncorrectNicNameFormat() {
 134     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 135     Nic nic = nicEntity.getNicCompositionData();
 136     nic.setNetworkType(NetworkType.Internal);
 137     nicEntity.setNicCompositionData(nic);
 138     doReturn(true).when(vspInfoDao).isManual(any(), any());
 139     Collection<NicEntity> nicEntities = new ArrayList<>();
 140
 141     NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 142     Nic newNameNic = nicEntityDiffName.getNicCompositionData();
 143     newNameNic.setName(NIC1_ID + "_Name/*");
 144     nicEntityDiffName.setNicCompositionData(newNameNic);
 145     nicEntities.add(nicEntityDiffName);
 146     doReturn(nicEntities).when(nicDao).list(any());
 147     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
 148
 149     try {
 150       NicEntity created = nicManager.createNic(nicEntity);
 151     } catch (CoreException exception) {
 152       Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
 153           exception.code().id());
 154     }
 155   }
 156
 157   @Test
 158   public void testCreateWithDupNicName() {
 159     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 160     Nic nic = nicEntity.getNicCompositionData();
 161     nic.setNetworkType(NetworkType.Internal);
 162     nicEntity.setNicCompositionData(nic);
 163     doReturn(true).when(vspInfoDao).isManual(any(), any());
 164     Collection<NicEntity> nicEntities = new ArrayList<>();
 165
 166     NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 167     Nic newNameNic = nicEntityDiffName.getNicCompositionData();
 168     newNameNic.setName(NIC1_ID + "_Name");
 169     nicEntityDiffName.setNicCompositionData(newNameNic);
 170     nicEntities.add(nicEntityDiffName);
 171     doReturn(nicEntities).when(nicDao).list(any());
 172     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
 173
 174     try {
 175       NicEntity created = nicManager.createNic(nicEntity);
 176     } catch (CoreException exception) {
 177       Assert.assertEquals("Invalid request, NIC with name " + nic.getName() +
 178               " already exist for component with ID " + nicEntity.getComponentId() + ".",
 179           exception.code().message());
 180       Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_NIC_NAME_NOT_ALLOWED,
 181           exception.code().id());
 182     }
 183   }
 184
 185   @Test
 186   public void testCreateWithExternalNetworkType() {
 187     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 188     Nic nic = nicEntity.getNicCompositionData();
 189     nic.setNetworkType(NetworkType.External);
 190     nicEntity.setNicCompositionData(nic);
 191     doReturn(true).when(vspInfoDao).isManual(any(), any());
 192     Collection<NicEntity> nicEntities = new ArrayList<>();
 193     doReturn(nicEntities).when(nicDao).list(any());
 194     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
 195
 196     try {
 197       NicEntity created = nicManager.createNic(nicEntity);
 198     } catch (CoreException exception) {
 199       Assert.assertEquals("Invalid request,NetworkId not allowed for External Networks",
 200           exception.code().message());
 201       Assert
 202           .assertEquals(VendorSoftwareProductErrorCodes.NETWORKID_NOT_ALLOWED_FOR_EXTERNAL_NETWORK,
 203               exception.code().id());
 204     }
 205   }
 206
 207   @Test
 208   public void testCreateWithNetworkDesc() {
 209     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 210     Nic nic = nicEntity.getNicCompositionData();
 211     nic.setNetworkType(NetworkType.Internal);
 212     nic.setNetworkDescription(NIC1_ID);
 213     nicEntity.setNicCompositionData(nic);
 214     doReturn(true).when(vspInfoDao).isManual(any(), any());
 215     Collection<NicEntity> nicEntities = new ArrayList<>();
 216     doReturn(nicEntities).when(nicDao).list(any());
 217     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
 218
 219     try {
 220       NicEntity created = nicManager.createNic(nicEntity);
 221     } catch (CoreException exception) {
 222       Assert.assertEquals("Invalid request, Network Description not allowed for Internal Networks",
 223           exception.code().message());
 224       Assert.assertEquals(VendorSoftwareProductErrorCodes
 225           .NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK, exception.code().id());
 226     }
 227   }
 228
 229   @Test
 230   public void testDeleteNic() {
 231     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 232     doReturn(true).when(vspInfoDao).isManual(any(), any());
 233     doReturn(nicEntity).when(nicDao).get(any());
 234
 235     nicManager.deleteNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 236
 237   }
 238
 239   @Test
 240   public void testUpdateNicQuestionnaire() {
 241     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 242
 243     doReturn(nicEntity).when(nicDao).get(any());
 244     doReturn("{}").when(nicManager).getNicCompositionSchema(any());
 245
 246     nicManager
 247         .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
 248
 249     verify(nicDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
 250   }
 251
 252 //    @Test(dependsOnMethods = "testListWhenNone")
 253 //    public void testCreate() {
 254 //        NIC1_ID = testCreate(VSP_ID, COMPONENT_ID, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 255 //    }
 256
 257 /*    @Test(dependsOnMethods = {"testCreate"})
 258     public void testCreateWithExistingName_negative() {
 259         NicEntity nic = new NicEntity(VSP_ID, null, COMPONENT_ID, null);
 260         Nic nicData = new Nic();
 261         nicData.setName("nic1 name");
 262         nic.setNicCompositionData(nicData);
 263         testCreate_negative(nic, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 264     }*/
 265
 266 //    @Test(dependsOnMethods = {"testCreate"})
 267 //    public void testCreateWithExistingNameUnderOtherComponent() {
 268 //        ComponentEntity component12 = new ComponentEntity(VSP_ID, null, null);
 269 //        ComponentData compData12 = new ComponentData();
 270 //        compData12.setName("comp12 name");
 271 //        compData12.setDescription("comp12 desc");
 272 //        component12.setComponentCompositionData(compData12);
 273 //
 274 //        String component12Id = nicManager.createComponent(component12).getId();
 275 //        testCreate(VSP_ID, component12Id, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 276 //    }
 277
 278 //    @Test(dependsOnMethods = {"testCreate"})
 279 //    public void testCreateWithExistingNameUnderOtherVsp() {
 280 //        testCreate(vsp2Id, component21Id, network2.getId(), network2.getNetworkCompositionData().getName());
 281 //    }
 282
 283   @Test
 284   public void testCreateOnUploadVsp_negative() {
 285
 286     testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null),
 287         VendorSoftwareProductErrorCodes.ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 288   }
 289
 290   @Test
 291   public void testUpdateNonExistingNicId_negative() {
 292     doReturn(null).when(nicDao).get(any());
 293
 294     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
 295         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 296   }
 297
 298   @Test
 299   public void testUpdateOnUploadVsp() {
 300     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 301         .when(nicDao).get(any());
 302
 303     doReturn(new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID))
 304         .when(compositionEntityDataManagerMock)
 305         .validateEntity(any(), any(), any());
 306
 307     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 308     Nic nicData = new Nic();
 309     nicData.setName(NIC1_ID + " name");
 310     nicData.setDescription(NIC1_ID + " desc updated");
 311     nicData.setNetworkId(NETWORK1_ID);
 312     nicEntity.setNicCompositionData(nicData);
 313
 314     CompositionEntityValidationData validationData =
 315         nicManager.updateNic(nicEntity);
 316     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 317     verify(nicDao).update(nicEntity);
 318   }
 319
 320   @Test
 321   public void testIllegalUpdateOnUploadVsp() {
 322     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 323         .when(nicDao).get(any());
 324
 325     CompositionEntityValidationData toBeReturned =
 326         new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
 327     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 328     doReturn(toBeReturned)
 329         .when(compositionEntityDataManagerMock)
 330         .validateEntity(any(), any(), any());
 331
 332     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 333     Nic nicData = new Nic();
 334     nicData.setName(NIC1_ID + "_name_updated");
 335     nicData.setDescription(NIC1_ID + " desc updated");
 336     nicData.setNetworkId(NETWORK1_ID);
 337     nicEntity.setNicCompositionData(nicData);
 338
 339     CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity);
 340     Assert.assertNotNull(validationData);
 341     Assert.assertEquals(validationData.getErrors().size(), 2);
 342
 343     verify(nicDao, never()).update(nicEntity);
 344   }
 345
 346   @Test
 347   public void testUpdateIncorrectNameFormat() {
 348     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 349         .when(nicDao).get(any());
 350
 351     CompositionEntityValidationData toBeReturned =
 352         new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
 353     toBeReturned.setErrors(Arrays.asList("Field does not conform to predefined criteria:name : must match [a-zA-Z0-9_]*$"));
 354     doReturn(toBeReturned)
 355         .when(compositionEntityDataManagerMock)
 356         .validateEntity(any(), any(), any());
 357     doReturn(true).when(vspInfoDao).isManual(any(), any());
 358
 359     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 360     Nic nicData = new Nic();
 361     nicData.setName(NIC1_ID + "_name_updated/*");
 362     nicData.setDescription(NIC1_ID + " desc updated");
 363     nicData.setNetworkId(NETWORK1_ID);
 364     nicEntity.setNicCompositionData(nicData);
 365
 366     CompositionEntityValidationData output = nicManager.updateNic(nicEntity);
 367     Assert.assertEquals(output.getErrors(),toBeReturned.getErrors());
 368
 369   }
 370
 371
 372   @Test
 373   public void testGetNonExistingNicId_negative() {
 374     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id",
 375         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 376   }
 377
 378
 379   @Test
 380   public void testGet() {
 381     NicEntity expected = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 382     doReturn(expected).when(nicDao).get(any());
 383     String compositionSchema = "schema string";
 384     doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(any());
 385
 386     CompositionEntityResponse<Nic> response =
 387         nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 388     Assert.assertEquals(response.getId(), expected.getId());
 389     Assert.assertEquals(response.getData(), expected.getNicCompositionData());
 390     Assert.assertEquals(response.getSchema(), compositionSchema);
 391   }
 392
 393 /*
 394     @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 395     public void testCreateWithRemovedName() {
 396         testCreate(VSP_ID, COMPONENT_ID);
 397     }
 398
 399     @Test
 400     public void testDeleteNonExistingNicId_negative() {
 401         testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 402     }
 403
 404     @Test(dependsOnMethods = "testList")
 405     public void testDeleteNonExistingComponentId_negative() {
 406         testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 407     }*/
 408
 409 /*
 410     @Test(dependsOnMethods = "testList")
 411     public void testDelete() {
 412         nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID);
 413         NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 414         Assert.assertNull(actual);
 415     }*/
 416
 417   @Test
 418   public void testDeleteOnUploadVsp_negative() {
 419     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
 420         VendorSoftwareProductErrorCodes.DELETE_NIC_NOT_ALLOWED);
 421   }
 422
 423   @Test(expected = CoreException.class)
 424   public void testGetNonExistingNicQuestionnaire() throws Exception {
 425     nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 426   }
 427
 428   @Test
 429   public void testGetQuestionnaire() throws Exception {
 430     NicEntity nic = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 431     nic.setQuestionnaireData("{}");
 432     doReturn(nic).when(nicDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 433
 434     String schema = "schema string";
 435     doReturn(schema).when(nicManager).getNicQuestionnaireSchema(any());
 436
 437     QuestionnaireResponse questionnaire =
 438         nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 439     Assert.assertNotNull(questionnaire);
 440     Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
 441     Assert.assertEquals(questionnaire.getSchema(), schema);
 442     Assert.assertNull(questionnaire.getErrorMessage());
 443   }
 444
 445   @Test(expected = CoreException.class)
 446   public void testUpdateNonExistingNicQuestionnaire() throws Exception {
 447     doReturn(null).when(nicDao).get(any());
 448     nicManager
 449         .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data");
 450   }
 451
 452   @Test
 453   public void testUpdateQuestionnaire() throws Exception {
 454
 455   }
 456
 457   private void testCreate_negative(NicEntity nic, String expectedErrorCode) {
 458     try {
 459       nicManager.createNic(nic);
 460       Assert.fail();
 461     } catch (CoreException exception) {
 462       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 463     }
 464   }
 465
 466   private void testGet_negative(String vspId, Version version, String componentId, String nicId,
 467                                 String expectedErrorCode) {
 468     try {
 469       nicManager.getNic(vspId, version, componentId, nicId);
 470       Assert.fail();
 471     } catch (CoreException exception) {
 472       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 473     }
 474   }
 475
 476   private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
 477                                    String expectedErrorCode) {
 478     try {
 479       nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId));
 480       Assert.fail();
 481     } catch (CoreException exception) {
 482       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 483     }
 484   }
 485
 486   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 487                                    String expectedErrorCode) {
 488     try {
 489       nicManager.deleteNic(vspId, version, componentId, nicId);
 490       Assert.fail();
 491     } catch (CoreException exception) {
 492       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 493     }
 494   }
 495
 496   static NicEntity createNic(String vspId, Version version, String compId, String nicId,
 497                              String networkId) {
 498     NicEntity nicEntity = new NicEntity(vspId, version, compId, nicId);
 499     Nic nicData = new Nic();
 500     nicData.setName(nicId + "_name");
 501     nicData.setDescription(nicId + " desc");
 502     nicData.setNetworkId(networkId);
 503     nicEntity.setNicCompositionData(nicData);
 504     return nicEntity;
 505   }
 506
 507
 508 }