catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 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.operations.impl;
  22
  23 import fj.data.Either;
  24 import org.junit.Before;
  25 import org.junit.BeforeClass;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  29 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  30 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  31 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  32 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.model.*;
  35 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  36 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  37 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  38 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  39 import org.openecomp.sdc.be.resources.data.*;
  40 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.springframework.test.context.ContextConfiguration;
  44 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  45
  46 import java.util.ArrayList;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50
  51 import static org.junit.Assert.*;
  52
  53 @RunWith(SpringJUnit4ClassRunner.class)
  54 @ContextConfiguration("classpath:application-context-test.xml")
  55 public class ArtifactOperationTest extends ModelTestBase {
  56
  57     private static final String ARTIFACT_NAME = "myHeatArtifact";
  58
  59     @javax.annotation.Resource(name = "janusgraph-generic-dao")
  60     private JanusGraphGenericDao janusGraphDao;
  61
  62     @javax.annotation.Resource(name = "tosca-operation-facade")
  63     private ToscaOperationFacade toscaOperationFacade;
  64
  65     @javax.annotation.Resource
  66     private ArtifactOperation artifactOperation;
  67
  68     private static final Logger log = LoggerFactory.getLogger(ToscaOperationFacade.class);
  69
  70     private static String RESOURCE_ID = "resourceId";
  71     private static String RESOURCE_ID_2 = "resourceId2";
  72
  73     private static String USER_ID = "muUserId";
  74     private static String CATEGORY_NAME = "category/mycategory";
  75
  76     @BeforeClass
  77     public static void setupBeforeClass() {
  78
  79         ModelTestBase.init();
  80     }
  81
  82     @Before
  83     public void createUserAndCategory() {
  84         deleteAndCreateCategory(CATEGORY_NAME);
  85         deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, null);
  86     }
  87
  88     @Test
  89     public void testCreateDeleteArtifactWithHeatParams() {
  90
  91         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
  92
  93         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
  94         assertNotNull(heatParameters);
  95         assertEquals(1, heatParameters.size());
  96         HeatParameterDefinition parameter = heatParameters.get(0);
  97         HeatParameterData parameterData = new HeatParameterData(parameter);
  98         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
  99         assertTrue(parameterNode.isLeft());
 100
 101         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 102         assertTrue(removeArifact.isLeft());
 103
 104         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 105         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 106         assertTrue(artifactAfterDelete.isRight());
 107
 108         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 109         assertTrue(parameterNodeAfterDelete.isRight());
 110
 111         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 112     }
 113
 114     @Test
 115     public void testUpdateArtifactWithHeatParams() {
 116
 117         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 118
 119         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 120         assertNotNull(heatParameters);
 121         assertEquals(1, heatParameters.size());
 122         HeatParameterDefinition parameter = heatParameters.get(0);
 123         HeatParameterData parameterData = new HeatParameterData(parameter);
 124         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 125         assertTrue(parameterNode.isLeft());
 126
 127         // update to artifact without params
 128         ArtifactDefinition artifactNoParams = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
 129         artifactNoParams.setUniqueId(artifactWithHeat.getUniqueId());
 130         artifactNoParams.setArtifactType("HEAT");
 131         artifactNoParams.setArtifactVersion("2");
 132         artifactNoParams.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 133
 134         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactNoParams, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 135         assertTrue(updateArifact.isLeft());
 136
 137         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 138         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 139         assertTrue(artifactAfterUpdate.isLeft());
 140         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 141         assertEquals(artifactNoParams.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 142                                                                                     .getArtifactVersion());
 143
 144         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 145         assertTrue(parameterNodeAfterDelete.isRight());
 146
 147         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 148         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 149         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 150     }
 151
 152     @Test
 153     public void testUpdateArtifactMetadataWithHeatParams() {
 154
 155         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 156
 157         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 158         assertNotNull(heatParameters);
 159         assertEquals(1, heatParameters.size());
 160         HeatParameterDefinition parameter = heatParameters.get(0);
 161         HeatParameterData parameterData = new HeatParameterData(parameter);
 162         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 163         assertTrue(parameterNode.isLeft());
 164
 165         // update to artifact without params
 166         artifactWithHeat.setArtifactVersion("2");
 167         artifactWithHeat.setArtifactChecksum(null);
 168         artifactWithHeat.setPayloadData(null);
 169
 170         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactWithHeat, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 171         assertTrue(updateArifact.isLeft());
 172
 173         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 174         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 175         assertTrue(artifactAfterUpdate.isLeft());
 176         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 177         assertEquals(artifactWithHeat.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 178                                                                                     .getArtifactVersion());
 179
 180         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 181         assertTrue(parameterNodeAfterDelete.isLeft());
 182
 183         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, (String) artifactAfterUpdateValue.getUniqueId(), NodeTypeEnum.Resource, true, false);
 184         removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 185         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 186         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 187
 188     }
 189
 190     @Test
 191     public void updateHeatArtifactWithTwoResources() {
 192         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 193
 194         ResourceMetadataData resource2 = createResource(RESOURCE_ID_2);
 195         Map<String, Object> props = new HashMap<>();
 196         props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name());
 197         Either<GraphRelation, JanusGraphOperationStatus> createRelation = janusGraphDao.createRelation(resource2, new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props);
 198         assertTrue(createRelation.isLeft());
 199
 200         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 201         assertNotNull(heatParameters);
 202         assertEquals(1, heatParameters.size());
 203         HeatParameterDefinition parameter = heatParameters.get(0);
 204         HeatParameterData parameterData = new HeatParameterData(parameter);
 205         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 206         assertTrue(parameterNode.isLeft());
 207
 208         ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat);
 209
 210         // update to artifact without params
 211         atifactToUpdate.setArtifactVersion("2");
 212         atifactToUpdate.setArtifactChecksum(null);
 213         atifactToUpdate.setPayloadData(null);
 214
 215         HeatParameterDefinition heatParamUpdate = new HeatParameterDefinition(parameter);
 216         List<HeatParameterDefinition> heatParametersUpdated = new ArrayList<>();
 217         heatParamUpdate.setCurrentValue("55");
 218         heatParametersUpdated.add(heatParamUpdate);
 219         atifactToUpdate.setListHeatParameters(heatParametersUpdated);
 220
 221         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(atifactToUpdate, RESOURCE_ID_2, atifactToUpdate.getUniqueId(), NodeTypeEnum.Resource, false);
 222         assertTrue(updateArifact.isLeft());
 223
 224         // verify old artifact and parameter still exist
 225         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 226         Either<ArtifactData, JanusGraphOperationStatus> origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 227         assertTrue(origArtifact.isLeft());
 228         ArtifactData origArtifactData = origArtifact.left().value();
 229         assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
 230                                                                             .getArtifactVersion());
 231
 232         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 233         assertTrue(parameterNodeAfterDelete.isLeft());
 234
 235         // verify new artifact and new parameter
 236         ArtifactDefinition artifactDefinitionUpdated = updateArifact.left().value();
 237         ArtifactData artifactDataUpdated = new ArtifactData(artifactDefinitionUpdated);
 238         Either<ArtifactData, JanusGraphOperationStatus> updatedArtifact = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
 239         assertTrue(updatedArtifact.isLeft());
 240         ArtifactData updatedArtifactData = updatedArtifact.left().value();
 241         assertEquals(atifactToUpdate.getArtifactVersion(), updatedArtifactData.getArtifactDataDefinition()
 242                                                                               .getArtifactVersion());
 243         assertFalse(((String) updatedArtifactData.getUniqueId()).equalsIgnoreCase((String) origArtifactData.getUniqueId()));
 244
 245         List<HeatParameterDefinition> heatParametersAfterUpdate = artifactDefinitionUpdated.getListHeatParameters();
 246         assertNotNull(heatParametersAfterUpdate);
 247         assertEquals(1, heatParametersAfterUpdate.size());
 248         HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0);
 249         assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase((String) parameterData.getUniqueId()));
 250         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterUpdate = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class);
 251         assertTrue(parameterNodeAfterUpdate.isLeft());
 252
 253         // delete new artifact
 254         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, artifactDefinitionUpdated.getUniqueId(), NodeTypeEnum.Resource, true, false);
 255         assertTrue(removeArifact.isLeft());
 256
 257         // verify old artifact and parameter still exist
 258         origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 259         assertTrue(origArtifact.isLeft());
 260         origArtifactData = origArtifact.left().value();
 261         assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
 262                                                                             .getArtifactVersion());
 263
 264         parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 265         assertTrue(parameterNodeAfterDelete.isLeft());
 266
 267         // verify new artifact is deleted
 268         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
 269         assertTrue(artifactAfterDelete.isRight());
 270
 271         parameterNodeAfterDelete = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class);
 272         assertTrue(parameterNodeAfterDelete.isRight());
 273
 274         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 275         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 276         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 277     }
 278
 279     private ArtifactDefinition createResourceWithHeat() {
 280         ResourceMetadataData resource = createResource(RESOURCE_ID);
 281         ArtifactDefinition artifactDefinition = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
 282         artifactDefinition.setArtifactType("HEAT");
 283         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 284
 285         List<HeatParameterDefinition> heatParams = new ArrayList<>();
 286         HeatParameterDefinition heatParam = new HeatParameterDefinition();
 287         heatParam.setCurrentValue("11");
 288         heatParam.setDefaultValue("22");
 289         heatParam.setDescription("desc");
 290         heatParam.setName("myParam");
 291         heatParam.setType("number");
 292         heatParams.add(heatParam);
 293         artifactDefinition.setListHeatParameters(heatParams);
 294
 295         Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactDefinition, RESOURCE_ID, NodeTypeEnum.Resource, true, false);
 296         assertTrue(artifact.isLeft());
 297         return artifact.left().value();
 298     }
 299
 300     private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
 301         ArtifactDefinition artifactInfo = createArtifactDefinition(userId, serviceId, artifactName);
 302
 303         Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
 304         assertTrue(artifact.isLeft());
 305         return artifact.left().value();
 306     }
 307
 308     private ArtifactDefinition createArtifactDefinition(String userId, String serviceId, String artifactName) {
 309         ArtifactDefinition artifactInfo = new ArtifactDefinition();
 310
 311         artifactInfo.setArtifactName(artifactName + ".sh");
 312         artifactInfo.setArtifactType("SHELL");
 313         artifactInfo.setDescription("hdkfhskdfgh");
 314         artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
 315
 316         artifactInfo.setUserIdCreator(userId);
 317         String fullName = "Jim H";
 318         artifactInfo.setUpdaterFullName(fullName);
 319         long time = System.currentTimeMillis();
 320         artifactInfo.setCreatorFullName(fullName);
 321         artifactInfo.setCreationDate(time);
 322         artifactInfo.setLastUpdateDate(time);
 323         artifactInfo.setUserIdLastUpdater(userId);
 324         artifactInfo.setArtifactLabel(artifactName);
 325         artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
 326         return artifactInfo;
 327     }
 328
 329     public Service createService(String userId, CategoryDefinition category, String serviceName, String serviceVersion, boolean isHighestVersion) {
 330
 331         Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
 332
 333         service.setHighestVersion(isHighestVersion);
 334
 335         Either<Service, StorageOperationStatus> result = toscaOperationFacade.createToscaComponent(service);
 336
 337         log.info(result.toString());
 338         assertTrue(result.isLeft());
 339         Service resultService = result.left().value();
 340
 341         // assertEquals("check resource unique id",
 342         // UniqueIdBuilder.buildServiceUniqueId(serviceName, serviceVersion),
 343         // resultService.getUniqueId());
 344         assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, resultService.getLifecycleState());
 345
 346         return resultService;
 347     }
 348
 349     private Service buildServiceMetadata(String userId, CategoryDefinition category, String serviceName, String serviceVersion) {
 350
 351         Service service = new Service();
 352         service.setName(serviceName);
 353         service.setVersion(serviceVersion);
 354         service.setDescription("description 1");
 355
 356         service.setCreatorUserId(userId);
 357         service.setContactId("contactId@sdc.com");
 358         List<CategoryDefinition> categories = new ArrayList<>();
 359         categories.add(category);
 360         service.setCategories(categories);
 361         service.setIcon("images/my.png");
 362         List<String> tags = new ArrayList<>();
 363         tags.add("TAG1");
 364         tags.add("TAG2");
 365         service.setTags(tags);
 366         return service;
 367     }
 368
 369     private void deleteAndCreateCategory(String category) {
 370         String[] names = category.split("/");
 371         OperationTestsUtil.deleteAndCreateServiceCategory(category, janusGraphDao);
 372         OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphDao);
 373     }
 374
 375     private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
 376         UserData userData = new UserData();
 377         userData.setUserId(userId);
 378         userData.setFirstName(firstName);
 379         userData.setLastName(lastName);
 380         if (role != null && !role.isEmpty()) {
 381             userData.setRole(role);
 382         } else {
 383             userData.setRole("ADMIN");
 384         }
 385
 386         janusGraphDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
 387         janusGraphDao.createNode(userData, UserData.class);
 388         janusGraphDao.commit();
 389
 390         return userData;
 391     }
 392
 393     public ResourceMetadataData createResource(String resourceName) {
 394
 395         ResourceMetadataData serviceData1 = new ResourceMetadataData();
 396         serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 397         Either<ResourceMetadataData, JanusGraphOperationStatus> createNode = janusGraphDao.createNode(serviceData1, ResourceMetadataData.class);
 398
 399         assertTrue("check resource created", createNode.isLeft());
 400         return createNode.left().value();
 401     }
 402 }