1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
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;
26 import java.util.ArrayList;
27 import java.util.Arrays;
28 import java.util.Collection;
29 import java.util.List;
31 import static org.mockito.Matchers.anyObject;
32 import static org.mockito.Mockito.*;
34 public class ImageManagerImplTest {
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";
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";
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"
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" + "}";
57 private ImageDao imageDao;
59 private CompositionEntityDataManager compositionEntityDataManagerMock;
61 private VendorSoftwareProductInfoDao vspInfoDao;
64 private ImageManagerImpl imageManager;
67 public void setUp() throws Exception {
68 MockitoAnnotations.initMocks(this);
72 public void tearDown() {
78 public void testListWhenNone() {
79 final Collection<ImageEntity> imageEntities = imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
80 Assert.assertEquals(imageEntities.size(), 0);
84 public void testList() {
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());
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");
99 public void testCreateOnNotManualImage_negative() {
101 testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null),
102 VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
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);
115 public void testUpdateNonExistingImageId_negative() {
116 testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
117 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
121 public void testUpdateImage() {
122 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(anyObject());
124 doReturn(new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID))
125 .when(compositionEntityDataManagerMock).validateEntity(anyObject(), anyObject(), anyObject());
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);
133 CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
134 Assert.assertTrue(validationData == null || validationData.getErrors() == null);
135 verify(imageDao).update(imageEntity);
139 public void testIllegalImageUpdate() {
140 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(anyObject());
142 doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
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());
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);
156 CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
157 Assert.assertNotNull(validationData);
158 Assert.assertEquals(validationData.getErrors().size(), 2);
160 verify(imageDao, never()).update(imageEntity);
164 public void testUpdateHEATImageFileName() throws Exception {
165 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(anyObject());
167 String updatedName = IMAGE1_ID + " name updated";
168 CompositionEntityValidationData toBeReturned =
169 new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
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());
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);
182 CompositionEntityValidationData output = imageManager.updateImage(imageEntity);
183 Assert.assertEquals(output.getErrors(), toBeReturned.getErrors());
188 public void testGetNonExistingImageId_negative() {
189 testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id",
190 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
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());
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()
204 Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().getDescription());
205 Assert.assertEquals(response.getSchema(), compositionSchema);
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);
217 public void testDeleteOnNotExistImage() {
218 testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
219 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
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());
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);
237 String schema = "schema string";
238 doReturn(schema).when(imageManager).getImageQuestionnaireSchema(anyObject());
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());
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());
254 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
255 verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
260 public void testUpdateManDupImageVerQuestionnaire() throws Exception {
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>() {{
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());
276 doReturn(IMAGE_QUEST_SCHEMA).when(imageManager).getImageQuestionnaireSchema(anyObject());
278 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
280 } catch (CoreException exception) {
281 Assert.assertEquals(exception.code().id(),
282 VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
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());
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\"}";
299 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
301 } catch (CoreException ex) {
302 Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
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());
313 String updJson = "{\"format\" :\"a22\"}";
315 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
317 } catch (CoreException ex) {
318 Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
322 private void testCreate_negative(ImageEntity image, String expectedErrorCode) {
324 imageManager.createImage(image);
326 } catch (CoreException exception) {
327 Assert.assertEquals(exception.code().id(), expectedErrorCode);
331 private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
332 String expectedErrorCode) {
334 imageManager.deleteImage(vspId, version, componentId, nicId);
336 } catch (CoreException exception) {
337 Assert.assertEquals(exception.code().id(), expectedErrorCode);
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);
350 private void testUpdate_negative(String vspId, Version version, String componentId, String imageId,
351 String expectedErrorCode) {
353 imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId));
355 } catch (CoreException exception) {
356 Assert.assertEquals(exception.code().id(), expectedErrorCode);
360 private void testGet_negative(String vspId, Version version, String componentId, String imageId,
361 String expectedErrorCode) {
363 imageManager.getImage(vspId, version, componentId, imageId);
365 } catch (CoreException exception) {
366 Assert.assertEquals(exception.code().id(), expectedErrorCode);