gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3
   4 import org.mockito.InjectMocks;
   5 import org.mockito.Mock;
   6 import org.mockito.MockitoAnnotations;
   7 import org.mockito.Spy;
   8 import org.openecomp.core.utilities.json.JsonUtil;
   9 import org.openecomp.sdc.common.errors.CoreException;
  10 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  11 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  12 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  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.ComputeEntity;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  18 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  19 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  20 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  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.DeploymentFlavor;
  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.AfterMethod;
  28 import org.testng.annotations.BeforeMethod;
  29 import org.testng.annotations.Test;
  30
  31 import java.util.ArrayList;
  32 import java.util.Arrays;
  33 import java.util.Collection;
  34 import java.util.List;
  35
  36 import static org.mockito.Matchers.anyObject;
  37 import static org.mockito.Mockito.doReturn;
  38 import static org.mockito.Mockito.verify;
  39
  40 public class DeploymentFlavorManagerImplTest {
  41   private static final String VSP_ID = "VSP_ID";
  42   private static final Version VERSION = new Version("version_id");
  43   private static final String COMPONENT_ID = "COMPONENT_ID";
  44   private static final String DF1_ID = "df1";
  45   private static final String DF2_ID = "df2";
  46
  47   @Mock
  48   private CompositionEntityDataManager compositionEntityDataManagerMock;
  49   @Mock
  50   private VendorSoftwareProductInfoDao vspInfoDao;
  51   @Mock
  52   private DeploymentFlavorDao deploymentFlavorDaoMock;
  53   @Mock
  54   private ComponentDao componentDaoMock;
  55   @Mock
  56   private ComputeDao computeDaoMock;
  57   @InjectMocks
  58   @Spy
  59   private DeploymentFlavorManagerImpl deploymentFlavorManager;
  60
  61   @BeforeMethod
  62   public void setUp() throws Exception {
  63     MockitoAnnotations.initMocks(this);
  64   }
  65
  66   @AfterMethod
  67   public void tearDown() {
  68     deploymentFlavorManager = null;
  69   }
  70
  71   @Test
  72   public void testListWhenNone() {
  73     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
  74         deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
  75     Assert.assertEquals(deploymentFlavorEntities.size(), 0);
  76   }
  77
  78   @Test
  79   public void testCreateOnNotManual_negative() {
  80
  81     testCreate_negative(new DeploymentFlavorEntity(VSP_ID, VERSION, null),
  82         VendorSoftwareProductErrorCodes.CREATE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
  83   }
  84
  85   @Test
  86   public void testCreateManualDepFlavor() {
  87     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
  88     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
  89
  90     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
  91     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
  92
  93     deploymentFlavorManager.createDeploymentFlavor(expected);
  94     verify(compositionEntityDataManagerMock).createDeploymentFlavor(expected);
  95   }
  96
  97   @Test
  98   public void testCreateManualDepFlavorWithDuplicateName() {
  99     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 100     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 101
 102     DeploymentFlavorEntity expectedDiffName = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 103     DeploymentFlavor deploymentFlavor = expectedDiffName.getDeploymentFlavorCompositionData();
 104     deploymentFlavor.setModel(DF1_ID + "Name");
 105     expectedDiffName.setDeploymentFlavorCompositionData(deploymentFlavor);
 106     List<DeploymentFlavorEntity> list = new ArrayList<>();
 107     list.add(expectedDiffName);
 108     doReturn(list).when(deploymentFlavorDaoMock).list(anyObject());
 109
 110     try {
 111       deploymentFlavorManager.createDeploymentFlavor(expected);
 112       Assert.fail();
 113     } catch (CoreException ex) {
 114       Assert.assertEquals(
 115           VendorSoftwareProductErrorCodes.DUPLICATE_DEPLOYMENT_FLAVOR_MODEL_NOT_ALLOWED,
 116           ex.code().id());
 117     }
 118   }
 119
 120   @Test
 121   public void testCreateManualDepFlavorWithFGNotInVSP() {
 122     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 123     final DeploymentFlavor deploymentFlavor =
 124         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 125     deploymentFlavor.setFeatureGroupId("fg3");
 126     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 127
 128     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 129
 130     List<String> featureGrps = new ArrayList<>();
 131     featureGrps.add("fg1");
 132     featureGrps.add("fg2");
 133
 134     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 135     vspDetails.setFeatureGroups(featureGrps);
 136     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 137
 138
 139     try {
 140       deploymentFlavorManager.createDeploymentFlavor(expected);
 141       Assert.fail();
 142     } catch (CoreException ex) {
 143       Assert.assertEquals(VendorSoftwareProductErrorCodes.FEATURE_GROUP_NOT_EXIST_FOR_VSP,
 144           ex.code().id());
 145     }
 146   }
 147
 148   @Test
 149   public void testCreateManualDepFlavorWithNullCompInAssociation() {
 150     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 151     final DeploymentFlavor deploymentFlavor =
 152         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 153     ComponentComputeAssociation association = new ComponentComputeAssociation();
 154     association.setComponentId(null);
 155     association.setComputeFlavorId("CF1");
 156     List<ComponentComputeAssociation> list = new ArrayList<>();
 157     list.add(association);
 158     deploymentFlavor.setComponentComputeAssociations(list);
 159     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 160
 161     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 162
 163     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 164     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 165
 166     try {
 167       deploymentFlavorManager.createDeploymentFlavor(expected);
 168     } catch (CoreException ex) {
 169       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPONENT_COMPUTE_ASSOCIATION,
 170           ex.code().id());
 171       Assert.assertEquals(
 172           "Invalid request,for valid association please provide ComponentId for Compute Flavor",
 173           ex.getMessage());
 174     }
 175   }
 176
 177   @Test
 178   public void testCreateManualDepFlavorWithInvalidComputeInAssociation() {
 179     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 180     final DeploymentFlavor deploymentFlavor =
 181         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 182     ComponentComputeAssociation association = new ComponentComputeAssociation();
 183     association.setComponentId(COMPONENT_ID);
 184     association.setComputeFlavorId("CF1");
 185     List<ComponentComputeAssociation> list = new ArrayList<>();
 186     list.add(association);
 187     deploymentFlavor.setComponentComputeAssociations(list);
 188     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 189
 190     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 191
 192     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 193     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 194
 195     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
 196     doReturn(component).when(componentDaoMock).get(anyObject());
 197
 198     doReturn(null).when(computeDaoMock).get(anyObject());
 199
 200     try {
 201       deploymentFlavorManager.createDeploymentFlavor(expected);
 202     } catch (CoreException ex) {
 203       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPUTE_FLAVOR_ID,
 204           ex.code().id());
 205     }
 206   }
 207
 208   @Test
 209   public void testCreateManualDepFlavorWithDuplicateVfcAssociation() {
 210     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 211     final DeploymentFlavor deploymentFlavor =
 212         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 213     ComponentComputeAssociation association = new ComponentComputeAssociation();
 214     association.setComponentId(COMPONENT_ID);
 215     association.setComputeFlavorId("CF1");
 216     List<ComponentComputeAssociation> list = new ArrayList<>();
 217     list.add(association);
 218     list.add(association);
 219     deploymentFlavor.setComponentComputeAssociations(list);
 220     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 221
 222     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 223
 224     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 225     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 226
 227     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
 228     doReturn(component).when(componentDaoMock).get(anyObject());
 229
 230     ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, "CF1");
 231     doReturn(computeEntity).when(computeDaoMock).get(anyObject());
 232
 233     try {
 234       deploymentFlavorManager.createDeploymentFlavor(expected);
 235     } catch (CoreException ex) {
 236       Assert.assertEquals(
 237           VendorSoftwareProductErrorCodes.SAME_VFC_ASSOCIATION_MORE_THAN_ONCE_NOT_ALLOWED,
 238           ex.code().id());
 239     }
 240   }
 241
 242   @Test
 243   public void testList() {
 244
 245     doReturn(Arrays.asList(
 246         createDeploymentFlavor(VSP_ID, VERSION, DF1_ID),
 247         createDeploymentFlavor(VSP_ID, VERSION, DF2_ID)))
 248         .when(deploymentFlavorDaoMock).list(anyObject());
 249
 250
 251     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 252         deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
 253     Assert.assertEquals(deploymentFlavorEntities.size(), 2);
 254     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 255       Assert.assertEquals(deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel()
 256           , DF1_ID.equals(deploymentFlavorEntity.getId()) ? DF1_ID + "name" : DF2_ID + "name");
 257     }
 258   }
 259
 260   @Test
 261   public void testUpdateHeatDepFlavor() {
 262     testUpdate_negative(VSP_ID, VERSION, DF1_ID,
 263         VendorSoftwareProductErrorCodes.EDIT_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 264   }
 265
 266   @Test
 267   public void testUpdateNonExistingManualDepFlavorId_negative() {
 268     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 269     testUpdate_negative(VSP_ID, VERSION, DF1_ID,
 270         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 271   }
 272
 273   @Test
 274   public void testManualUpdateDepFlavor() {
 275     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 276
 277     doReturn(createDeploymentFlavor(VSP_ID, VERSION, DF1_ID))
 278         .when(deploymentFlavorDaoMock).get(anyObject());
 279
 280     doReturn(new CompositionEntityValidationData(CompositionEntityType.image, DF1_ID))
 281         .when(compositionEntityDataManagerMock)
 282         .validateEntity(anyObject(), anyObject(), anyObject());
 283
 284     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 285     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 286
 287     DeploymentFlavorEntity deploymentFlavorEntity =
 288         new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
 289     DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
 290     deploymentFlavor.setModel(DF1_ID + "_name");
 291     deploymentFlavor.setDescription(DF1_ID + " desc updated");
 292     deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 293
 294     CompositionEntityValidationData validationData =
 295         deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity);
 296     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 297     verify(deploymentFlavorDaoMock).update(deploymentFlavorEntity);
 298   }
 299
 300   @Test
 301   public void testGetNonExistingDepFlavorId_negative() {
 302     testGet_negative(VSP_ID, VERSION, "non existing image id",
 303         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 304   }
 305
 306   /*
 307   @Test
 308   public void testGet() {
 309     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 310     doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
 311
 312     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 313     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 314
 315     CompositionEntityResponse<DeploymentFlavor> response =
 316         deploymentFlavorManager.getDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 317     Assert.assertEquals(response.getId(), expected.getId());
 318     Assert
 319         .assertEquals(response.getData().getModel(), expected.getDeploymentFlavorCompositionData().
 320             getModel());
 321     Assert.assertEquals(response.getData().getDescription(),
 322         expected.getDeploymentFlavorCompositionData().
 323             getDescription());
 324   }
 325 */
 326   @Test
 327   public void testDeleteDepFlavorOnHEAT() {
 328     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 329     doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
 330     testDelete_negative(VSP_ID, VERSION, DF1_ID,
 331         VendorSoftwareProductErrorCodes.DELETE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 332   }
 333
 334   @Test
 335   public void testDeleteOnNotExistImage() {
 336     testDelete_negative(VSP_ID, VERSION, DF1_ID,
 337         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 338   }
 339
 340   @Test
 341   public void testDeleteOnManualImage() {
 342     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 343     doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
 344     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 345     deploymentFlavorManager.deleteDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 346     verify(deploymentFlavorDaoMock).delete(anyObject());
 347   }
 348
 349   private void testCreate_negative(DeploymentFlavorEntity deploymentFlavorEntity,
 350                                    String expectedErrorCode) {
 351     try {
 352       deploymentFlavorManager.createDeploymentFlavor(deploymentFlavorEntity);
 353       Assert.fail();
 354     } catch (CoreException exception) {
 355       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 356     }
 357   }
 358
 359   private void testDelete_negative(String vspId, Version version, String deploymentFlavorId,
 360                                    String expectedErrorCode) {
 361     try {
 362       deploymentFlavorManager.deleteDeploymentFlavor(vspId, version, deploymentFlavorId);
 363       Assert.fail();
 364     } catch (CoreException exception) {
 365       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 366     }
 367   }
 368
 369   private static DeploymentFlavorEntity createDeploymentFlavor(String vspId, Version version,
 370                                                                String deploymentFlavorId) {
 371
 372     DeploymentFlavorEntity deploymentFlavorEntity =
 373         new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
 374     DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
 375     deploymentFlavor.setModel(deploymentFlavorId + "name");
 376     deploymentFlavor.setDescription(deploymentFlavorId + " desc");
 377
 378     deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 379     return deploymentFlavorEntity;
 380   }
 381
 382   private void testUpdate_negative(String vspId, Version version, String deploymentFlavorId,
 383                                    String expectedErrorCode) {
 384     try {
 385       DeploymentFlavorEntity deploymentFlavorEntity =
 386           new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
 387       DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
 388       deploymentFlavor.setModel("Name");
 389       deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 390       deploymentFlavorManager
 391           .updateDeploymentFlavor(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 392       Assert.fail();
 393     } catch (CoreException exception) {
 394       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 395     }
 396   }
 397
 398   private void testGet_negative(String vspId, Version version, String deploymentFlavorId,
 399                                 String expectedErrorCode) {
 400     try {
 401       deploymentFlavorManager.getDeploymentFlavor(vspId, version, deploymentFlavorId);
 402       Assert.fail();
 403     } catch (CoreException exception) {
 404       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 405     }
 406   }
 407
 408 }