catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JanusGraphGenericDaoTest.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.resources;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25
  26 import com.google.gson.Gson;
  27 import fj.data.Either;
  28 import java.util.HashMap;
  29 import java.util.Iterator;
  30 import java.util.List;
  31 import java.util.Map;
  32 import javax.annotation.Resource;
  33 import org.apache.commons.configuration.BaseConfiguration;
  34 import org.apache.commons.lang3.tuple.ImmutablePair;
  35 import org.apache.tinkerpop.gremlin.structure.Direction;
  36 import org.apache.tinkerpop.gremlin.structure.Edge;
  37 import org.apache.tinkerpop.gremlin.structure.Vertex;
  38 import org.janusgraph.core.JanusGraph;
  39 import org.janusgraph.core.JanusGraphEdge;
  40 import org.janusgraph.core.JanusGraphFactory;
  41 import org.janusgraph.core.JanusGraphVertex;
  42 import org.janusgraph.core.PropertyKey;
  43 import org.janusgraph.core.attribute.Text;
  44 import org.janusgraph.core.schema.JanusGraphManagement;
  45 import org.junit.jupiter.api.BeforeAll;
  46 import org.junit.jupiter.api.Test;
  47 import org.openecomp.sdc.be.config.ConfigurationManager;
  48 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  50 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  51 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  52 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  53 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  55 import org.openecomp.sdc.be.resources.data.AdditionalInfoParameterData;
  56 import org.openecomp.sdc.be.resources.data.ArtifactData;
  57 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
  58 import org.openecomp.sdc.be.resources.data.GraphNodeLock;
  59 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  60 import org.openecomp.sdc.be.resources.data.UserData;
  61 import org.openecomp.sdc.common.api.ConfigurationSource;
  62 import org.openecomp.sdc.common.api.UserRoleEnum;
  63 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  64 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67 import org.springframework.test.context.TestExecutionListeners;
  68 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  69 import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
  70 import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
  71 import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
  72
  73 @SpringJUnitConfig(locations = "classpath:application-context-test.xml")
  74 @TestExecutionListeners(listeners = {DependencyInjectionTestExecutionListener.class,
  75     DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class})
  76 public class JanusGraphGenericDaoTest {
  77
  78     private static Logger log = LoggerFactory.getLogger(JanusGraphGenericDaoTest.class.getName());
  79     private static ConfigurationManager configurationManager;
  80
  81     @Resource(name = "janusgraph-generic-dao")
  82     private JanusGraphGenericDao janusGraphDao;
  83
  84     @BeforeAll
  85     public static void setupBeforeClass() {
  86         ExternalConfiguration.setAppName("catalog-dao");
  87         String appConfigDir = "src/test/resources/config/catalog-dao";
  88         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
  89             appConfigDir);
  90         configurationManager = new ConfigurationManager(configurationSource);
  91         configurationManager.getConfiguration().setJanusGraphCfgFile("../catalog-be/src/main/resources/config/janusgraph.properties");
  92         configurationManager.getConfiguration().setJanusGraphInMemoryGraph(true);
  93     }
  94
  95     @Test
  96     public void testcheckEdgeProps() {
  97         JanusGraph graph = janusGraphDao.getGraph().left().value();
  98         JanusGraphVertex v1 = graph.addVertex();
  99         v1.property("prop1", 123);
 100         JanusGraphVertex v2 = graph.addVertex();
 101         v2.property("prop1", 456);
 102         JanusGraphEdge addEdge = v1.addEdge("label11", v2);
 103         addEdge.property("edgeProp", "my prop edge");
 104         graph.tx().commit();
 105
 106         Either<JanusGraphVertex, JanusGraphOperationStatus> v11 = janusGraphDao.getVertexByProperty("prop1", 123);
 107         Iterator<Edge> edges = v11.left().value().edges(Direction.OUT, "label11");
 108         Edge edge = edges.next();
 109         // String value = (String)edge.value("edgeProp");
 110         String value = (String) janusGraphDao.getProperty(edge, "edgeProp");
 111         log.debug(value);
 112
 113     }
 114
 115     @Test
 116     public void testCrudNode() {
 117
 118         String id = "userId12345abc";
 119         UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
 120             UserStatusEnum.ACTIVE.name(), null);
 121
 122         Either<UserData, JanusGraphOperationStatus> newNode = janusGraphDao.createNode(userData, UserData.class);
 123
 124         assertTrue(newNode.isLeft());
 125
 126         log.debug("{}", newNode.left().value());
 127
 128         janusGraphDao.commit();
 129
 130         ImmutablePair<String, Object> keyValueId = userData.getKeyValueId();
 131         Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(),
 132             UserData.class);
 133         janusGraphDao.commit();
 134         assertTrue(node.isLeft());
 135         log.debug("{}", node.left().value());
 136
 137         userData.setRole("Designer");
 138         node = janusGraphDao.updateNode(userData, UserData.class);
 139         assertTrue(node.isLeft());
 140         log.debug("{}", node.left().value());
 141         assertEquals(null, "Designer", node.left().value().getRole());
 142         janusGraphDao.commit();
 143
 144         node = janusGraphDao.deleteNode(userData, UserData.class);
 145         assertTrue(node.isLeft());
 146         log.debug("{}", node.left().value());
 147         janusGraphDao.commit();
 148
 149         node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class);
 150         assertTrue(node.isRight());
 151         log.debug("{}", node.right().value());
 152
 153     }
 154
 155     @Test
 156     public void testGetByCategoryAndAll() {
 157
 158         // create 2 nodes
 159         String id = "userId12345abc";
 160         UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
 161             UserStatusEnum.ACTIVE.name(), null);
 162
 163         Either<UserData, JanusGraphOperationStatus> node1 = janusGraphDao.createNode(userData1, UserData.class);
 164         assertTrue(node1.isLeft());
 165         log.debug("{}", node1.left().value());
 166
 167         id = "userIddfkoer45abc";
 168         UserData userData2 = new UserData("Mynadyhme123", "Mylasghtname", id, "emaighdl123", "Designer",
 169             UserStatusEnum.ACTIVE.name(), null);
 170         Either<UserData, JanusGraphOperationStatus> node2 = janusGraphDao.createNode(userData2, UserData.class);
 171         assertTrue(node2.isLeft());
 172         log.debug("{}", node2.left().value());
 173
 174         janusGraphDao.commit();
 175
 176         ImmutablePair<String, Object> keyValueId1 = userData1.getKeyValueId();
 177         // get first node
 178         Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(),
 179             UserData.class);
 180         assertTrue(node.isLeft());
 181         log.debug("{}", node.left().value());
 182         janusGraphDao.commit();
 183
 184         // get all must be 2 + 1 default user = 3
 185         Either<List<UserData>, JanusGraphOperationStatus> all = janusGraphDao.getAll(NodeTypeEnum.User, UserData.class);
 186         assertTrue(all.isLeft());
 187         assertTrue(all.left().value().size() > 0);
 188
 189         log.debug("{}", all.left().value());
 190
 191         Map<String, Object> props = new HashMap<>();
 192
 193         props.put(keyValueId1.getKey(), keyValueId1.getValue());
 194
 195         // get by criteria. must be 1
 196         Either<List<UserData>, JanusGraphOperationStatus> byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.User, props,
 197             UserData.class);
 198         assertTrue(byCriteria.isLeft());
 199         assertEquals(1, byCriteria.left().value().size());
 200
 201         log.debug("{}", byCriteria.left().value());
 202
 203         // delete all nodes
 204         node = janusGraphDao.deleteNode(userData1, UserData.class);
 205         assertTrue(node.isLeft());
 206         node = janusGraphDao.deleteNode(userData2, UserData.class);
 207         assertTrue(node.isLeft());
 208     }
 209
 210     @Test
 211     public void testGetEdgesForNode() {
 212         String id = "userId12345abc";
 213         UserData userData = new UserData("Myname123", "Mylastname", id, "email123", UserRoleEnum.ADMIN.name(),
 214             UserStatusEnum.ACTIVE.name(), null);
 215         janusGraphDao.createNode(userData, UserData.class);
 216         ResourceMetadataData resourceData = new ResourceMetadataData();
 217         resourceData.getMetadataDataDefinition().setName("resourceForLock");
 218         resourceData.getMetadataDataDefinition().setVersion("0.1");
 219         resourceData.getMetadataDataDefinition().setState("newState");
 220         resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
 221             + resourceData.getMetadataDataDefinition().getVersion());
 222
 223         janusGraphDao.createNode(resourceData, ResourceMetadataData.class);
 224         janusGraphDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
 225         janusGraphDao.commit();
 226
 227         Either<List<Edge>, JanusGraphOperationStatus> eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.OUT);
 228         assertTrue(eitherEdges.isLeft());
 229         assertEquals(1, eitherEdges.left().value().size());
 230
 231         eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.IN);
 232         assertTrue(eitherEdges.isLeft());
 233         assertEquals(0, eitherEdges.left().value().size());
 234
 235         eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.OUT);
 236         assertTrue(eitherEdges.isLeft());
 237         assertEquals(0, eitherEdges.left().value().size());
 238
 239         eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.IN);
 240         assertTrue(eitherEdges.isLeft());
 241         assertEquals(1, eitherEdges.left().value().size());
 242
 243         eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.BOTH);
 244         assertTrue(eitherEdges.isLeft());
 245         assertEquals(1, eitherEdges.left().value().size());
 246
 247         eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.BOTH);
 248         assertTrue(eitherEdges.isLeft());
 249         assertEquals(1, eitherEdges.left().value().size());
 250
 251         janusGraphDao.deleteNode(userData, UserData.class);
 252         janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
 253         janusGraphDao.commit();
 254     }
 255
 256     @Test
 257     public void testLockElement() {
 258
 259         ResourceMetadataData resourceData = new ResourceMetadataData();
 260
 261         resourceData.getMetadataDataDefinition().setName("resourceForLock");
 262         resourceData.getMetadataDataDefinition().setVersion("0.1");
 263         resourceData.getMetadataDataDefinition().setState("newState");
 264         resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
 265             + resourceData.getMetadataDataDefinition().getVersion());
 266
 267         Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
 268             ResourceMetadataData.class);
 269         assertTrue(resource1.isLeft());
 270         janusGraphDao.commit();
 271         String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId();
 272
 273         Either<GraphNodeLock, JanusGraphOperationStatus> nodeLock = janusGraphDao
 274             .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 275         assertTrue(nodeLock.isRight());
 276         assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
 277
 278         JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
 279         assertEquals(JanusGraphOperationStatus.OK, status);
 280
 281         nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 282         assertTrue(nodeLock.isLeft());
 283         assertEquals(lockId, nodeLock.left().value().getUniqueId());
 284
 285         janusGraphDao.commit();
 286
 287         status = janusGraphDao.lockElement(resourceData);
 288         assertEquals(JanusGraphOperationStatus.ALREADY_LOCKED, status);
 289
 290         status = janusGraphDao.releaseElement(resourceData);
 291         assertEquals(JanusGraphOperationStatus.OK, status);
 292
 293         nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 294         assertTrue(nodeLock.isRight());
 295         assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
 296         janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
 297         janusGraphDao.commit();
 298
 299     }
 300
 301     @Test
 302     public void testReLockElement() throws InterruptedException {
 303
 304         ResourceMetadataData resourceData = new ResourceMetadataData();
 305
 306         resourceData.getMetadataDataDefinition().setName("resourceForReLock");
 307         resourceData.getMetadataDataDefinition().setVersion("0.1");
 308         resourceData.getMetadataDataDefinition().setState("newState");
 309         resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
 310             + resourceData.getMetadataDataDefinition().getVersion());
 311
 312         Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
 313             ResourceMetadataData.class);
 314         assertTrue(resource1.isLeft());
 315         janusGraphDao.commit();
 316         String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId();
 317
 318         Either<GraphNodeLock, JanusGraphOperationStatus> nodeLock = janusGraphDao
 319             .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 320         assertTrue(nodeLock.isRight());
 321         assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
 322
 323         // lock
 324         JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
 325         assertEquals(JanusGraphOperationStatus.OK, status);
 326
 327         nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 328         assertTrue(nodeLock.isLeft());
 329         assertEquals(lockId, nodeLock.left().value().getUniqueId());
 330         long time1 = nodeLock.left().value().getTime();
 331
 332         janusGraphDao.commit();
 333
 334         // timeout
 335         configurationManager.getConfiguration().setJanusGraphLockTimeout(2L);
 336         Thread.sleep(5001);
 337
 338         // relock
 339         status = janusGraphDao.lockElement(resourceData);
 340         assertEquals(JanusGraphOperationStatus.OK, status);
 341
 342         nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 343         assertTrue(nodeLock.isLeft());
 344         assertEquals(lockId, nodeLock.left().value().getUniqueId());
 345
 346         long time2 = nodeLock.left().value().getTime();
 347
 348         assertTrue(time2 > time1);
 349
 350         status = janusGraphDao.releaseElement(resourceData);
 351         assertEquals(JanusGraphOperationStatus.OK, status);
 352
 353         nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
 354         assertTrue(nodeLock.isRight());
 355         assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
 356
 357         janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
 358         janusGraphDao.commit();
 359
 360     }
 361
 362     @Test
 363     public void testBoolean() {
 364         ResourceMetadataData resourceData = new ResourceMetadataData();
 365
 366         resourceData.getMetadataDataDefinition().setName("resourceForLock");
 367         resourceData.getMetadataDataDefinition().setVersion("0.1");
 368         resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT");
 369         resourceData.getMetadataDataDefinition().setHighestVersion(true);
 370         resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
 371             + resourceData.getMetadataDataDefinition().getVersion());
 372
 373         Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
 374             ResourceMetadataData.class);
 375         assertTrue(resource1.isLeft());
 376
 377         resourceData = new ResourceMetadataData();
 378
 379         resourceData.getMetadataDataDefinition().setName("resourceForLock");
 380         resourceData.getMetadataDataDefinition().setVersion("0.2");
 381         resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT");
 382         resourceData.getMetadataDataDefinition().setHighestVersion(false);
 383         resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
 384             + resourceData.getMetadataDataDefinition().getVersion());
 385
 386         Either<ResourceMetadataData, JanusGraphOperationStatus> resource2 = janusGraphDao.createNode(resourceData,
 387             ResourceMetadataData.class);
 388         janusGraphDao.commit();
 389
 390         Map<String, Object> props = new HashMap<>();
 391
 392         props.put(GraphPropertiesDictionary.STATE.getProperty(), "NOT_CERTIFIED_CHECKOUT");
 393         props.put("name", "resourceForLock");
 394         props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false);
 395
 396         // get by criteria. must be 1
 397         Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
 398             .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 399         assertTrue(byCriteria.isLeft());
 400
 401         janusGraphDao.deleteNode(resource1.left().value(), ResourceMetadataData.class);
 402
 403         janusGraphDao.deleteNode(resource2.left().value(), ResourceMetadataData.class);
 404         janusGraphDao.commit();
 405     }
 406
 407     @Test
 408     public void testStringSearch() {
 409         JanusGraph graph;
 410
 411         BaseConfiguration conf = new BaseConfiguration();
 412         conf.setProperty("storage.backend", "inmemory");
 413         graph = JanusGraphFactory.open(conf);
 414
 415         // JanusGraphManagement graphMgt = graph.getManagementSystem();
 416         JanusGraphManagement graphMgt = graph.openManagement();
 417         PropertyKey propKey = graphMgt.makePropertyKey("string1").dataType(String.class).make();
 418         graphMgt.buildIndex("string1", Vertex.class).addKey(propKey).unique().buildCompositeIndex();
 419
 420         propKey = graphMgt.makePropertyKey("string2").dataType(String.class).make();
 421
 422         graphMgt.buildIndex("string2", Vertex.class).addKey(propKey).unique().buildCompositeIndex();
 423         graphMgt.commit();
 424
 425         log.debug("**** predicat index search non case");
 426         Iterable<JanusGraphVertex> vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices();
 427         Iterator<JanusGraphVertex> iter = vertices.iterator();
 428         while (iter.hasNext()) {
 429             Vertex ver = iter.next();
 430             // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver));
 431             log.debug("{}", janusGraphDao.getProperties(ver));
 432         }
 433
 434     }
 435
 436     @Test
 437     public void testDuplicateResultDueToJanusGraphBug() {
 438
 439         ResourceMetadataData resourceData1 = new ResourceMetadataData();
 440         resourceData1.getMetadataDataDefinition().setUniqueId("A");
 441         ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
 442         resourceData1.getMetadataDataDefinition().setName("aaaa");
 443
 444         Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
 445             ResourceMetadataData.class);
 446         assertTrue(newNode1.isLeft());
 447         log.debug("{}", newNode1.left().value());
 448         // janusGraphDao.commit();
 449
 450         Map<String, Object> props = new HashMap<>();
 451         props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true);
 452         Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
 453             .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 454         assertTrue(byCriteria.isLeft());
 455         assertEquals("check one result returned", 1, byCriteria.left().value().size());
 456         // janusGraphDao.commit();
 457
 458         ResourceMetadataData resourceToUpdate = new ResourceMetadataData();
 459         ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false);
 460         resourceToUpdate.getMetadataDataDefinition().setUniqueId("A");
 461         Either<ResourceMetadataData, JanusGraphOperationStatus> updateNode = janusGraphDao.updateNode(resourceToUpdate,
 462             ResourceMetadataData.class);
 463         assertTrue(updateNode.isLeft());
 464         // janusGraphDao.commit();
 465
 466         byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 467         assertTrue(byCriteria.isRight());
 468         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 469             byCriteria.right().value());
 470
 471         AdditionalInfoParameterData infoParameterData = new AdditionalInfoParameterData();
 472         infoParameterData.getAdditionalInfoParameterDataDefinition().setUniqueId("123");
 473         Map<String, String> idToKey = new HashMap<>();
 474         idToKey.put("key1", "value1");
 475         infoParameterData.setIdToKey(idToKey);
 476
 477         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> newNode2 = janusGraphDao.createNode(infoParameterData,
 478             AdditionalInfoParameterData.class);
 479         assertTrue(newNode2.isLeft());
 480         log.debug("{}", newNode2.left().value());
 481         // janusGraphDao.commit();
 482
 483         Map<String, String> idToKey2 = new HashMap<>();
 484         idToKey2.put("key1", "value2");
 485
 486         Map<String, Object> props2 = new HashMap<>();
 487         props2.put(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), "123");
 488         Gson gson = new Gson();
 489         props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), gson.toJson(idToKey2));
 490         // props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(),
 491         // idToKey2);
 492
 493         Either<List<AdditionalInfoParameterData>, JanusGraphOperationStatus> byCriteria2 = janusGraphDao
 494             .getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, AdditionalInfoParameterData.class);
 495         assertTrue(byCriteria2.isRight());
 496         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 497             byCriteria2.right().value());
 498
 499         infoParameterData.setIdToKey(idToKey2);
 500
 501         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode2 = janusGraphDao.updateNode(infoParameterData,
 502             AdditionalInfoParameterData.class);
 503         assertTrue(updateNode2.isLeft());
 504         // janusGraphDao.commit();
 505
 506         props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), idToKey);
 507         byCriteria2 = janusGraphDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2,
 508             AdditionalInfoParameterData.class);
 509         assertTrue(byCriteria2.isRight());
 510         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 511             byCriteria2.right().value());
 512
 513         ComponentInstanceData resourceInstanceData = new ComponentInstanceData();
 514         resourceInstanceData.getComponentInstDataDefinition().setUniqueId("ri123");
 515         resourceInstanceData.getComponentInstDataDefinition().setPosX("22");
 516         resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1");
 517
 518         Either<ComponentInstanceData, JanusGraphOperationStatus> newNode3 = janusGraphDao.createNode(resourceInstanceData,
 519             ComponentInstanceData.class);
 520         assertTrue(newNode3.isLeft());
 521         log.debug("{}", newNode3.left().value());
 522         // janusGraphDao.commit();
 523
 524         resourceInstanceData.getComponentInstDataDefinition().setPosX("50");
 525         Either<ComponentInstanceData, JanusGraphOperationStatus> updateNode3 = janusGraphDao.updateNode(resourceInstanceData,
 526             ComponentInstanceData.class);
 527         assertTrue(updateNode3.isLeft());
 528         // janusGraphDao.commit();
 529
 530         resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2");
 531         updateNode3 = janusGraphDao.updateNode(resourceInstanceData, ComponentInstanceData.class);
 532         assertTrue(updateNode3.isLeft());
 533         // janusGraphDao.commit();
 534
 535         Map<String, Object> props3 = new HashMap<>();
 536         props3.put("positionX", "22");
 537         Either<List<ComponentInstanceData>, JanusGraphOperationStatus> byCriteria3 = janusGraphDao
 538             .getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
 539         assertTrue(byCriteria3.isRight());
 540         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 541             byCriteria3.right().value());
 542
 543         props3.put("positionX", "50");
 544         byCriteria3 = janusGraphDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
 545         assertTrue(byCriteria3.isLeft());
 546
 547         /////////////////////////// check integer ////////////////////////
 548
 549         ArtifactData artifactData = new ArtifactData();
 550         artifactData.getArtifactDataDefinition().setUniqueId("ad234");
 551         artifactData.getArtifactDataDefinition().setTimeout(100);
 552
 553         Either<ArtifactData, JanusGraphOperationStatus> newNode4 = janusGraphDao.createNode(artifactData, ArtifactData.class);
 554         assertTrue(newNode4.isLeft());
 555         log.debug("{}", newNode4.left().value());
 556         // janusGraphDao.commit();
 557
 558         artifactData.getArtifactDataDefinition().setTimeout(50);
 559         Either<ArtifactData, JanusGraphOperationStatus> updateNode4 = janusGraphDao.updateNode(artifactData, ArtifactData.class);
 560         assertTrue(updateNode4.isLeft());
 561         // janusGraphDao.commit();
 562
 563         Map<String, Object> props4 = new HashMap<>();
 564         props4.put("timeout", 100);
 565         Either<List<ArtifactData>, JanusGraphOperationStatus> byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef,
 566             props4, ArtifactData.class);
 567         assertTrue(byCriteria4.isRight());
 568         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 569             byCriteria4.right().value());
 570
 571         props4.put("timeout", 50);
 572         byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class);
 573         assertTrue(byCriteria4.isLeft());
 574
 575         janusGraphDao.rollback();
 576     }
 577
 578     @Test
 579     public void testDuplicateResultUSeHasNotQueryDueToJanusGraphBug() {
 580
 581         String name = "bbbb";
 582
 583         ResourceMetadataData resourceData1 = new ResourceMetadataData();
 584         resourceData1.getMetadataDataDefinition().setUniqueId("A");
 585         ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
 586         resourceData1.getMetadataDataDefinition().setName(name);
 587
 588         Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
 589             ResourceMetadataData.class);
 590         assertTrue(newNode1.isLeft());
 591         log.debug("{}", newNode1.left().value());
 592         // janusGraphDao.commit();
 593
 594         Map<String, Object> props = new HashMap<>();
 595         props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true);
 596         Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
 597             .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 598         assertTrue(byCriteria.isLeft());
 599         assertEquals("check one result returned", 1, byCriteria.left().value().size());
 600         // janusGraphDao.commit();
 601
 602         ResourceMetadataData resourceToUpdate = new ResourceMetadataData();
 603         ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false);
 604         resourceToUpdate.getMetadataDataDefinition().setUniqueId("A");
 605         Either<ResourceMetadataData, JanusGraphOperationStatus> updateNode = janusGraphDao.updateNode(resourceToUpdate,
 606             ResourceMetadataData.class);
 607         assertTrue(updateNode.isLeft());
 608         // janusGraphDao.commit();
 609
 610         // no result where isAbstract = true
 611         byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
 612         assertTrue(byCriteria.isRight());
 613         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 614             byCriteria.right().value());
 615
 616         // one result where isAbstract != true
 617         byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
 618         assertTrue(byCriteria.isLeft());
 619         assertEquals("check one result returned", 1, byCriteria.left().value().size());
 620
 621         props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false);
 622         byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
 623         assertTrue(byCriteria.isRight());
 624         assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
 625             byCriteria.right().value());
 626
 627         janusGraphDao.rollback();
 628
 629     }
 630
 631 }