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

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