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