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