gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import static org.mockito.Matchers.anyObject;
   4 import static org.mockito.Mockito.doReturn;
   5 import static org.mockito.Mockito.never;
   6 import static org.mockito.Mockito.verify;
   7
   8 import org.mockito.InjectMocks;
   9 import org.mockito.Mock;
  10 import org.mockito.MockitoAnnotations;
  11 import org.mockito.Spy;
  12 import org.openecomp.sdc.common.errors.CoreException;
  13 import org.openecomp.sdc.logging.api.Logger;
  14 import org.openecomp.sdc.logging.api.LoggerFactory;
  15 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
  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.ComputeEntity;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  21 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  22 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  23 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  24 import org.openecomp.sdc.vendorsoftwareproduct.types.ListComputeResponse;
  25 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  26 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  27 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  28 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
  30 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  31 import org.openecomp.sdc.versioning.dao.types.Version;
  32 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  33 import org.testng.Assert;
  34 import org.testng.annotations.BeforeMethod;
  35 import org.testng.annotations.Test;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.Collection;
  40 import java.util.List;
  41
  42 public class ComputeManagerImplTest {
  43
  44     private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
  45
  46     private static final String COMPUTE_NOT_EXIST_MSG =
  47             "Vendor Software Product COMPUTE with Id compute1 does not exist for Vendor Software Product with " +
  48                     "id VSP_ID and version 0.1";
  49
  50     private static final String USER = "computeTestUser";
  51     private static final String VSP_ID = "VSP_ID";
  52     private static final Version VERSION = new Version(0, 1);
  53     private static final String COMPONENT_ID = "COMPONENT_ID";
  54     private static final String COMPUTE1_ID = "compute1";
  55     private static final String COMPUTE2_ID = "compute2";
  56
  57   @Mock
  58   private ComputeDao computeDao;
  59
  60   @Mock
  61   private CompositionEntityDataManager compositionEntityDataManagerMock;
  62
  63   @Mock
  64   private NetworkManager networkManagerMock;
  65
  66   @Mock
  67   private VendorSoftwareProductInfoDao vspInfoDao;
  68
  69   @Mock
  70   private ComputeEntity computeEntity;
  71
  72   @Mock
  73   private ListComputeResponse listComputeResponse;
  74
  75   @Mock
  76   private DeploymentFlavorEntity deploymentFlavorEntity;
  77
  78   @Mock
  79   private DeploymentFlavorDao deploymentFlavorDao;
  80
  81   @Mock
  82   private ComponentComputeAssociation componentComputeAssociation;
  83
  84   @Mock
  85   DeploymentFlavor deploymentFlavor;
  86
  87   @InjectMocks
  88   @Spy
  89   private ComputeManagerImpl computeManager;
  90
  91   @BeforeMethod
  92   public void setUp() throws Exception {
  93       MockitoAnnotations.initMocks(this);
  94   }
  95
  96    @Test
  97   public void testListWhenNone() {
  98     Collection<ListComputeResponse> computes = computeManager.listCompute(VSP_ID, VERSION, COMPONENT_ID, USER);
  99     Assert.assertEquals(computes.size(), 0);
 100   }
 101
 102   @Test
 103   public void testList(){
 104       doReturn(Arrays.asList(
 105         createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID),
 106         createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE2_ID)))
 107               .when(computeDao).list(anyObject());
 108
 109
 110       Collection<ListComputeResponse> computes = computeManager.listCompute(VSP_ID, VERSION, COMPONENT_ID, USER);
 111       Assert.assertEquals(computes.size(), 2);
 112       for (ListComputeResponse compute : computes) {
 113           Assert.assertEquals(compute.getComputeEntity().getComputeCompositionData().getName(),
 114                   COMPUTE1_ID.equals(compute.getComputeEntity().getId())
 115                           ? "compute1name"
 116                           : "compute2name");
 117       };
 118   }
 119
 120     @Test
 121     public void testCreateOnNotManualCompute_negative() {
 122
 123         testCreate_negative(new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
 124                 VendorSoftwareProductErrorCodes.ADD_COMPUTE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
 125     }
 126
 127     @Test
 128     public void testCreateManualCompute() {
 129         ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 130         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 131         computeManager.createCompute(expected, USER);
 132         verify(compositionEntityDataManagerMock).createCompute(expected);
 133         verify(compositionEntityDataManagerMock).createCompute(expected);
 134     }
 135
 136     @Test
 137     public void testCreateManualComputeWithDuplicateName() {
 138         ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 139         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 140
 141         ComputeEntity expectedDiffName = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 142         expectedDiffName.setId(COMPUTE1_ID + "Name");
 143         ComputeData computeData = expectedDiffName.getComputeCompositionData();
 144         computeData.setName(COMPUTE1_ID + "Name");
 145         expectedDiffName.setComputeCompositionData(computeData);
 146         List<ComputeEntity> vfcImageList = new ArrayList<ComputeEntity>();
 147         vfcImageList.add(expectedDiffName);
 148         doReturn(vfcImageList).when(computeDao).list(anyObject());
 149
 150         try {
 151             computeManager.createCompute(expected, USER);
 152             Assert.fail();
 153         }
 154         catch (CoreException ex) {
 155           log.debug("",ex);
 156             Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_COMPUTE_NAME_NOT_ALLOWED,
 157                     ex.code().id());
 158         }
 159     }
 160
 161     @Test
 162     public void testUpdateNonExistingComputeId_negative() {
 163
 164         testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
 165                 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 166     }
 167
 168     @Test
 169     public void testUpdateCompute() {
 170         doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
 171                 .when(computeDao).get(anyObject());
 172
 173         doReturn(new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID))
 174                 .when(compositionEntityDataManagerMock)
 175                 .validateEntity(anyObject(), anyObject(), anyObject());
 176
 177         ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 178         ComputeData computeData = new ComputeData();
 179         computeData.setName(COMPUTE1_ID + "name");
 180         computeData.setDescription(COMPUTE1_ID + "desc updated");
 181         computeEntity.setComputeCompositionData(computeData);
 182
 183         CompositionEntityValidationData validationData =
 184                 computeManager.updateCompute(computeEntity, USER);
 185         Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 186         verify(computeDao).update(computeEntity);
 187     }
 188
 189     @Test
 190     public void testIllegalComputeUpdate() {
 191         doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
 192                 .when(computeDao).get(anyObject());
 193
 194         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 195
 196         CompositionEntityValidationData toBeReturned =
 197                 new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID);
 198         toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 199         doReturn(toBeReturned)
 200                 .when(compositionEntityDataManagerMock)
 201                 .validateEntity(anyObject(), anyObject(), anyObject());
 202
 203         ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 204         ComputeData computeData = new ComputeData();
 205         computeData.setName(COMPUTE1_ID + "_name_updated");
 206         computeData.setDescription(COMPUTE1_ID + " desc updated");
 207         computeEntity.setComputeCompositionData(computeData);
 208
 209         CompositionEntityValidationData validationData = computeManager.updateCompute(computeEntity, USER);
 210         Assert.assertNotNull(validationData);
 211         Assert.assertEquals(validationData.getErrors().size(), 2);
 212
 213         verify(computeDao, never()).update(computeEntity);
 214     }
 215
 216     @Test
 217     public void testUpdateHEATComputeName() throws Exception {
 218         doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
 219                 .when(computeDao).get(anyObject());
 220         ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 221         ComputeData computeData = new ComputeData();
 222         computeData.setName(COMPUTE1_ID + " name updated");
 223         computeData.setDescription(COMPUTE1_ID + " desc updated");
 224         computeEntity.setComputeCompositionData(computeData);
 225
 226         try {
 227             computeManager.updateCompute(computeEntity, USER);
 228         }
 229         catch (CoreException ex) {
 230           log.debug("",ex);
 231             Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_COMPUTE_NOT_ALLOWED);
 232         }
 233
 234     }
 235
 236     @Test
 237     public void testUpdateManualComputeQuestionnaire() throws Exception {
 238         String json = "{\"md5\" :\"FFDSD33SS\"}";
 239         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 240         doReturn(new ComputeEntity(null,null,null,null)).when(computeDao).get(anyObject());
 241
 242         computeManager.updateComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json, USER);
 243         verify(computeDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json);
 244     }
 245
 246     @Test
 247     public void testGetNonExistingComputeId_negative() {
 248         testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing compute id", USER,
 249                 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 250     }
 251
 252     @Test
 253     public void testGet() {
 254         ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 255         doReturn(expected).when(computeDao).get(anyObject());
 256         String compositionSchema = "schema string";
 257         doReturn(compositionSchema).when(computeManager).getComputeCompositionSchema(anyObject());
 258
 259         CompositionEntityResponse<ComputeData> response =
 260                 computeManager.getCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
 261         Assert.assertEquals(response.getId(), expected.getId());
 262         Assert.assertEquals(response.getData().getName(), expected.getComputeCompositionData().getName());
 263         Assert.assertEquals(response.getData().getDescription(), expected.getComputeCompositionData().
 264                 getDescription());
 265         Assert.assertEquals(response.getSchema(), compositionSchema);
 266     }
 267
 268     @Test
 269     public void testGetQuestionnaire() throws Exception {
 270         ComputeEntity compute = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 271         compute.setQuestionnaireData("{}");
 272         doReturn(compute).when(computeDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 273
 274         String schema = "schema string";
 275
 276
 277         doReturn(schema).when(computeManager).getComputeQuestionnaireSchema(anyObject());
 278
 279         QuestionnaireResponse questionnaire =
 280                 computeManager.getComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
 281
 282         Assert.assertNotNull(questionnaire);
 283         Assert.assertEquals(questionnaire.getData(), compute.getQuestionnaireData());
 284         Assert.assertEquals(questionnaire.getSchema(), schema);
 285         Assert.assertNull(questionnaire.getErrorMessage());
 286     }
 287
 288     @Test
 289     public void testDeleteOnNotManualCompute() {
 290         ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 291         doReturn(expected).when(computeDao).get(anyObject());
 292         testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
 293                 VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 294     }
 295
 296     @Test
 297     public void testDeleteOnManualCompute() {
 298         ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 299         doReturn(expected).when(computeDao).get(anyObject());
 300         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 301         computeManager.deleteCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
 302         verify(computeDao).delete(anyObject());
 303     }
 304
 305     @Test
 306     public void testDeleteOnNotExistCompute() {
 307         testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
 308                 VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 309     }
 310
 311
 312     private void testDelete_negative(String vspId, Version version, String componentId, String computeId,
 313                                      String user,
 314                                      String expectedErrorCode) {
 315         try {
 316             computeManager.deleteCompute(vspId, version, componentId, computeId, user);
 317             Assert.fail();
 318         } catch (CoreException exception) {
 319           log.debug("",exception);
 320             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 321         }
 322     }
 323
 324     private void testGet_negative(String vspId, Version version, String componentId, String computeId,
 325                                 String user, String expectedErrorCode) {
 326       try {
 327           computeManager.getCompute(vspId, version, componentId, computeId, user);
 328           Assert.fail();
 329       } catch (CoreException exception) {
 330         log.debug("",exception);
 331           Assert.assertEquals(exception.code().id(), expectedErrorCode);
 332       }
 333   }
 334
 335     private void testList_negative(String vspId, Version version, String componentId, String user,
 336                                    String expectedErrorCode, String expectedErrorMsg) {
 337         try {
 338             computeManager.listCompute(vspId, version, componentId, user);
 339             Assert.fail();
 340         } catch (CoreException exception) {
 341           log.debug("",exception);
 342             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 343             Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
 344         }
 345     }
 346
 347
 348
 349     private void testUpdate_negative(String vspId, Version version, String componentId, String computeId,
 350                                  String user, String expectedErrorCode) {
 351   try {
 352     computeManager.updateCompute(new ComputeEntity(vspId, version, componentId, computeId), user);
 353     Assert.fail();
 354   } catch (CoreException exception) {
 355     log.debug("",exception);
 356       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 357     }
 358   }
 359
 360   private void testCreate_negative(ComputeEntity computeEntity1, String user, String expectedErrorCode) {
 361         try {
 362             computeManager.createCompute(computeEntity1, user);
 363             Assert.fail();
 364         } catch (CoreException exception) {
 365           log.debug("",exception);
 366             Assert.assertEquals(exception.code().id(), expectedErrorCode);
 367         }
 368     }
 369
 370   static ComputeEntity createCompute(String vspId, Version version, String compId, String computeId){
 371       ComputeEntity computeEntity1 = new ComputeEntity(vspId, version, compId, computeId);
 372       ComputeData computeData = new ComputeData();
 373       computeData.setName(computeId+"name");
 374       computeData.setDescription(computeId+"desc");
 375       computeEntity1.setComputeCompositionData(computeData);
 376       return computeEntity1;
 377   }
 378 }