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