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