2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.vendorsoftwareproduct.impl;
24 import org.junit.After;
25 import org.junit.Assert;
26 import org.junit.Before;
27 import org.junit.Test;
28 import org.mockito.InjectMocks;
29 import org.mockito.Mock;
30 import org.mockito.MockitoAnnotations;
31 import org.mockito.Spy;
32 import org.openecomp.sdc.common.errors.CoreException;
33 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
34 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
35 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
36 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
37 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
38 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
39 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
40 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
41 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
42 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
43 import org.openecomp.sdc.versioning.dao.types.Version;
44 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.Collection;
49 import java.util.List;
51 import static org.mockito.ArgumentMatchers.any;
52 import static org.mockito.Mockito.doReturn;
53 import static org.mockito.Mockito.never;
54 import static org.mockito.Mockito.verify;
56 public class ImageManagerImplTest {
58 private static final String IMAGE_NOT_EXIST_MSG =
59 "Vendor Software Product Image with Id image1 does not exist for Vendor Software Product with"
60 + " id VSP_ID and version 0.1";
62 private static final String VSP_ID = "VSP_ID";
63 private static final Version VERSION = new Version(0, 1);
64 private static final String COMPONENT_ID = "COMPONENT_ID";
65 private static final String IMAGE1_ID = "image1";
66 private static final String IMAGE2_ID = "image2";
68 private static final String IMAGE_QUEST_SCHEMA =
69 "{\n" + "\"$schema\": \"http://json-schema.org/draft-04/schema#\",\n" + "\"type\": \"object\",\n"
70 + "\"properties\": {\n" + " \"format\": {\n" + " \"type\": \"string\",\n"
72 + " \"aki\",\"ami\",\"ari\",\"iso\",\"qcow2\",\"raw\", \"vdi\",\"vhd\",\"vmdk\"\n"
73 + " ]\n" + " },\n" + " \"version\": {\n" + " \"type\": \"string\",\n"
74 + " \"minLength\": 1\n" + " },\n" + " \"md5\": {\n" + " \"type\": \"string\",\n"
75 + " \"maxLength\": 32\n" + " }\n" + "},\n" + " \"additionalProperties\": false,\n"
76 + " \"required\": [\n" + " \"version\"\n" + " ]\n" + "}";
79 private ImageDao imageDao;
81 private CompositionEntityDataManager compositionEntityDataManagerMock;
83 private VendorSoftwareProductInfoDao vspInfoDao;
86 private ImageManagerImpl imageManager;
89 public void setUp() throws Exception {
90 MockitoAnnotations.openMocks(this);
94 public void tearDown() {
100 public void testListWhenNone() {
101 final Collection<ImageEntity> imageEntities = imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
102 Assert.assertEquals(imageEntities.size(), 0);
106 public void testList() {
108 doReturn(Arrays.asList(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID),
109 createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE2_ID))).when(imageDao).list(any());
112 final Collection<ImageEntity> images = imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
113 Assert.assertEquals(images.size(), 2);
114 for (ImageEntity image : images) {
115 Assert.assertEquals(image.getImageCompositionData().getFileName(),
116 IMAGE1_ID.equals(image.getId()) ? IMAGE1_ID + "_name" : IMAGE2_ID + "_name");
121 public void testCreateOnNotManualImage_negative() {
123 testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null),
124 VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
128 public void testCreateManualImage() {
129 ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
130 doReturn(true).when(vspInfoDao).isManual(any(), any());
131 imageManager.createImage(expected);
132 verify(compositionEntityDataManagerMock).createImage(expected);
133 verify(compositionEntityDataManagerMock).createImage(expected);
137 public void testUpdateNonExistingImageId_negative() {
138 testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
139 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
143 public void testUpdateImage() {
144 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
146 doReturn(new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID))
147 .when(compositionEntityDataManagerMock).validateEntity(any(), any(), any());
149 ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
150 Image imageData = new Image();
151 imageData.setFileName(IMAGE1_ID + "_name");
152 imageData.setDescription(IMAGE1_ID + " desc updated");
153 imageEntity.setImageCompositionData(imageData);
155 CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
156 Assert.assertTrue(validationData == null || validationData.getErrors() == null);
157 verify(imageDao).update(imageEntity);
161 public void testIllegalImageUpdate() {
162 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
164 doReturn(true).when(vspInfoDao).isManual(any(), any());
166 CompositionEntityValidationData toBeReturned =
167 new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
168 toBeReturned.setErrors(Arrays.asList("error1", "error2"));
169 doReturn(toBeReturned).when(compositionEntityDataManagerMock)
170 .validateEntity(any(), any(), any());
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);
178 CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
179 Assert.assertNotNull(validationData);
180 Assert.assertEquals(validationData.getErrors().size(), 2);
182 verify(imageDao, never()).update(imageEntity);
186 public void testUpdateHEATImageFileName() throws Exception {
187 doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID)).when(imageDao).get(any());
189 String updatedName = IMAGE1_ID + " name updated";
190 CompositionEntityValidationData toBeReturned =
191 new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
193 toBeReturned.setErrors(Arrays.asList("#/name: " + updatedName + " is not a valid value." + IMAGE1_ID
194 + "is the only possible value for this field"));
195 doReturn(toBeReturned).when(compositionEntityDataManagerMock)
196 .validateEntity(any(), any(), any());
198 ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
199 Image imageData = new Image();
200 imageData.setFileName(updatedName);
201 imageData.setDescription(IMAGE1_ID + " desc updated");
202 imageEntity.setImageCompositionData(imageData);
204 CompositionEntityValidationData output = imageManager.updateImage(imageEntity);
205 Assert.assertEquals(output.getErrors(), toBeReturned.getErrors());
210 public void testGetNonExistingImageId_negative() {
211 testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id",
212 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
216 public void testGet() {
217 ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
218 doReturn(expected).when(imageDao).get(any());
219 String compositionSchema = "schema string";
220 doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(any());
222 CompositionEntityResponse<Image> response = imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
223 Assert.assertEquals(response.getId(), expected.getId());
224 Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData()
226 Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().getDescription());
227 Assert.assertEquals(response.getSchema(), compositionSchema);
231 public void testDeleteOnNotManualImage() {
232 ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
233 doReturn(expected).when(imageDao).get(any());
234 testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
235 VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
239 public void testDeleteOnNotExistImage() {
240 testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
241 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
245 public void testDeleteOnManualImage() {
246 ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
247 doReturn(expected).when(imageDao).get(any());
248 doReturn(true).when(vspInfoDao).isManual(any(), any());
249 imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
250 verify(imageDao).delete(any());
254 public void testGetQuestionnaire() throws Exception {
255 ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
256 image.setQuestionnaireData("{}");
257 doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
259 String schema = "schema string";
260 doReturn(schema).when(imageManager).getImageQuestionnaireSchema(any());
262 QuestionnaireResponse questionnaire =
263 imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
264 Assert.assertNotNull(questionnaire);
265 Assert.assertEquals(questionnaire.getData(), image.getQuestionnaireData());
266 Assert.assertEquals(questionnaire.getSchema(), schema);
267 Assert.assertNull(questionnaire.getErrorMessage());
271 public void testUpdateManualImageQuestionnaire() throws Exception {
272 String json = "{\"md5\" :\"FFDSD33SS\"}";
273 doReturn(true).when(vspInfoDao).isManual(any(), any());
274 doReturn(new ImageEntity()).when(imageDao).get(any());
276 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
277 verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
282 public void testUpdateManDupImageVerQuestionnaire() throws Exception {
284 String json = "{\"md5\" :\"FFDSD33SS\", \"version\" :\"1.0\"}";
285 ImageEntity imageEntity = new ImageEntity();
286 imageEntity.setId(IMAGE2_ID);
287 imageEntity.setQuestionnaireData(json);
288 List<ImageEntity> imageEntities = new ArrayList<ImageEntity>() {{
292 doReturn(true).when(vspInfoDao).isManual(any(), any());
293 doReturn(imageEntity).when(imageDao).get(any());
294 doReturn(imageEntities).when(imageDao).list(any());
295 doReturn(imageEntities.get(0)).when(imageDao)
296 .getQuestionnaireData(any(), any(), any(), any());
298 doReturn(IMAGE_QUEST_SCHEMA).when(imageManager).getImageQuestionnaireSchema(any());
300 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
302 } catch (CoreException exception) {
303 Assert.assertEquals(exception.code().id(),
304 VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
310 public void testUpdateHEATImageQuestionnaireWithFormat() throws Exception {
311 String json = "{\"format\" :\"qcow2\"}";
312 ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
313 image.setQuestionnaireData(json);
314 doReturn(image).when(imageDao).get(any());
316 doReturn(false).when(vspInfoDao).isManual(any(), any());
317 doReturn(IMAGE_QUEST_SCHEMA).when(imageManager).getImageQuestionnaireSchema(any());
318 doReturn(image).when(imageDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
319 String updJson = "{\"format\" :\"aki\"}";
321 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
323 } catch (CoreException ex) {
324 Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
329 public void testUpdateImageQuestionnaireWithInvalidFormat() throws Exception {
330 String json = "{\"format\" :\"qcow2\"}";
331 ImageEntity image = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
332 image.setQuestionnaireData(json);
333 doReturn(image).when(imageDao).get(any());
335 String updJson = "{\"format\" :\"a22\"}";
337 imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
339 } catch (CoreException ex) {
340 Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
344 private void testCreate_negative(ImageEntity image, String expectedErrorCode) {
346 imageManager.createImage(image);
348 } catch (CoreException exception) {
349 Assert.assertEquals(exception.code().id(), expectedErrorCode);
353 private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
354 String expectedErrorCode) {
356 imageManager.deleteImage(vspId, version, componentId, nicId);
358 } catch (CoreException exception) {
359 Assert.assertEquals(exception.code().id(), expectedErrorCode);
363 private static ImageEntity createImage(String vspId, Version version, String compId, String imageId) {
364 ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
365 Image imageData = new Image();
366 imageData.setFileName(imageId + "_name");
367 imageData.setDescription(imageId + " desc");
368 imageEntity.setImageCompositionData(imageData);
372 private void testUpdate_negative(String vspId, Version version, String componentId, String imageId,
373 String expectedErrorCode) {
375 imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId));
377 } catch (CoreException exception) {
378 Assert.assertEquals(exception.code().id(), expectedErrorCode);
382 private void testGet_negative(String vspId, Version version, String componentId, String imageId,
383 String expectedErrorCode) {
385 imageManager.getImage(vspId, version, componentId, imageId);
387 } catch (CoreException exception) {
388 Assert.assertEquals(exception.code().id(), expectedErrorCode);