2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.resources;
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;
62 import javax.annotation.Resource;
63 import java.util.HashMap;
64 import java.util.Iterator;
65 import java.util.List;
68 import static org.junit.Assert.assertEquals;
69 import static org.junit.Assert.assertTrue;
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;
79 @Resource(name = "janusgraph-generic-dao")
80 private JanusGraphGenericDao janusGraphDao;
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(),
88 configurationManager = new ConfigurationManager(configurationSource);
89 configurationManager.getConfiguration().setJanusGraphCfgFile("../catalog-be/src/main/resources/config/janusgraph.properties");
90 configurationManager.getConfiguration().setJanusGraphInMemoryGraph(true);
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");
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");
114 public void testCrudNode() {
116 String id = "userId12345abc";
117 UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
118 UserStatusEnum.ACTIVE.name(), null);
120 Either<UserData, JanusGraphOperationStatus> newNode = janusGraphDao.createNode(userData, UserData.class);
122 assertTrue(newNode.isLeft());
124 log.debug("{}", newNode.left().value());
126 janusGraphDao.commit();
128 ImmutablePair<String, Object> keyValueId = userData.getKeyValueId();
129 Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(),
131 janusGraphDao.commit();
132 assertTrue(node.isLeft());
133 log.debug("{}", node.left().value());
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();
142 node = janusGraphDao.deleteNode(userData, UserData.class);
143 assertTrue(node.isLeft());
144 log.debug("{}", node.left().value());
145 janusGraphDao.commit();
147 node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class);
148 assertTrue(node.isRight());
149 log.debug("{}", node.right().value());
154 public void testGetByCategoryAndAll() {
157 String id = "userId12345abc";
158 UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
159 UserStatusEnum.ACTIVE.name(), null);
161 Either<UserData, JanusGraphOperationStatus> node1 = janusGraphDao.createNode(userData1, UserData.class);
162 assertTrue(node1.isLeft());
163 log.debug("{}", node1.left().value());
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());
172 janusGraphDao.commit();
174 ImmutablePair<String, Object> keyValueId1 = userData1.getKeyValueId();
176 Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(),
178 assertTrue(node.isLeft());
179 log.debug("{}", node.left().value());
180 janusGraphDao.commit();
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);
187 log.debug("{}", all.left().value());
189 Map<String, Object> props = new HashMap<>();
191 props.put(keyValueId1.getKey(), keyValueId1.getValue());
193 // get by criteria. must be 1
194 Either<List<UserData>, JanusGraphOperationStatus> byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.User, props,
196 assertTrue(byCriteria.isLeft());
197 assertEquals(1, byCriteria.left().value().size());
199 log.debug("{}", byCriteria.left().value());
202 node = janusGraphDao.deleteNode(userData1, UserData.class);
203 assertTrue(node.isLeft());
204 node = janusGraphDao.deleteNode(userData2, UserData.class);
205 assertTrue(node.isLeft());
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());
221 janusGraphDao.createNode(resourceData, ResourceMetadataData.class);
222 janusGraphDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
223 janusGraphDao.commit();
225 Either<List<Edge>, JanusGraphOperationStatus> eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.OUT);
226 assertTrue(eitherEdges.isLeft());
227 assertEquals(1, eitherEdges.left().value().size());
229 eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.IN);
230 assertTrue(eitherEdges.isLeft());
231 assertEquals(0, eitherEdges.left().value().size());
233 eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.OUT);
234 assertTrue(eitherEdges.isLeft());
235 assertEquals(0, eitherEdges.left().value().size());
237 eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.IN);
238 assertTrue(eitherEdges.isLeft());
239 assertEquals(1, eitherEdges.left().value().size());
241 eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.BOTH);
242 assertTrue(eitherEdges.isLeft());
243 assertEquals(1, eitherEdges.left().value().size());
245 eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.BOTH);
246 assertTrue(eitherEdges.isLeft());
247 assertEquals(1, eitherEdges.left().value().size());
249 janusGraphDao.deleteNode(userData, UserData.class);
250 janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
251 janusGraphDao.commit();
255 public void testLockElement() {
257 ResourceMetadataData resourceData = new ResourceMetadataData();
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());
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();
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());
276 JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
277 assertEquals(JanusGraphOperationStatus.OK, status);
279 nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
280 assertTrue(nodeLock.isLeft());
281 assertEquals(lockId, nodeLock.left().value().getUniqueId());
283 janusGraphDao.commit();
285 status = janusGraphDao.lockElement(resourceData);
286 assertEquals(JanusGraphOperationStatus.ALREADY_LOCKED, status);
288 status = janusGraphDao.releaseElement(resourceData);
289 assertEquals(JanusGraphOperationStatus.OK, status);
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();
300 public void testReLockElement() throws InterruptedException {
302 ResourceMetadataData resourceData = new ResourceMetadataData();
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());
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();
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());
322 JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
323 assertEquals(JanusGraphOperationStatus.OK, status);
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();
330 janusGraphDao.commit();
333 configurationManager.getConfiguration().setJanusGraphLockTimeout(2L);
337 status = janusGraphDao.lockElement(resourceData);
338 assertEquals(JanusGraphOperationStatus.OK, status);
340 nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
341 assertTrue(nodeLock.isLeft());
342 assertEquals(lockId, nodeLock.left().value().getUniqueId());
344 long time2 = nodeLock.left().value().getTime();
346 assertTrue(time2 > time1);
348 status = janusGraphDao.releaseElement(resourceData);
349 assertEquals(JanusGraphOperationStatus.OK, status);
351 nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
352 assertTrue(nodeLock.isRight());
353 assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
355 janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
356 janusGraphDao.commit();
361 public void testBoolean() {
362 ResourceMetadataData resourceData = new ResourceMetadataData();
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());
371 Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
372 ResourceMetadataData.class);
373 assertTrue(resource1.isLeft());
375 resourceData = new ResourceMetadataData();
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());
384 Either<ResourceMetadataData, JanusGraphOperationStatus> resource2 = janusGraphDao.createNode(resourceData,
385 ResourceMetadataData.class);
386 janusGraphDao.commit();
388 Map<String, Object> props = new HashMap<>();
390 props.put(GraphPropertiesDictionary.STATE.getProperty(), "NOT_CERTIFIED_CHECKOUT");
391 props.put("name", "resourceForLock");
392 props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false);
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());
399 janusGraphDao.deleteNode(resource1.left().value(), ResourceMetadataData.class);
401 janusGraphDao.deleteNode(resource2.left().value(), ResourceMetadataData.class);
402 janusGraphDao.commit();
406 public void testStringSearch() {
409 BaseConfiguration conf = new BaseConfiguration();
410 conf.setProperty("storage.backend", "inmemory");
411 graph = JanusGraphFactory.open(conf);
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();
418 propKey = graphMgt.makePropertyKey("string2").dataType(String.class).make();
420 graphMgt.buildIndex("string2", Vertex.class).addKey(propKey).unique().buildCompositeIndex();
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));
436 public void testDuplicateResultDueToJanusGraphBug() {
438 ResourceMetadataData resourceData1 = new ResourceMetadataData();
439 resourceData1.getMetadataDataDefinition().setUniqueId("A");
440 ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
441 resourceData1.getMetadataDataDefinition().setName("aaaa");
443 Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
444 ResourceMetadataData.class);
445 assertTrue(newNode1.isLeft());
446 log.debug("{}", newNode1.left().value());
447 // janusGraphDao.commit();
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();
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();
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());
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);
476 Either<AdditionalInfoParameterData, JanusGraphOperationStatus> newNode2 = janusGraphDao.createNode(infoParameterData,
477 AdditionalInfoParameterData.class);
478 assertTrue(newNode2.isLeft());
479 log.debug("{}", newNode2.left().value());
480 // janusGraphDao.commit();
482 Map<String, String> idToKey2 = new HashMap<>();
483 idToKey2.put("key1", "value2");
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(),
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());
498 infoParameterData.setIdToKey(idToKey2);
500 Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode2 = janusGraphDao.updateNode(infoParameterData,
501 AdditionalInfoParameterData.class);
502 assertTrue(updateNode2.isLeft());
503 // janusGraphDao.commit();
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());
512 ComponentInstanceData resourceInstanceData = new ComponentInstanceData();
513 resourceInstanceData.getComponentInstDataDefinition().setUniqueId("ri123");
514 resourceInstanceData.getComponentInstDataDefinition().setPosX("22");
515 resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1");
517 Either<ComponentInstanceData, JanusGraphOperationStatus> newNode3 = janusGraphDao.createNode(resourceInstanceData,
518 ComponentInstanceData.class);
519 assertTrue(newNode3.isLeft());
520 log.debug("{}", newNode3.left().value());
521 // janusGraphDao.commit();
523 resourceInstanceData.getComponentInstDataDefinition().setPosX("50");
524 Either<ComponentInstanceData, JanusGraphOperationStatus> updateNode3 = janusGraphDao.updateNode(resourceInstanceData,
525 ComponentInstanceData.class);
526 assertTrue(updateNode3.isLeft());
527 // janusGraphDao.commit();
529 resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2");
530 updateNode3 = janusGraphDao.updateNode(resourceInstanceData, ComponentInstanceData.class);
531 assertTrue(updateNode3.isLeft());
532 // janusGraphDao.commit();
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());
542 props3.put("positionX", "50");
543 byCriteria3 = janusGraphDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
544 assertTrue(byCriteria3.isLeft());
546 /////////////////////////// check integer ////////////////////////
548 ArtifactData artifactData = new ArtifactData();
549 artifactData.getArtifactDataDefinition().setUniqueId("ad234");
550 artifactData.getArtifactDataDefinition().setTimeout(100);
552 Either<ArtifactData, JanusGraphOperationStatus> newNode4 = janusGraphDao.createNode(artifactData, ArtifactData.class);
553 assertTrue(newNode4.isLeft());
554 log.debug("{}", newNode4.left().value());
555 // janusGraphDao.commit();
557 artifactData.getArtifactDataDefinition().setTimeout(50);
558 Either<ArtifactData, JanusGraphOperationStatus> updateNode4 = janusGraphDao.updateNode(artifactData, ArtifactData.class);
559 assertTrue(updateNode4.isLeft());
560 // janusGraphDao.commit();
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());
570 props4.put("timeout", 50);
571 byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class);
572 assertTrue(byCriteria4.isLeft());
574 janusGraphDao.rollback();
578 public void testDuplicateResultUSeHasNotQueryDueToJanusGraphBug() {
580 String name = "bbbb";
582 ResourceMetadataData resourceData1 = new ResourceMetadataData();
583 resourceData1.getMetadataDataDefinition().setUniqueId("A");
584 ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
585 resourceData1.getMetadataDataDefinition().setName(name);
587 Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
588 ResourceMetadataData.class);
589 assertTrue(newNode1.isLeft());
590 log.debug("{}", newNode1.left().value());
591 // janusGraphDao.commit();
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();
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();
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());
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());
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());
626 janusGraphDao.rollback();