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