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