openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImplTest.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import org.mockito.InjectMocks;
   4 import org.mockito.Mock;
   5 import org.mockito.Mockito;
   6 import org.mockito.MockitoAnnotations;
   7 import org.mockito.Spy;
   8 import org.openecomp.sdc.common.errors.CoreException;
   9 import org.openecomp.sdc.vendorsoftwareproduct.NicManager;
  10 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  11 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  12 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  13 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  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.ComponentData;
  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.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
  37 public class ComponentManagerImplTest {
  38   private static final String COMP_NOT_EXIST_MSG =
  39       "Vendor Software Product Component with Id 1 does not exist for Vendor Software Product with id VSP_ID and version 0.1";
  40   private static final String USER = "componentsTestUser";
  41   private static final String VSP_ID = "VSP_ID";
  42   private static final Version VERSION = new Version(0, 1);
  43   private static final String COMP1_ID = "1";
  44   private static final String COMP2_ID = "2";
  45
  46   @Mock
  47   private ComponentDao componentDaoMock;
  48   @Mock
  49   private CompositionEntityDataManager compositionEntityDataManagerMock;
  50   @Mock
  51   private NicManager nicManagerMock;
  52   @Mock
  53   private VendorSoftwareProductInfoDao vspInfoDao;
  54   @InjectMocks
  55   @Spy
  56   private ComponentManagerImpl componentManager;
  57
  58   @BeforeMethod
  59   public void setUp() throws Exception {
  60     MockitoAnnotations.initMocks(this);
  61   }
  62
  63   @Test
  64   public void testListWhenNone() {
  65     Collection<ComponentEntity> components =
  66         componentManager.listComponents(VSP_ID, VERSION, USER);
  67     Assert.assertEquals(components.size(), 0);
  68   }
  69
  70   @Test(expectedExceptions = CoreException.class,
  71       expectedExceptionsMessageRegExp = "Vendor Software Product Component with Id dummyComponentId " +
  72           "does not exist for Vendor Software Product with id dummyVsp and version 1.0")
  73   public void validateExceptionWhenTryingToRetriveNotExistingComponentEntity() {
  74     Version version = Mockito.mock(Version.class);
  75     doReturn("1.0").when(version).toString();
  76     doReturn(null).when(componentDaoMock).get(anyObject());
  77     componentManager.validateComponentExistence("dummyVsp", version, "dummyComponentId",
  78         "dummyUser");
  79   }
  80
  81   @Test
  82   public void testList() {
  83     doReturn(Arrays.asList(
  84         createComponent(VSP_ID, VERSION, COMP1_ID),
  85         createComponent(VSP_ID, VERSION, COMP2_ID)))
  86         .when(componentDaoMock).list(anyObject());
  87
  88     Collection<ComponentEntity> actual =
  89         componentManager.listComponents(VSP_ID, VERSION, USER);
  90     Assert.assertEquals(actual.size(), 2);
  91   }
  92
  93   @Test
  94   public void testDeleteListOnUploadVsp_negative() {
  95     testDeleteList_negative(VSP_ID, VERSION, USER,
  96         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
  97   }
  98
  99 /*    @Test
 100     public void testCreate() {
 101         COMP1_ID = testCreate(VSP_ID);
 102     }*/
 103   @Test
 104   public void testCreate() {
 105     ComponentEntity expected = new ComponentEntity(VSP_ID, null, null);
 106     ComponentData compData = new ComponentData();
 107     compData.setName("comp1 name");
 108     compData.setDescription("comp1 desc");
 109     expected.setComponentCompositionData(compData);
 110
 111     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 112     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
 113     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
 114     doReturn(expected).when(compositionEntityDataManagerMock).createComponent(anyObject());
 115
 116     ComponentEntity created = componentManager.createComponent(expected, USER);
 117     Assert.assertNotNull(created);
 118     //expected.setId(created.getId());
 119     //expected.setVersion(VERSION);
 120
 121     //ComponentEntity actual = componentDaoMock.getComponent(VSP_ID, VERSION, created.getId());
 122
 123     //Assert.assertEquals(actual, expected);
 124     //return created.getId();
 125   }
 126
 127   @Test
 128   public void testCreateWithVspCompListMoreThanOne() {
 129     ComponentEntity expected = new ComponentEntity(VSP_ID, null, null);
 130     ComponentData compData = new ComponentData();
 131     compData.setName("comp1 name");
 132     compData.setDescription("comp1 desc");
 133     expected.setComponentCompositionData(compData);
 134
 135     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 136     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
 137     vspComponentList.add(expected);
 138     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
 139
 140     try {
 141       ComponentEntity created = componentManager.createComponent(expected, USER);
 142     }  catch (CoreException exception) {
 143       Assert.assertEquals("Creation of only one VFC per VSP allowed.", exception.code().message());
 144       Assert.assertEquals(VendorSoftwareProductErrorCodes.VSP_VFC_COUNT_EXCEED,
 145           exception.code().id());
 146     }
 147   }
 148
 149   @Test
 150   public void testUpdateComp() {
 151     ComponentEntity expected = new ComponentEntity(VSP_ID, null, COMP1_ID);
 152     ComponentData compData = new ComponentData();
 153     compData.setName("comp1 name");
 154     compData.setDescription("comp1 desc");
 155     expected.setComponentCompositionData(compData);
 156
 157     doReturn(expected).when(componentDaoMock).get(anyObject());
 158     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 159     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
 160     vspComponentList.add(expected);
 161     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
 162     doReturn(new CompositionEntityValidationData(null,null)).when(compositionEntityDataManagerMock)
 163         .validateEntity(anyObject(),anyObject(),anyObject());
 164
 165     CompositionEntityValidationData created = componentManager.updateComponent(expected, USER);
 166     Assert.assertNotNull(created);
 167   }
 168
 169   @Test
 170   public void testUpdateCompWithSameVfcDisplayName() {
 171     ComponentEntity expected = new ComponentEntity(VSP_ID, null, COMP1_ID);
 172     ComponentData compData = new ComponentData();
 173     compData.setName("comp1 name");
 174     compData.setDescription("comp1 desc");
 175     compData.setDisplayName("comp1 displayname");
 176     expected.setComponentCompositionData(compData);
 177
 178     doReturn(expected).when(componentDaoMock).get(anyObject());
 179     doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
 180     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
 181     vspComponentList.add(expected);
 182     ComponentEntity expected2 = new ComponentEntity(VSP_ID+"2", null, COMP1_ID+"2");
 183     expected2.setComponentCompositionData(compData);
 184     vspComponentList.add(expected2);
 185     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
 186     doReturn(new CompositionEntityValidationData(null,null)).when(compositionEntityDataManagerMock)
 187         .validateEntity(anyObject(),anyObject(),anyObject());
 188
 189     try {
 190       CompositionEntityValidationData created = componentManager.updateComponent(expected, USER);
 191     }  catch (CoreException exception) {
 192       Assert.assertEquals("VFC with specified name already present in given VSP.",
 193           exception.code().message());
 194       Assert.assertEquals(VendorSoftwareProductErrorCodes.VSP_VFC_DUPLICATE_NAME,
 195           exception.code().id());
 196     }
 197   }
 198
 199 /*    @Test
 200     public void testCreateWithExistingName_negative() {
 201         ComponentEntity component = new ComponentEntity(VSP_ID, null, null);
 202         ComponentData compData = new ComponentData();
 203         compData.setName("comp1 name");
 204         compData.setDescription("comp1 desc");
 205         component.setComponentCompositionData(compData);
 206         testCreate_negative(component, USER, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 207     }*/
 208
 209 /*    @Test
 210     public void testCreateWithExistingNameUnderOtherVsp() {
 211         testCreate(vsp2Id);
 212     }*/
 213
 214   @Test
 215   public void testCreateOnUploadVsp_negative() {
 216     testCreate_negative(new ComponentEntity(VSP_ID, VERSION, null), USER,
 217         VendorSoftwareProductErrorCodes.VFC_ADD_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 218   }
 219
 220   @Test
 221   public void testUpdateNonExistingComponentId_negative() {
 222     String componentId = "non existing component id";
 223     doReturn(null).when(componentDaoMock).get(anyObject());
 224
 225     testUpdate_negative(VSP_ID, VERSION, componentId, USER,
 226         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 227   }
 228
 229   @Test
 230   public void testUpdateOnUploadVsp() {
 231     doReturn(createComponent(VSP_ID, VERSION, COMP1_ID)).when(componentDaoMock)
 232         .get(anyObject());
 233
 234     doReturn(new CompositionEntityValidationData(CompositionEntityType.component, COMP1_ID))
 235         .when(compositionEntityDataManagerMock)
 236         .validateEntity(anyObject(), anyObject(), anyObject());
 237
 238     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, COMP1_ID);
 239     ComponentData compData = new ComponentData();
 240     compData.setName(COMP1_ID + " name");                // no change
 241     compData.setDisplayName(COMP1_ID + " display name"); // no change
 242     compData.setVfcCode(COMP1_ID + " display name"); // no change
 243     compData.setNfcCode(COMP1_ID + " display name"); // no change
 244     compData.setNfcFunction(COMP1_ID + " display name"); // no change
 245     compData.setDescription(COMP1_ID + " desc updated"); // allowed change
 246     component.setComponentCompositionData(compData);
 247
 248
 249     CompositionEntityValidationData validationData =
 250         componentManager.updateComponent(component, USER);
 251     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 252     verify(componentDaoMock).update(component);
 253   }
 254
 255   @Test
 256   public void testIllegalUpdateOnUploadVsp() {
 257     doReturn(createComponent(VSP_ID, VERSION, COMP1_ID))
 258         .when(componentDaoMock).get(anyObject());
 259
 260     CompositionEntityValidationData toBeReturned =
 261         new CompositionEntityValidationData(CompositionEntityType.component, COMP1_ID);
 262     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 263     doReturn(toBeReturned)
 264         .when(compositionEntityDataManagerMock)
 265         .validateEntity(anyObject(), anyObject(), anyObject());
 266
 267     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, COMP1_ID);
 268     ComponentData compData = new ComponentData();
 269     compData.setName("comp1 name updated");// not allowed: changed name + omitted display name
 270     component.setComponentCompositionData(compData);
 271
 272     CompositionEntityValidationData validationData =
 273         componentManager.updateComponent(component, USER);
 274     Assert.assertNotNull(validationData);
 275     Assert.assertEquals(validationData.getErrors().size(), 2);
 276
 277     verify(componentDaoMock, never()).update(component);
 278   }
 279
 280   @Test
 281   public void testGetNonExistingComponentId_negative() {
 282     String componentId = "non existing component id";
 283     doReturn(null).when(componentDaoMock).get(anyObject());
 284
 285     testGet_negative(VSP_ID, VERSION, componentId, USER,
 286         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 287   }
 288
 289   @Test
 290   public void testGet() {
 291     ComponentEntity expected = createComponent(VSP_ID, VERSION, COMP1_ID);
 292     doReturn(expected).when(componentDaoMock).get(anyObject());
 293
 294     doReturn("schema string").when(componentManager).getComponentCompositionSchema(anyObject());
 295
 296     testGet(VSP_ID, VERSION, COMP1_ID, USER, expected);
 297   }
 298
 299
 300
 301
 302 /*
 303     @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 304     public void testCreateWithERemovedName() {
 305         testCreate(VSP_ID);
 306     }
 307
 308     @Test(dependsOnMethods = "testList")
 309     public void testDeleteNonExistingComponentId_negative() {
 310         testDelete_negative(VSP_ID, "non existing component id", USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 311     }*/
 312
 313
 314
 315 /*
 316     @Test(dependsOnMethods = "testList")
 317     public void testDelete() {
 318         componentManager.deleteComponent(VSP_ID, COMP1_ID, USER);
 319         ComponentEntity actual = componentDaoMock.getComponent(VSP_ID, VERSION, COMP1_ID);
 320         Assert.assertNull(actual);
 321     }*/
 322
 323   @Test
 324   public void testDeleteOnUploadVsp_negative() {
 325     testDelete_negative(VSP_ID, VERSION, COMP1_ID, USER,
 326         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 327   }
 328
 329   @Test(expectedExceptions = CoreException.class,
 330       expectedExceptionsMessageRegExp = COMP_NOT_EXIST_MSG)
 331   public void testGetNonExistingComponentQuestionnaire() throws Exception {
 332     componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
 333   }
 334
 335   @Test
 336   public void testComponentNullQuestionnaire() throws Exception {
 337     doReturn(new ComponentEntity(VSP_ID, VERSION, COMP1_ID)).when(componentDaoMock)
 338         .getQuestionnaireData(VSP_ID, VERSION, COMP1_ID);
 339     String schema = "schema string";
 340     doReturn(schema).when(componentManager).getComponentQuestionnaireSchema(anyObject());
 341
 342     QuestionnaireResponse questionnaire =
 343         componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
 344     Assert.assertNotNull(questionnaire);
 345     Assert.assertEquals(questionnaire.getData(), null);
 346     Assert.assertEquals(questionnaire.getSchema(), schema);
 347     Assert.assertNull(questionnaire.getErrorMessage());
 348   }
 349
 350
 351   @Test
 352   public void testGetQuestionnaire() throws Exception {
 353     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, COMP1_ID);
 354     component.setQuestionnaireData("{}");
 355     doReturn(component).when(componentDaoMock).getQuestionnaireData(VSP_ID, VERSION, COMP1_ID);
 356
 357     NicEntity nicEntity1 = new NicEntity();
 358     Nic nic1 = new Nic();
 359     nic1.setName("nic1");
 360     nicEntity1.setNicCompositionData(nic1);
 361
 362     NicEntity nicEntity2 = new NicEntity();
 363     Nic nic2 = new Nic();
 364     nic2.setName("nic2");
 365     nicEntity2.setNicCompositionData(nic2);
 366
 367     doReturn(Arrays.asList(nicEntity1, nicEntity2))
 368         .when(nicManagerMock).listNics(VSP_ID, VERSION, COMP1_ID, USER);
 369
 370     String schema = "schema string";
 371     doReturn(schema).when(componentManager).getComponentQuestionnaireSchema(anyObject());
 372
 373     QuestionnaireResponse questionnaire =
 374         componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
 375     Assert.assertNotNull(questionnaire);
 376     Assert.assertEquals(questionnaire.getData(), component.getQuestionnaireData());
 377     Assert.assertEquals(questionnaire.getSchema(), schema);
 378     Assert.assertNull(questionnaire.getErrorMessage());
 379   }
 380
 381   @Test(expectedExceptions = CoreException.class,
 382       expectedExceptionsMessageRegExp = COMP_NOT_EXIST_MSG)
 383   public void testUpdateNonExistingComponentQuestionnaire() throws Exception {
 384     doReturn(null).when(componentDaoMock).get(anyObject());
 385     componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data", USER);
 386   }
 387
 388   @Test
 389   public void testUpdateQuestionnaire() throws Exception {
 390     ComponentEntity component = createComponent(VSP_ID, VERSION, COMP1_ID);
 391     doReturn(component).when(componentDaoMock).get(anyObject());
 392
 393     componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data", USER);
 394
 395     verify(componentDaoMock)
 396         .updateQuestionnaireData(VSP_ID, VERSION, COMP1_ID, "questionnaire data");
 397   }
 398
 399 /*
 400     @Test(dependsOnMethods = "testDelete")
 401     public void testDeleteList() {
 402         ComponentEntity comp3 = new ComponentEntity(VSP_ID, null, null);
 403         comp3.setName("comp3 name");
 404         comp3.setDescription("comp3 desc");
 405         componentManager.createComponent(comp3, USER);
 406
 407         componentManager.deleteComponents(VSP_ID, USER);
 408
 409         Collection<ComponentEntity> actual = componentManager.listComponents(VSP_ID, null, USER);
 410         Assert.assertEquals(actual.size(), 0);
 411     }*/
 412
 413   private void testGet(String vspId, Version version, String componentId, String user,
 414                        ComponentEntity expected) {
 415
 416     CompositionEntityResponse<ComponentData>
 417         response = componentManager.getComponent(vspId, version, componentId, user);
 418     Assert.assertEquals(response.getId(), expected.getId());
 419     Assert.assertEquals(response.getData(), expected.getComponentCompositionData());
 420     Assert.assertNotNull(response.getSchema());
 421   }
 422
 423   private void testCreate_negative(ComponentEntity component, String user,
 424                                    String expectedErrorCode) {
 425     try {
 426       componentManager.createComponent(component, user);
 427       Assert.fail();
 428     } catch (CoreException exception) {
 429       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 430     }
 431   }
 432
 433   private void testGet_negative(String vspId, Version version, String componentId, String user,
 434                                 String expectedErrorCode) {
 435     try {
 436       componentManager.getComponent(vspId, version, componentId, user);
 437       Assert.fail();
 438     } catch (CoreException exception) {
 439       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 440     }
 441   }
 442
 443   private void testUpdate_negative(String vspId, Version version, String componentId, String user,
 444                                    String expectedErrorCode) {
 445     try {
 446       componentManager
 447           .updateComponent(new ComponentEntity(vspId, version, componentId), user);
 448       Assert.fail();
 449     } catch (CoreException exception) {
 450       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 451     }
 452   }
 453
 454   private void testList_negative(String vspId, Version version, String user,
 455                                  String expectedErrorCode) {
 456     try {
 457       componentManager.listComponents(vspId, version, user);
 458       Assert.fail();
 459     } catch (CoreException exception) {
 460       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 461     }
 462   }
 463
 464   private void testDeleteList_negative(String vspId, Version version, String user,
 465                                        String expectedErrorCode) {
 466     try {
 467       componentManager.deleteComponents(vspId, version, user);
 468       Assert.fail();
 469     } catch (CoreException exception) {
 470       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 471     }
 472   }
 473
 474   private void testDelete_negative(String vspId, Version version, String componentId, String user,
 475                                    String expectedErrorCode) {
 476     try {
 477       componentManager.deleteComponent(vspId, version, componentId, user);
 478       Assert.fail();
 479     } catch (CoreException exception) {
 480       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 481     }
 482   }
 483
 484
 485   public static ComponentEntity createComponent(String vspId, Version version, String compId) {
 486     ComponentEntity componentEntity = new ComponentEntity(vspId, version, compId);
 487     ComponentData compData = new ComponentData();
 488     compData.setName(compId + " name");
 489     compData.setDisplayName(compId + " display name");
 490     compData.setVfcCode(compId + " display name");
 491     compData.setDescription(compId + " desc");
 492     componentEntity.setComponentCompositionData(compData);
 493     componentEntity.setQuestionnaireData("{}");
 494     return componentEntity;
 495   }
 496 }