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