catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperationsTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  22
  23 import static org.junit.jupiter.api.Assertions.assertEquals;
  24 import static org.junit.jupiter.api.Assertions.assertFalse;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.mockito.Mockito.CALLS_REAL_METHODS;
  27 import static org.mockito.Mockito.doReturn;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.times;
  30 import static org.mockito.Mockito.verify;
  31
  32 import fj.data.Either;
  33 import java.util.Collections;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import org.junit.jupiter.api.Test;
  38 import org.mockito.Mockito;
  39 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  40 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  41 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  42 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  48 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  49 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  50 import org.openecomp.sdc.be.model.ArtifactDefinition;
  51 import org.openecomp.sdc.be.model.Resource;
  52 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  53 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  54
  55 public class ArtifactsOperationsTest {
  56
  57     private static final String SERVICE_ID = "serviceId";
  58     private static final String INSTANCE_ID = "instanceId";
  59     private ArtifactsOperations testInstance = mock(ArtifactsOperations.class, CALLS_REAL_METHODS);
  60
  61     @Test
  62     public void addArtifactToComponent() {
  63         ArtifactDefinition artifactDef = new ArtifactDefinition();
  64         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
  65         final Resource resource = new Resource();
  66         resource.setUniqueId(INSTANCE_ID);
  67         Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1"));
  68         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
  69         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
  70             Mockito.any());
  71         Map<String, ArtifactDefinition> artMap = new HashMap<>();
  72         artMap.put(INSTANCE_ID, artifactDef);
  73         doReturn(Either.left(artifactDef)).when(testInstance).updateArtifactOnGraph(resource,
  74             artifactDef, NodeTypeEnum.Resource, null, INSTANCE_ID, false,
  75             false);
  76
  77         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.addArtifactToComponent(
  78             artifactDef, resource, NodeTypeEnum.Resource, false, "instanceId");
  79
  80         assertTrue(ret.isLeft());
  81     }
  82
  83     @Test
  84     public void addArtifactToComponentEsId() {
  85         ArtifactDefinition artifactDef = new ArtifactDefinition();
  86         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
  87         artifactDef.setUniqueId(null);
  88         artifactDef.setEsId(INSTANCE_ID);
  89         final Resource resource = new Resource();
  90         resource.setUniqueId(INSTANCE_ID);
  91         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
  92         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
  93         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
  94             Mockito.any());
  95         Map<String, ArtifactDefinition> artMap = new HashMap<>();
  96         artMap.put(INSTANCE_ID, artifactDef);
  97         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
  98             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
  99         doReturn(Either.left(artifactDef)).when(testInstance).updateArtifactOnGraph(resource,
 100             artifactDef, NodeTypeEnum.Resource, null, INSTANCE_ID, false,
 101             false);
 102
 103         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.addArtifactToComponent(
 104             artifactDef, resource, NodeTypeEnum.Resource, false, "instanceId");
 105
 106         assertTrue(ret.isLeft());
 107     }
 108
 109     @Test
 110     public void addArtifactToComponentFail() {
 111         ArtifactDefinition artifactDef = new ArtifactDefinition();
 112         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 113         final Resource resource = new Resource();
 114         resource.setUniqueId(INSTANCE_ID);
 115         Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1"));
 116         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 117         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 118             Mockito.any());
 119         Map<String, ArtifactDefinition> artMap = new HashMap<>();
 120         artMap.put(INSTANCE_ID, artifactDef);
 121         doReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND)).when(testInstance).updateArtifactOnGraph(resource,
 122             artifactDef, NodeTypeEnum.Resource, null, INSTANCE_ID, false,
 123             false);
 124
 125         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.addArtifactToComponent(
 126             artifactDef, resource, NodeTypeEnum.Resource, false, "instanceId");
 127
 128         assertTrue(ret.isRight());
 129     }
 130
 131     @Test
 132     public void updateArtifactOnResource() {
 133         ArtifactDefinition artifactDef = new ArtifactDefinition();
 134         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 135         final Resource resource = new Resource();
 136         resource.setUniqueId(INSTANCE_ID);
 137         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 138         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 139         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 140             Mockito.any());
 141         Map<String, ArtifactDefinition> artMap = new HashMap<>();
 142         artMap.put(INSTANCE_ID, artifactDef);
 143         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
 144             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
 145         doReturn(Either.left(artifactDef)).when(testInstance).updateArtifactOnGraph(resource,
 146             artifactDef, NodeTypeEnum.Resource, null, INSTANCE_ID, false,
 147             false);
 148
 149         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateArtifactOnResource(
 150             artifactDef, resource, "instanceId", NodeTypeEnum.Resource, "instanceId", false);
 151
 152         assertTrue(ret.isLeft());
 153     }
 154
 155     @Test
 156     public void updateArtifactOnResourceFail() {
 157         ArtifactDefinition artifactDef = new ArtifactDefinition();
 158         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 159         final Resource resource = new Resource();
 160         resource.setUniqueId(INSTANCE_ID);
 161         Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1"));
 162         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 163         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 164             Mockito.any());
 165         Map<String, ArtifactDefinition> artMap = new HashMap<>();
 166         artMap.put(INSTANCE_ID, artifactDef);
 167
 168         doReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND)).when(testInstance).updateArtifactOnGraph(resource,
 169             artifactDef, NodeTypeEnum.Resource, INSTANCE_ID, INSTANCE_ID, false,
 170             false);
 171
 172         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateArtifactOnResource(
 173             artifactDef, resource, "instanceId", NodeTypeEnum.Resource, "instanceId", false);
 174
 175         assertTrue(ret.isRight());
 176     }
 177
 178     @Test
 179     public void isCloneNeeded() {
 180         ArtifactDefinition artifactDef = new ArtifactDefinition();
 181         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 182         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 183             Mockito.any());
 184
 185         Either<Boolean, StorageOperationStatus> ret = testInstance.isCloneNeeded(
 186             INSTANCE_ID, artifactDef, NodeTypeEnum.Resource);
 187
 188         assertTrue(ret.isLeft());
 189     }
 190
 191     @Test
 192     public void getArtifactById() {
 193         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 194         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 195         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 196             INSTANCE_ID, "artifactDefId");
 197
 198         assertTrue(ret.isLeft());
 199     }
 200
 201     @Test
 202     public void getArtifactById2() {
 203         Map<String, ToscaDataDefinition> instanceArtifacts =
 204             Collections.singletonMap(INSTANCE_ID, getArtifactsByInstanceSettingUniqueId("artifactDefId"));
 205         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph("containerId",
 206             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 207         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 208             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 209
 210         assertTrue(ret.isLeft());
 211     }
 212
 213     @Test
 214     public void getArtifactById3() {
 215         Map<String, ToscaDataDefinition> instanceArtifacts =
 216             Collections.singletonMap(INSTANCE_ID, getArtifactsByInstanceSettingUniqueId("artifactDefId"));
 217         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 218             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 219         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph("containerId", EdgeLabelEnum.INSTANCE_ARTIFACTS);
 220         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 221             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 222
 223         assertTrue(ret.isLeft());
 224     }
 225
 226     @Test
 227     public void getArtifactById4() {
 228         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 229         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 230             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 231         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 232             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 233         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 234             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 235         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 236         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 237             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 238
 239         assertTrue(ret.isLeft());
 240     }
 241
 242     @Test
 243     public void getArtifactById5() {
 244         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 245         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 246             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 247         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 248             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 249         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 250             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 251         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 252         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 253         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 254             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 255
 256         assertTrue(ret.isLeft());
 257     }
 258
 259     @Test
 260     public void getArtifactById6() {
 261         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 262         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 263             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 264         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 265             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 266         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 267             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 268         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 269         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 270         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 271         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 272             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 273
 274         assertTrue(ret.isLeft());
 275     }
 276
 277     @Test
 278     public void getArtifactById7_NotFound1() {
 279         Map<String, InterfaceDataDefinition> interfaceDefinitions = getInterfaceDataDefinitionsByName("artifactDefId");
 280         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 281             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 282         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 283             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 284         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 285             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 286         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 287         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 288         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 289             EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 290         doReturn(Either.left(interfaceDefinitions)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INTERFACE);
 291         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 292             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 293
 294         assertTrue(ret.isRight());
 295     }
 296
 297     @Test
 298     public void getArtifactById7_NotFound2() {
 299         Map<String, InterfaceDataDefinition> interfaceDefinitions = getInterfaceDataDefinitionsByName("artifactDefId");
 300         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 301             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 302         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 303             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 304         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 305             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 306         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 307         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 308         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 309             EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 310         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INTERFACE);
 311         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 312             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 313
 314         assertTrue(ret.isRight());
 315     }
 316
 317     @Test
 318     public void getArtifactById7_NotFound3() {
 319         Map<String, InterfaceDataDefinition> interfaceDefinitions =
 320             getInterfaceDataDefinitionsWithOperationsByNameNotFound("artifactDefId");
 321         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 322             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 323         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 324             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 325         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 326             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 327         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 328         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 329         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 330             EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 331         doReturn(Either.left(interfaceDefinitions)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INTERFACE);
 332         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 333             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 334
 335         assertTrue(ret.isRight());
 336     }
 337
 338     @Test
 339     public void getArtifactById7() {
 340         Map<String, InterfaceDataDefinition> interfaceDefinitions = getInterfaceDataDefinitionsWithOperationsByName("artifactDefId");
 341         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 342             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 343         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph("containerId",
 344             EdgeLabelEnum.INSTANCE_ARTIFACTS);
 345         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 346             EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 347         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 348         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 349         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID,
 350             EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 351         doReturn(Either.left(interfaceDefinitions)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INTERFACE);
 352         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getArtifactById(
 353             INSTANCE_ID, "artifactDefId", ComponentTypeEnum.RESOURCE_INSTANCE, "containerId");
 354
 355         assertTrue(ret.isLeft());
 356     }
 357
 358     @Test
 359     public void removeArtifactFromResource() {
 360         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName2("artifactDefId");
 361         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 362         doReturn(StorageOperationStatus.OK).when(testInstance).deleteToscaDataElement(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS, VertexTypeEnum.ARTIFACTS,
 363             null, JsonPresentationFields.ARTIFACT_LABEL);
 364         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.removeArifactFromResource(
 365             INSTANCE_ID, "instanceId", NodeTypeEnum.Resource, false);
 366
 367         assertTrue(ret.isLeft());
 368     }
 369
 370     @Test
 371     public void removeArtifactFromResource_Mandatory() {
 372         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName2("artifactDefId");
 373         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 374         doReturn(StorageOperationStatus.OK).when(testInstance).deleteToscaDataElement(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS, VertexTypeEnum.ARTIFACTS,
 375             null, JsonPresentationFields.ARTIFACT_LABEL);
 376         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.removeArifactFromResource(
 377             INSTANCE_ID, "instanceId", NodeTypeEnum.Resource, true);
 378
 379         assertTrue(ret.isLeft());
 380     }
 381
 382     @Test
 383     public void removeArtifactFromResource_NotFound() {
 384         doReturn(Either.right(StorageOperationStatus.NOT_FOUND)).when(testInstance).getArtifactById(INSTANCE_ID, INSTANCE_ID);
 385         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.removeArifactFromResource(
 386             INSTANCE_ID, "instanceId", NodeTypeEnum.Resource, false);
 387
 388         assertTrue(ret.isRight());
 389     }
 390
 391     @Test
 392     public void removeArtifactFromResource_NotFound2() {
 393         doReturn(Either.right(StorageOperationStatus.NOT_FOUND)).when(testInstance).removeArtifactOnGraph(INSTANCE_ID, INSTANCE_ID,
 394             NodeTypeEnum.Resource, false);
 395         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.removeArifactFromResource(
 396             INSTANCE_ID, "instanceId", NodeTypeEnum.Resource, false);
 397
 398         assertTrue(ret.isRight());
 399     }
 400
 401     @Test
 402     public void getArtifacts() {
 403         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName2("artifactDefId");
 404         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 405
 406         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> ret = testInstance.getArtifacts(INSTANCE_ID, NodeTypeEnum.Resource,
 407             ArtifactGroupTypeEnum.INFORMATIONAL, INSTANCE_ID);
 408
 409         assertTrue(ret.isLeft());
 410     }
 411
 412     @Test
 413     public void getArtifacts_NotFound() {
 414         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 415
 416         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> ret = testInstance.getArtifacts(INSTANCE_ID, NodeTypeEnum.Resource,
 417             ArtifactGroupTypeEnum.INFORMATIONAL, INSTANCE_ID);
 418
 419         assertTrue(ret.isRight());
 420     }
 421
 422     @Test
 423     public void getArtifacts2() {
 424         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName2("artifactDefId");
 425         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 426         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 427         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 428
 429         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> ret = testInstance.getArtifacts(INSTANCE_ID);
 430
 431         assertTrue(ret.isLeft());
 432     }
 433
 434     @Test
 435     public void addHeatEnvArtifact() {
 436         ArtifactDefinition artifactDef = new ArtifactDefinition();
 437         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 438         ArtifactDefinition artifactDefHeat = new ArtifactDefinition();
 439         artifactDefHeat.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 440         final Resource resource = new Resource();
 441         resource.setUniqueId(INSTANCE_ID);
 442         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 443             Mockito.any());
 444         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 445         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 446         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
 447             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
 448         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.addHeatEnvArtifact(artifactDef, artifactDefHeat,
 449             resource, NodeTypeEnum.Resource, false, INSTANCE_ID);
 450
 451         assertTrue(ret.isLeft());
 452     }
 453
 454     @Test
 455     public void getHeatArtifactByHeatEnvId() {
 456         Map<String, InterfaceDataDefinition> interfaceDefinitions = getInterfaceDataDefinitionsByName("artifactDefId");
 457         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 458         ArtifactDefinition artifactDefHeat = new ArtifactDefinition();
 459         artifactDefHeat.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 460         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 461         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.TOSCA_ARTIFACTS);
 462         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 463         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.SERVICE_API_ARTIFACTS);
 464         doReturn(Either.left(interfaceDefinitions)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INTERFACE);
 465         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.getHeatArtifactByHeatEnvId(
 466             INSTANCE_ID, artifactDefHeat, "containerId", ComponentTypeEnum.RESOURCE);
 467
 468         assertTrue(ret.isRight());
 469     }
 470
 471     @Test
 472     public void updateHeatEnvArtifact() {
 473         ArtifactDefinition artifactDef = new ArtifactDefinition();
 474         artifactDef.setUniqueId("artifactId");
 475         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 476         ArtifactDefinition artifactDefHeat = new ArtifactDefinition();
 477         artifactDefHeat.setUniqueId("newArtifactId");
 478         artifactDefHeat.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 479         final Resource resource = new Resource();
 480         resource.setUniqueId(INSTANCE_ID);
 481         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 482         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 483         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 484             Mockito.any());
 485         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 486         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
 487             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
 488
 489         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateHeatEnvArtifact(
 490             resource, artifactDef, "artifactId", "newArtifactId", NodeTypeEnum.Resource, INSTANCE_ID);
 491
 492         assertTrue(ret.isLeft());
 493     }
 494
 495     @Test
 496     public void updateHeatEnvArtifact_NotFound() {
 497         ArtifactDefinition artifactDef = new ArtifactDefinition();
 498         artifactDef.setUniqueId("artifactId");
 499         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 500         ArtifactDefinition artifactDefHeat = new ArtifactDefinition();
 501         artifactDefHeat.setUniqueId("newArtifactId");
 502         artifactDefHeat.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 503         final Resource resource = new Resource();
 504         resource.setUniqueId(INSTANCE_ID);
 505         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 506         doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 507         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateHeatEnvArtifact(
 508             resource, artifactDef, "artifactId", "newArtifactId", NodeTypeEnum.Resource, INSTANCE_ID);
 509
 510         assertTrue(ret.isRight());
 511     }
 512
 513     @Test
 514     public void updateHeatEnvArtifactOnInstance() {
 515         ArtifactDefinition artifactDef = new ArtifactDefinition();
 516         artifactDef.setUniqueId("artifactId");
 517         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 518         ArtifactDefinition artifactDefHeat = new ArtifactDefinition();
 519         artifactDefHeat.setUniqueId("newArtifactId");
 520         artifactDefHeat.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 521         final Resource resource = new Resource();
 522         resource.setUniqueId(INSTANCE_ID);
 523         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 524         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 525         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
 526         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 527             Mockito.any());
 528         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 529         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
 530             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
 531
 532         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateHeatEnvArtifactOnInstance(
 533             resource, artifactDef, "artifactId", "newArtifactId", NodeTypeEnum.Resource, INSTANCE_ID);
 534
 535         assertTrue(ret.isLeft());
 536     }
 537
 538     @Test
 539     public void updateHeatEnvPlaceholder() {
 540         ArtifactDefinition artifactDef = new ArtifactDefinition();
 541         artifactDef.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 542         final Resource resource = new Resource();
 543         resource.setUniqueId(INSTANCE_ID);
 544         Map<String, ArtifactDataDefinition> instanceArtifacts = getMapArtifactsByName("artifactDefId");
 545         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(INSTANCE_ID, EdgeLabelEnum.ARTIFACTS);
 546         doReturn(Either.left(false)).when(testInstance).isCloneNeeded(Mockito.any(),
 547             Mockito.any());
 548         Map<String, ArtifactDefinition> artMap = new HashMap<>();
 549         artMap.put(INSTANCE_ID, artifactDef);
 550         doReturn(StorageOperationStatus.OK).when(testInstance).updateToscaDataOfToscaElement(Mockito.anyString(),
 551             Mockito.any(), Mockito.any(), (List<ToscaDataDefinition>) Mockito.any(), Mockito.any());
 552         doReturn(Either.left(artifactDef)).when(testInstance).updateArtifactOnGraph(resource,
 553             artifactDef, NodeTypeEnum.Resource, null, INSTANCE_ID, false,
 554             false);
 555
 556         Either<ArtifactDefinition, StorageOperationStatus> ret = testInstance.updateHeatEnvPlaceholder(
 557             artifactDef, resource, NodeTypeEnum.Resource);
 558
 559         assertTrue(ret.isLeft());
 560     }
 561
 562     @Test
 563     public void getInstanceArtifacts_collectAllInstanceArtifacts() throws Exception {
 564         Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1"));
 565
 566         Map<String, ToscaDataDefinition> instanceDeploymentArtifacts = new HashMap<>();
 567         instanceDeploymentArtifacts.put(INSTANCE_ID, getArtifactsByInstance("name2", "name3"));
 568         instanceDeploymentArtifacts.put("instanceId2", getArtifactsByInstance("name4"));
 569
 570         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 571         doReturn(Either.left(instanceDeploymentArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 572         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts =
 573             testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID);
 574
 575         assertTrue(allInstArtifacts.isLeft());
 576         assertEquals(allInstArtifacts.left().value().size(), 3);
 577         assertTrue(allInstArtifacts.left().value().containsKey("name1"));
 578         assertTrue(allInstArtifacts.left().value().containsKey("name2"));
 579         assertTrue(allInstArtifacts.left().value().containsKey("name3"));
 580         assertFalse(allInstArtifacts.left().value().containsKey("name4"));//this key is of different instance
 581     }
 582
 583     @Test
 584     public void getInstanceArtifacts_noArtifactsForInstance() throws Exception {
 585         Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1"));
 586
 587         doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 588         doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 589         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts =
 590             testInstance.getAllInstanceArtifacts(SERVICE_ID, "someOtherInstance");
 591
 592         assertTrue(allInstArtifacts.isLeft());
 593         assertTrue(allInstArtifacts.left().value().isEmpty());
 594     }
 595
 596     @Test
 597     public void getInstanceArtifacts_errorGettingInstanceArtifacts() throws Exception {
 598         doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(testInstance)
 599             .getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 600         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts =
 601             testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID);
 602         verify(testInstance, times(0)).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 603         assertTrue(allInstArtifacts.isRight());
 604     }
 605
 606     @Test
 607     public void getAllInstanceArtifacts_errorGettingDeploymentArtifacts() throws Exception {
 608         doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS);
 609         doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID,
 610             EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
 611         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts =
 612             testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID);
 613         assertTrue(allInstArtifacts.isRight());
 614     }
 615
 616     private ToscaDataDefinition getArtifactsByInstance(String ... artifactsNames) {
 617         MapArtifactDataDefinition artifactsByInstance = new MapArtifactDataDefinition();
 618         Map<String, ArtifactDataDefinition> artifactsByName = new HashMap<>();
 619         for (String artifactName : artifactsNames) {
 620             artifactsByName.put(artifactName, new ArtifactDataDefinition());
 621         }
 622         artifactsByInstance.setMapToscaDataDefinition(artifactsByName);
 623         return artifactsByInstance;
 624     }
 625
 626     private ToscaDataDefinition getArtifactsByInstanceSettingUniqueId(String ... artifactsNames) {
 627         MapArtifactDataDefinition artifactsByInstance = new MapArtifactDataDefinition();
 628         Map<String, ArtifactDataDefinition> artifactsByName = new HashMap<>();
 629         for (String artifactName : artifactsNames) {
 630             ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 631             artifactDataDefinition.setUniqueId(artifactName);
 632             artifactsByName.put(artifactName, artifactDataDefinition);
 633         }
 634         artifactsByInstance.setMapToscaDataDefinition(artifactsByName);
 635         return artifactsByInstance;
 636     }
 637
 638     private Map<String, ArtifactDataDefinition> getMapArtifactsByName(String ... artifactsNames) {
 639         Map<String, ArtifactDataDefinition> artifactsByName = new HashMap<>();
 640         for (String artifactName : artifactsNames) {
 641             ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 642             artifactDataDefinition.setUniqueId(artifactName);
 643             artifactDataDefinition.setGeneratedFromId("artifactId");
 644             artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 645             artifactsByName.put(artifactName, artifactDataDefinition);
 646         }
 647         return artifactsByName;
 648     }
 649
 650     private Map<String, ArtifactDataDefinition> getMapArtifactsByName2(String ... artifactsNames) {
 651         Map<String, ArtifactDataDefinition> artifactsByName = new HashMap<>();
 652         for (String artifactName : artifactsNames) {
 653             ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 654             artifactDataDefinition.setUniqueId(INSTANCE_ID);
 655             artifactDataDefinition.setMandatory(true);
 656             artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
 657             artifactsByName.put(artifactName, artifactDataDefinition);
 658         }
 659         return artifactsByName;
 660     }
 661
 662     private Map<String, InterfaceDataDefinition> getInterfaceDataDefinitionsByName(String ... artifactsNames) {
 663         Map<String, InterfaceDataDefinition> interfaceDataDefinitionsByName = new HashMap<>();
 664         for (String artifactName : artifactsNames) {
 665             InterfaceDataDefinition interfaceDataDefinition = new InterfaceDataDefinition();
 666             interfaceDataDefinition.setUniqueId(artifactName);
 667             interfaceDataDefinitionsByName.put(artifactName, interfaceDataDefinition);
 668         }
 669         return interfaceDataDefinitionsByName;
 670     }
 671
 672     private Map<String, InterfaceDataDefinition> getInterfaceDataDefinitionsWithOperationsByName(String ... artifactsNames) {
 673         Map<String, InterfaceDataDefinition> interfaceDataDefinitionsByName = new HashMap<>();
 674         for (String artifactName : artifactsNames) {
 675             Map<String, OperationDataDefinition> operations = new HashMap<>();
 676             OperationDataDefinition operation1 = new OperationDataDefinition();
 677             operation1.setName("operation1");
 678             ArtifactDataDefinition impl1 = new ArtifactDataDefinition();
 679             impl1.setUniqueId(artifactName);
 680             operation1.setImplementation(impl1);
 681             operations.put(artifactName, operation1);
 682             InterfaceDataDefinition interfaceDataDefinition = new InterfaceDataDefinition();
 683             interfaceDataDefinition.setUniqueId(artifactName);
 684             interfaceDataDefinition.setOperations(operations);
 685             interfaceDataDefinitionsByName.put(artifactName, interfaceDataDefinition);
 686         }
 687         return interfaceDataDefinitionsByName;
 688     }
 689
 690     private Map<String, InterfaceDataDefinition> getInterfaceDataDefinitionsWithOperationsByNameNotFound(String ... artifactsNames) {
 691         Map<String, InterfaceDataDefinition> interfaceDataDefinitionsByName = new HashMap<>();
 692         for (String artifactName : artifactsNames) {
 693             Map<String, OperationDataDefinition> operations = new HashMap<>();
 694             OperationDataDefinition operation1 = new OperationDataDefinition();
 695             operation1.setName("operation1");
 696             ArtifactDataDefinition impl1 = new ArtifactDataDefinition();
 697             impl1.setUniqueId("implementation1");
 698             operation1.setImplementation(impl1);
 699             operations.put(artifactName, operation1);
 700             InterfaceDataDefinition interfaceDataDefinition = new InterfaceDataDefinition();
 701             interfaceDataDefinition.setUniqueId(artifactName);
 702             interfaceDataDefinition.setOperations(operations);
 703             interfaceDataDefinitionsByName.put(artifactName, interfaceDataDefinition);
 704         }
 705         return interfaceDataDefinitionsByName;
 706     }
 707 }