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.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 testCreateWithDupNicName() {
 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("Invalid request, NIC with name "+ nic.getName() +
 133           " already exist for component with ID "+ nicEntity.getComponentId() +".",
 134           exception.code().message());
 135       Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_NIC_NAME_NOT_ALLOWED,
 136           exception.code().id());
 137     }
 138   }
 139
 140   @Test
 141   public void testCreateWithExternalNetworkType() {
 142     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 143     Nic nic = nicEntity.getNicCompositionData();
 144     nic.setNetworkType(NetworkType.External);
 145     nicEntity.setNicCompositionData(nic);
 146     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 147     Collection<NicEntity> nicEntities = new ArrayList<>();
 148     doReturn(nicEntities).when(nicDao).list(anyObject());
 149     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 150
 151     try {
 152       NicEntity created = nicManager.createNic(nicEntity,USER);
 153     }  catch (CoreException exception) {
 154       Assert.assertEquals("Invalid request,NetworkId not allowed for External Networks",
 155           exception.code().message());
 156       Assert.assertEquals(VendorSoftwareProductErrorCodes.NETWORKID_NOT_ALLOWED_FOR_EXTERNAL_NETWORK,
 157           exception.code().id());
 158     }
 159   }
 160
 161   @Test
 162   public void testCreateWithNetworkDesc() {
 163     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 164     Nic nic = nicEntity.getNicCompositionData();
 165     nic.setNetworkType(NetworkType.Internal);
 166     nic.setNetworkDescription(NIC1_ID);
 167     nicEntity.setNicCompositionData(nic);
 168     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 169     Collection<NicEntity> nicEntities = new ArrayList<>();
 170     doReturn(nicEntities).when(nicDao).list(anyObject());
 171     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 172
 173     try {
 174       NicEntity created = nicManager.createNic(nicEntity,USER);
 175     }  catch (CoreException exception) {
 176       Assert.assertEquals("Invalid request, Network Description not allowed for Internal Networks",
 177           exception.code().message());
 178       Assert.assertEquals(VendorSoftwareProductErrorCodes
 179           .NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK,exception.code().id());
 180     }
 181   }
 182
 183   @Test
 184   public void testDeleteNic() {
 185     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 186     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 187     doReturn(nicEntity).when(nicDao).get(anyObject());
 188
 189     nicManager.deleteNic(VSP_ID,new Version(0,1),COMPONENT_ID,NIC1_ID,USER);
 190
 191   }
 192
 193   @Test
 194   public void testUpdateNicQuestionnaire() {
 195     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 196
 197     doReturn(nicEntity).when(nicDao).get(anyObject());
 198
 199     nicManager.updateNicQuestionnaire(VSP_ID,new Version(0,1),COMPONENT_ID,NIC1_ID,"Ques",USER);
 200
 201   }
 202
 203 //    @Test(dependsOnMethods = "testListWhenNone")
 204 //    public void testCreate() {
 205 //        NIC1_ID = testCreate(VSP_ID, COMPONENT_ID, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 206 //    }
 207
 208 /*    @Test(dependsOnMethods = {"testCreate"})
 209     public void testCreateWithExistingName_negative() {
 210         NicEntity nic = new NicEntity(VSP_ID, null, COMPONENT_ID, null);
 211         Nic nicData = new Nic();
 212         nicData.setName("nic1 name");
 213         nic.setNicCompositionData(nicData);
 214         testCreate_negative(nic, USER, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 215     }*/
 216
 217 //    @Test(dependsOnMethods = {"testCreate"})
 218 //    public void testCreateWithExistingNameUnderOtherComponent() {
 219 //        ComponentEntity component12 = new ComponentEntity(VSP_ID, null, null);
 220 //        ComponentData compData12 = new ComponentData();
 221 //        compData12.setName("comp12 name");
 222 //        compData12.setDescription("comp12 desc");
 223 //        component12.setComponentCompositionData(compData12);
 224 //
 225 //        String component12Id = nicManager.createComponent(component12, USER).getId();
 226 //        testCreate(VSP_ID, component12Id, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 227 //    }
 228
 229 //    @Test(dependsOnMethods = {"testCreate"})
 230 //    public void testCreateWithExistingNameUnderOtherVsp() {
 231 //        testCreate(vsp2Id, component21Id, network2.getId(), network2.getNetworkCompositionData().getName());
 232 //    }
 233
 234   @Test
 235   public void testCreateOnUploadVsp_negative() {
 236
 237     testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
 238         VendorSoftwareProductErrorCodes.ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 239   }
 240
 241   @Test
 242   public void testUpdateNonExistingNicId_negative() {
 243     doReturn(null).when(nicDao).get(anyObject());
 244
 245     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
 246         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 247   }
 248
 249   @Test
 250   public void testUpdateOnUploadVsp() {
 251     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 252         .when(nicDao).get(anyObject());
 253
 254     doReturn(new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID))
 255         .when(compositionEntityDataManagerMock)
 256         .validateEntity(anyObject(), anyObject(), anyObject());
 257
 258     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 259     Nic nicData = new Nic();
 260     nicData.setName(NIC1_ID + " name");
 261     nicData.setDescription(NIC1_ID + " desc updated");
 262     nicData.setNetworkId(NETWORK1_ID);
 263     nicEntity.setNicCompositionData(nicData);
 264
 265     CompositionEntityValidationData validationData =
 266         nicManager.updateNic(nicEntity, USER);
 267     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 268     verify(nicDao).update(nicEntity);
 269   }
 270
 271   @Test
 272   public void testIllegalUpdateOnUploadVsp() {
 273     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 274         .when(nicDao).get(anyObject());
 275
 276     CompositionEntityValidationData toBeReturned =
 277         new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
 278     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 279     doReturn(toBeReturned)
 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 updated");
 286     nicData.setDescription(NIC1_ID + " desc updated");
 287     nicData.setNetworkId(NETWORK1_ID);
 288     nicEntity.setNicCompositionData(nicData);
 289
 290     CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity, USER);
 291     Assert.assertNotNull(validationData);
 292     Assert.assertEquals(validationData.getErrors().size(), 2);
 293
 294     verify(nicDao, never()).update(nicEntity);
 295   }
 296
 297
 298   @Test
 299   public void testGetNonExistingNicId_negative() {
 300     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id", USER,
 301         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 302   }
 303
 304
 305   @Test
 306   public void testGet() {
 307     NicEntity expected = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 308     doReturn(expected).when(nicDao).get(anyObject());
 309     String compositionSchema = "schema string";
 310     doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(anyObject());
 311
 312     CompositionEntityResponse<Nic> response =
 313         nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 314     Assert.assertEquals(response.getId(), expected.getId());
 315     Assert.assertEquals(response.getData(), expected.getNicCompositionData());
 316     Assert.assertEquals(response.getSchema(), compositionSchema);
 317   }
 318
 319 /*
 320     @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 321     public void testCreateWithRemovedName() {
 322         testCreate(VSP_ID, COMPONENT_ID);
 323     }
 324
 325     @Test
 326     public void testDeleteNonExistingNicId_negative() {
 327         testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 328     }
 329
 330     @Test(dependsOnMethods = "testList")
 331     public void testDeleteNonExistingComponentId_negative() {
 332         testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 333     }*/
 334
 335 /*
 336     @Test(dependsOnMethods = "testList")
 337     public void testDelete() {
 338         nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID, USER);
 339         NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 340         Assert.assertNull(actual);
 341     }*/
 342
 343   @Test
 344   public void testDeleteOnUploadVsp_negative() {
 345     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
 346         VendorSoftwareProductErrorCodes.DELETE_NIC_NOT_ALLOWED);
 347   }
 348
 349   @Test(expectedExceptions = CoreException.class,
 350       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 351   public void testGetNonExistingNicQuestionnaire() throws Exception {
 352     nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 353   }
 354
 355   @Test
 356   public void testGetQuestionnaire() throws Exception {
 357     NicEntity nic = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 358     nic.setQuestionnaireData("{}");
 359     doReturn(nic).when(nicDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 360
 361     String schema = "schema string";
 362     doReturn(schema).when(nicManager).getNicQuestionnaireSchema(anyObject());
 363
 364     QuestionnaireResponse questionnaire =
 365         nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 366     Assert.assertNotNull(questionnaire);
 367     Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
 368     Assert.assertEquals(questionnaire.getSchema(), schema);
 369     Assert.assertNull(questionnaire.getErrorMessage());
 370   }
 371
 372   @Test(expectedExceptions = CoreException.class,
 373       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 374   public void testUpdateNonExistingNicQuestionnaire() throws Exception {
 375     doReturn(null).when(nicDao).get(anyObject());
 376     nicManager
 377         .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data", USER);
 378   }
 379
 380   @Test
 381   public void testUpdateQuestionnaire() throws Exception {
 382
 383   }
 384
 385   private void testCreate_negative(NicEntity nic, String user, String expectedErrorCode) {
 386     try {
 387       nicManager.createNic(nic, user);
 388       Assert.fail();
 389     } catch (CoreException exception) {
 390       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 391     }
 392   }
 393
 394   private void testGet_negative(String vspId, Version version, String componentId, String nicId,
 395                                 String user, String expectedErrorCode) {
 396     try {
 397       nicManager.getNic(vspId, version, componentId, nicId, user);
 398       Assert.fail();
 399     } catch (CoreException exception) {
 400       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 401     }
 402   }
 403
 404   private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
 405                                    String user, String expectedErrorCode) {
 406     try {
 407       nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId), user);
 408       Assert.fail();
 409     } catch (CoreException exception) {
 410       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 411     }
 412   }
 413
 414   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 415                                    String user,
 416                                    String expectedErrorCode) {
 417     try {
 418       nicManager.deleteNic(vspId, version, componentId, nicId, user);
 419       Assert.fail();
 420     } catch (CoreException exception) {
 421       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 422     }
 423   }
 424
 425   static NicEntity createNic(String vspId, Version version, String compId, String nicId,
 426                              String networkId) {
 427     NicEntity nicEntity = new NicEntity(vspId, version, compId, nicId);
 428     Nic nicData = new Nic();
 429     nicData.setName(nicId + " name");
 430     nicData.setDescription(nicId + " desc");
 431     nicData.setNetworkId(networkId);
 432     nicEntity.setNicCompositionData(nicData);
 433     return nicEntity;
 434   }
 435
 436
 437 }