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