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.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.CompositionEntityDataManager;
  11 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  12 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  13 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  19 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  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.*;
  32
  33 import static org.mockito.Matchers.anyObject;
  34 import static org.mockito.Mockito.doReturn;
  35 import static org.mockito.Mockito.verify;
  36
  37 public class DeploymentFlavorManagerImplTest {
  38   private static final String VSP_ID = "VSP_ID";
  39   private static final Version VERSION = new Version("version_id");
  40   private static final String COMPONENT_ID = "COMPONENT_ID";
  41   private static final String DF1_ID = "df1";
  42   private static final String DF2_ID = "df2";
  43   private static final String FG_ID = "FG_ID";
  44   private static final List<String> fgs = Collections.singletonList(FG_ID);
  45
  46   @Mock
  47   private CompositionEntityDataManager compositionEntityDataManagerMock;
  48   @Mock
  49   private VendorSoftwareProductInfoDao vspInfoDao;
  50   @Mock
  51   private DeploymentFlavorDao deploymentFlavorDaoMock;
  52   @Mock
  53   private ComponentDao componentDaoMock;
  54   @Mock
  55   private ComputeDao computeDaoMock;
  56   @InjectMocks
  57   @Spy
  58   private DeploymentFlavorManagerImpl deploymentFlavorManager;
  59
  60   @BeforeMethod
  61   public void setUp() throws Exception {
  62     MockitoAnnotations.initMocks(this);
  63   }
  64
  65   @AfterMethod
  66   public void tearDown() {
  67     deploymentFlavorManager = null;
  68   }
  69
  70   @Test
  71   public void testListWhenNone() {
  72     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
  73         deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
  74     Assert.assertEquals(deploymentFlavorEntities.size(), 0);
  75   }
  76
  77   @Test
  78   public void testCreateOnNotManual_negative() {
  79
  80     testCreate_negative(new DeploymentFlavorEntity(VSP_ID, VERSION, null),
  81         VendorSoftwareProductErrorCodes.CREATE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
  82   }
  83
  84   @Test
  85   public void testCreateManualDepFlavor() {
  86     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
  87     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
  88
  89     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
  90     vspDetails.setFeatureGroups(fgs);
  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 testCreateManualDepFlavorWithNoFGNInDFAndInVSP() {
 150     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 151     final DeploymentFlavor deploymentFlavor =
 152         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 153     deploymentFlavor.setFeatureGroupId(null);
 154     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 155
 156     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 157
 158     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 159     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 160     deploymentFlavorManager.createDeploymentFlavor(expected);
 161     verify(compositionEntityDataManagerMock).createDeploymentFlavor(expected);
 162   }
 163
 164   @Test
 165   public void testCreateManualDepFlavorWithNullCompInAssociation() {
 166     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 167     final DeploymentFlavor deploymentFlavor =
 168         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 169     ComponentComputeAssociation association = new ComponentComputeAssociation();
 170     association.setComponentId(null);
 171     association.setComputeFlavorId("CF1");
 172     List<ComponentComputeAssociation> list = new ArrayList<>();
 173     list.add(association);
 174     deploymentFlavor.setComponentComputeAssociations(list);
 175     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 176
 177     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 178
 179     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 180     vspDetails.setFeatureGroups(fgs);
 181     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 182
 183     try {
 184       deploymentFlavorManager.createDeploymentFlavor(expected);
 185     } catch (CoreException ex) {
 186       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPONENT_COMPUTE_ASSOCIATION,
 187           ex.code().id());
 188       Assert.assertEquals(
 189           "Invalid request,for valid association please provide ComponentId for Compute Flavor",
 190           ex.getMessage());
 191     }
 192   }
 193
 194   @Test
 195   public void testCreateManualDepFlavorWithInvalidComputeInAssociation() {
 196     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 197     final DeploymentFlavor deploymentFlavor =
 198         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 199     ComponentComputeAssociation association = new ComponentComputeAssociation();
 200     association.setComponentId(COMPONENT_ID);
 201     association.setComputeFlavorId("CF1");
 202     List<ComponentComputeAssociation> list = new ArrayList<>();
 203     list.add(association);
 204     deploymentFlavor.setComponentComputeAssociations(list);
 205     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 206
 207     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 208
 209     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 210     vspDetails.setFeatureGroups(fgs);
 211     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 212
 213     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
 214     doReturn(component).when(componentDaoMock).get(anyObject());
 215
 216     doReturn(null).when(computeDaoMock).get(anyObject());
 217
 218     try {
 219       deploymentFlavorManager.createDeploymentFlavor(expected);
 220     } catch (CoreException ex) {
 221       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPUTE_FLAVOR_ID,
 222           ex.code().id());
 223     }
 224   }
 225
 226   @Test
 227   public void testCreateManualDepFlavorWithDuplicateVfcAssociation() {
 228     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
 229     final DeploymentFlavor deploymentFlavor =
 230         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
 231     ComponentComputeAssociation association = new ComponentComputeAssociation();
 232     association.setComponentId(COMPONENT_ID);
 233     association.setComputeFlavorId("CF1");
 234     List<ComponentComputeAssociation> list = new ArrayList<>();
 235     list.add(association);
 236     list.add(association);
 237     deploymentFlavor.setComponentComputeAssociations(list);
 238     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
 239
 240     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 241
 242     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 243     vspDetails.setFeatureGroups(fgs);
 244     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 245
 246     ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
 247     doReturn(component).when(componentDaoMock).get(anyObject());
 248
 249     ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, "CF1");
 250     doReturn(computeEntity).when(computeDaoMock).get(anyObject());
 251
 252     try {
 253       deploymentFlavorManager.createDeploymentFlavor(expected);
 254     } catch (CoreException ex) {
 255       Assert.assertEquals(
 256           VendorSoftwareProductErrorCodes.SAME_VFC_ASSOCIATION_MORE_THAN_ONCE_NOT_ALLOWED,
 257           ex.code().id());
 258     }
 259   }
 260
 261   @Test
 262   public void testList() {
 263
 264     doReturn(Arrays.asList(
 265         createDeploymentFlavor(VSP_ID, VERSION, DF1_ID),
 266         createDeploymentFlavor(VSP_ID, VERSION, DF2_ID)))
 267         .when(deploymentFlavorDaoMock).list(anyObject());
 268
 269
 270     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 271         deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
 272     Assert.assertEquals(deploymentFlavorEntities.size(), 2);
 273     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 274       Assert.assertEquals(deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel()
 275           , DF1_ID.equals(deploymentFlavorEntity.getId()) ? DF1_ID + "name" : DF2_ID + "name");
 276     }
 277   }
 278
 279   @Test
 280   public void testUpdateHeatDepFlavor() {
 281     testUpdate_negative(VSP_ID, VERSION, DF1_ID,
 282         VendorSoftwareProductErrorCodes.EDIT_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 283   }
 284
 285   @Test
 286   public void testUpdateNonExistingManualDepFlavorId_negative() {
 287     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 288     testUpdate_negative(VSP_ID, VERSION, DF1_ID,
 289         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 290   }
 291
 292   @Test
 293   public void testManualUpdateDepFlavor() {
 294     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 295
 296     doReturn(createDeploymentFlavor(VSP_ID, VERSION, DF1_ID))
 297         .when(deploymentFlavorDaoMock).get(anyObject());
 298
 299     doReturn(new CompositionEntityValidationData(CompositionEntityType.image, DF1_ID))
 300         .when(compositionEntityDataManagerMock)
 301         .validateEntity(anyObject(), anyObject(), anyObject());
 302
 303     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
 304     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 305
 306     DeploymentFlavorEntity deploymentFlavorEntity =
 307         new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
 308     DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
 309     deploymentFlavor.setModel(DF1_ID + "_name");
 310     deploymentFlavor.setDescription(DF1_ID + " desc updated");
 311     deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 312
 313     CompositionEntityValidationData validationData =
 314         deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity);
 315     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 316     verify(deploymentFlavorDaoMock).update(deploymentFlavorEntity);
 317   }
 318
 319   @Test
 320   public void testGetNonExistingDepFlavorId_negative() {
 321     testGet_negative(VSP_ID, VERSION,
 322         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 323   }
 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     deploymentFlavor.setFeatureGroupId(FG_ID);
 378
 379     deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 380     return deploymentFlavorEntity;
 381   }
 382
 383   private void testUpdate_negative(String vspId, Version version, String deploymentFlavorId,
 384                                    String expectedErrorCode) {
 385     try {
 386       DeploymentFlavorEntity deploymentFlavorEntity =
 387           new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
 388       DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
 389       deploymentFlavor.setModel("Name");
 390       deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 391       deploymentFlavorManager
 392           .updateDeploymentFlavor(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 393       Assert.fail();
 394     } catch (CoreException exception) {
 395       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 396     }
 397   }
 398
 399   private void testGet_negative(String vspId, Version version,
 400                                 String expectedErrorCode) {
 401     try {
 402       deploymentFlavorManager.getDeploymentFlavor(vspId, version, "non existing image id");
 403       Assert.fail();
 404     } catch (CoreException exception) {
 405       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 406     }
 407   }
 408
 409 }