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