package org.openecomp.sdc.be.resources;
import com.google.gson.Gson;
-import com.thinkaurelius.titan.core.PropertyKey;
-import com.thinkaurelius.titan.core.TitanEdge;
-import com.thinkaurelius.titan.core.TitanFactory;
-import com.thinkaurelius.titan.core.TitanGraph;
-import com.thinkaurelius.titan.core.TitanVertex;
-import com.thinkaurelius.titan.core.attribute.Text;
-import com.thinkaurelius.titan.core.schema.TitanManagement;
+import org.janusgraph.core.PropertyKey;
+import org.janusgraph.core.JanusGraphEdge;
+import org.janusgraph.core.JanusGraphFactory;
+import org.janusgraph.core.JanusGraph;
+import org.janusgraph.core.JanusGraphVertex;
+import org.janusgraph.core.attribute.Text;
+import org.janusgraph.core.schema.JanusGraphManagement;
import fj.data.Either;
import org.apache.commons.configuration.BaseConfiguration;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
-import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
-import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
@ContextConfiguration("classpath:application-context-test.xml")
@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class,
DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class })
-public class TitanGenericDaoTest {
- private static Logger log = LoggerFactory.getLogger(TitanGenericDaoTest.class.getName());
+public class JanusGraphGenericDaoTest {
+ private static Logger log = LoggerFactory.getLogger(JanusGraphGenericDaoTest.class.getName());
private static ConfigurationManager configurationManager;
- @Resource(name = "titan-generic-dao")
- private TitanGenericDao titanDao;
+ @Resource(name = "janusgraph-generic-dao")
+ private JanusGraphGenericDao janusGraphDao;
@BeforeClass
public static void setupBeforeClass() {
ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
appConfigDir);
configurationManager = new ConfigurationManager(configurationSource);
- configurationManager.getConfiguration()
- .setTitanCfgFile("../catalog-be/src/main/resources/config/titan.properties");
- configurationManager.getConfiguration().setTitanInMemoryGraph(true);
+ configurationManager.getConfiguration().setJanusGraphCfgFile("../catalog-be/src/main/resources/config/janusgraph.properties");
+ configurationManager.getConfiguration().setJanusGraphInMemoryGraph(true);
}
// @Test
public void testcheckEdgeProps() {
- TitanGraph graph = titanDao.getGraph().left().value();
- TitanVertex v1 = graph.addVertex();
+ JanusGraph graph = janusGraphDao.getGraph().left().value();
+ JanusGraphVertex v1 = graph.addVertex();
v1.property("prop1", 123);
- TitanVertex v2 = graph.addVertex();
+ JanusGraphVertex v2 = graph.addVertex();
v2.property("prop1", 456);
- TitanEdge addEdge = v1.addEdge("label11", v2);
+ JanusGraphEdge addEdge = v1.addEdge("label11", v2);
addEdge.property("edgeProp", "my prop edge");
graph.tx().commit();
- Either<TitanVertex, TitanOperationStatus> v11 = titanDao.getVertexByProperty("prop1", 123);
+ Either<JanusGraphVertex, JanusGraphOperationStatus> v11 = janusGraphDao.getVertexByProperty("prop1", 123);
Iterator<Edge> edges = v11.left().value().edges(Direction.OUT, "label11");
Edge edge = edges.next();
// String value = (String)edge.value("edgeProp");
- String value = (String) titanDao.getProperty(edge, "edgeProp");
+ String value = (String) janusGraphDao.getProperty(edge, "edgeProp");
log.debug(value);
}
UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
UserStatusEnum.ACTIVE.name(), null);
- Either<UserData, TitanOperationStatus> newNode = titanDao.createNode(userData, UserData.class);
+ Either<UserData, JanusGraphOperationStatus> newNode = janusGraphDao.createNode(userData, UserData.class);
assertTrue(newNode.isLeft());
log.debug("{}", newNode.left().value());
- titanDao.commit();
+ janusGraphDao.commit();
ImmutablePair<String, Object> keyValueId = userData.getKeyValueId();
- Either<UserData, TitanOperationStatus> node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(),
+ Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(),
UserData.class);
- titanDao.commit();
+ janusGraphDao.commit();
assertTrue(node.isLeft());
log.debug("{}", node.left().value());
userData.setRole("Designer");
- node = titanDao.updateNode(userData, UserData.class);
+ node = janusGraphDao.updateNode(userData, UserData.class);
assertTrue(node.isLeft());
log.debug("{}", node.left().value());
assertEquals(null, "Designer", node.left().value().getRole());
- titanDao.commit();
+ janusGraphDao.commit();
- node = titanDao.deleteNode(userData, UserData.class);
+ node = janusGraphDao.deleteNode(userData, UserData.class);
assertTrue(node.isLeft());
log.debug("{}", node.left().value());
- titanDao.commit();
+ janusGraphDao.commit();
- node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class);
+ node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class);
assertTrue(node.isRight());
log.debug("{}", node.right().value());
UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester",
UserStatusEnum.ACTIVE.name(), null);
- Either<UserData, TitanOperationStatus> node1 = titanDao.createNode(userData1, UserData.class);
+ Either<UserData, JanusGraphOperationStatus> node1 = janusGraphDao.createNode(userData1, UserData.class);
assertTrue(node1.isLeft());
log.debug("{}", node1.left().value());
id = "userIddfkoer45abc";
UserData userData2 = new UserData("Mynadyhme123", "Mylasghtname", id, "emaighdl123", "Designer",
UserStatusEnum.ACTIVE.name(), null);
- Either<UserData, TitanOperationStatus> node2 = titanDao.createNode(userData2, UserData.class);
+ Either<UserData, JanusGraphOperationStatus> node2 = janusGraphDao.createNode(userData2, UserData.class);
assertTrue(node2.isLeft());
log.debug("{}", node2.left().value());
- titanDao.commit();
+ janusGraphDao.commit();
ImmutablePair<String, Object> keyValueId1 = userData1.getKeyValueId();
// get first node
- Either<UserData, TitanOperationStatus> node = titanDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(),
+ Either<UserData, JanusGraphOperationStatus> node = janusGraphDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(),
UserData.class);
assertTrue(node.isLeft());
log.debug("{}", node.left().value());
- titanDao.commit();
+ janusGraphDao.commit();
// get all must be 2 + 1 default user = 3
- Either<List<UserData>, TitanOperationStatus> all = titanDao.getAll(NodeTypeEnum.User, UserData.class);
+ Either<List<UserData>, JanusGraphOperationStatus> all = janusGraphDao.getAll(NodeTypeEnum.User, UserData.class);
assertTrue(all.isLeft());
assertTrue(all.left().value().size() > 0);
props.put(keyValueId1.getKey(), keyValueId1.getValue());
// get by criteria. must be 1
- Either<List<UserData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.User, props,
+ Either<List<UserData>, JanusGraphOperationStatus> byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.User, props,
UserData.class);
assertTrue(byCriteria.isLeft());
assertEquals(1, byCriteria.left().value().size());
log.debug("{}", byCriteria.left().value());
// delete all nodes
- node = titanDao.deleteNode(userData1, UserData.class);
+ node = janusGraphDao.deleteNode(userData1, UserData.class);
assertTrue(node.isLeft());
- node = titanDao.deleteNode(userData2, UserData.class);
+ node = janusGraphDao.deleteNode(userData2, UserData.class);
assertTrue(node.isLeft());
}
String id = "userId12345abc";
UserData userData = new UserData("Myname123", "Mylastname", id, "email123", UserRoleEnum.ADMIN.name(),
UserStatusEnum.ACTIVE.name(), null);
- titanDao.createNode(userData, UserData.class);
+ janusGraphDao.createNode(userData, UserData.class);
ResourceMetadataData resourceData = new ResourceMetadataData();
resourceData.getMetadataDataDefinition().setName("resourceForLock");
resourceData.getMetadataDataDefinition().setVersion("0.1");
resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
+ resourceData.getMetadataDataDefinition().getVersion());
- titanDao.createNode(resourceData, ResourceMetadataData.class);
- titanDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
- titanDao.commit();
+ janusGraphDao.createNode(resourceData, ResourceMetadataData.class);
+ janusGraphDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
+ janusGraphDao.commit();
- Either<List<Edge>, TitanOperationStatus> eitherEdges = titanDao.getEdgesForNode(userData, Direction.OUT);
+ Either<List<Edge>, JanusGraphOperationStatus> eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.OUT);
assertTrue(eitherEdges.isLeft());
assertEquals(1, eitherEdges.left().value().size());
- eitherEdges = titanDao.getEdgesForNode(userData, Direction.IN);
+ eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.IN);
assertTrue(eitherEdges.isLeft());
assertEquals(0, eitherEdges.left().value().size());
- eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.OUT);
+ eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.OUT);
assertTrue(eitherEdges.isLeft());
assertEquals(0, eitherEdges.left().value().size());
- eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.IN);
+ eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.IN);
assertTrue(eitherEdges.isLeft());
assertEquals(1, eitherEdges.left().value().size());
- eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.BOTH);
+ eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.BOTH);
assertTrue(eitherEdges.isLeft());
assertEquals(1, eitherEdges.left().value().size());
- eitherEdges = titanDao.getEdgesForNode(userData, Direction.BOTH);
+ eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.BOTH);
assertTrue(eitherEdges.isLeft());
assertEquals(1, eitherEdges.left().value().size());
- titanDao.deleteNode(userData, UserData.class);
- titanDao.deleteNode(resourceData, ResourceMetadataData.class);
- titanDao.commit();
+ janusGraphDao.deleteNode(userData, UserData.class);
+ janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
+ janusGraphDao.commit();
}
@Test
resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
+ resourceData.getMetadataDataDefinition().getVersion());
- Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
ResourceMetadataData.class);
assertTrue(resource1.isLeft());
- titanDao.commit();
+ janusGraphDao.commit();
String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId();
- Either<GraphNodeLock, TitanOperationStatus> nodeLock = titanDao
+ Either<GraphNodeLock, JanusGraphOperationStatus> nodeLock = janusGraphDao
.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isRight());
- assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value());
+ assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
- TitanOperationStatus status = titanDao.lockElement(resourceData);
- assertEquals(TitanOperationStatus.OK, status);
+ JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.OK, status);
- nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
+ nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isLeft());
assertEquals(lockId, nodeLock.left().value().getUniqueId());
- titanDao.commit();
+ janusGraphDao.commit();
- status = titanDao.lockElement(resourceData);
- assertEquals(TitanOperationStatus.ALREADY_LOCKED, status);
+ status = janusGraphDao.lockElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.ALREADY_LOCKED, status);
- status = titanDao.releaseElement(resourceData);
- assertEquals(TitanOperationStatus.OK, status);
+ status = janusGraphDao.releaseElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.OK, status);
- nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
+ nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isRight());
- assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value());
- titanDao.deleteNode(resourceData, ResourceMetadataData.class);
- titanDao.commit();
+ assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
+ janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
+ janusGraphDao.commit();
}
resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
+ resourceData.getMetadataDataDefinition().getVersion());
- Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
ResourceMetadataData.class);
assertTrue(resource1.isLeft());
- titanDao.commit();
+ janusGraphDao.commit();
String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId();
- Either<GraphNodeLock, TitanOperationStatus> nodeLock = titanDao
+ Either<GraphNodeLock, JanusGraphOperationStatus> nodeLock = janusGraphDao
.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isRight());
- assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value());
+ assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
// lock
- TitanOperationStatus status = titanDao.lockElement(resourceData);
- assertEquals(TitanOperationStatus.OK, status);
+ JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.OK, status);
- nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
+ nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isLeft());
assertEquals(lockId, nodeLock.left().value().getUniqueId());
long time1 = nodeLock.left().value().getTime();
- titanDao.commit();
+ janusGraphDao.commit();
// timeout
- configurationManager.getConfiguration().setTitanLockTimeout(2L);
+ configurationManager.getConfiguration().setJanusGraphLockTimeout(2L);
Thread.sleep(5001);
// relock
- status = titanDao.lockElement(resourceData);
- assertEquals(TitanOperationStatus.OK, status);
+ status = janusGraphDao.lockElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.OK, status);
- nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
+ nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isLeft());
assertEquals(lockId, nodeLock.left().value().getUniqueId());
assertTrue(time2 > time1);
- status = titanDao.releaseElement(resourceData);
- assertEquals(TitanOperationStatus.OK, status);
+ status = janusGraphDao.releaseElement(resourceData);
+ assertEquals(JanusGraphOperationStatus.OK, status);
- nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
+ nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class);
assertTrue(nodeLock.isRight());
- assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value());
+ assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value());
- titanDao.deleteNode(resourceData, ResourceMetadataData.class);
- titanDao.commit();
+ janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class);
+ janusGraphDao.commit();
}
resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
+ resourceData.getMetadataDataDefinition().getVersion());
- Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> resource1 = janusGraphDao.createNode(resourceData,
ResourceMetadataData.class);
assertTrue(resource1.isLeft());
resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "."
+ resourceData.getMetadataDataDefinition().getVersion());
- Either<ResourceMetadataData, TitanOperationStatus> resource2 = titanDao.createNode(resourceData,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> resource2 = janusGraphDao.createNode(resourceData,
ResourceMetadataData.class);
- titanDao.commit();
+ janusGraphDao.commit();
Map<String, Object> props = new HashMap<>();
props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false);
// get by criteria. must be 1
- Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao
+ Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
assertTrue(byCriteria.isLeft());
- titanDao.deleteNode(resource1.left().value(), ResourceMetadataData.class);
+ janusGraphDao.deleteNode(resource1.left().value(), ResourceMetadataData.class);
- titanDao.deleteNode(resource2.left().value(), ResourceMetadataData.class);
- titanDao.commit();
+ janusGraphDao.deleteNode(resource2.left().value(), ResourceMetadataData.class);
+ janusGraphDao.commit();
}
// @Test
public void testStringSearch() {
- TitanGraph graph;
+ JanusGraph graph;
BaseConfiguration conf = new BaseConfiguration();
conf.setProperty("storage.backend", "inmemory");
- graph = TitanFactory.open(conf);
+ graph = JanusGraphFactory.open(conf);
- // TitanManagement graphMgt = graph.getManagementSystem();
- TitanManagement graphMgt = graph.openManagement();
+ // JanusGraphManagement graphMgt = graph.getManagementSystem();
+ JanusGraphManagement graphMgt = graph.openManagement();
PropertyKey propKey = graphMgt.makePropertyKey("string1").dataType(String.class).make();
graphMgt.buildIndex("string1", Vertex.class).addKey(propKey).unique().buildCompositeIndex();
log.debug("**** predicat index search non case");
- Iterable<TitanVertex> vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices();
- Iterator<TitanVertex> iter = vertices.iterator();
+ Iterable<JanusGraphVertex> vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices();
+ Iterator<JanusGraphVertex> iter = vertices.iterator();
while (iter.hasNext()) {
Vertex ver = iter.next();
// System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver));
- log.debug("{}", titanDao.getProperties(ver));
+ log.debug("{}", janusGraphDao.getProperties(ver));
}
}
@Test
- public void testDuplicateResultDueToTitanBug() {
+ public void testDuplicateResultDueToJanusGraphBug() {
ResourceMetadataData resourceData1 = new ResourceMetadataData();
resourceData1.getMetadataDataDefinition().setUniqueId("A");
((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
resourceData1.getMetadataDataDefinition().setName("aaaa");
- Either<ResourceMetadataData, TitanOperationStatus> newNode1 = titanDao.createNode(resourceData1,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
ResourceMetadataData.class);
assertTrue(newNode1.isLeft());
log.debug("{}", newNode1.left().value());
- // titanDao.commit();
+ // janusGraphDao.commit();
Map<String, Object> props = new HashMap<>();
props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true);
- Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao
+ Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
assertTrue(byCriteria.isLeft());
assertEquals("check one result returned", 1, byCriteria.left().value().size());
- // titanDao.commit();
+ // janusGraphDao.commit();
ResourceMetadataData resourceToUpdate = new ResourceMetadataData();
((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false);
resourceToUpdate.getMetadataDataDefinition().setUniqueId("A");
- Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceToUpdate,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> updateNode = janusGraphDao.updateNode(resourceToUpdate,
ResourceMetadataData.class);
assertTrue(updateNode.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
- byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+ byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
assertTrue(byCriteria.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria.right().value());
AdditionalInfoParameterData infoParameterData = new AdditionalInfoParameterData();
idToKey.put("key1", "value1");
infoParameterData.setIdToKey(idToKey);
- Either<AdditionalInfoParameterData, TitanOperationStatus> newNode2 = titanDao.createNode(infoParameterData,
+ Either<AdditionalInfoParameterData, JanusGraphOperationStatus> newNode2 = janusGraphDao.createNode(infoParameterData,
AdditionalInfoParameterData.class);
assertTrue(newNode2.isLeft());
log.debug("{}", newNode2.left().value());
- // titanDao.commit();
+ // janusGraphDao.commit();
Map<String, String> idToKey2 = new HashMap<>();
idToKey2.put("key1", "value2");
// props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(),
// idToKey2);
- Either<List<AdditionalInfoParameterData>, TitanOperationStatus> byCriteria2 = titanDao
+ Either<List<AdditionalInfoParameterData>, JanusGraphOperationStatus> byCriteria2 = janusGraphDao
.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, AdditionalInfoParameterData.class);
assertTrue(byCriteria2.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria2.right().value());
infoParameterData.setIdToKey(idToKey2);
- Either<AdditionalInfoParameterData, TitanOperationStatus> updateNode2 = titanDao.updateNode(infoParameterData,
+ Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode2 = janusGraphDao.updateNode(infoParameterData,
AdditionalInfoParameterData.class);
assertTrue(updateNode2.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), idToKey);
- byCriteria2 = titanDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2,
+ byCriteria2 = janusGraphDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2,
AdditionalInfoParameterData.class);
assertTrue(byCriteria2.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria2.right().value());
ComponentInstanceData resourceInstanceData = new ComponentInstanceData();
resourceInstanceData.getComponentInstDataDefinition().setPosX("22");
resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1");
- Either<ComponentInstanceData, TitanOperationStatus> newNode3 = titanDao.createNode(resourceInstanceData,
+ Either<ComponentInstanceData, JanusGraphOperationStatus> newNode3 = janusGraphDao.createNode(resourceInstanceData,
ComponentInstanceData.class);
assertTrue(newNode3.isLeft());
log.debug("{}", newNode3.left().value());
- // titanDao.commit();
+ // janusGraphDao.commit();
resourceInstanceData.getComponentInstDataDefinition().setPosX("50");
- Either<ComponentInstanceData, TitanOperationStatus> updateNode3 = titanDao.updateNode(resourceInstanceData,
+ Either<ComponentInstanceData, JanusGraphOperationStatus> updateNode3 = janusGraphDao.updateNode(resourceInstanceData,
ComponentInstanceData.class);
assertTrue(updateNode3.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2");
- updateNode3 = titanDao.updateNode(resourceInstanceData, ComponentInstanceData.class);
+ updateNode3 = janusGraphDao.updateNode(resourceInstanceData, ComponentInstanceData.class);
assertTrue(updateNode3.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
Map<String, Object> props3 = new HashMap<>();
props3.put("positionX", "22");
- Either<List<ComponentInstanceData>, TitanOperationStatus> byCriteria3 = titanDao
+ Either<List<ComponentInstanceData>, JanusGraphOperationStatus> byCriteria3 = janusGraphDao
.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
assertTrue(byCriteria3.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria3.right().value());
props3.put("positionX", "50");
- byCriteria3 = titanDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
+ byCriteria3 = janusGraphDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class);
assertTrue(byCriteria3.isLeft());
/////////////////////////// check integer ////////////////////////
artifactData.getArtifactDataDefinition().setUniqueId("ad234");
artifactData.getArtifactDataDefinition().setTimeout(100);
- Either<ArtifactData, TitanOperationStatus> newNode4 = titanDao.createNode(artifactData, ArtifactData.class);
+ Either<ArtifactData, JanusGraphOperationStatus> newNode4 = janusGraphDao.createNode(artifactData, ArtifactData.class);
assertTrue(newNode4.isLeft());
log.debug("{}", newNode4.left().value());
- // titanDao.commit();
+ // janusGraphDao.commit();
artifactData.getArtifactDataDefinition().setTimeout(50);
- Either<ArtifactData, TitanOperationStatus> updateNode4 = titanDao.updateNode(artifactData, ArtifactData.class);
+ Either<ArtifactData, JanusGraphOperationStatus> updateNode4 = janusGraphDao.updateNode(artifactData, ArtifactData.class);
assertTrue(updateNode4.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
Map<String, Object> props4 = new HashMap<>();
props4.put("timeout", 100);
- Either<List<ArtifactData>, TitanOperationStatus> byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef,
+ Either<List<ArtifactData>, JanusGraphOperationStatus> byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef,
props4, ArtifactData.class);
assertTrue(byCriteria4.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria4.right().value());
props4.put("timeout", 50);
- byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class);
+ byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class);
assertTrue(byCriteria4.isLeft());
- titanDao.rollback();
+ janusGraphDao.rollback();
}
@Test
- public void testDuplicateResultUSeHasNotQueryDueToTitanBug() {
+ public void testDuplicateResultUSeHasNotQueryDueToJanusGraphBug() {
String name = "bbbb";
((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true);
resourceData1.getMetadataDataDefinition().setName(name);
- Either<ResourceMetadataData, TitanOperationStatus> newNode1 = titanDao.createNode(resourceData1,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> newNode1 = janusGraphDao.createNode(resourceData1,
ResourceMetadataData.class);
assertTrue(newNode1.isLeft());
log.debug("{}", newNode1.left().value());
- // titanDao.commit();
+ // janusGraphDao.commit();
Map<String, Object> props = new HashMap<>();
props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true);
- Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao
+ Either<List<ResourceMetadataData>, JanusGraphOperationStatus> byCriteria = janusGraphDao
.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
assertTrue(byCriteria.isLeft());
assertEquals("check one result returned", 1, byCriteria.left().value().size());
- // titanDao.commit();
+ // janusGraphDao.commit();
ResourceMetadataData resourceToUpdate = new ResourceMetadataData();
((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false);
resourceToUpdate.getMetadataDataDefinition().setUniqueId("A");
- Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceToUpdate,
+ Either<ResourceMetadataData, JanusGraphOperationStatus> updateNode = janusGraphDao.updateNode(resourceToUpdate,
ResourceMetadataData.class);
assertTrue(updateNode.isLeft());
- // titanDao.commit();
+ // janusGraphDao.commit();
// no result where isAbstract = true
- byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
+ byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
assertTrue(byCriteria.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria.right().value());
// one result where isAbstract != true
- byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
+ byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
assertTrue(byCriteria.isLeft());
assertEquals("check one result returned", 1, byCriteria.left().value().size());
props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false);
- byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
+ byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class);
assertTrue(byCriteria.isRight());
- assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND,
+ assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND,
byCriteria.right().value());
- titanDao.rollback();
+ janusGraphDao.rollback();
}
Code Review / sdc.git / blobdiff