gerrit.onap Code Review - sdc.git/blob

   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.mockito.InjectMocks;
  20 import org.mockito.Mock;
  21 import org.mockito.MockitoAnnotations;
  22 import org.mockito.Spy;
  23 import org.openecomp.sdc.common.errors.CoreException;
  24 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
  25 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  26 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  29 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  30 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  32 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  33 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  37 import org.openecomp.sdc.versioning.dao.types.Version;
  38 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  39 import org.testng.Assert;
  40 import org.testng.annotations.AfterMethod;
  41 import org.testng.annotations.BeforeMethod;
  42 import org.testng.annotations.Test;
  43
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Collection;
  47
  48 import static org.mockito.Matchers.anyObject;
  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   @BeforeMethod
  80   public void setUp() throws Exception {
  81     MockitoAnnotations.initMocks(this);
  82   }
  83
  84   @AfterMethod
  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(anyObject());
 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(anyObject(), anyObject());
 124     Collection<NicEntity> nicEntities = new ArrayList<>();
 125     doReturn(nicEntities).when(nicDao).list(anyObject());
 126     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 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(anyObject(), anyObject());
 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(anyObject());
 147     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 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(anyObject(), anyObject());
 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(anyObject());
 172     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 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(anyObject(), anyObject());
 192     Collection<NicEntity> nicEntities = new ArrayList<>();
 193     doReturn(nicEntities).when(nicDao).list(anyObject());
 194     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 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(anyObject(), anyObject());
 215     Collection<NicEntity> nicEntities = new ArrayList<>();
 216     doReturn(nicEntities).when(nicDao).list(anyObject());
 217     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 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(anyObject(), anyObject());
 233     doReturn(nicEntity).when(nicDao).get(anyObject());
 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(anyObject());
 244     doReturn("{}").when(nicManager).getNicCompositionSchema(anyObject());
 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(anyObject());
 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(anyObject());
 302
 303     doReturn(new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID))
 304         .when(compositionEntityDataManagerMock)
 305         .validateEntity(anyObject(), anyObject(), anyObject());
 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(anyObject());
 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(anyObject(), anyObject(), anyObject());
 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(anyObject());
 350
 351     CompositionEntityValidationData toBeReturned =
 352         new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
 353     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 354     doReturn(toBeReturned)
 355         .when(compositionEntityDataManagerMock)
 356         .validateEntity(anyObject(), anyObject(), anyObject());
 357     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 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     try {
 367       nicManager.updateNic(nicEntity);
 368       Assert.fail();
 369     } catch (CoreException ex) {
 370       Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
 371           ex.code().id());
 372     }
 373   }
 374
 375
 376   @Test
 377   public void testGetNonExistingNicId_negative() {
 378     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id",
 379         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 380   }
 381
 382
 383   @Test
 384   public void testGet() {
 385     NicEntity expected = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 386     doReturn(expected).when(nicDao).get(anyObject());
 387     String compositionSchema = "schema string";
 388     doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(anyObject());
 389
 390     CompositionEntityResponse<Nic> response =
 391         nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 392     Assert.assertEquals(response.getId(), expected.getId());
 393     Assert.assertEquals(response.getData(), expected.getNicCompositionData());
 394     Assert.assertEquals(response.getSchema(), compositionSchema);
 395   }
 396
 397 /*
 398     @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 399     public void testCreateWithRemovedName() {
 400         testCreate(VSP_ID, COMPONENT_ID);
 401     }
 402
 403     @Test
 404     public void testDeleteNonExistingNicId_negative() {
 405         testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 406     }
 407
 408     @Test(dependsOnMethods = "testList")
 409     public void testDeleteNonExistingComponentId_negative() {
 410         testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 411     }*/
 412
 413 /*
 414     @Test(dependsOnMethods = "testList")
 415     public void testDelete() {
 416         nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID);
 417         NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 418         Assert.assertNull(actual);
 419     }*/
 420
 421   @Test
 422   public void testDeleteOnUploadVsp_negative() {
 423     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
 424         VendorSoftwareProductErrorCodes.DELETE_NIC_NOT_ALLOWED);
 425   }
 426
 427   @Test(expectedExceptions = CoreException.class,
 428       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 429   public void testGetNonExistingNicQuestionnaire() throws Exception {
 430     nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 431   }
 432
 433   @Test
 434   public void testGetQuestionnaire() throws Exception {
 435     NicEntity nic = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 436     nic.setQuestionnaireData("{}");
 437     doReturn(nic).when(nicDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 438
 439     String schema = "schema string";
 440     doReturn(schema).when(nicManager).getNicQuestionnaireSchema(anyObject());
 441
 442     QuestionnaireResponse questionnaire =
 443         nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 444     Assert.assertNotNull(questionnaire);
 445     Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
 446     Assert.assertEquals(questionnaire.getSchema(), schema);
 447     Assert.assertNull(questionnaire.getErrorMessage());
 448   }
 449
 450   @Test(expectedExceptions = CoreException.class,
 451       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 452   public void testUpdateNonExistingNicQuestionnaire() throws Exception {
 453     doReturn(null).when(nicDao).get(anyObject());
 454     nicManager
 455         .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data");
 456   }
 457
 458   @Test
 459   public void testUpdateQuestionnaire() throws Exception {
 460
 461   }
 462
 463   private void testCreate_negative(NicEntity nic, String expectedErrorCode) {
 464     try {
 465       nicManager.createNic(nic);
 466       Assert.fail();
 467     } catch (CoreException exception) {
 468       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 469     }
 470   }
 471
 472   private void testGet_negative(String vspId, Version version, String componentId, String nicId,
 473                                 String expectedErrorCode) {
 474     try {
 475       nicManager.getNic(vspId, version, componentId, nicId);
 476       Assert.fail();
 477     } catch (CoreException exception) {
 478       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 479     }
 480   }
 481
 482   private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
 483                                    String expectedErrorCode) {
 484     try {
 485       nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId));
 486       Assert.fail();
 487     } catch (CoreException exception) {
 488       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 489     }
 490   }
 491
 492   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 493                                    String expectedErrorCode) {
 494     try {
 495       nicManager.deleteNic(vspId, version, componentId, nicId);
 496       Assert.fail();
 497     } catch (CoreException exception) {
 498       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 499     }
 500   }
 501
 502   static NicEntity createNic(String vspId, Version version, String compId, String nicId,
 503                              String networkId) {
 504     NicEntity nicEntity = new NicEntity(vspId, version, compId, nicId);
 505     Nic nicData = new Nic();
 506     nicData.setName(nicId + "_name");
 507     nicData.setDescription(nicId + " desc");
 508     nicData.setNetworkId(networkId);
 509     nicEntity.setNicCompositionData(nicData);
 510     return nicEntity;
 511   }
 512
 513
 514 }