2 * Copyright (c) 2018 AT&T Intellectual Property.
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.
16 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
18 import static org.assertj.core.api.Assertions.assertThat;
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertFalse;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.assertNull;
23 import static org.junit.jupiter.api.Assertions.assertSame;
24 import static org.junit.jupiter.api.Assertions.assertThrows;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.mockito.ArgumentMatchers.any;
27 import static org.mockito.ArgumentMatchers.anyInt;
28 import static org.mockito.ArgumentMatchers.anyMap;
29 import static org.mockito.ArgumentMatchers.anyString;
30 import static org.mockito.ArgumentMatchers.eq;
31 import static org.mockito.Mockito.doReturn;
32 import static org.mockito.Mockito.times;
33 import static org.mockito.Mockito.verify;
34 import static org.mockito.Mockito.when;
36 import fj.data.Either;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.Collections;
40 import java.util.EnumMap;
41 import java.util.HashMap;
42 import java.util.HashSet;
43 import java.util.List;
46 import java.util.stream.Collectors;
47 import java.util.stream.IntStream;
48 import org.apache.commons.collections.map.HashedMap;
49 import org.apache.commons.lang3.tuple.ImmutablePair;
50 import org.junit.jupiter.api.BeforeEach;
51 import org.junit.jupiter.api.Test;
52 import org.junit.jupiter.api.extension.ExtendWith;
53 import org.mockito.ArgumentCaptor;
54 import org.mockito.ArgumentMatchers;
55 import org.mockito.InjectMocks;
56 import org.mockito.Mock;
57 import org.mockito.Mockito;
58 import org.mockito.MockitoAnnotations;
59 import org.mockito.junit.jupiter.MockitoExtension;
60 import org.openecomp.sdc.be.config.ComponentType;
61 import org.openecomp.sdc.be.dao.api.ActionStatus;
62 import org.openecomp.sdc.be.dao.api.exception.JanusGraphException;
63 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphDao;
64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
65 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
66 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
67 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
68 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
69 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
74 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
76 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
77 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
79 import org.openecomp.sdc.be.datatypes.enums.PromoteVersionEnum;
80 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
81 import org.openecomp.sdc.be.model.AttributeDefinition;
82 import org.openecomp.sdc.be.model.Component;
83 import org.openecomp.sdc.be.model.ComponentInstance;
84 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
85 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
86 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
87 import org.openecomp.sdc.be.model.ComponentParametersView;
88 import org.openecomp.sdc.be.model.DataTypeDefinition;
89 import org.openecomp.sdc.be.model.InputDefinition;
90 import org.openecomp.sdc.be.model.LifecycleStateEnum;
91 import org.openecomp.sdc.be.model.OutputDefinition;
92 import org.openecomp.sdc.be.model.PolicyDefinition;
93 import org.openecomp.sdc.be.model.PropertyDefinition;
94 import org.openecomp.sdc.be.model.Resource;
95 import org.openecomp.sdc.be.model.Service;
96 import org.openecomp.sdc.be.model.User;
97 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
98 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
99 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
100 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
101 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
102 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
103 import org.openecomp.sdc.be.model.operations.StorageException;
104 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
105 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
107 @ExtendWith(MockitoExtension.class)
108 class ToscaOperationFacadeTest {
110 private static final String COMPONENT_ID = "componentId";
111 private static final String PROPERTY1_NAME = "prop1";
112 private static final String PROPERTY1_TYPE = "string";
113 private static final String PROPERTY2_NAME = "prop2";
114 private static final String PROPERTY2_TYPE = "integer";
115 private static final String ICON_NAME = "icon";
116 private static final String SERVICE_MODEL_NAME = "Test_Service";
117 private static final String SERVICE_PROXY_INSTANCE0_NAME = "testservice_proxy0";
118 private static final String SERVICE_SUBSTITUTION_INSTANCE0_NAME = "testservice0";
121 private ToscaOperationFacade testInstance;
124 private HealingJanusGraphDao janusGraphDaoMock;
127 private TopologyTemplateOperation topologyTemplateOperationMock;
130 private NodeTypeOperation nodeTypeOperationMock;
133 private NodeTemplateOperation nodeTemplateOperationMock;
136 private IGraphLockOperation graphLockOperationMock;
139 void setUp() throws Exception {
140 testInstance = new ToscaOperationFacade();
141 MockitoAnnotations.openMocks(this);
144 @SuppressWarnings("unchecked")
146 void fetchMetaDataByResourceType() throws Exception {
147 ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
148 ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class);
149 ComponentParametersView dataFilter = new ComponentParametersView();
150 List<GraphVertex> mockVertices = getMockVertices(2);
151 Either<List<GraphVertex>, JanusGraphOperationStatus> returnedVertices = Either.left(mockVertices);
153 when(janusGraphDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata)))
154 .thenReturn(returnedVertices);
155 when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0")));
156 when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1")));
157 Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance
158 .fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter);
160 verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture);
161 verifyCriteriaNotIsDeleted(criteriaNotCapture);
163 assertTrue(fetchedComponents.isLeft());
164 List<Component> cmpts = fetchedComponents.left().value();
165 assertEquals(2, cmpts.size());
166 assertEquals("0", cmpts.get(0).getUniqueId());
167 assertEquals("1", cmpts.get(1).getUniqueId());
170 private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor<Map> criteriaCapture) {
171 Map<GraphPropertyEnum, Object> criteria = (Map<GraphPropertyEnum, Object>) criteriaCapture.getValue();
172 assertEquals(2, criteria.size());
173 assertEquals("VF", criteria.get(GraphPropertyEnum.RESOURCE_TYPE));
174 assertEquals(true, criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION));
177 private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) {
178 Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>) criteriaNotCapture.getValue();
179 assertEquals(1, notCriteria.size());
180 assertEquals(true, notCriteria.get(GraphPropertyEnum.IS_DELETED));
183 @SuppressWarnings("unchecked")
185 void fetchMetaDataByResourceType_failedToGetData() throws Exception {
186 when(janusGraphDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(
187 JanusGraphOperationStatus.GENERAL_ERROR));
188 Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance
189 .fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView());
190 assertTrue(fetchedComponents.isRight());
191 assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value());
195 void associatePolicyToComponentSuccessTest() {
196 Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK);
197 assertTrue(result.isLeft());
201 void associatePolicyToComponentFailureTest() {
202 Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
203 assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
207 void updatePolicyOfComponentSuccessTest() {
208 Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK);
209 assertTrue(result.isLeft());
213 void updatePolicyOfComponentFailureTest() {
214 Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND);
215 assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
219 void removePolicyFromComponentSuccessTest() {
220 removePolicyFromComponentWithStatus(StorageOperationStatus.OK);
224 void removePolicyFromComponentFailureTest() {
225 removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND);
229 void testFindLastCertifiedToscaElementByUUID() {
230 Either<Component, StorageOperationStatus> result;
231 Component component = new Resource();
232 List<GraphVertex> list = new ArrayList<>();
233 GraphVertex graphVertex = getTopologyTemplateVertex();
234 list.add(graphVertex);
235 Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
236 props.put(GraphPropertyEnum.UUID, component.getUUID());
237 props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
238 props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
239 ToscaElement toscaElement = getToscaElementForTest();
240 when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class)))
241 .thenReturn(Either.left(toscaElement));
242 when(janusGraphDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list));
243 result = testInstance.findLastCertifiedToscaElementByUUID(component);
244 Component resultComp = result.left().value();
245 assertEquals(resultComp.getToscaType(), ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue());
249 void testLatestComponentByToscaResourceName() {
250 Either<Component, StorageOperationStatus> result;
251 TopologyTemplate toscaElement = new TopologyTemplate();
252 toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
253 List<GraphVertex> list = new ArrayList<>();
254 GraphVertex graphVertex = getTopologyTemplateVertex();
255 Map<GraphPropertyEnum, Object> props = new HashMap<>();
256 props.put(GraphPropertyEnum.VERSION, "1.0");
257 graphVertex.setMetadataProperties(props);
258 list.add(graphVertex);
260 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
261 Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
262 propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName");
263 propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
264 propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
266 when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll, null))
267 .thenReturn(Either.left(list));
268 when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class)))
269 .thenReturn(Either.left(toscaElement));
271 result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName");
272 assertTrue(result.isLeft());
276 void testValidateCsarUuidUniqueness() {
277 StorageOperationStatus result;
278 String csarUUID = "csarUUID";
279 Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
280 properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
281 List<GraphVertex> vertexList = new ArrayList<>();
282 when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
283 result = testInstance.validateCsarUuidUniqueness(csarUUID);
284 assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result);
288 void testValidateCsarUuidUnique_true() {
289 StorageOperationStatus result;
290 String csarUUID = "csarUUID";
291 Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
292 properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
293 when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
294 JanusGraphOperationStatus.NOT_FOUND));
295 result = testInstance.validateCsarUuidUniqueness(csarUUID);
296 assertEquals(StorageOperationStatus.OK, result);
300 void testGetLatestCertiNodeTypeByToscaResourceName() {
301 Either<Resource, StorageOperationStatus> result;
302 String toscaResourceName = "resourceName";
303 String uniqueId = "uniqueId";
304 GraphVertex graphVertex = getTopologyTemplateVertex();
305 graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0");
306 graphVertex.setUniqueId(uniqueId);
307 List<GraphVertex> vertexList = new ArrayList<>();
308 vertexList.add(graphVertex);
309 Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
310 props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
311 props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
312 props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
313 ToscaElement topologyTemplate = new TopologyTemplate();
314 topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
315 when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
316 when(janusGraphDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
317 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
318 .thenReturn(Either.left(topologyTemplate));
319 result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName);
320 assertTrue(result.isLeft());
324 void testValidateCompExists() {
325 Either<Boolean, StorageOperationStatus> result;
326 String componentId = "componentId";
327 GraphVertex graphVertex = getTopologyTemplateVertex();
328 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
329 result = testInstance.validateComponentExists(componentId);
330 assertEquals(true, result.left().value());
334 void testValidateCompExists_NotFound() {
335 Either<Boolean, StorageOperationStatus> result;
336 String componentId = "componentId";
337 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
338 JanusGraphOperationStatus.NOT_FOUND));
339 result = testInstance.validateComponentExists(componentId);
340 assertEquals(false, result.left().value());
344 void testValidateToscaResourceNameExists() {
345 Either<Boolean, StorageOperationStatus> result;
346 String templateName = "templateName";
347 Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
348 properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
349 List<GraphVertex> graphVertexList = new ArrayList<>();
350 GraphVertex graphVertex = getTopologyTemplateVertex();
351 graphVertexList.add(graphVertex);
352 when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
353 result = testInstance.validateToscaResourceNameExists(templateName);
354 assertEquals(true, result.left().value());
358 void testValidateToscaResourceNameExists_false() {
359 Either<Boolean, StorageOperationStatus> result;
360 String templateName = "templateName";
361 Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
362 properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
363 List<GraphVertex> graphVertexList = new ArrayList<>();
364 GraphVertex graphVertex = getTopologyTemplateVertex();
365 graphVertexList.add(graphVertex);
366 when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
367 JanusGraphOperationStatus.NOT_FOUND));
368 result = testInstance.validateToscaResourceNameExists(templateName);
369 assertEquals(false, result.left().value());
373 void testOverrideComponent() {
374 Either<Resource, StorageOperationStatus> result;
375 Resource resource = new Resource();
377 resource.setUniqueId(id);
378 GraphVertex graphVertex = getTopologyTemplateVertex();
379 graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
380 NodeType nodeType = new NodeType();
381 nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
382 ToscaElement toscaElement = new TopologyTemplate();
383 toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
384 when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
385 when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
386 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
387 when(nodeTypeOperationMock.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
388 when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
389 when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(
390 JanusGraphOperationStatus.OK);
391 result = testInstance.overrideComponent(resource, resource);
392 assertTrue(result.isLeft());
396 void testGetToscaElement() {
397 Either<Component, StorageOperationStatus> result;
399 GraphVertex graphVertex = getTopologyTemplateVertex();
400 ToscaElement toscaElement = getToscaElementForTest();
401 when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
402 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
403 .thenReturn(Either.left(toscaElement));
404 result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll);
405 assertTrue(result.isLeft());
409 void testDeleteService_ServiceInUse() {
410 String invariantUUID = "12345";
411 String serviceUid = "1";
412 GraphVertex service1 = getTopologyTemplateVertex();
413 service1.setUniqueId(serviceUid);
414 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
415 allResourcesToDelete.add(service1);
416 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
417 propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
418 ToscaElement toscaElement = getToscaElementForTest();
419 toscaElement.setUniqueId(serviceUid);
420 String service2Name = "service2Name";
421 Map<String, Object> service2MetadataJson = new HashMap<>();
422 service2MetadataJson.put(GraphPropertyEnum.COMPONENT_TYPE.getProperty(), ComponentType.SERVICE);
423 service2MetadataJson.put(GraphPropertyEnum.NAME.getProperty(), service2Name);
424 String service2Uid = "2";
425 GraphVertex usingService = getTopologyTemplateVertex();
426 usingService.setUniqueId(service2Uid);
427 usingService.setMetadataJson(service2MetadataJson);
428 List<GraphVertex> inUseBy = new ArrayList<>();
429 inUseBy.add(usingService);
431 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
432 thenReturn(allResourcesToDelete);
433 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), eq(JsonParseFlagEnum.ParseAll))).
434 thenReturn(Either.left(inUseBy)).thenReturn(Either.left(inUseBy));
435 final OperationException actualException = assertThrows(OperationException.class, () -> testInstance.deleteService(invariantUUID, true));
436 assertEquals(ActionStatus.COMPONENT_IN_USE_BY_ANOTHER_COMPONENT, actualException.getActionStatus());
437 assertEquals(actualException.getParams()[0], ComponentType.SERVICE + " " + service2Name);
441 void testDeleteService_WithOneVersion() {
442 String invariantUUID = "12345";
443 String serviceUid = "1";
444 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
445 propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
446 GraphVertex service1 = getTopologyTemplateVertex();
447 service1.setUniqueId(serviceUid);
448 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
449 allResourcesToDelete.add(service1);
450 ToscaElement toscaElement = getToscaElementForTest();
451 toscaElement.setUniqueId(serviceUid);
452 List<String> affectedComponentIds = new ArrayList<>();
453 affectedComponentIds.add(service1.getUniqueId());
455 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
456 thenReturn(allResourcesToDelete);
457 when(janusGraphDaoMock.getParentVertices(eq(service1), any(), eq(JsonParseFlagEnum.ParseAll))).
458 thenReturn(Either.right(JanusGraphOperationStatus.OK));
459 when(graphLockOperationMock.lockComponent(service1.getUniqueId(), NodeTypeEnum.Service)).
460 thenReturn(StorageOperationStatus.OK);
461 when(topologyTemplateOperationMock.deleteToscaElement(service1)).thenReturn(Either.left(toscaElement));
462 assertEquals(affectedComponentIds, testInstance.deleteService(invariantUUID, true));
466 void testDeleteService_WithTwoVersions() {
467 String invariantUUID = "12345";
468 String serviceUid = "1";
469 String service2Uid = "2";
470 GraphVertex service = getTopologyTemplateVertex();
471 service.setUniqueId(serviceUid);
472 GraphVertex serviceV2 = getTopologyTemplateVertex();
473 serviceV2.setUniqueId(service2Uid);
474 ToscaElement toscaElement = getToscaElementForTest();
475 toscaElement.setUniqueId(serviceUid);
476 ToscaElement toscaElement2 = getToscaElementForTest();
477 toscaElement2.setUniqueId(service2Uid);
478 List<String> affectedComponentIds = new ArrayList<>();
479 affectedComponentIds.add(service.getUniqueId());
480 affectedComponentIds.add(serviceV2.getUniqueId());
481 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
482 allResourcesToDelete.add(service);
483 allResourcesToDelete.add(serviceV2);
484 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
485 propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
487 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
488 thenReturn(allResourcesToDelete);
489 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), eq(JsonParseFlagEnum.ParseAll))).
490 thenReturn(Either.right(JanusGraphOperationStatus.OK));
491 when(graphLockOperationMock.lockComponent(service.getUniqueId(), NodeTypeEnum.Service)).
492 thenReturn(StorageOperationStatus.OK);
493 when(graphLockOperationMock.lockComponent(serviceV2.getUniqueId(), NodeTypeEnum.Service)).
494 thenReturn(StorageOperationStatus.OK);
495 when(topologyTemplateOperationMock.deleteToscaElement(service)).thenReturn(Either.left(toscaElement));
496 when(topologyTemplateOperationMock.deleteToscaElement(serviceV2)).thenReturn(Either.left(toscaElement));
497 assertEquals(affectedComponentIds, testInstance.deleteService(invariantUUID, true));
501 void testDeleteService_FailDelete() {
502 String invariantUUID = "12345";
503 String serviceUid = "1";
504 GraphVertex service = getTopologyTemplateVertex();
505 service.setUniqueId(serviceUid);
506 ToscaElement toscaElement = getToscaElementForTest();
507 toscaElement.setUniqueId(serviceUid);
508 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
509 allResourcesToDelete.add(service);
511 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
512 thenReturn(allResourcesToDelete);
513 when(janusGraphDaoMock.getParentVertices(eq(service), any(), eq(JsonParseFlagEnum.ParseAll))).
514 thenReturn(Either.right(JanusGraphOperationStatus.OK));
515 when(graphLockOperationMock.lockComponent(service.getUniqueId(), NodeTypeEnum.Service)).
516 thenReturn(StorageOperationStatus.OK);
517 when(topologyTemplateOperationMock.deleteToscaElement(service))
518 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
519 StorageException actualException = assertThrows(StorageException.class, () -> testInstance.deleteService(invariantUUID, false));
520 assertEquals(StorageOperationStatus.NOT_FOUND, actualException.getStorageOperationStatus());
521 assertEquals(0, actualException.getParams().length);
525 void testDeleteService_NotFound() {
526 String invariantUUID = "12345";
527 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
528 thenReturn(Collections.emptyList());
529 assertEquals(0, testInstance.deleteService(invariantUUID, true).size());
533 void testDeleteService_GeneralErrorInJanusGraphDao() {
534 String invariantUUID = "12345";
535 JanusGraphException janusException = new JanusGraphException(JanusGraphOperationStatus.GENERAL_ERROR, "General error");
536 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).
537 thenThrow(janusException);
539 StorageException actualException = assertThrows(StorageException.class, () -> testInstance.deleteService(invariantUUID, false));
540 assertEquals(StorageOperationStatus.GENERAL_ERROR, actualException.getStorageOperationStatus());
541 assertEquals(0, actualException.getParams().length);
545 void testMarkComponentToDelete() {
546 StorageOperationStatus result;
547 Component component = new Resource();
549 component.setUniqueId(id);
550 GraphVertex graphVertex = getTopologyTemplateVertex();
551 when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
552 when(nodeTypeOperationMock.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
553 result = testInstance.markComponentToDelete(component);
554 assertEquals(StorageOperationStatus.OK, result);
558 void testDelToscaComponent() {
559 Either<Component, StorageOperationStatus> result;
560 String componentId = "compId";
561 GraphVertex graphVertex = getTopologyTemplateVertex();
562 ToscaElement toscaElement = getToscaElementForTest();
563 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
564 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
565 result = testInstance.deleteToscaComponent(componentId);
566 assertTrue(result.isLeft());
570 void testGetLatestByToscaResourceName() {
571 Either<Component, StorageOperationStatus> result;
572 String toscaResourceName = "name";
573 String model = "testModel";
574 ToscaElement toscaElement = getToscaElementForTest();
576 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
577 propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
578 propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
579 Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
580 propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
582 List<GraphVertex> graphVertexList = new ArrayList<>();
583 GraphVertex graphVertex = getTopologyTemplateVertex();
584 graphVertex.setUniqueId(toscaResourceName);
585 Map<GraphPropertyEnum, Object> props = new HashMap<>();
586 props.put(GraphPropertyEnum.VERSION, "1.0");
587 graphVertex.setMetadataProperties(props);
588 graphVertexList.add(graphVertex);
590 when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata, model))
591 .thenReturn(Either.left(graphVertexList));
592 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
593 .thenReturn(Either.left(toscaElement));
594 result = testInstance.getLatestByToscaResourceName(toscaResourceName, model);
595 assertTrue(result.isLeft());
600 void testGetLatestResourceByToscaResourceName() {
601 Either<Resource, StorageOperationStatus> result;
602 String toscaResourceName = "org.openecomp.resource.vf";
603 ToscaElement toscaElement = getToscaElementForTest();
605 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
606 propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
607 propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
608 if (!toscaResourceName.contains("org.openecomp.resource.vf")) {
609 propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
612 List<GraphVertex> graphVertexList = new ArrayList<>();
613 GraphVertex graphVertex = getTopologyTemplateVertex();
614 graphVertex.setUniqueId(toscaResourceName);
615 Map<JsonPresentationFields, Object> props = new HashMap<>();
616 props.put(JsonPresentationFields.VERSION, "1.0");
617 graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, props.get(JsonPresentationFields.VERSION));
618 graphVertexList.add(graphVertex);
620 when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, JsonParseFlagEnum.ParseMetadata))
621 .thenReturn(Either.left(graphVertexList));
622 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
623 .thenReturn(Either.left(toscaElement));
625 when(janusGraphDaoMock.getVertexById(toscaResourceName, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
627 result = testInstance.getLatestResourceByToscaResourceName(toscaResourceName);
628 assertTrue(result.isLeft());
632 void testGetFollowed() {
633 Either<Set<Component>, StorageOperationStatus> result;
634 String userId = "id";
635 Set<LifecycleStateEnum> lifecycleStates = new HashSet<>();
636 Set<LifecycleStateEnum> lastStateStates = new HashSet<>();
637 lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
638 lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
639 lifecycleStates.add(LifecycleStateEnum.CERTIFIED);
640 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
641 List<ToscaElement> toscaEleList = new ArrayList<>();
642 ToscaElement toscaElement = getToscaElementForTest();
643 toscaEleList.add(toscaElement);
644 when(nodeTypeOperationMock.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType))
645 .thenReturn(Either.left(toscaEleList));
646 result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType);
647 assertTrue(result.isLeft());
648 assertEquals(1, result.left().value().size());
652 void testGetBySystemNameAndVersion() {
653 Either<Component, StorageOperationStatus> result;
654 String sysName = "sysName";
655 String version = "version";
656 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
657 ToscaElement toscaElement = getToscaElementForTest();
658 List<GraphVertex> componentVertices = new ArrayList<>();
659 GraphVertex graphVertex = getTopologyTemplateVertex();
660 componentVertices.add(graphVertex);
661 Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
662 Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
664 propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName);
665 propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name());
666 propertiesToMatch.put(GraphPropertyEnum.VERSION, version);
668 propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
670 when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll))
671 .thenReturn(Either.left(componentVertices));
672 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
673 .thenReturn(Either.left(toscaElement));
674 result = testInstance.getBySystemNameAndVersion(componentTypeEnum, sysName, version);
675 assertTrue(result.isLeft());
676 assertNotNull(result.left().value());
680 void testGetCompByNameAndVersion() {
681 Either<Component, StorageOperationStatus> result;
682 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
683 String name = "name";
684 String version = "1.0";
685 JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll;
686 List<GraphVertex> graphVertexList = new ArrayList<>();
687 GraphVertex graphVertex = getTopologyTemplateVertex();
688 graphVertexList.add(graphVertex);
689 ToscaElement toscaElement = getToscaElementForTest();
690 Map<GraphPropertyEnum, Object> hasProperties = new EnumMap<>(GraphPropertyEnum.class);
691 Map<GraphPropertyEnum, Object> hasNotProperties = new EnumMap<>(GraphPropertyEnum.class);
693 hasProperties.put(GraphPropertyEnum.NAME, name);
694 hasProperties.put(GraphPropertyEnum.VERSION, version);
695 hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true);
696 hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name());
697 when(janusGraphDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList));
698 when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
699 .thenReturn(Either.left(toscaElement));
700 result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag);
701 assertTrue(result.isLeft());
704 private ToscaElement getToscaElementForTest() {
705 ToscaElement toscaElement = new TopologyTemplate();
706 toscaElement.setComponentType(ComponentTypeEnum.RESOURCE);
711 void addDataTypesToComponentSuccessTest() {
712 Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK);
713 assertTrue(result.isLeft());
717 void addDataTypesToComponentFailureTest_BadRequest() {
718 Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
719 assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
722 private Either<List<DataTypeDefinition>, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) {
723 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
724 String componentId = "componentid";
727 PropertyDefinition noDefaultProp = new PropertyDefinition();
728 noDefaultProp.setName("noDefaultProp");
729 PropertyDefinition prop1 = new PropertyDefinition();
730 prop1.setDefaultValue("def1");
731 prop1.setName("prop1");
732 PropertyDefinition prop2 = new PropertyDefinition();
733 prop2.setType("dataType1");
734 prop2.setName("prop2");
735 PropertyDefinition prop3 = new PropertyDefinition();
736 prop3.setDefaultValue("def3");
737 prop3.setName("prop3");
739 DataTypeDefinition noDefaultValue = new DataTypeDefinition();
740 noDefaultValue.setProperties(Collections.singletonList(noDefaultProp));
741 noDefaultValue.setDerivedFromName("name0");
743 DataTypeDefinition dataType1 = new DataTypeDefinition();
744 dataType1.setProperties(Arrays.asList(prop1, prop3));
745 dataType1.setName("name1");
746 dataType1.setDerivedFromName("derivedfromname1");
748 DataTypeDefinition dataType2 = new DataTypeDefinition();
749 dataType2.setDerivedFrom(dataType1);
750 dataType2.setName("name2");
751 dataType2.setDerivedFromName("derivedfromname2");
753 DataTypeDefinition dataType3 = new DataTypeDefinition();
754 dataType3.setProperties(Collections.singletonList(prop2));
755 dataType3.setDerivedFrom(noDefaultValue);
756 dataType3.setName("name3");
757 dataType3.setDerivedFromName("derivedfromname3");
759 dataTypes.put("noDefault", noDefaultValue);
760 dataTypes.put("dataType1", dataType1);
761 dataTypes.put("dataType2", dataType2);
762 dataTypes.put("dataType3", dataType3);
765 if (status == StorageOperationStatus.OK) {
766 vertex = getTopologyTemplateVertex();
768 vertex = getNodeTypeVertex();
770 Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
771 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
772 when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex),
773 eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status);
774 return testInstance.addDataTypesToComponent(dataTypes, componentId);
778 void testDataTypesToComponentFailureTest_NotFound() {
779 Either<List<DataTypeDefinition>, StorageOperationStatus> result;
780 String componentId = "componentId";
781 GraphVertex vertex = getNodeTypeVertex();
782 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
783 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
784 JanusGraphOperationStatus.NOT_FOUND));
785 result = testInstance.addDataTypesToComponent(dataTypes, componentId);
786 assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
790 void testDeleteDataTypeOfComponent() {
791 Component component = new Resource();
793 component.setUniqueId(id);
795 DataTypeDefinition dataType1 = new DataTypeDefinition();
796 dataType1.setName("name1");
797 Map<String, DataTypeDataDefinition> dataTypeDataMap = new HashMap<>();
798 dataTypeDataMap.put("datatype1", dataType1);
799 List<DataTypeDefinition> dataTypeMap = dataTypeDataMap.values().stream().map(e -> {
800 return new DataTypeDefinition(e);
801 }).collect(Collectors.toList());
802 component.setDataTypes(dataTypeMap);
803 GraphVertex graphVertex = getTopologyTemplateVertex();
804 assertNull(testInstance.deleteDataTypeOfComponent(component, "datatype1"));
808 void testAddComponentInstancePropertiesToComponent() {
809 // set up component object
810 Component component = new Resource();
811 component.setUniqueId(COMPONENT_ID);
812 List<ComponentInstanceProperty> instanceProps = new ArrayList<>();
813 ComponentInstanceProperty instanceProp = new ComponentInstanceProperty();
814 instanceProp.setName(PROPERTY1_NAME);
815 instanceProp.setType(PROPERTY1_TYPE);
816 instanceProps.add(instanceProp);
817 instanceProp = new ComponentInstanceProperty();
818 instanceProp.setName(PROPERTY2_NAME);
819 instanceProp.setType(PROPERTY2_TYPE);
820 instanceProps.add(instanceProp);
821 Map<String, List<ComponentInstanceProperty>> instancePropsMap =
822 Collections.singletonMap(COMPONENT_ID, instanceProps);
823 component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>()));
825 when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any()))
826 .thenReturn(StorageOperationStatus.OK);
828 Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> result =
829 testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap);
830 assertTrue(result.isLeft());
831 verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any());
832 List<ComponentInstanceProperty> resultProps = result.left().value().get(COMPONENT_ID);
833 assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME)));
834 assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME)));
838 void testAddComponentInstanceToTopologyTemplate_ServiceProxy() {
839 Component containerComponent = new Service();
840 Component originalComponent = new Service();
841 ComponentInstance componentInstance = new ComponentInstance();
842 ComponentInstance existingComponentInstance = new ComponentInstance();
843 User user = new User();
845 containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
847 originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
848 originalComponent.setIcon(ICON_NAME);
850 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
851 componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
853 List<ComponentInstance> existingInstances = new ArrayList<>();
854 existingComponentInstance.setNormalizedName(SERVICE_PROXY_INSTANCE0_NAME);
855 existingInstances.add(existingComponentInstance);
856 containerComponent.setComponentInstances(existingInstances);
858 when(nodeTemplateOperationMock
859 .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
860 .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
861 TopologyTemplate topologyTemplate = new TopologyTemplate();
862 // preset COMPONENT_TYPE field for internal ModelConverter call
863 topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
864 when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
865 .thenReturn(Either.left(topologyTemplate));
867 Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
868 testInstance.addComponentInstanceToTopologyTemplate(
869 containerComponent, originalComponent, componentInstance, false, user);
871 assertTrue(result.isLeft());
872 assertEquals(ICON_NAME, componentInstance.getIcon());
873 assertEquals(COMPONENT_ID, result.left().value().getRight());
874 // the instance counter must be 1 because the service proxy instance with suffix 0 already exists.
875 verify(nodeTemplateOperationMock, times(1))
876 .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
880 void testAddComponentInstanceToTopologyTemplate_ServiceSubstitution() {
881 Component containerComponent = new Service();
882 Component originalComponent = new Service();
883 ComponentInstance componentInstance = new ComponentInstance();
884 ComponentInstance existingComponentInstance = new ComponentInstance();
885 User user = new User();
887 containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
889 originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
890 originalComponent.setIcon(ICON_NAME);
892 componentInstance.setOriginType(OriginTypeEnum.ServiceSubstitution);
893 componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
895 List<ComponentInstance> existingInstances = new ArrayList<>();
896 existingComponentInstance.setNormalizedName(SERVICE_SUBSTITUTION_INSTANCE0_NAME);
897 existingInstances.add(existingComponentInstance);
898 containerComponent.setComponentInstances(existingInstances);
900 when(nodeTemplateOperationMock
901 .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
902 .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
903 TopologyTemplate topologyTemplate = new TopologyTemplate();
904 topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
905 when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
906 .thenReturn(Either.left(topologyTemplate));
908 Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
909 testInstance.addComponentInstanceToTopologyTemplate(
910 containerComponent, originalComponent, componentInstance, false, user);
912 assertTrue(result.isLeft());
913 assertEquals(ICON_NAME, componentInstance.getIcon());
914 assertEquals(COMPONENT_ID, result.left().value().getRight());
915 verify(nodeTemplateOperationMock, times(1))
916 .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
920 void testUpdateComponentInstanceRequirement() {
921 String containerComponentId = "containerComponentId";
922 String componentInstanceUniqueId = "componentInstanceUniqueId";
923 RequirementDataDefinition requirementDataDefinition = Mockito.mock(RequirementDataDefinition.class);
925 when(nodeTemplateOperationMock.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition))
926 .thenReturn(StorageOperationStatus.OK);
927 StorageOperationStatus result = testInstance
928 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
929 assertEquals(StorageOperationStatus.OK, result);
930 verify(nodeTemplateOperationMock, times(1))
931 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
936 void associateCapabilitiesToServiceFailureTest() {
937 StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
938 assertSame(StorageOperationStatus.BAD_REQUEST, result);
942 void associateCapabilitiesToServiceSuccessTest() {
943 StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.OK);
944 assertSame(StorageOperationStatus.OK, result);
947 private StorageOperationStatus associateCapabilitiesToServiceWithStatus(StorageOperationStatus status) {
948 Map<String, ListCapabilityDataDefinition> capabilitiesMap = new HashedMap();
949 String componentId = "componentid";
951 ListCapabilityDataDefinition listCapabilityDataDefinition1 = new ListCapabilityDataDefinition();
952 capabilitiesMap.put("capabilities1", listCapabilityDataDefinition1);
955 if (status == StorageOperationStatus.OK) {
956 vertex = getTopologyTemplateVertex();
958 vertex = getNodeTypeVertex();
961 Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
962 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
963 when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
964 eq(VertexTypeEnum.CAPABILITIES), eq(EdgeLabelEnum.CAPABILITIES), anyMap())).thenReturn(Either.right(status));
965 return testInstance.associateCapabilitiesToService(capabilitiesMap, componentId);
969 void associateRequirementsToServiceFailureTest() {
970 StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
971 assertSame(StorageOperationStatus.BAD_REQUEST, result);
975 void associateRequirementsToServiceSuccessTest() {
976 StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.OK);
977 assertSame(StorageOperationStatus.OK, result);
981 void test_addOutputsToComponent() {
982 final GraphVertex graphVertex = getTopologyTemplateVertex();
984 doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse);
985 doReturn(StorageOperationStatus.OK).when(topologyTemplateOperationMock)
986 .addToscaDataToToscaElement(
987 any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
989 final Map<String, OutputDefinition> outputs = new HashMap<>();
990 final OutputDefinition outputDefinition = new OutputDefinition();
991 outputs.put("mock", outputDefinition);
992 final Either<List<OutputDefinition>, StorageOperationStatus> result = testInstance.addOutputsToComponent(outputs, COMPONENT_ID);
993 assertNotNull(result);
994 assertTrue(result.isLeft());
995 assertFalse(result.left().value().isEmpty());
996 assertThat(result.left().value().get(0)).isInstanceOf(OutputDefinition.class);
997 verify(janusGraphDaoMock, times(1)).getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse);
998 verify(topologyTemplateOperationMock, times(1)).addToscaDataToToscaElement(
999 any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
1003 void test_addComponentInstanceOutputsToComponent_updateComponentInstanceOutput() {
1004 final Component component = new Resource();
1005 component.setUniqueId(COMPONENT_ID);
1006 final Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
1007 final List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
1008 final ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
1009 componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
1010 componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
1011 componentInstanceOutput.setName(COMPONENT_ID);
1012 componentInstanceOutputList.add(componentInstanceOutput);
1013 map.put("mock", componentInstanceOutputList);
1014 component.setComponentInstancesOutputs(map);
1016 doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
1017 .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
1019 final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result
1020 = testInstance.addComponentInstanceOutputsToComponent(component, map);
1021 assertNotNull(result);
1022 assertTrue(result.isLeft());
1023 assertFalse(result.left().value().isEmpty());
1024 assertSame(result.left().value(), map);
1025 verify(nodeTemplateOperationMock, times(1))
1026 .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
1031 void test_addComponentInstanceOutputsToComponent_addComponentInstanceOutput() {
1032 final Component component = new Resource();
1033 component.setUniqueId(COMPONENT_ID);
1034 Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
1035 List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
1036 ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
1037 componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
1038 componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
1039 componentInstanceOutput.setName(COMPONENT_ID);
1040 componentInstanceOutputList.add(componentInstanceOutput);
1041 map.put("mock", componentInstanceOutputList);
1042 component.setComponentInstancesOutputs(map);
1044 map = new HashMap<>();
1045 componentInstanceOutputList = new ArrayList<>();
1046 componentInstanceOutput = new ComponentInstanceOutput();
1047 componentInstanceOutput.setComponentInstanceId("mock");
1048 componentInstanceOutput.setComponentInstanceName("mock");
1049 componentInstanceOutput.setName("mock");
1050 componentInstanceOutputList.add(componentInstanceOutput);
1051 map.put("mock", componentInstanceOutputList);
1053 final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result = testInstance
1054 .addComponentInstanceOutputsToComponent(component, map);
1055 assertNotNull(result);
1056 assertTrue(result.isRight());
1060 void test_addComponentInstanceAttributesToComponent() {
1061 final Component component = new Resource();
1062 component.setUniqueId(COMPONENT_ID);
1063 Map<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
1064 List<ComponentInstanceAttribute> componentInstanceOutputList = new ArrayList<>();
1065 ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
1066 componentInstanceAttribute.setComponentInstanceId(COMPONENT_ID);
1067 componentInstanceAttribute.setUniqueId(COMPONENT_ID);
1068 componentInstanceOutputList.add(componentInstanceAttribute);
1069 map.put("mock", componentInstanceOutputList);
1070 component.setComponentInstancesAttributes(map);
1072 doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
1073 .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
1075 final Either<Map<String, List<ComponentInstanceAttribute>>, StorageOperationStatus> result
1076 = testInstance.addComponentInstanceAttributesToComponent(component, map);
1078 assertNotNull(result);
1079 assertTrue(result.isLeft());
1080 assertFalse(result.left().value().isEmpty());
1081 assertSame(result.left().value(), map);
1082 verify(nodeTemplateOperationMock, times(1))
1083 .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
1087 void test_updateAttributeOfComponent_success() {
1088 final GraphVertex graphVertex = getTopologyTemplateVertex();
1089 final String componentId = "componentId";
1090 final Component component = new Resource();
1091 component.setUniqueId(COMPONENT_ID);
1092 doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
1093 anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
1094 eq(JsonPresentationFields.NAME));
1095 doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
1097 final ToscaElement toscaElement = getToscaElementForTest();
1098 final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
1099 final AttributeDefinition attributeDefinition = new AttributeDefinition();
1100 attributeDefinition.setName("mock");
1101 attributes.put("mock", attributeDefinition);
1102 toscaElement.setAttributes(attributes);
1103 doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
1104 .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
1106 final Either<AttributeDefinition, StorageOperationStatus> result
1107 = testInstance.updateAttributeOfComponent(component, attributeDefinition);
1108 assertNotNull(result);
1112 void test_updateAttributeOfComponent_isNotPresent() {
1113 final GraphVertex graphVertex = getTopologyTemplateVertex();
1114 final String componentId = "componentId";
1115 final Component component = new Resource();
1116 component.setUniqueId(COMPONENT_ID);
1117 doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
1118 anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
1119 eq(JsonPresentationFields.NAME));
1120 doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
1122 final ToscaElement toscaElement = getToscaElementForTest();
1123 final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
1124 final AttributeDefinition attributeDefinition = new AttributeDefinition();
1125 attributeDefinition.setName("mock");
1126 attributes.put("mock", attributeDefinition);
1127 toscaElement.setAttributes(attributes);
1128 doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
1129 .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
1131 final AttributeDefinition attributeDefinitionOneMore = new AttributeDefinition();
1132 attributeDefinitionOneMore.setName("Anothermock");
1134 final Either<AttributeDefinition, StorageOperationStatus> result
1135 = testInstance.updateAttributeOfComponent(component, attributeDefinitionOneMore);
1136 assertNotNull(result);
1140 void test_updateComponentInstanceAttributes() {
1141 final GraphVertex graphVertex = getTopologyTemplateVertex();
1142 final String componentId = "componentId";
1143 final Component component = new Resource();
1144 component.setUniqueId(COMPONENT_ID);
1146 final List<ComponentInstanceAttribute> attributes = new ArrayList<>();
1147 final ComponentInstanceAttribute attributeDefinition = new ComponentInstanceAttribute();
1148 attributeDefinition.setName("mock");
1149 attributes.add(attributeDefinition);
1151 doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceAttributes(component, componentId, attributes);
1153 final StorageOperationStatus result = testInstance.updateComponentInstanceAttributes(component, componentId, attributes);
1154 assertNotNull(result);
1155 assertEquals(StorageOperationStatus.OK, result);
1156 verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceAttributes(component, componentId, attributes);
1160 void test_updateComponentInstanceOutputs() {
1161 final GraphVertex graphVertex = getTopologyTemplateVertex();
1162 final String componentId = "componentId";
1163 final Component component = new Resource();
1164 component.setUniqueId(COMPONENT_ID);
1166 final List<ComponentInstanceOutput> list = new ArrayList<>();
1167 final ComponentInstanceOutput output = new ComponentInstanceOutput();
1168 output.setName("mock");
1171 doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceOutputs(component, componentId, list);
1173 final StorageOperationStatus result = testInstance.updateComponentInstanceOutputs(component, componentId, list);
1174 assertNotNull(result);
1175 assertEquals(StorageOperationStatus.OK, result);
1176 verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceOutputs(component, componentId, list);
1180 void test_deleteOutputOfResource() {
1181 final Component component = new Resource();
1182 component.setUniqueId(COMPONENT_ID);
1184 doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock)
1185 .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
1187 final StorageOperationStatus result = testInstance.deleteOutputOfResource(component, "mock");
1188 assertNotNull(result);
1189 assertEquals(StorageOperationStatus.OK, result);
1190 verify(nodeTypeOperationMock, times(1))
1191 .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
1195 void testDeleteResource_ResourceInUse() {
1196 GraphVertex graphVertex = getTopologyTemplateVertex();
1197 String invariantUuid = "1";
1198 graphVertex.setUniqueId(invariantUuid);
1199 GraphVertex usingComponent = getTopologyTemplateVertex();
1200 usingComponent.setUniqueId("2");
1201 Map<String, Object> metadataJson = new HashMap<>();
1202 metadataJson.put("COMPONENT_TYPE", "SERVICE");
1203 metadataJson.put("NAME", "serviceName");
1204 usingComponent.setMetadataJson(metadataJson);
1205 List<GraphVertex> inUseBy = new ArrayList<>();
1206 inUseBy.add(usingComponent);
1207 Map<String, Object> metadata = new HashMap<>();
1208 metadata.put("ex1", new Object());
1209 graphVertex.setMetadataJson(metadata);
1210 ToscaElement toscaElement = getToscaElementForTest();
1211 toscaElement.setUniqueId(invariantUuid);
1212 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
1213 allResourcesToDelete.add(graphVertex);
1215 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUuid, Collections.emptyMap())).
1216 thenReturn(allResourcesToDelete);
1217 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), eq(JsonParseFlagEnum.ParseAll))).thenReturn(Either.left(inUseBy));
1219 final OperationException actualException = assertThrows(OperationException.class,
1220 () -> testInstance.deleteComponent(invariantUuid, NodeTypeEnum.Resource, true));
1221 assertEquals(ActionStatus.COMPONENT_IN_USE_BY_ANOTHER_COMPONENT, actualException.getActionStatus());
1225 void testDeleteResource_WithTwoVersions() {
1226 GraphVertex graphVertex = getTopologyTemplateVertex();
1227 String invariantUuid = "1";
1228 graphVertex.setUniqueId(invariantUuid);
1229 Map<String, Object> metadata1 = new HashMap<>();
1230 metadata1.put("ex1", new Object());
1231 graphVertex.setMetadataJson(metadata1);
1232 ToscaElement toscaElement1 = getToscaElementForTest();
1233 toscaElement1.setUniqueId(invariantUuid);
1234 ToscaElement toscaElement2 = getToscaElementForTest();
1235 toscaElement2.setUniqueId("2");
1236 GraphVertex graphVertex2 = getTopologyTemplateVertex();
1237 graphVertex2.setUniqueId("2");
1238 Map<String, Object> metadata2 = new HashMap<>();
1239 metadata2.put("ex2", new Object());
1240 graphVertex.setMetadataJson(metadata2);
1241 List<GraphVertex> parentVertices = new ArrayList<>();
1242 parentVertices.add(graphVertex2);
1243 List<String> affectedComponentIds = new ArrayList<>();
1244 affectedComponentIds.add(graphVertex.getUniqueId());
1245 affectedComponentIds.add(graphVertex2.getUniqueId());
1247 when(graphLockOperationMock.lockComponent(graphVertex.getUniqueId(), NodeTypeEnum.Resource)).
1248 thenReturn(StorageOperationStatus.OK);
1249 when(graphLockOperationMock.lockComponent(graphVertex2.getUniqueId(), NodeTypeEnum.Resource)).
1250 thenReturn(StorageOperationStatus.OK);
1251 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement1));
1252 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex2)).thenReturn(Either.left(toscaElement2));
1253 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
1254 allResourcesToDelete.add(graphVertex);
1255 allResourcesToDelete.add(graphVertex2);
1256 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUuid, Collections.emptyMap())).
1257 thenReturn(allResourcesToDelete);
1258 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), any())).thenReturn(Either.right(JanusGraphOperationStatus.OK));
1259 assertEquals(affectedComponentIds, testInstance.deleteComponent(invariantUuid, NodeTypeEnum.Resource, false));
1263 void testDeleteResource_WithOneVersion() {
1264 GraphVertex graphVertex = getTopologyTemplateVertex();
1265 graphVertex.setUniqueId("1");
1266 Map<String, Object> metadata = new HashMap<>();
1267 metadata.put("ex1", new Object());
1268 graphVertex.setMetadataJson(metadata);
1269 ToscaElement toscaElement = getToscaElementForTest();
1270 List<String> affectedComponentIds = new ArrayList<>();
1271 affectedComponentIds.add(graphVertex.getUniqueId());
1272 when(graphLockOperationMock.lockComponent(graphVertex.getUniqueId(), NodeTypeEnum.Resource)).
1273 thenReturn(StorageOperationStatus.OK);
1274 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
1275 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
1276 allResourcesToDelete.add(graphVertex);
1277 when(janusGraphDaoMock.findAllVertexByInvariantUuid(graphVertex.getUniqueId(), Collections.emptyMap())).
1278 thenReturn(allResourcesToDelete);
1279 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), any())).thenReturn(Either.right(JanusGraphOperationStatus.OK));
1280 assertEquals(affectedComponentIds, testInstance.deleteComponent("1", NodeTypeEnum.Resource, true));
1284 void testDeleteResource_FailDelete() {
1285 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
1286 metadataProperties.put(GraphPropertyEnum.NAME, "graphVertex");
1287 GraphVertex graphVertex = getTopologyTemplateVertex();
1288 String invariantUUID = "1";
1289 graphVertex.setUniqueId(invariantUUID);
1290 graphVertex.setMetadataProperties(metadataProperties);
1291 ToscaElement toscaElement1 = getToscaElementForTest();
1292 toscaElement1.setUniqueId(invariantUUID);
1293 List<String> affectedComponentIds = new ArrayList<>();
1294 affectedComponentIds.add(graphVertex.getUniqueId());
1295 List<GraphVertex> allResourcesToDelete = new ArrayList<>();
1296 allResourcesToDelete.add(graphVertex);
1298 when(janusGraphDaoMock.findAllVertexByInvariantUuid(graphVertex.getUniqueId(), Collections.emptyMap())).
1299 thenReturn(allResourcesToDelete);
1300 when(graphLockOperationMock.lockComponent(graphVertex.getUniqueId(), NodeTypeEnum.Resource)).
1301 thenReturn(StorageOperationStatus.OK);
1302 when(topologyTemplateOperationMock.deleteToscaElement(graphVertex))
1303 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1304 when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), any())).thenReturn(Either.right(JanusGraphOperationStatus.OK));
1305 StorageException actualException = assertThrows(StorageException.class,
1306 () -> testInstance.deleteComponent(invariantUUID, NodeTypeEnum.Resource, false));
1307 assertEquals(StorageOperationStatus.NOT_FOUND, actualException.getStorageOperationStatus());
1308 assertEquals(0, actualException.getParams().length);
1312 void testDeleteResource_NotFound() {
1313 String invariantUUID = "12345";
1314 when(janusGraphDaoMock.findAllVertexByInvariantUuid(invariantUUID, Collections.emptyMap())).thenReturn(Collections.emptyList());
1315 assertEquals(0, testInstance.deleteComponent(invariantUUID, NodeTypeEnum.Resource, true).size());
1319 void testCreateAndAssociateInputs_OK() {
1320 GraphVertex vertex = getTopologyTemplateVertex();
1321 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1322 when(topologyTemplateOperationMock.associateInputsToComponent(eq(vertex), anyMap(), anyString())).thenReturn(StorageOperationStatus.OK);
1323 Map<String, InputDefinition> inputs = new HashMap<>();
1324 inputs.put("1", new InputDefinition());
1325 inputs.put("2", new InputDefinition());
1326 final var result = testInstance.createAndAssociateInputs(inputs, COMPONENT_ID);
1327 assertTrue(result.isLeft());
1328 assertNotNull(result.left());
1329 assertEquals(2, result.left().value().size());
1333 void testCreateAndAssociateInputs_NegativeAssociateInputsToComponentStatus() {
1334 GraphVertex vertex = getTopologyTemplateVertex();
1335 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1336 when(topologyTemplateOperationMock.associateInputsToComponent(eq(vertex), anyMap(), anyString()))
1337 .thenReturn(StorageOperationStatus.NOT_FOUND);
1338 final var result = testInstance.createAndAssociateInputs(new HashMap<>(), COMPONENT_ID);
1339 assertTrue(result.isRight());
1340 assertEquals(StorageOperationStatus.NOT_FOUND, result.right().value());
1344 void testCreateAndAssociateInputs_componentNotFound() {
1345 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
1346 final var result = testInstance.createAndAssociateInputs(new HashMap<>(), COMPONENT_ID);
1347 assertTrue(result.isRight());
1348 assertEquals(StorageOperationStatus.NOT_FOUND, result.right().value());
1352 void testCreateAndAssociateOutputs_OK() {
1353 GraphVertex vertex = getTopologyTemplateVertex();
1354 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1355 when(topologyTemplateOperationMock.associateOutputsToComponent(eq(vertex), anyMap(), anyString())).thenReturn(StorageOperationStatus.OK);
1356 Map<String, OutputDefinition> outputs = new HashMap<>();
1357 outputs.put("1", new OutputDefinition());
1358 outputs.put("2", new OutputDefinition());
1359 final var result = testInstance.createAndAssociateOutputs(outputs, COMPONENT_ID);
1360 assertTrue(result.isLeft());
1361 assertNotNull(result.left());
1362 assertEquals(2, result.left().value().size());
1366 void testCreateAndAssociateOutputs_NegativeAssociateOutputsToComponentStatus() {
1367 GraphVertex vertex = getTopologyTemplateVertex();
1368 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1369 when(topologyTemplateOperationMock.associateOutputsToComponent(eq(vertex), anyMap(), anyString()))
1370 .thenReturn(StorageOperationStatus.NOT_FOUND);
1371 final var result = testInstance.createAndAssociateOutputs(new HashMap<>(), COMPONENT_ID);
1372 assertTrue(result.isRight());
1373 assertEquals(StorageOperationStatus.NOT_FOUND, result.right().value());
1377 void testCreateAndAssociateOutputs_componentNotFound() {
1378 when(janusGraphDaoMock.getVertexById(COMPONENT_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
1379 final var result = testInstance.createAndAssociateOutputs(new HashMap<>(), COMPONENT_ID);
1380 assertTrue(result.isRight());
1381 assertEquals(StorageOperationStatus.NOT_FOUND, result.right().value());
1384 private StorageOperationStatus associateRequirementsToServiceWithStatus(StorageOperationStatus status) {
1385 Map<String, ListRequirementDataDefinition> requirementsMap = new HashedMap();
1386 String componentId = "componentid";
1388 ListRequirementDataDefinition listRequirementDataDefinition1 = new ListRequirementDataDefinition();
1389 requirementsMap.put("requirements1", listRequirementDataDefinition1);
1392 if (status == StorageOperationStatus.OK) {
1393 vertex = getTopologyTemplateVertex();
1395 vertex = getNodeTypeVertex();
1398 Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1399 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
1400 when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
1401 eq(VertexTypeEnum.REQUIREMENTS), eq(EdgeLabelEnum.REQUIREMENTS), anyMap())).thenReturn(Either.right(status));
1402 return testInstance.associateRequirementsToService(requirementsMap, componentId);
1405 private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) {
1406 PolicyDefinition policy = new PolicyDefinition();
1407 String componentId = "componentId";
1410 if (status == StorageOperationStatus.OK) {
1411 vertex = getTopologyTemplateVertex();
1413 vertex = getNodeTypeVertex();
1415 Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1416 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata)).thenReturn(getVertexEither);
1417 if (status == StorageOperationStatus.OK) {
1418 when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status);
1420 return testInstance.associatePolicyToComponent(componentId, policy, counter);
1423 private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) {
1424 PolicyDefinition policy = new PolicyDefinition();
1425 String componentId = "componentId";
1426 GraphVertex vertex = getTopologyTemplateVertex();
1427 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1428 when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status);
1429 return testInstance.updatePolicyOfComponent(componentId, policy, PromoteVersionEnum.NONE);
1432 private void removePolicyFromComponentWithStatus(StorageOperationStatus status) {
1433 String componentId = "componentId";
1434 String policyId = "policyId";
1435 GraphVertex vertex = getTopologyTemplateVertex();
1436 Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1437 when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
1438 when(topologyTemplateOperationMock.removePolicyFromToscaElement(vertex, policyId)).thenReturn(status);
1439 StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId);
1440 assertSame(result, status);
1443 private List<GraphVertex> getMockVertices(int numOfVertices) {
1444 return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList());
1447 private ToscaElement getResourceToscaElement(String id) {
1448 ToscaElement toscaElement = new TopologyTemplate();
1449 toscaElement.setMetadata(new HashMap<>());
1450 toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE");
1451 toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id);
1452 return toscaElement;
1455 private GraphVertex getTopologyTemplateVertex() {
1456 GraphVertex graphVertex = new GraphVertex();
1457 graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
1461 private GraphVertex getNodeTypeVertex() {
1462 GraphVertex graphVertex = new GraphVertex();
1463 graphVertex.setLabel(VertexTypeEnum.NODE_TYPE);