gerrit.onap Code Review - sdc.git/blob

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