2 * Copyright © 2018 European Support Limited
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.openecomp.sdc.vendorsoftwareproduct.impl;
19 import org.junit.After;
20 import org.junit.Assert;
21 import org.junit.Before;
22 import org.junit.Test;
23 import org.mockito.InjectMocks;
24 import org.mockito.Mock;
25 import org.mockito.MockitoAnnotations;
26 import org.mockito.Spy;
27 import org.openecomp.sdc.common.errors.CoreException;
28 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
29 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
30 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
31 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
32 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
33 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
34 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
35 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
36 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
39 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
40 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
41 import org.openecomp.sdc.versioning.dao.types.Version;
42 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
44 import java.util.ArrayList;
45 import java.util.Arrays;
46 import java.util.Collection;
48 import static org.mockito.ArgumentMatchers.any;
49 import static org.mockito.Mockito.doReturn;
50 import static org.mockito.Mockito.never;
51 import static org.mockito.Mockito.verify;
53 public class NicManagerImplTest {
55 private static final String NIC_NOT_EXIST_MSG =
56 "Vendor Software Product NIC with Id nic1 does not exist for Vendor Software Product with " +
57 "id VSP_ID and version version_id";
59 private static final String VSP_ID = "VSP_ID";
60 private static final Version VERSION = new Version("version_id");
61 private static final String COMPONENT_ID = "COMPONENT_ID";
62 private static final String NIC1_ID = "nic1";
63 private static final String NIC2_ID = "nic2";
64 private static final String NETWORK1_ID = "network1";
65 private static final String NETWORK2_ID = "network2";
68 private NicDao nicDao;
70 private CompositionEntityDataManager compositionEntityDataManagerMock;
72 private NetworkManager networkManagerMock;
74 private VendorSoftwareProductInfoDao vspInfoDao;
77 private NicManagerImpl nicManager;
80 public void setUp() throws Exception {
81 MockitoAnnotations.openMocks(this);
85 public void tearDown() {
90 public void testListWhenNone() {
91 Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
92 Assert.assertEquals(nics.size(), 0);
96 public void testList() {
97 doReturn(Arrays.asList(
98 createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID),
99 createNic(VSP_ID, VERSION, COMPONENT_ID, NIC2_ID, NETWORK2_ID)))
100 .when(nicDao).list(any());
102 NetworkEntity network1 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK1_ID);
103 NetworkEntity network2 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK2_ID);
104 doReturn(Arrays.asList(network1, network2))
105 .when(networkManagerMock).listNetworks(VSP_ID, VERSION);
107 Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
108 Assert.assertEquals(nics.size(), 2);
109 for (NicEntity nic : nics) {
110 Assert.assertEquals(nic.getNicCompositionData().getNetworkName(),
111 NIC1_ID.equals(nic.getId())
112 ? network1.getNetworkCompositionData().getName()
113 : network2.getNetworkCompositionData().getName());
118 public void testCreate() {
119 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
120 Nic nic = nicEntity.getNicCompositionData();
121 nic.setNetworkType(NetworkType.Internal);
122 nicEntity.setNicCompositionData(nic);
123 doReturn(true).when(vspInfoDao).isManual(any(), any());
124 Collection<NicEntity> nicEntities = new ArrayList<>();
125 doReturn(nicEntities).when(nicDao).list(any());
126 doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
128 NicEntity created = nicManager.createNic(nicEntity);
129 Assert.assertNotNull(created);
133 public void testCreateWithIncorrectNicNameFormat() {
134 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
135 Nic nic = nicEntity.getNicCompositionData();
136 nic.setNetworkType(NetworkType.Internal);
137 nicEntity.setNicCompositionData(nic);
138 doReturn(true).when(vspInfoDao).isManual(any(), any());
139 Collection<NicEntity> nicEntities = new ArrayList<>();
141 NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
142 Nic newNameNic = nicEntityDiffName.getNicCompositionData();
143 newNameNic.setName(NIC1_ID + "_Name/*");
144 nicEntityDiffName.setNicCompositionData(newNameNic);
145 nicEntities.add(nicEntityDiffName);
146 doReturn(nicEntities).when(nicDao).list(any());
147 doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
150 NicEntity created = nicManager.createNic(nicEntity);
151 } catch (CoreException exception) {
152 Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
153 exception.code().id());
158 public void testCreateWithDupNicName() {
159 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
160 Nic nic = nicEntity.getNicCompositionData();
161 nic.setNetworkType(NetworkType.Internal);
162 nicEntity.setNicCompositionData(nic);
163 doReturn(true).when(vspInfoDao).isManual(any(), any());
164 Collection<NicEntity> nicEntities = new ArrayList<>();
166 NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
167 Nic newNameNic = nicEntityDiffName.getNicCompositionData();
168 newNameNic.setName(NIC1_ID + "_Name");
169 nicEntityDiffName.setNicCompositionData(newNameNic);
170 nicEntities.add(nicEntityDiffName);
171 doReturn(nicEntities).when(nicDao).list(any());
172 doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
175 NicEntity created = nicManager.createNic(nicEntity);
176 } catch (CoreException exception) {
177 Assert.assertEquals("Invalid request, NIC with name " + nic.getName() +
178 " already exist for component with ID " + nicEntity.getComponentId() + ".",
179 exception.code().message());
180 Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_NIC_NAME_NOT_ALLOWED,
181 exception.code().id());
186 public void testCreateWithExternalNetworkType() {
187 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
188 Nic nic = nicEntity.getNicCompositionData();
189 nic.setNetworkType(NetworkType.External);
190 nicEntity.setNicCompositionData(nic);
191 doReturn(true).when(vspInfoDao).isManual(any(), any());
192 Collection<NicEntity> nicEntities = new ArrayList<>();
193 doReturn(nicEntities).when(nicDao).list(any());
194 doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
197 NicEntity created = nicManager.createNic(nicEntity);
198 } catch (CoreException exception) {
199 Assert.assertEquals("Invalid request,NetworkId not allowed for External Networks",
200 exception.code().message());
202 .assertEquals(VendorSoftwareProductErrorCodes.NETWORKID_NOT_ALLOWED_FOR_EXTERNAL_NETWORK,
203 exception.code().id());
208 public void testCreateWithNetworkDesc() {
209 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
210 Nic nic = nicEntity.getNicCompositionData();
211 nic.setNetworkType(NetworkType.Internal);
212 nic.setNetworkDescription(NIC1_ID);
213 nicEntity.setNicCompositionData(nic);
214 doReturn(true).when(vspInfoDao).isManual(any(), any());
215 Collection<NicEntity> nicEntities = new ArrayList<>();
216 doReturn(nicEntities).when(nicDao).list(any());
217 doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(any());
220 NicEntity created = nicManager.createNic(nicEntity);
221 } catch (CoreException exception) {
222 Assert.assertEquals("Invalid request, Network Description not allowed for Internal Networks",
223 exception.code().message());
224 Assert.assertEquals(VendorSoftwareProductErrorCodes
225 .NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK, exception.code().id());
230 public void testDeleteNic() {
231 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
232 doReturn(true).when(vspInfoDao).isManual(any(), any());
233 doReturn(nicEntity).when(nicDao).get(any());
235 nicManager.deleteNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
240 public void testUpdateNicQuestionnaire() {
241 NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
243 doReturn(nicEntity).when(nicDao).get(any());
244 doReturn("{}").when(nicManager).getNicCompositionSchema(any());
247 .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
249 verify(nicDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
252 // @Test(dependsOnMethods = "testListWhenNone")
253 // public void testCreate() {
254 // NIC1_ID = testCreate(VSP_ID, COMPONENT_ID, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
257 /* @Test(dependsOnMethods = {"testCreate"})
258 public void testCreateWithExistingName_negative() {
259 NicEntity nic = new NicEntity(VSP_ID, null, COMPONENT_ID, null);
260 Nic nicData = new Nic();
261 nicData.setName("nic1 name");
262 nic.setNicCompositionData(nicData);
263 testCreate_negative(nic, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
266 // @Test(dependsOnMethods = {"testCreate"})
267 // public void testCreateWithExistingNameUnderOtherComponent() {
268 // ComponentEntity component12 = new ComponentEntity(VSP_ID, null, null);
269 // ComponentData compData12 = new ComponentData();
270 // compData12.setName("comp12 name");
271 // compData12.setDescription("comp12 desc");
272 // component12.setComponentCompositionData(compData12);
274 // String component12Id = nicManager.createComponent(component12).getId();
275 // testCreate(VSP_ID, component12Id, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
278 // @Test(dependsOnMethods = {"testCreate"})
279 // public void testCreateWithExistingNameUnderOtherVsp() {
280 // testCreate(vsp2Id, component21Id, network2.getId(), network2.getNetworkCompositionData().getName());
284 public void testCreateOnUploadVsp_negative() {
286 testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null),
287 VendorSoftwareProductErrorCodes.ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING);
291 public void testUpdateNonExistingNicId_negative() {
292 doReturn(null).when(nicDao).get(any());
294 testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
295 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
299 public void testUpdateOnUploadVsp() {
300 doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
301 .when(nicDao).get(any());
303 doReturn(new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID))
304 .when(compositionEntityDataManagerMock)
305 .validateEntity(any(), any(), any());
307 NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
308 Nic nicData = new Nic();
309 nicData.setName(NIC1_ID + " name");
310 nicData.setDescription(NIC1_ID + " desc updated");
311 nicData.setNetworkId(NETWORK1_ID);
312 nicEntity.setNicCompositionData(nicData);
314 CompositionEntityValidationData validationData =
315 nicManager.updateNic(nicEntity);
316 Assert.assertTrue(validationData == null || validationData.getErrors() == null);
317 verify(nicDao).update(nicEntity);
321 public void testIllegalUpdateOnUploadVsp() {
322 doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
323 .when(nicDao).get(any());
325 CompositionEntityValidationData toBeReturned =
326 new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
327 toBeReturned.setErrors(Arrays.asList("error1", "error2"));
328 doReturn(toBeReturned)
329 .when(compositionEntityDataManagerMock)
330 .validateEntity(any(), any(), any());
332 NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
333 Nic nicData = new Nic();
334 nicData.setName(NIC1_ID + "_name_updated");
335 nicData.setDescription(NIC1_ID + " desc updated");
336 nicData.setNetworkId(NETWORK1_ID);
337 nicEntity.setNicCompositionData(nicData);
339 CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity);
340 Assert.assertNotNull(validationData);
341 Assert.assertEquals(validationData.getErrors().size(), 2);
343 verify(nicDao, never()).update(nicEntity);
347 public void testUpdateIncorrectNameFormat() {
348 doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
349 .when(nicDao).get(any());
351 CompositionEntityValidationData toBeReturned =
352 new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
353 toBeReturned.setErrors(Arrays.asList("Field does not conform to predefined criteria:name : must match [a-zA-Z0-9_]*$"));
354 doReturn(toBeReturned)
355 .when(compositionEntityDataManagerMock)
356 .validateEntity(any(), any(), any());
357 doReturn(true).when(vspInfoDao).isManual(any(), any());
359 NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
360 Nic nicData = new Nic();
361 nicData.setName(NIC1_ID + "_name_updated/*");
362 nicData.setDescription(NIC1_ID + " desc updated");
363 nicData.setNetworkId(NETWORK1_ID);
364 nicEntity.setNicCompositionData(nicData);
366 CompositionEntityValidationData output = nicManager.updateNic(nicEntity);
367 Assert.assertEquals(output.getErrors(),toBeReturned.getErrors());
373 public void testGetNonExistingNicId_negative() {
374 testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id",
375 VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
380 public void testGet() {
381 NicEntity expected = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
382 doReturn(expected).when(nicDao).get(any());
383 String compositionSchema = "schema string";
384 doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(any());
386 CompositionEntityResponse<Nic> response =
387 nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
388 Assert.assertEquals(response.getId(), expected.getId());
389 Assert.assertEquals(response.getData(), expected.getNicCompositionData());
390 Assert.assertEquals(response.getSchema(), compositionSchema);
394 @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
395 public void testCreateWithRemovedName() {
396 testCreate(VSP_ID, COMPONENT_ID);
400 public void testDeleteNonExistingNicId_negative() {
401 testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
404 @Test(dependsOnMethods = "testList")
405 public void testDeleteNonExistingComponentId_negative() {
406 testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
410 @Test(dependsOnMethods = "testList")
411 public void testDelete() {
412 nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID);
413 NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
414 Assert.assertNull(actual);
418 public void testDeleteOnUploadVsp_negative() {
419 testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
420 VendorSoftwareProductErrorCodes.DELETE_NIC_NOT_ALLOWED);
423 @Test(expected = CoreException.class)
424 public void testGetNonExistingNicQuestionnaire() throws Exception {
425 nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
429 public void testGetQuestionnaire() throws Exception {
430 NicEntity nic = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
431 nic.setQuestionnaireData("{}");
432 doReturn(nic).when(nicDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
434 String schema = "schema string";
435 doReturn(schema).when(nicManager).getNicQuestionnaireSchema(any());
437 QuestionnaireResponse questionnaire =
438 nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
439 Assert.assertNotNull(questionnaire);
440 Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
441 Assert.assertEquals(questionnaire.getSchema(), schema);
442 Assert.assertNull(questionnaire.getErrorMessage());
445 @Test(expected = CoreException.class)
446 public void testUpdateNonExistingNicQuestionnaire() throws Exception {
447 doReturn(null).when(nicDao).get(any());
449 .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data");
453 public void testUpdateQuestionnaire() throws Exception {
457 private void testCreate_negative(NicEntity nic, String expectedErrorCode) {
459 nicManager.createNic(nic);
461 } catch (CoreException exception) {
462 Assert.assertEquals(exception.code().id(), expectedErrorCode);
466 private void testGet_negative(String vspId, Version version, String componentId, String nicId,
467 String expectedErrorCode) {
469 nicManager.getNic(vspId, version, componentId, nicId);
471 } catch (CoreException exception) {
472 Assert.assertEquals(exception.code().id(), expectedErrorCode);
476 private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
477 String expectedErrorCode) {
479 nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId));
481 } catch (CoreException exception) {
482 Assert.assertEquals(exception.code().id(), expectedErrorCode);
486 private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
487 String expectedErrorCode) {
489 nicManager.deleteNic(vspId, version, componentId, nicId);
491 } catch (CoreException exception) {
492 Assert.assertEquals(exception.code().id(), expectedErrorCode);
496 static NicEntity createNic(String vspId, Version version, String compId, String nicId,
498 NicEntity nicEntity = new NicEntity(vspId, version, compId, nicId);
499 Nic nicData = new Nic();
500 nicData.setName(nicId + "_name");
501 nicData.setDescription(nicId + " desc");
502 nicData.setNetworkId(networkId);
503 nicEntity.setNicCompositionData(nicData);