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

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