gerrit.onap Code Review - sdc.git/blob

   1 /*
   2
   3  * Copyright (c) 2018 AT&T Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  31
  32 import fj.data.Either;
  33 import org.apache.commons.lang3.tuple.ImmutablePair;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.junit.runner.RunWith;
  37 import org.mockito.ArgumentCaptor;
  38 import org.mockito.InjectMocks;
  39 import org.mockito.Mock;
  40 import org.mockito.Mockito;
  41 import org.mockito.ArgumentMatchers;
  42 import org.mockito.MockitoAnnotations;
  43 import org.mockito.junit.MockitoJUnitRunner;
  44 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  45 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  46 import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao;
  47 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  48 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  49 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  50 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  53 import org.openecomp.sdc.be.datatypes.enums.PromoteVersionEnum;
  54 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  56 import org.openecomp.sdc.be.model.Component;
  57 import org.openecomp.sdc.be.model.ComponentInstance;
  58 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  59 import org.openecomp.sdc.be.model.Resource;
  60 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  61 import org.openecomp.sdc.be.model.ComponentParametersView;
  62 import org.openecomp.sdc.be.model.PolicyDefinition;
  63 import org.openecomp.sdc.be.model.Service;
  64 import org.openecomp.sdc.be.model.User;
  65 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
  66 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  67 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  68 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
  70 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  71 import org.openecomp.sdc.be.model.DataTypeDefinition;
  72 import org.openecomp.sdc.be.model.PropertyDefinition;
  73 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
  74 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  75 import static org.assertj.core.api.Assertions.assertThat;
  76
  77 import java.util.HashMap;
  78 import java.util.List;
  79 import java.util.Map;
  80 import java.util.ArrayList;
  81 import java.util.EnumMap;
  82 import java.util.Set;
  83 import java.util.HashSet;
  84 import java.util.stream.Collectors;
  85 import java.util.stream.IntStream;
  86 import java.util.Collections;
  87 import java.util.Arrays;
  88
  89 import static org.junit.Assert.assertEquals;
  90 import static org.junit.Assert.assertSame;
  91 import static org.junit.Assert.assertTrue;
  92 import static org.mockito.Mockito.times;
  93 import static org.mockito.Mockito.verify;
  94 import static org.mockito.Mockito.when;
  95 import static org.mockito.ArgumentMatchers.any;
  96 import static org.mockito.ArgumentMatchers.anyMap;
  97 import static org.mockito.ArgumentMatchers.anyInt;
  98 import static org.mockito.ArgumentMatchers.eq;
  99
 100 @RunWith(MockitoJUnitRunner.class)
 101 public class ToscaOperationFacadeTest {
 102     private static final String COMPONENT_ID = "componentId";
 103     private static final String PROPERTY1_NAME = "prop1";
 104     private static final String PROPERTY1_TYPE = "string";
 105     private static final String PROPERTY2_NAME = "prop2";
 106     private static final String PROPERTY2_TYPE = "integer";
 107     private static final String ICON_NAME = "icon";
 108     private static final String SERVICE_MODEL_NAME = "Test_Service";
 109     private static final String SERVICE_PROXY_INSTANCE0_NAME = "testservice_proxy0";
 110     private static final String SERVICE_SUBSTITUTION_INSTANCE0_NAME = "testservice0";
 111
 112     @InjectMocks
 113     private ToscaOperationFacade testInstance;
 114
 115     @Mock
 116     private HealingJanusGraphDao janusGraphDaoMock;
 117
 118     @Mock
 119     private TopologyTemplateOperation topologyTemplateOperationMock;
 120
 121     @Mock
 122     private NodeTypeOperation nodeTypeOperation;
 123
 124     @Mock
 125     private NodeTemplateOperation nodeTemplateOperationMock;
 126
 127     @Before
 128     public void setUp() throws Exception {
 129         testInstance = new ToscaOperationFacade();
 130         MockitoAnnotations.initMocks(this);
 131     }
 132
 133     @SuppressWarnings("unchecked")
 134     @Test
 135     public void fetchMetaDataByResourceType() throws Exception {
 136         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
 137         ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class);
 138         ComponentParametersView dataFilter = new ComponentParametersView();
 139         List<GraphVertex> mockVertices = getMockVertices(2);
 140         Either<List<GraphVertex>, JanusGraphOperationStatus> returnedVertices = Either.left(mockVertices);
 141
 142         when(janusGraphDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices);
 143         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0")));
 144         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1")));
 145         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter);
 146
 147         verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture);
 148         verifyCriteriaNotIsDeleted(criteriaNotCapture);
 149
 150         assertTrue(fetchedComponents.isLeft());
 151         List<Component> cmpts = fetchedComponents.left().value();
 152         assertEquals(2, cmpts.size());
 153         assertEquals("0", cmpts.get(0).getUniqueId());
 154         assertEquals("1", cmpts.get(1).getUniqueId());
 155     }
 156
 157     private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor<Map> criteriaCapture) {
 158         Map<GraphPropertyEnum, Object> criteria = (Map<GraphPropertyEnum, Object>)criteriaCapture.getValue();
 159         assertEquals(2, criteria.size());
 160         assertEquals(criteria.get(GraphPropertyEnum.RESOURCE_TYPE), "VF");
 161         assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true);
 162     }
 163
 164     private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) {
 165         Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>)criteriaNotCapture.getValue();
 166         assertEquals(1, notCriteria.size());
 167         assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true);
 168     }
 169
 170     @SuppressWarnings("unchecked")
 171     @Test
 172     public void fetchMetaDataByResourceType_failedToGetData() throws Exception {
 173         when(janusGraphDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(
 174             JanusGraphOperationStatus.GENERAL_ERROR));
 175         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView());
 176         assertTrue(fetchedComponents.isRight());
 177         assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value());
 178     }
 179
 180     @Test
 181     public void associatePolicyToComponentSuccessTest(){
 182         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK);
 183         assertTrue(result.isLeft());
 184     }
 185
 186     @Test
 187     public void associatePolicyToComponentFailureTest(){
 188         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 189         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 190     }
 191
 192     @Test
 193     public void updatePolicyOfComponentSuccessTest(){
 194         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK);
 195         assertTrue(result.isLeft());
 196     }
 197
 198     @Test
 199     public void updatePolicyOfComponentFailureTest(){
 200         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 201         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 202     }
 203
 204     @Test
 205     public void removePolicyFromComponentSuccessTest(){
 206         removePolicyFromComponentWithStatus(StorageOperationStatus.OK);
 207     }
 208
 209     @Test
 210     public void removePolicyFromComponentFailureTest(){
 211         removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 212     }
 213
 214     @Test
 215     public void testFindLastCertifiedToscaElementByUUID(){
 216         Either<Component, StorageOperationStatus> result;
 217         Component component = new Resource();
 218         List<GraphVertex> list = new ArrayList<>();
 219         GraphVertex graphVertex = getTopologyTemplateVertex();
 220         list.add(graphVertex);
 221         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 222         props.put(GraphPropertyEnum.UUID, component.getUUID());
 223         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 224         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 225         ToscaElement toscaElement = getToscaElementForTest();
 226         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 227         when(janusGraphDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list));
 228         result = testInstance.findLastCertifiedToscaElementByUUID(component);
 229         Component resultComp = result.left().value();
 230         assertEquals(resultComp.getToscaType(),ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue());
 231     }
 232
 233     @Test
 234     public void testLatestComponentByToscaResourceName(){
 235         Either<Component, StorageOperationStatus> result;
 236         TopologyTemplate toscaElement = new TopologyTemplate();
 237         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 238         List<GraphVertex> list = new ArrayList<>();
 239         GraphVertex graphVertex = getTopologyTemplateVertex();
 240         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 241         props.put(GraphPropertyEnum.VERSION, "1.0");
 242         graphVertex.setMetadataProperties(props);
 243         list.add(graphVertex);
 244
 245         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 246         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 247         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName");
 248         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 249         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 250
 251         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(list));
 252         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 253
 254         result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName");
 255         assertThat(result.isLeft());
 256     }
 257
 258     @Test
 259     public void testValidateCsarUuidUniqueness() {
 260         StorageOperationStatus result;
 261         String csarUUID = "csarUUID";
 262         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 263         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 264         List<GraphVertex> vertexList = new ArrayList<>();
 265         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 266         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 267         assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result);
 268     }
 269
 270     @Test
 271     public void testValidateCsarUuidUnique_true() {
 272         StorageOperationStatus result;
 273         String csarUUID = "csarUUID";
 274         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 275         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 276         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 277             JanusGraphOperationStatus.NOT_FOUND));
 278         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 279         assertEquals(StorageOperationStatus.OK, result);
 280     }
 281
 282     @Test
 283     public void testGetLatestCertiNodeTypeByToscaResourceName() {
 284         Either<Resource, StorageOperationStatus> result;
 285         String toscaResourceName = "resourceName";
 286         String uniqueId = "uniqueId";
 287         GraphVertex graphVertex = getTopologyTemplateVertex();
 288         graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0");
 289         graphVertex.setUniqueId(uniqueId);
 290         List<GraphVertex> vertexList = new ArrayList<>();
 291         vertexList.add(graphVertex);
 292         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 293         props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 294         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 295         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 296         ToscaElement topologyTemplate = new TopologyTemplate();
 297         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 298         when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 299         when(janusGraphDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 300         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(topologyTemplate));
 301         result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName);
 302         assertThat(result.isLeft());
 303     }
 304
 305     @Test
 306     public void testValidateCompExists() {
 307         Either<Boolean, StorageOperationStatus> result;
 308         String componentId = "componentId";
 309         GraphVertex graphVertex = getTopologyTemplateVertex();
 310         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 311         result = testInstance.validateComponentExists(componentId);
 312         assertEquals(true, result.left().value());
 313     }
 314
 315     @Test
 316     public void testValidateCompExists_NotFound() {
 317         Either<Boolean, StorageOperationStatus> result;
 318         String componentId = "componentId";
 319         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 320             JanusGraphOperationStatus.NOT_FOUND));
 321         result = testInstance.validateComponentExists(componentId);
 322         assertEquals(false, result.left().value());
 323     }
 324
 325     @Test
 326     public void testValidateToscaResourceNameExists() {
 327         Either<Boolean, StorageOperationStatus> result;
 328         String templateName = "templateName";
 329         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 330         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 331         List<GraphVertex> graphVertexList = new ArrayList<>();
 332         GraphVertex graphVertex = getTopologyTemplateVertex();
 333         graphVertexList.add(graphVertex);
 334         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 335         result = testInstance.validateToscaResourceNameExists(templateName);
 336         assertEquals(true, result.left().value());
 337     }
 338
 339     @Test
 340     public void testValidateToscaResourceNameExists_false() {
 341         Either<Boolean, StorageOperationStatus> result;
 342         String templateName = "templateName";
 343         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 344         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 345         List<GraphVertex> graphVertexList = new ArrayList<>();
 346         GraphVertex graphVertex = getTopologyTemplateVertex();
 347         graphVertexList.add(graphVertex);
 348         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 349             JanusGraphOperationStatus.NOT_FOUND));
 350         result = testInstance.validateToscaResourceNameExists(templateName);
 351         assertEquals(false, result.left().value());
 352     }
 353
 354     @Test
 355     public void testOverrideComponent() {
 356         Either<Resource, StorageOperationStatus> result;
 357         Resource resource = new Resource();
 358         String id = "id";
 359         resource.setUniqueId(id);
 360         GraphVertex graphVertex = getTopologyTemplateVertex();
 361         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 362         NodeType nodeType = new NodeType();
 363         nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
 364         ToscaElement toscaElement = new TopologyTemplate();
 365         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 366         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 367         when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 368         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 369         when(nodeTypeOperation.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
 370         when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 371         when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(
 372             JanusGraphOperationStatus.OK);
 373         result = testInstance.overrideComponent(resource, resource);
 374         assertTrue(result.isLeft());
 375     }
 376
 377     @Test
 378     public void testGetToscaElement() {
 379         Either<Component, StorageOperationStatus> result;
 380         String id = "id";
 381         GraphVertex graphVertex = getTopologyTemplateVertex();
 382         ToscaElement toscaElement = getToscaElementForTest();
 383         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 384         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 385         result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll);
 386         assertTrue(result.isLeft());
 387     }
 388
 389     @Test
 390     public void testMarkComponentToDelete() {
 391         StorageOperationStatus result;
 392         Component component = new Resource();
 393         String id = "id";
 394         component.setUniqueId(id);
 395         GraphVertex graphVertex = getTopologyTemplateVertex();
 396         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 397         when(nodeTypeOperation.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
 398         result = testInstance.markComponentToDelete(component);
 399         assertEquals(result, StorageOperationStatus.OK);
 400     }
 401
 402     @Test
 403     public void testDelToscaComponent() {
 404         Either<Component, StorageOperationStatus> result;
 405         String componentId = "compId";
 406         GraphVertex graphVertex = getTopologyTemplateVertex();
 407         ToscaElement toscaElement = getToscaElementForTest();
 408         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 409         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 410         result = testInstance.deleteToscaComponent(componentId);
 411         assertTrue(result.isLeft());
 412     }
 413
 414     @Test
 415     public void testGetLatestByToscaResourceName() {
 416         Either<Component, StorageOperationStatus> result;
 417         String toscaResourceName = "name";
 418         ToscaElement toscaElement = getToscaElementForTest();
 419
 420         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 421         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 422         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 423         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 424         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 425
 426         List<GraphVertex> graphVertexList = new ArrayList<>();
 427         GraphVertex graphVertex = getTopologyTemplateVertex();
 428         graphVertex.setUniqueId(toscaResourceName);
 429         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 430         props.put(GraphPropertyEnum.VERSION, "1.0");
 431         graphVertex.setMetadataProperties(props);
 432         graphVertexList.add(graphVertex);
 433
 434         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 435         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 436         result = testInstance.getLatestByToscaResourceName(toscaResourceName);
 437         assertTrue(result.isLeft());
 438     }
 439
 440     @Test
 441     public void testGetFollowed() {
 442         Either<Set<Component>, StorageOperationStatus> result;
 443         String userId = "id";
 444         Set<LifecycleStateEnum> lifecycleStates = new HashSet<>();
 445         Set<LifecycleStateEnum> lastStateStates = new HashSet<>();
 446         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 447         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 448         lifecycleStates.add(LifecycleStateEnum.CERTIFIED);
 449         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 450         List<ToscaElement> toscaEleList = new ArrayList<>();
 451         ToscaElement toscaElement = getToscaElementForTest();
 452         toscaEleList.add(toscaElement);
 453         when(nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType)).thenReturn(Either.left(toscaEleList));
 454         result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType);
 455         assertTrue(result.isLeft());
 456         assertEquals(1, result.left().value().size());
 457     }
 458
 459     @Test
 460     public void testGetBySystemName() {
 461         Either<List<Component>, StorageOperationStatus> result;
 462         String sysName = "sysName";
 463         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 464         ToscaElement toscaElement = getToscaElementForTest();
 465         List<GraphVertex> componentVertices = new ArrayList<>();
 466         GraphVertex graphVertex = getTopologyTemplateVertex();
 467         componentVertices.add(graphVertex);
 468         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 469         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 470
 471         propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName);
 472         propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name());
 473
 474         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 475
 476         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertices));
 477         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 478         result = testInstance.getBySystemName(componentTypeEnum, sysName);
 479         assertTrue(result.isLeft());
 480         assertEquals(1, result.left().value().size());
 481     }
 482
 483     @Test
 484     public void testGetCompByNameAndVersion() {
 485         Either<Component, StorageOperationStatus> result;
 486         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 487         String name = "name";
 488         String version = "1.0";
 489         JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll;
 490         List<GraphVertex> graphVertexList = new ArrayList<>();
 491         GraphVertex graphVertex = getTopologyTemplateVertex();
 492         graphVertexList.add(graphVertex);
 493         ToscaElement toscaElement = getToscaElementForTest();
 494         Map<GraphPropertyEnum, Object> hasProperties = new EnumMap<>(GraphPropertyEnum.class);
 495         Map<GraphPropertyEnum, Object> hasNotProperties = new EnumMap<>(GraphPropertyEnum.class);
 496
 497         hasProperties.put(GraphPropertyEnum.NAME, name);
 498         hasProperties.put(GraphPropertyEnum.VERSION, version);
 499         hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true);
 500         hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name());
 501         when(janusGraphDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList));
 502         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 503         result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag);
 504         assertTrue(result.isLeft());
 505     }
 506
 507     private ToscaElement getToscaElementForTest() {
 508         ToscaElement toscaElement = new TopologyTemplate();
 509         toscaElement.setComponentType(ComponentTypeEnum.RESOURCE);
 510         return toscaElement;
 511     }
 512
 513     @Test
 514     public void addDataTypesToComponentSuccessTest(){
 515         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK);
 516         assertTrue(result.isLeft());
 517     }
 518
 519     @Test
 520     public void addDataTypesToComponentFailureTest_BadRequest(){
 521         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 522         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 523     }
 524
 525     private Either<List<DataTypeDefinition>, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) {
 526         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 527         String componentId = "componentid";
 528         String Id = "id";
 529
 530         PropertyDefinition noDefaultProp = new PropertyDefinition();
 531         noDefaultProp.setName("noDefaultProp");
 532         PropertyDefinition prop1 = new PropertyDefinition();
 533         prop1.setDefaultValue("def1");
 534         prop1.setName("prop1");
 535         PropertyDefinition prop2 = new PropertyDefinition();
 536         prop2.setType("dataType1");
 537         prop2.setName("prop2");
 538         PropertyDefinition prop3 = new PropertyDefinition();
 539         prop3.setDefaultValue("def3");
 540         prop3.setName("prop3");
 541
 542         DataTypeDefinition noDefaultValue = new DataTypeDefinition();
 543         noDefaultValue.setProperties(Collections.singletonList(noDefaultProp));
 544         noDefaultValue.setDerivedFromName("name0");
 545
 546         DataTypeDefinition dataType1 = new DataTypeDefinition();
 547         dataType1.setProperties(Arrays.asList(prop1, prop3));
 548         dataType1.setName("name1");
 549         dataType1.setDerivedFromName("derivedfromname1");
 550
 551         DataTypeDefinition dataType2 = new DataTypeDefinition();
 552         dataType2.setDerivedFrom(dataType1);
 553         dataType2.setName("name2");
 554         dataType2.setDerivedFromName("derivedfromname2");
 555
 556         DataTypeDefinition dataType3 = new DataTypeDefinition();
 557         dataType3.setProperties(Collections.singletonList(prop2));
 558         dataType3.setDerivedFrom(noDefaultValue);
 559         dataType3.setName("name3");
 560         dataType3.setDerivedFromName("derivedfromname3");
 561
 562         dataTypes.put("noDefault", noDefaultValue);
 563         dataTypes.put("dataType1", dataType1);
 564         dataTypes.put("dataType2", dataType2);
 565         dataTypes.put("dataType3", dataType3);
 566
 567         GraphVertex vertex;
 568         if(status == StorageOperationStatus.OK){
 569             vertex = getTopologyTemplateVertex();
 570         } else {
 571             vertex = getNodeTypeVertex();
 572         }
 573         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 574         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 575         when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex),
 576                 eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status);
 577         return testInstance.addDataTypesToComponent(dataTypes, componentId);
 578     }
 579
 580     @Test
 581     public void testDataTypesToComponentFailureTest_NotFound() {
 582         Either<List<DataTypeDefinition>, StorageOperationStatus> result;
 583         String componentId = "componentId";
 584         GraphVertex vertex = getNodeTypeVertex();
 585         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 586         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 587             JanusGraphOperationStatus.NOT_FOUND));
 588         result = testInstance.addDataTypesToComponent(dataTypes, componentId);
 589         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 590     }
 591
 592     @Test
 593     public void testDeleteDataTypeOfComponent() {
 594         StorageOperationStatus result;
 595         Component component = new Resource();
 596         String id = "id";
 597         component.setUniqueId(id);
 598         String datatype = null;
 599
 600         DataTypeDefinition dataType1 = new DataTypeDefinition();
 601         dataType1.setName("name1");
 602         Map<String, DataTypeDataDefinition> dataTypeDataMap = new HashMap<>();
 603         dataTypeDataMap.put("datatype1", dataType1);
 604         List<DataTypeDefinition> dataTypeMap = dataTypeDataMap.values().stream().map(e -> { DataTypeDefinition dataType = new DataTypeDefinition(e);return dataType; }).collect(Collectors.toList());
 605         component.setDataTypes(dataTypeMap);
 606         GraphVertex graphVertex = getTopologyTemplateVertex();
 607         result = testInstance.deleteDataTypeOfComponent(component, "datatype1");
 608         assertEquals(datatype, result);
 609     }
 610
 611     @Test
 612     public void testAddComponentInstancePropertiesToComponent() {
 613         // set up component object
 614         Component component = new Resource();
 615         component.setUniqueId(COMPONENT_ID);
 616         List<ComponentInstanceProperty> instanceProps = new ArrayList<>();
 617         ComponentInstanceProperty instanceProp = new ComponentInstanceProperty();
 618         instanceProp.setName(PROPERTY1_NAME);
 619         instanceProp.setType(PROPERTY1_TYPE);
 620         instanceProps.add(instanceProp);
 621         instanceProp = new ComponentInstanceProperty();
 622         instanceProp.setName(PROPERTY2_NAME);
 623         instanceProp.setType(PROPERTY2_TYPE);
 624         instanceProps.add(instanceProp);
 625         Map<String, List<ComponentInstanceProperty>> instancePropsMap =
 626             Collections.singletonMap(COMPONENT_ID, instanceProps);
 627         component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>()));
 628
 629         when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any()))
 630             .thenReturn(StorageOperationStatus.OK);
 631
 632         Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> result =
 633             testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap);
 634         assertTrue(result.isLeft());
 635         verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any());
 636         List<ComponentInstanceProperty> resultProps = result.left().value().get(COMPONENT_ID);
 637         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME)));
 638         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME)));
 639     }
 640
 641     @Test
 642     public void testAddComponentInstanceToTopologyTemplate_ServiceProxy() {
 643         Component containerComponent = new Service();
 644         Component originalComponent = new Service();
 645         ComponentInstance componentInstance = new ComponentInstance();
 646         ComponentInstance existingComponentInstance = new ComponentInstance();
 647         User user = new User();
 648
 649         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 650
 651         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 652         originalComponent.setIcon(ICON_NAME);
 653
 654         componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
 655         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 656
 657         List<ComponentInstance> existingInstances = new ArrayList<>();
 658         existingComponentInstance.setNormalizedName(SERVICE_PROXY_INSTANCE0_NAME);
 659         existingInstances.add(existingComponentInstance);
 660         containerComponent.setComponentInstances(existingInstances);
 661
 662         when(nodeTemplateOperationMock
 663             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 664             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 665         TopologyTemplate topologyTemplate = new TopologyTemplate();
 666         // preset COMPONENT_TYPE field for internal ModelConverter call
 667         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 668         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 669             .thenReturn(Either.left(topologyTemplate));
 670
 671         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 672             testInstance.addComponentInstanceToTopologyTemplate(
 673                 containerComponent, originalComponent, componentInstance, false, user);
 674
 675         assertTrue(result.isLeft());
 676         assertEquals(componentInstance.getIcon(), ICON_NAME);
 677         assertEquals(result.left().value().getRight(), COMPONENT_ID);
 678         // the instance counter must be 1 because the service proxy instance with suffix 0 already exists.
 679         verify(nodeTemplateOperationMock, times(1))
 680             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 681     }
 682     @Test
 683     public void testAddComponentInstanceToTopologyTemplate_ServiceSubstitution() {
 684         Component containerComponent = new Service();
 685         Component originalComponent = new Service();
 686         ComponentInstance componentInstance = new ComponentInstance();
 687         ComponentInstance existingComponentInstance = new ComponentInstance();
 688         User user = new User();
 689
 690         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 691
 692         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 693         originalComponent.setIcon(ICON_NAME);
 694
 695         componentInstance.setOriginType(OriginTypeEnum.ServiceSubstitution);
 696         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 697
 698         List<ComponentInstance> existingInstances = new ArrayList<>();
 699         existingComponentInstance.setNormalizedName(SERVICE_SUBSTITUTION_INSTANCE0_NAME);
 700         existingInstances.add(existingComponentInstance);
 701         containerComponent.setComponentInstances(existingInstances);
 702
 703         when(nodeTemplateOperationMock
 704             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 705             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 706         TopologyTemplate topologyTemplate = new TopologyTemplate();
 707         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 708         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 709             .thenReturn(Either.left(topologyTemplate));
 710
 711         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 712             testInstance.addComponentInstanceToTopologyTemplate(
 713                 containerComponent, originalComponent, componentInstance, false, user);
 714
 715         assertTrue(result.isLeft());
 716         assertEquals(ICON_NAME, componentInstance.getIcon());
 717         assertEquals(COMPONENT_ID, result.left().value().getRight());
 718         verify(nodeTemplateOperationMock, times(1))
 719             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 720     }
 721
 722     @Test
 723     public void testUpdateComponentInstanceRequirement() {
 724         String containerComponentId = "containerComponentId";
 725         String componentInstanceUniqueId= "componentInstanceUniqueId";
 726         RequirementDataDefinition requirementDataDefinition= Mockito.mock(RequirementDataDefinition.class);
 727
 728         when(nodeTemplateOperationMock.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition)).thenReturn(StorageOperationStatus.OK);
 729         StorageOperationStatus result = testInstance.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 730         assertEquals(StorageOperationStatus.OK, result);
 731         verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 732
 733     }
 734
 735     private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) {
 736         PolicyDefinition policy = new PolicyDefinition();
 737         String componentId = "componentId";
 738         int counter = 0;
 739         GraphVertex vertex;
 740         if(status == StorageOperationStatus.OK){
 741             vertex = getTopologyTemplateVertex();
 742         } else {
 743             vertex = getNodeTypeVertex();
 744         }
 745         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 746         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither);
 747         when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status);
 748         return testInstance.associatePolicyToComponent(componentId, policy, counter);
 749     }
 750
 751     private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) {
 752         PolicyDefinition policy = new PolicyDefinition();
 753         String componentId = "componentId";
 754         GraphVertex vertex = getTopologyTemplateVertex();
 755         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex));
 756         when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status);
 757         return testInstance.updatePolicyOfComponent(componentId, policy, PromoteVersionEnum.NONE);
 758     }
 759
 760     private void removePolicyFromComponentWithStatus(StorageOperationStatus status) {
 761         String componentId = "componentId";
 762         String policyId = "policyId";
 763         GraphVertex vertex = getTopologyTemplateVertex();
 764         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 765         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither);
 766         when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status);
 767         StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId);
 768         assertSame(result, status);
 769     }
 770
 771     private List<GraphVertex> getMockVertices(int numOfVertices) {
 772         return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList());
 773     }
 774
 775     private ToscaElement getResourceToscaElement(String id) {
 776         ToscaElement toscaElement = new TopologyTemplate();
 777         toscaElement.setMetadata(new HashMap<>());
 778         toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE");
 779         toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id);
 780         return toscaElement;
 781     }
 782
 783     private GraphVertex getTopologyTemplateVertex() {
 784         GraphVertex graphVertex = new GraphVertex();
 785         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 786         return graphVertex;
 787     }
 788
 789     private GraphVertex getNodeTypeVertex() {
 790         GraphVertex graphVertex = new GraphVertex();
 791         graphVertex.setLabel(VertexTypeEnum.NODE_TYPE);
 792         return graphVertex;
 793     }
 794 }