gerrit.onap Code Review - sdc.git/blob

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