gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3
   4 import static org.mockito.Matchers.anyObject;
   5 import static org.mockito.Mockito.doReturn;
   6
   7 import org.mockito.InjectMocks;
   8 import org.mockito.Mock;
   9 import org.mockito.MockitoAnnotations;
  10 import org.mockito.Spy;
  11 import org.openecomp.sdc.common.errors.CoreException;
  12 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  13 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  16 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  17 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  18 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  19 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  20 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  21 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  22 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  23 import org.openecomp.sdc.versioning.dao.types.Version;
  24 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  25 import org.testng.Assert;
  26 import org.testng.annotations.BeforeMethod;
  27 import org.testng.annotations.Test;
  28
  29 import java.util.ArrayList;
  30 import java.util.Arrays;
  31 import java.util.Collection;
  32 import java.util.List;
  33
  34 import static org.mockito.Mockito.never;
  35 import static org.mockito.Mockito.verify;
  36
  37 public class ImageManagerImplTest {
  38
  39   private static final String IMAGE_NOT_EXIST_MSG =
  40       "Vendor Software Product Image with Id image1 does not exist for Vendor Software Product with" +
  41           " " +
  42           "id VSP_ID and version 0.1";
  43
  44   private static final String USER = "imageTestUser";
  45   private static final String VSP_ID = "VSP_ID";
  46   private static final Version VERSION = new Version(0, 1);
  47   private static final String COMPONENT_ID = "COMPONENT_ID";
  48   private static final String IMAGE1_ID = "image1";
  49   private static final String IMAGE2_ID = "image2";
  50
  51   @Mock
  52   private ImageDao imageDao;
  53   @Mock
  54   private CompositionEntityDataManager compositionEntityDataManagerMock;
  55   @Mock
  56   private VendorSoftwareProductInfoDao vspInfoDao;
  57   @InjectMocks
  58   @Spy
  59   private ImageManagerImpl imageManager;
  60
  61   @BeforeMethod
  62   public void setUp() throws Exception {
  63     MockitoAnnotations.initMocks(this);
  64   }
  65
  66   @Test
  67   public void testListWhenNone() {
  68     final Collection<ImageEntity> imageEntities =
  69         imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID, USER);
  70     Assert.assertEquals(imageEntities.size(), 0);
  71   }
  72
  73   @Test
  74   public void testList() {
  75
  76     doReturn(Arrays.asList(
  77         createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID),
  78         createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE2_ID)))
  79         .when(imageDao).list(anyObject());
  80
  81
  82     final Collection<ImageEntity> images =
  83         imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID, USER);
  84     Assert.assertEquals(images.size(), 2);
  85     for (ImageEntity image : images) {
  86       Assert.assertEquals(image.getImageCompositionData().getFileName(),
  87           IMAGE1_ID.equals(image.getId()) ? IMAGE1_ID+"_name" : IMAGE2_ID+"_name" );
  88     }
  89   }
  90
  91   @Test
  92   public void testCreateOnNotManualImage_negative() {
  93
  94     testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
  95         VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
  96   }
  97
  98   @Test
  99   public void testCreateManualImage() {
 100     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 101     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 102     imageManager.createImage(expected, USER);
 103     verify(compositionEntityDataManagerMock).createImage(expected);
 104     verify(compositionEntityDataManagerMock).createImage(expected);
 105   }
 106
 107   @Test
 108   public void testCreateManualImageWithDuplicateName() {
 109     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 110     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 111
 112     ImageEntity expectedDiffName = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 113     Image image = expectedDiffName.getImageCompositionData();
 114     image.setFileName(IMAGE1_ID + "_Name");
 115     expectedDiffName.setImageCompositionData(image);
 116     List<ImageEntity> vfcImageList = new ArrayList<ImageEntity>();
 117     vfcImageList.add(expectedDiffName);
 118     doReturn(vfcImageList).when(imageDao).list(anyObject());
 119     try {
 120       imageManager.createImage(expected, USER);
 121       Assert.fail();
 122     }
 123     catch (CoreException ex) {
 124       Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_NAME_NOT_ALLOWED,
 125           ex.code().id());
 126     }
 127   }
 128
 129   @Test
 130   public void testUpdateNonExistingImageId_negative() {
 131     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
 132         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 133   }
 134
 135   @Test
 136   public void testUpdateImage() {
 137     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
 138         .when(imageDao).get(anyObject());
 139
 140     doReturn(new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID))
 141         .when(compositionEntityDataManagerMock)
 142         .validateEntity(anyObject(), anyObject(), anyObject());
 143
 144     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 145     Image imageData = new Image();
 146     imageData.setFileName(IMAGE1_ID + "_name");
 147     imageData.setDescription(IMAGE1_ID + " desc updated");
 148     imageEntity.setImageCompositionData(imageData);
 149
 150     CompositionEntityValidationData validationData =
 151         imageManager.updateImage(imageEntity, USER);
 152     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 153     verify(imageDao).update(imageEntity);
 154   }
 155
 156   @Test
 157   public void testIllegalImageUpdate() {
 158     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
 159         .when(imageDao).get(anyObject());
 160
 161     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 162
 163     CompositionEntityValidationData toBeReturned =
 164         new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
 165     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 166     doReturn(toBeReturned)
 167         .when(compositionEntityDataManagerMock)
 168         .validateEntity(anyObject(), anyObject(), anyObject());
 169
 170     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 171     Image imageData = new Image();
 172     imageData.setFileName(IMAGE1_ID + "_name_updated");
 173     imageData.setDescription(IMAGE1_ID + " desc updated");
 174     imageEntity.setImageCompositionData(imageData);
 175
 176     CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity, USER);
 177     Assert.assertNotNull(validationData);
 178     Assert.assertEquals(validationData.getErrors().size(), 2);
 179
 180     verify(imageDao, never()).update(imageEntity);
 181   }
 182
 183   @Test
 184   public void testUpdateHEATImageFileName() throws Exception {
 185     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
 186         .when(imageDao).get(anyObject());
 187     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 188     Image imageData = new Image();
 189     imageData.setFileName(IMAGE1_ID + " name updated");
 190     imageData.setDescription(IMAGE1_ID + " desc updated");
 191     imageEntity.setImageCompositionData(imageData);
 192
 193     try {
 194       imageManager.updateImage(imageEntity, USER);
 195     }
 196     catch (CoreException ex) {
 197       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
 198     }
 199
 200   }
 201
 202   @Test
 203   public void testGetNonExistingImageId_negative() {
 204     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id", USER,
 205         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 206   }
 207
 208   @Test
 209   public void testGet() {
 210     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 211     doReturn(expected).when(imageDao).get(anyObject());
 212     String compositionSchema = "schema string";
 213     doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(anyObject());
 214
 215     CompositionEntityResponse<Image> response =
 216         imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 217     Assert.assertEquals(response.getId(), expected.getId());
 218     Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData().
 219         getFileName());
 220     Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().
 221         getDescription());
 222     Assert.assertEquals(response.getSchema(), compositionSchema);
 223   }
 224
 225   @Test
 226   public void testDeleteOnNotManualImage() {
 227     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 228     doReturn(expected).when(imageDao).get(anyObject());
 229     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
 230         VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
 231   }
 232
 233   @Test
 234   public void testDeleteOnNotExistImage() {
 235     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
 236         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 237   }
 238
 239   @Test
 240   public void testDeleteOnManualImage() {
 241     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 242     doReturn(expected).when(imageDao).get(anyObject());
 243     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 244     imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 245     verify(imageDao).delete(anyObject());
 246   }
 247
 248   @Test
 249   public void testGetQuestionnaire() throws Exception {
 250     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 251     image.setQuestionnaireData("{}");
 252     doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 253
 254     String schema = "schema string";
 255     doReturn(schema).when(imageManager).getImageQuestionnaireSchema(anyObject());
 256
 257     QuestionnaireResponse questionnaire =
 258         imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
 259     Assert.assertNotNull(questionnaire);
 260     Assert.assertEquals(questionnaire.getData(), image.getQuestionnaireData());
 261     Assert.assertEquals(questionnaire.getSchema(), schema);
 262     Assert.assertNull(questionnaire.getErrorMessage());
 263   }
 264
 265   @Test
 266   public void testUpdateManualImageQuestionnaire() throws Exception {
 267     String json = "{\"md5\" :\"FFDSD33SS\"}";
 268     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 269     doReturn(new ImageEntity()).when(imageDao).get(anyObject());
 270
 271     imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json, USER);
 272     verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
 273   }
 274
 275   /*
 276   @Test
 277   public void testUpdateManDupImageVerQuestionnaire() throws Exception {
 278     try{
 279         String json = "{\"md5\" :\"FFDSD33SS\", \"version\" :\"1.0\"}";
 280         ImageEntity imageEntity = new ImageEntity();
 281         imageEntity.setId(IMAGE2_ID);
 282         imageEntity.setQuestionnaireData(json);
 283         List<ImageEntity> imageEntities = new ArrayList(){{
 284             add(imageEntity);
 285         }};
 286
 287         doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 288         doReturn(imageEntity).when(imageDao).get(anyObject());
 289         doReturn(imageEntities).when(imageDao).list(anyObject());
 290         doReturn(imageEntities.get(0)).when(imageDao).getQuestionnaireData(anyObject(), anyObject(), anyObject(), anyObject());
 291
 292         imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json, USER);
 293         Assert.fail();
 294     } catch (CoreException exception) {
 295         Assert.assertEquals(exception.code().id(), VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
 296
 297     }
 298   }
 299
 300   */
 301
 302   /*
 303
 304   @Test
 305   public void testUpdateHEATImageQuestionnaireWithFormat() throws Exception {
 306     String json = "{\"format\" :\"qcow2\"}";
 307     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 308     image.setQuestionnaireData(json);
 309     doReturn(image).when(imageDao).get(anyObject());
 310
 311     doReturn(false).when(vspInfoDao).isManual(anyObject(), anyObject());
 312     doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 313
 314     String updJson = "{\"format\" :\"aki\"}";
 315     try {
 316       imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
 317           USER);
 318       Assert.fail();
 319     }
 320     catch(CoreException ex) {
 321       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
 322     }
 323   }
 324
 325   */
 326
 327   @Test
 328   public void testUpdateHEATImageQuestionnaireWithInvalidFormat() throws Exception {
 329     String json = "{\"format\" :\"qcow2\"}";
 330     ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
 331     image.setQuestionnaireData(json);
 332     doReturn(image).when(imageDao).get(anyObject());
 333
 334     String updJson = "{\"format\" :\"a22\"}";
 335     try {
 336       imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
 337           USER);
 338       Assert.fail();
 339     }
 340     catch(CoreException ex) {
 341       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
 342     }
 343   }
 344
 345   private void testList_negative(String vspId, Version version, String componentId, String user,
 346                                  String expectedErrorCode, String expectedErrorMsg) {
 347     try {
 348       imageManager.listImages(vspId, version, componentId, user);
 349       Assert.fail();
 350     } catch (CoreException exception) {
 351       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 352       Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
 353     }
 354   }
 355
 356   private void testCreate_negative(ImageEntity image, String user, String expectedErrorCode) {
 357     try {
 358       imageManager.createImage(image, user);
 359       Assert.fail();
 360     } catch (CoreException exception) {
 361       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 362     }
 363   }
 364
 365   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 366                                    String user,
 367                                    String expectedErrorCode) {
 368     try {
 369       imageManager.deleteImage(vspId, version, componentId, nicId, user);
 370       Assert.fail();
 371     } catch (CoreException exception) {
 372       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 373     }
 374   }
 375
 376   static ImageEntity createImage(String vspId, Version version, String compId, String imageId) {
 377     ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
 378     Image imageData = new Image();
 379     imageData.setFileName(imageId + "_name");
 380     imageData.setDescription(imageId + " desc");
 381     imageEntity.setImageCompositionData(imageData);
 382     return imageEntity;
 383   }
 384
 385   private void testUpdate_negative(String vspId, Version version, String componentId, String
 386       imageId, String user, String expectedErrorCode) {
 387     try {
 388       imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId), user);
 389       Assert.fail();
 390     } catch (CoreException exception) {
 391       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 392     }
 393   }
 394
 395   private void testGet_negative(String vspId, Version version, String componentId, String imageId,
 396                                 String user, String expectedErrorCode) {
 397     try {
 398       imageManager.getImage(vspId, version, componentId, imageId, user);
 399       Assert.fail();
 400     } catch (CoreException exception) {
 401       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 402     }
 403   }
 404
 405 }