should return path detail from A to B.
return neo.findPath(testNode[0]._id, { "to": "http://localhost:7474/db/data/node/" + testNode[1]._id, "max_depth": 3, "relationships": { "type": "testfriend", "direction": "out" }, "algorithm": "shortestPath" }).then(function(result) { result[0].start.should.equal("http://localhost:7474/db/data/node/" + testNode[0]._id); return result[0].end.should.equal("http://localhost:7474/db/data/node/" + testNode[1]._id); });
should throw error message.
(function() { return neo.findPath(); }).should["throw"](Error); return (function() { return neo.findPath(1); }).should["throw"](Error);
should return all task result.
return neo.executeBatch([ { "method": "GET", "to": "/node/" + testNode[0]._id, "id": parseInt(testNode[0]._id) }, { "method": "GET", "to": "/node/" + testNode[1]._id, "id": parseInt(testNode[1]._id) } ]).then(function(result) { result[0].id.should.equal(parseInt(testNode[0]._id)); return result[1].id.should.equal(parseInt(testNode[1]._id)); });
return (function() { return neo.executeBatch(); }).should["throw"](Error);
should return true.
return neo.createUniquenessConstraint('person', [randomProperty]).then(function(result) { return result.should.be["true"]; }).fail(function(result) { return console.log(randomProperty); });
(function() { return neo.createUniquenessConstraint(); }).should["throw"](Error); (function() { return neo.createUniquenessConstraint(1); }).should["throw"](Error); (function() { return neo.createUniquenessConstraint(1, 'some'); }).should["throw"](Error); return (function() { return neo.createUniquenessConstraint('testperson', {}); }).should["throw"](Error);
should return all constraint.
return neo.readConstraint().should.eventually.have.length.of.at.least(1);
return (function() { return neo.readConstraint(1); }).should["throw"](Error);
should return node with specified label and constraint.
return neo.readUniquenessConstraint('person', randomProperty).then(function(result) { return result[0]['property-keys'][0].should.equal(randomProperty); });
(function() { return neo.readUniquenessConstraint(); }).should["throw"](Error); (function() { return neo.readUniquenessConstraint(1); }).should["throw"](Error); (function() { return neo.readUniquenessConstraint(1, 'some'); }).should["throw"](Error); return (function() { return neo.readUniquenessConstraint('testperson', {}); }).should["throw"](Error);
return neo.deleteConstraint('person', randomProperty).should.eventually.be["true"];
(function() { return neo.deleteConstraint(); }).should["throw"](Error); (function() { return neo.deleteConstraint(1); }).should["throw"](Error); return (function() { return neo.deleteConstraint('some', 1); }).should["throw"](Error);
should run cypher query.
return neo.executeCypher('START n = node({nodeId}) RETURN n', { "nodeId": parseInt(testNode[0]._id) }).then(function(result) { return result.should.include.keys('columns'); });
should construct correct cypher query.
return queryBuilder.cypher('START n = node(*)').toString().should.equal('START n = node(*)');
return queryBuilder.direction('n').toString().should.equal('()');
return queryBuilder.direction('tn=n').toString().should.equal('-->(n)');
return queryBuilder.direction('fn=n').toString().should.equal('<--(n)');
return queryBuilder.direction('r=r').toString().should.equal('-[r]->');
return queryBuilder.direction('tr=r').toString().should.equal('-[r]->');
return queryBuilder.direction('fr=r').toString().should.equal('<-[r]-');
return queryBuilder.direction('or=r').toString().should.equal('<-[r]->');
return queryBuilder.direction('ir=r').toString().should.equal('-[r]-');
return queryBuilder.direction('--').toString().should.equal('--');
return queryBuilder.direction('n=n/r=friend/n=m').toString().should.equal('(n)-[friend]->(m)');
return queryBuilder.start('*').toString().should.equal('START n = node(*)');
queryBuilder.start(1).toString().should.equal('START n = node({id})'); queryBuilder.getParams().should.include.keys('id'); return queryBuilder.getParams().id.should.equal(1);
return queryBuilder.start('n = node(*)').toString().should.equal('START n = node(*)');
queryBuilder.start({ name: 'Kieve' }).toString().should.equal('START name = node({name})'); queryBuilder.getParams().should.include.keys('name'); return queryBuilder.getParams().name.should.equal('Kieve');
return queryBuilder.start('*', true).toString().should.equal('START r = relationship(*)');
queryBuilder.start(1, true).toString().should.equal('START r = relationship({id})'); queryBuilder.getParams().should.include.keys('id'); return queryBuilder.getParams().id.should.equal(1);
should create normal query.
return queryBuilder.create('n').toString().should.equal('CREATE n');
should create unique query.
return queryBuilder.create('n', true).toString().should.equal('CREATE UNIQUE n');
return queryBuilder.match('(movie:Movie)').toString().should.equal('MATCH (movie:Movie)');
return queryBuilder.where('n:Swedish').toString().should.equal('WHERE n:Swedish');
return queryBuilder["with"]('m').toString().should.equal('WITH m');
return queryBuilder.set("n.surname = 'Kieve'").toString().should.equal("SET n.surname = 'Kieve'");
return queryBuilder.merge('kieve:Critic').toString().should.equal('MERGE (kieve:Critic)');
return queryBuilder.drop('(movie:Movie)').toString().should.equal('DROP (movie:Movie)');
return queryBuilder.remove('kieve.age').toString().should.equal('REMOVE kieve.age');
return queryBuilder.del('n').toString().should.equal('DELETE n');
return queryBuilder.del(['n', 'm']).toString().should.equal('DELETE n, m');
return queryBuilder.foreach('(n IN nodes(p)| SET n.marked = TRUE )').toString().should.equal('FOREACH (n IN nodes(p)| SET n.marked = TRUE )');
return queryBuilder["return"]('n').toString().should.equal('RETURN n');
return queryBuilder["return"](['name', 'age']).toString().should.equal('RETURN n.name, n.age');
return queryBuilder["return"]({ 'name': 'Name', 'age': 'Age' }).toString().should.equal('RETURN n.name AS Name, n.age AS Age');
return queryBuilder["return"](['name', 'age'], true).toString().should.equal('RETURN r.name, r.age');
return queryBuilder["return"]({ 'name': 'Name', 'age': 'Age' }, true).toString().should.equal('RETURN r.name AS Name, r.age AS Age');
return queryBuilder.union('all').toString().should.equal('UNION ALL');
return queryBuilder.using('n:Swedish(surname)').toString().should.equal('USING n:Swedish(surname)');
return queryBuilder.using('n:Swedish(surname)', 'INDEX').toString().should.equal('USING INDEX n:Swedish(surname)');
return queryBuilder.orderBy('n.name').toString().should.equal('ORDER BY n.name');
return queryBuilder.orderBy(['name', 'age']).toString().should.equal('ORDER BY n.name, n.age');
return queryBuilder.orderBy({ 'name': 'asc', 'age': 1, 'gender': true }).toString().should.equal('ORDER BY n.name ASC, n.age ASC, n.gender ASC');
return queryBuilder.orderBy(['name', 'age'], true).toString().should.equal('ORDER BY r.name, r.age');
return queryBuilder.orderBy({ 'name': 'asc', 'age': 1, 'gender': true }, true).toString().should.equal('ORDER BY r.name ASC, r.age ASC, r.gender ASC');
return queryBuilder.skip(1).toString().should.equal('SKIP 1');
return queryBuilder.limit(1).toString().should.equal('LIMIT 1');
return queryBuilder.limit(1, 2).toString().should.equal('LIMIT 1 SKIP 2');
return queryBuilder.getList('function').should.deep.equal(['ALL', 'ANY', 'NONE', 'SINGLE', 'LENGTH', 'TYPE', 'ID', 'COALESCE', 'HEAD', 'LAST', 'TIMESTAMP', 'STARTNODE', 'ENDNODE', 'NODES', 'RELATIONSHIPS', 'LABELS', 'EXTRACT', 'FILTER', 'TAIL', 'RANGE', 'REDUCE', 'ABS', 'ACOS', 'ASIN', 'ATAN', 'COS', 'COT', 'DEGREES', 'E', 'EXP', 'FLOOR', 'HAVERSIN', 'LOG', 'LOG10', 'PI', 'RADIANS', 'RAND', 'ROUND', 'SIGN', 'SIN', 'SQRT', 'TAN', 'STR', 'REPLACE', 'SUBSTRING', 'LEFT', 'RIGHT', 'LTRIM', 'RTRIM', 'TRIM', 'LOWER', 'UPPER']);
var result; result = queryBuilder.start('*')["return"]('*').execute(); return result.should.eventually.include.keys('data');
should create an index.
return neo.createIndex('testuser', ['name']).then(function(result) { result.label.should.equal('testuser'); return result['property-keys'].should.include('name'); });
should return nodes under specified label.
return neo.readIndex('testuser').then(function(result) { result[0].label.should.equal('testuser'); return result[0]['property-keys'].should.include('name'); });
should drop index.
return neo.deleteIndex('testuser', 'name').should.eventually.be["true"];
should insert labels to a node.
return neo.createLabel(testNode[0]._id, ['testfriend', 'testcolleagu2e']).should.eventually.be["true"];
should insert label to a node.
return neo.createLabel(testNode[1]._id, 'testfriend').should.eventually.be["true"];
should replace labels of a node.
return neo.updateLabel(testNode[0]._id, ['testbestfriend']).should.eventually.be["true"];
should return labels of a node.
return neo.readLabel(testNode[0]._id).should.eventually.include('testbestfriend');
should return all labels of the database.
return neo.readLabel().then(function(result) { result.should.include('testbestfriend'); return result.should.include('testfriend'); });
should remove label from a node.
return neo.deleteLabel(testNode[1]._id, 'testfriend').should.eventually.be["true"];
should return default Neo4j connection.
return neo.url.should.equal('http://localhost:7474');
return neo.url.should.equal('http://localhost:8484');
should return Neo4j setting.
return neo.service().should.eventually.have.contain.keys('node', 'node_index', 'relationship_index', 'extensions_info');
should create a new node.
return neo.createNode({ name: 'Kieve' }).then(function(node) { node.should.have.property('name').equal('Kieve'); return testNode = node; });
should return node details.
return neo.readNode(testNode._id).then(function(result) { return result.name.should.equal('Kieve'); });
should update node property.
return neo.updateNodeProperty(testNode._id, 'gender', 'male').should.eventually.be["true"];
should update node properties.
return neo.updateNodeProperty(testNode._id, { 'name': 'Kieve Chua', 'age': 17 }).should.eventually.be["true"];
should return properties of a node.
return neo.readNodeProperty(testNode._id).then(function(result) { result.name.should.equal('Kieve Chua'); return result.age.should.equal(17); });
should delete node property.
return neo.deleteNodeProperty(testNode._id, 'name').should.eventually.be["true"];
should delete all property of a node.
return neo.deleteNodeProperty(testNode._id).should.eventually.be["true"];
should delete a node.
return neo.deleteNode(testNode._id).should.eventually.be["true"];
should create relationship between nodes.
return neo.createRelationship(testNode[0]._id, testNode[1]._id, 'friend', { since: '10 years ago' }).then(function(relationship) { testRelationship = relationship; return relationship.since.should.equal('10 years ago'); });
should return details of a relationship.
return neo.readRelationship(testRelationship._id).then(function(result) { return result.since.should.equal('10 years ago'); });
should update relationship's property value.
return neo.updateRelationshipProperty(testRelationship._id, 'since', '11 years ago').should.eventually.be["true"];
should update relationship's properties value.
return neo.updateRelationshipProperty(testRelationship._id, { 'since': '12 years ago', 'sinceAge': 17 }).should.eventually.be["true"];
should return properties of a relationship.
return neo.readRelationshipProperty(testRelationship._id).then(function(result) { result.since.should.equal('12 years ago'); return result.sinceAge.should.equal(17); });
should return all relationships type.
return neo.readRelationshipType().should.eventually.include('friend');
should return all relationship for a node.
return neo.readTypedRelationship(testNode[1]._id, 'all').should.eventually.have.length(1);
should return all inbound relationship for a node.
return neo.readTypedRelationship(testNode[1]._id, 'in').should.eventually.have.length(1);
should return all outbound relationship for a node.
return neo.readTypedRelationship(testNode[1]._id, 'out').should.eventually.be.empty;
return neo.readTypedRelationship(testNode[1]._id, 'all', 'friend').should.eventually.have.length(1);
return neo.readTypedRelationship(testNode[1]._id, 'in', 'friend').should.eventually.have.length(1);
return neo.readTypedRelationship(testNode[1]._id, 'out', 'friend').should.eventually.be.empty;
return neo.readTypedRelationship(testNode[1]._id, 'all', ['friend', 'lover']).should.eventually.have.length(1);
should delete relationships's property.
return neo.deleteRelationshipProperty(testRelationship._id, 'since').should.eventually.be["true"];
should delete all relationships's properties.
return neo.deleteRelationshipProperty(testRelationship._id).should.eventually.be["true"];
should delete relationship.
return neo.deleteRelationship(testRelationship._id).should.eventually.be["true"];
should create a paged traverse.
return neo.createPagedTraverse(testNode[0]._id, { "prune_evaluator": { "language": "builtin", "name": "none" }, "return_filter": { "language": "javascript", "body": "position.endNode().getProperty('name').contains('Test traversal 1');" }, "order": "depth_first", "relationships": { "type": "testfriend", "direction": "out" } }).should.eventually.have.length.of.at.least(1);
should return traversed path.
return neo.traversePath(testNode[0]._id, { "order": "breadth_first", "uniqueness": "none", "return_filter": { "language": "builtin", "name": "all" } }).should.eventually.have.length.of.at.least(1);
should return traversed node.
return neo.traverseNode(testNode[0]._id, { "order": "breadth_first", "uniqueness": "none", "return_filter": { "language": "builtin", "name": "all" } }).should.eventually.have.length.of.at.least(1);
return neo.traverseRelationship(testNode[0]._id, { "order": "breadth_first", "uniqueness": "none", "return_filter": { "language": "builtin", "name": "all" } }).should.eventually.have.length.of.at.least(1);
should return paged traverse path.
return neo.pagedTraverse(testNode[0]._id, { pageSize: 1 }).should.eventually.have.length.of.at.least(1);
should return stringified object.
return utils.objToStr({ name: 'kieve', age: 18 }).should.equal("{ name : 'kieve', age : '18' }");
return utils.get('http://localhost:7474/db/data').then(function(result) { return result.ok.should.be["true"]; });
TOC
Algorithm
neo.findPath(nodeId, {parameters})
when valid
should return path detail from A to B.
when invalid
should throw error message.
Batch
neo.executeBatch([tasks])
when valid
should return all task result.
when invalid
should throw error message.
Constraint
neo.createUniquenessConstraint(label, [property])
when valid
should return true.
when invalid
should throw error message.
neo.readConstraint()
when valid
should return all constraint.
when invalid
should throw error message.
neo.readUniquenessConstraint(label, property)
when valid
should return node with specified label and constraint.
when invalid
should throw error message.
neo.deleteConstraint(label, property)
when valid
should return true.
when invalid
should throw error message.
Cypher
neo.executeCypher(query, parameters)
when valid
should run cypher query.
neo.queryBuilder()
queryBuilder.cypher(query)
when valid
should construct correct cypher query.
queryBuilder.direction(query)
n
when valid
should construct correct cypher query.
tn
when valid
should construct correct cypher query.
fn
when valid
should construct correct cypher query.
r
when valid
should construct correct cypher query.
tr
when valid
should construct correct cypher query.
fr
when valid
should construct correct cypher query.
or
when valid
should construct correct cypher query.
ir
when valid
should construct correct cypher query.
--
when valid
should construct correct cypher query.
chaining
when valid
should construct correct cypher query.
queryBuilder.start(query)
when valid
should construct correct cypher query.
queryBuilder.start(nodeId)
when valid
should construct correct cypher query.
queryBuilder.start(query)
when valid
should construct correct cypher query.
queryBuilder.start({query})
when valid
should construct correct cypher query.
queryBuilder.start(query, true)
when valid
should construct correct cypher query.
queryBuilder.start(nodeId, true)
when valid
should construct correct cypher query.
queryBuilder.create(query)
when valid
should create normal query.
queryBuilder.create(query, true)
when valid
should create unique query.
queryBuilder.match(query)
when valid
should construct correct cypher query.
queryBuilder.where(query)
when valid
should construct correct cypher query.
queryBuilder.with(query)
when valid
should construct correct cypher query.
queryBuilder.set(query)
when valid
should construct correct cypher query.
queryBuilder.merge(query)
when valid
should construct correct cypher query.
queryBuilder.drop(query)
when valid
should construct correct cypher query.
queryBuilder.remove(query)
when valid
should construct correct cypher query.
queryBuilder.del(query)
when valid
should construct correct cypher query.
queryBuilder.del([query])
when valid
should construct correct cypher query.
queryBuilder.foreach([query])
when valid
should construct correct cypher query.
queryBuilder.return(query)
when valid
should construct correct cypher query.
queryBuilder.return([query])
when valid
should construct correct cypher query.
queryBuilder.return({query})
when valid
should construct correct cypher query.
queryBuilder.return([query], true)
when valid
should construct correct cypher query.
queryBuilder.return({query}, true)
when valid
should construct correct cypher query.
queryBuilder.union([query])
when valid
should construct correct cypher query.
queryBuilder.using(query)
when valid
should construct correct cypher query.
queryBuilder.using(query, parameter)
when valid
should construct correct cypher query.
queryBuilder.orderBy(query)
when valid
should construct correct cypher query.
queryBuilder.orderBy([query])
when valid
should construct correct cypher query.
queryBuilder.orderBy({query})
when valid
should construct correct cypher query.
queryBuilder.orderBy([query], true)
when valid
should construct correct cypher query.
queryBuilder.orderBy({query}, true)
when valid
should construct correct cypher query.
queryBuilder.skip(skip)
when valid
should construct correct cypher query.
queryBuilder.limit(limit)
when valid
should construct correct cypher query.
queryBuilder.limit(limit, step)
when valid
should construct correct cypher query.
queryBuilder.getList(type)
when valid
should construct correct cypher query.
queryBuilder.execute()
when valid
should run cypher query.
Index
neo.createIndex(label, [property])
when valid
should create an index.
neo.readIndex(label)
when valid
should return nodes under specified label.
neo.deleteIndex(label, property)
when valid
should drop index.
Label
neo.createLabel(nodeId, [labels])
when valid
should insert labels to a node.
neo.createLabel(nodeId, label)
when valid
should insert label to a node.
neo.updateLabel(nodeId, labels)
when valid
should replace labels of a node.
neo.readLabel(nodeId)
when valid
should return labels of a node.
neo.readLabel()
when valid
should return all labels of the database.
neo.deleteLabel(nodeId, label)
when valid
should remove label from a node.
Main
create new connection
new Neo4js()
when valid
should return default Neo4j connection.
new Neo4js(url)
when valid
should return default Neo4j connection.
neo.service()
when valid
should return Neo4j setting.
Node
neo.createNode({properties})
when valid
should create a new node.
neo.readNode(nodeId)
when valid
should return node details.
neo.updateNodeProperty(nodeId, property, value)
when valid
should update node property.
neo.updateNodeProperty(nodeId, {properties})
when valid
should update node properties.
neo.readNodeProperty(nodeId)
when valid
should return properties of a node.
neo.deleteNodeProperty(nodeId, property)
when valid
should delete node property.
neo.deleteNodeProperty(nodeId)
when valid
should delete all property of a node.
neo.deleteNode(nodeId)
when valid
should delete a node.
Relationship
neo.createRelationship(fromNodeId, toNodeId, relationship, relationshipProperty)
when valid
should create relationship between nodes.
neo.readRelationship(relationshipId)
when valid
should return details of a relationship.
neo.updateRelationshipProperty(relationshipId, property, value)
when valid
should update relationship's property value.
neo.updateRelationshipProperty(relationshipId, {properties})
when valid
should update relationship's properties value.
neo.readRelationshipProperty(relationshipId)
when valid
should return properties of a relationship.
neo.readRelationshipType()
when valid
should return all relationships type.
neo.readTypedRelationship(nodeId, 'all')
when valid
should return all relationship for a node.
neo.readTypedRelationship(nodeId, 'in')
when valid
should return all inbound relationship for a node.
neo.readTypedRelationship(nodeId, 'out')
when valid
should return all outbound relationship for a node.
neo.readTypedRelationship(nodeId, 'all', label)
when valid
should return all outbound relationship for a node.
neo.readTypedRelationship(nodeId, 'in', label)
when valid
should return all outbound relationship for a node.
neo.readTypedRelationship(nodeId, 'out', label)
when valid
should return all outbound relationship for a node.
neo.readTypedRelationship(nodeId, 'all', [labels])
when valid
should return all outbound relationship for a node.
neo.deleteRelationshipProperty(relationshipId, property)
when valid
should delete relationships's property.
neo.deleteRelationshipProperty(relationshipId)
when valid
should delete all relationships's properties.
neo.deleteRelationship(relationshipId)
when valid
should delete relationship.
Traversal
neo.createPagedTraverse(nodeId, {properties})
when valid
should create a paged traverse.
neo.traversePath(nodeId, {properties})
when valid
should return traversed path.
neo.traverseNode(nodeId, {property})
when valid
should return traversed node.
neo.traverseRelationship(nodeId, {property})
when valid
should return traversed node.
neo.pagedTraverse(nodeId, {parameters})
when valid
should return paged traverse path.
Utils
neo.objToStr({object})
when valid
should return stringified object.
neo.get(url)
when valid
should return stringified object.