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