test/test.md

TOC

Algorithm

neo.findPath(nodeId, {parameters})

when valid

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);
});

when invalid

should throw error message.

(function() {
  return neo.findPath();
}).should["throw"](Error);
return (function() {
  return neo.findPath(1);
}).should["throw"](Error);

Batch

neo.executeBatch([tasks])

when valid

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));
});

when invalid

should throw error message.

return (function() {
  return neo.executeBatch();
}).should["throw"](Error);

Constraint

neo.createUniquenessConstraint(label, [property])

when valid

should return true.

return neo.createUniquenessConstraint('person', [randomProperty]).then(function(result) {
  return result.should.be["true"];
}).fail(function(result) {
  return console.log(randomProperty);
});

when invalid

should throw error message.

(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);

neo.readConstraint()

when valid

should return all constraint.

return neo.readConstraint().should.eventually.have.length.of.at.least(1);

when invalid

should throw error message.

return (function() {
  return neo.readConstraint(1);
}).should["throw"](Error);

neo.readUniquenessConstraint(label, property)

when valid

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);
});

when invalid

should throw error message.

(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);

neo.deleteConstraint(label, property)

when valid

should return true.

return neo.deleteConstraint('person', randomProperty).should.eventually.be["true"];

when invalid

should throw error message.

(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);

Cypher

neo.executeCypher(query, parameters)

when valid

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');
});

neo.queryBuilder()

queryBuilder.cypher(query)

when valid

should construct correct cypher query.

return queryBuilder.cypher('START n = node(*)').toString().should.equal('START n = node(*)');

queryBuilder.direction(query)

n

when valid

should construct correct cypher query.

return queryBuilder.direction('n').toString().should.equal('()');

tn

when valid

should construct correct cypher query.

return queryBuilder.direction('tn=n').toString().should.equal('-->(n)');

fn

when valid

should construct correct cypher query.

return queryBuilder.direction('fn=n').toString().should.equal('<--(n)');

r

when valid

should construct correct cypher query.

return queryBuilder.direction('r=r').toString().should.equal('-[r]->');

tr

when valid

should construct correct cypher query.

return queryBuilder.direction('tr=r').toString().should.equal('-[r]->');

fr

when valid

should construct correct cypher query.

return queryBuilder.direction('fr=r').toString().should.equal('<-[r]-');

or

when valid

should construct correct cypher query.

return queryBuilder.direction('or=r').toString().should.equal('<-[r]->');

ir

when valid

should construct correct cypher query.

return queryBuilder.direction('ir=r').toString().should.equal('-[r]-');

--

when valid

should construct correct cypher query.

return queryBuilder.direction('--').toString().should.equal('--');

chaining

when valid

should construct correct cypher query.

return queryBuilder.direction('n=n/r=friend/n=m').toString().should.equal('(n)-[friend]->(m)');

queryBuilder.start(query)

when valid

should construct correct cypher query.

return queryBuilder.start('*').toString().should.equal('START n = node(*)');

queryBuilder.start(nodeId)

when valid

should construct correct cypher query.

queryBuilder.start(1).toString().should.equal('START n = node({id})');
queryBuilder.getParams().should.include.keys('id');
return queryBuilder.getParams().id.should.equal(1);

queryBuilder.start(query)

when valid

should construct correct cypher query.

return queryBuilder.start('n = node(*)').toString().should.equal('START n = node(*)');

queryBuilder.start({query})

when valid

should construct correct cypher query.

queryBuilder.start({
  name: 'Kieve'
}).toString().should.equal('START name = node({name})');
queryBuilder.getParams().should.include.keys('name');
return queryBuilder.getParams().name.should.equal('Kieve');

queryBuilder.start(query, true)

when valid

should construct correct cypher query.

return queryBuilder.start('*', true).toString().should.equal('START r = relationship(*)');

queryBuilder.start(nodeId, true)

when valid

should construct correct cypher query.

queryBuilder.start(1, true).toString().should.equal('START r = relationship({id})');
queryBuilder.getParams().should.include.keys('id');
return queryBuilder.getParams().id.should.equal(1);

queryBuilder.create(query)

when valid

should create normal query.

return queryBuilder.create('n').toString().should.equal('CREATE n');

queryBuilder.create(query, true)

when valid

should create unique query.

return queryBuilder.create('n', true).toString().should.equal('CREATE UNIQUE n');

queryBuilder.match(query)

when valid

should construct correct cypher query.

return queryBuilder.match('(movie:Movie)').toString().should.equal('MATCH (movie:Movie)');

queryBuilder.where(query)

when valid

should construct correct cypher query.

return queryBuilder.where('n:Swedish').toString().should.equal('WHERE n:Swedish');

queryBuilder.with(query)

when valid

should construct correct cypher query.

return queryBuilder["with"]('m').toString().should.equal('WITH m');

queryBuilder.set(query)

when valid

should construct correct cypher query.

return queryBuilder.set("n.surname = 'Kieve'").toString().should.equal("SET n.surname = 'Kieve'");

queryBuilder.merge(query)

when valid

should construct correct cypher query.

return queryBuilder.merge('kieve:Critic').toString().should.equal('MERGE (kieve:Critic)');

queryBuilder.drop(query)

when valid

should construct correct cypher query.

return queryBuilder.drop('(movie:Movie)').toString().should.equal('DROP (movie:Movie)');

queryBuilder.remove(query)

when valid

should construct correct cypher query.

return queryBuilder.remove('kieve.age').toString().should.equal('REMOVE kieve.age');

queryBuilder.del(query)

when valid

should construct correct cypher query.

return queryBuilder.del('n').toString().should.equal('DELETE n');

queryBuilder.del([query])

when valid

should construct correct cypher query.

return queryBuilder.del(['n', 'm']).toString().should.equal('DELETE n, m');

queryBuilder.foreach([query])

when valid

should construct correct cypher query.

return queryBuilder.foreach('(n IN nodes(p)| SET n.marked = TRUE )').toString().should.equal('FOREACH (n IN nodes(p)| SET n.marked = TRUE )');

queryBuilder.return(query)

when valid

should construct correct cypher query.

return queryBuilder["return"]('n').toString().should.equal('RETURN n');

queryBuilder.return([query])

when valid

should construct correct cypher query.

return queryBuilder["return"](['name', 'age']).toString().should.equal('RETURN n.name, n.age');

queryBuilder.return({query})

when valid

should construct correct cypher query.

return queryBuilder["return"]({
  'name': 'Name',
  'age': 'Age'
}).toString().should.equal('RETURN n.name AS Name, n.age AS Age');

queryBuilder.return([query], true)

when valid

should construct correct cypher query.

return queryBuilder["return"](['name', 'age'], true).toString().should.equal('RETURN r.name, r.age');

queryBuilder.return({query}, true)

when valid

should construct correct cypher query.

return queryBuilder["return"]({
  'name': 'Name',
  'age': 'Age'
}, true).toString().should.equal('RETURN r.name AS Name, r.age AS Age');

queryBuilder.union([query])

when valid

should construct correct cypher query.

return queryBuilder.union('all').toString().should.equal('UNION ALL');

queryBuilder.using(query)

when valid

should construct correct cypher query.

return queryBuilder.using('n:Swedish(surname)').toString().should.equal('USING n:Swedish(surname)');

queryBuilder.using(query, parameter)

when valid

should construct correct cypher query.

return queryBuilder.using('n:Swedish(surname)', 'INDEX').toString().should.equal('USING INDEX n:Swedish(surname)');

queryBuilder.orderBy(query)

when valid

should construct correct cypher query.

return queryBuilder.orderBy('n.name').toString().should.equal('ORDER BY n.name');

queryBuilder.orderBy([query])

when valid

should construct correct cypher query.

return queryBuilder.orderBy(['name', 'age']).toString().should.equal('ORDER BY n.name, n.age');

queryBuilder.orderBy({query})

when valid

should construct correct cypher query.

return queryBuilder.orderBy({
  'name': 'asc',
  'age': 1,
  'gender': true
}).toString().should.equal('ORDER BY n.name ASC, n.age ASC, n.gender ASC');

queryBuilder.orderBy([query], true)

when valid

should construct correct cypher query.

return queryBuilder.orderBy(['name', 'age'], true).toString().should.equal('ORDER BY r.name, r.age');

queryBuilder.orderBy({query}, true)

when valid

should construct correct cypher query.

return queryBuilder.orderBy({
  'name': 'asc',
  'age': 1,
  'gender': true
}, true).toString().should.equal('ORDER BY r.name ASC, r.age ASC, r.gender ASC');

queryBuilder.skip(skip)

when valid

should construct correct cypher query.

return queryBuilder.skip(1).toString().should.equal('SKIP 1');

queryBuilder.limit(limit)

when valid

should construct correct cypher query.

return queryBuilder.limit(1).toString().should.equal('LIMIT 1');

queryBuilder.limit(limit, step)

when valid

should construct correct cypher query.

return queryBuilder.limit(1, 2).toString().should.equal('LIMIT 1 SKIP 2');

queryBuilder.getList(type)

when valid

should construct correct cypher query.

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']);

queryBuilder.execute()

when valid

should run cypher query.

var result;
result = queryBuilder.start('*')["return"]('*').execute();
return result.should.eventually.include.keys('data');

Index

neo.createIndex(label, [property])

when valid

should create an index.

return neo.createIndex('testuser', ['name']).then(function(result) {
  result.label.should.equal('testuser');
  return result['property-keys'].should.include('name');
});

neo.readIndex(label)

when valid

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');
});

neo.deleteIndex(label, property)

when valid

should drop index.

return neo.deleteIndex('testuser', 'name').should.eventually.be["true"];

Label

neo.createLabel(nodeId, [labels])

when valid

should insert labels to a node.

return neo.createLabel(testNode[0]._id, ['testfriend', 'testcolleagu2e']).should.eventually.be["true"];

neo.createLabel(nodeId, label)

when valid

should insert label to a node.

return neo.createLabel(testNode[1]._id, 'testfriend').should.eventually.be["true"];

neo.updateLabel(nodeId, labels)

when valid

should replace labels of a node.

return neo.updateLabel(testNode[0]._id, ['testbestfriend']).should.eventually.be["true"];

neo.readLabel(nodeId)

when valid

should return labels of a node.

return neo.readLabel(testNode[0]._id).should.eventually.include('testbestfriend');

neo.readLabel()

when valid

should return all labels of the database.

return neo.readLabel().then(function(result) {
  result.should.include('testbestfriend');
  return result.should.include('testfriend');
});

neo.deleteLabel(nodeId, label)

when valid

should remove label from a node.

return neo.deleteLabel(testNode[1]._id, 'testfriend').should.eventually.be["true"];

Main

create new connection

new Neo4js()

when valid

should return default Neo4j connection.

return neo.url.should.equal('http://localhost:7474');

new Neo4js(url)

when valid

should return default Neo4j connection.

return neo.url.should.equal('http://localhost:8484');

neo.service()

when valid

should return Neo4j setting.

return neo.service().should.eventually.have.contain.keys('node', 'node_index', 'relationship_index', 'extensions_info');

Node

neo.createNode({properties})

when valid

should create a new node.

return neo.createNode({
  name: 'Kieve'
}).then(function(node) {
  node.should.have.property('name').equal('Kieve');
  return testNode = node;
});

neo.readNode(nodeId)

when valid

should return node details.

return neo.readNode(testNode._id).then(function(result) {
  return result.name.should.equal('Kieve');
});

neo.updateNodeProperty(nodeId, property, value)

when valid

should update node property.

return neo.updateNodeProperty(testNode._id, 'gender', 'male').should.eventually.be["true"];

neo.updateNodeProperty(nodeId, {properties})

when valid

should update node properties.

return neo.updateNodeProperty(testNode._id, {
  'name': 'Kieve Chua',
  'age': 17
}).should.eventually.be["true"];

neo.readNodeProperty(nodeId)

when valid

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);
});

neo.deleteNodeProperty(nodeId, property)

when valid

should delete node property.

return neo.deleteNodeProperty(testNode._id, 'name').should.eventually.be["true"];

neo.deleteNodeProperty(nodeId)

when valid

should delete all property of a node.

return neo.deleteNodeProperty(testNode._id).should.eventually.be["true"];

neo.deleteNode(nodeId)

when valid

should delete a node.

return neo.deleteNode(testNode._id).should.eventually.be["true"];

Relationship

neo.createRelationship(fromNodeId, toNodeId, relationship, relationshipProperty)

when valid

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');
});

neo.readRelationship(relationshipId)

when valid

should return details of a relationship.

return neo.readRelationship(testRelationship._id).then(function(result) {
  return result.since.should.equal('10 years ago');
});

neo.updateRelationshipProperty(relationshipId, property, value)

when valid

should update relationship's property value.

return neo.updateRelationshipProperty(testRelationship._id, 'since', '11 years ago').should.eventually.be["true"];

neo.updateRelationshipProperty(relationshipId, {properties})

when valid

should update relationship's properties value.

return neo.updateRelationshipProperty(testRelationship._id, {
  'since': '12 years ago',
  'sinceAge': 17
}).should.eventually.be["true"];

neo.readRelationshipProperty(relationshipId)

when valid

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);
});

neo.readRelationshipType()

when valid

should return all relationships type.

return neo.readRelationshipType().should.eventually.include('friend');

neo.readTypedRelationship(nodeId, 'all')

when valid

should return all relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'all').should.eventually.have.length(1);

neo.readTypedRelationship(nodeId, 'in')

when valid

should return all inbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'in').should.eventually.have.length(1);

neo.readTypedRelationship(nodeId, 'out')

when valid

should return all outbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'out').should.eventually.be.empty;

neo.readTypedRelationship(nodeId, 'all', label)

when valid

should return all outbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'all', 'friend').should.eventually.have.length(1);

neo.readTypedRelationship(nodeId, 'in', label)

when valid

should return all outbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'in', 'friend').should.eventually.have.length(1);

neo.readTypedRelationship(nodeId, 'out', label)

when valid

should return all outbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'out', 'friend').should.eventually.be.empty;

neo.readTypedRelationship(nodeId, 'all', [labels])

when valid

should return all outbound relationship for a node.

return neo.readTypedRelationship(testNode[1]._id, 'all', ['friend', 'lover']).should.eventually.have.length(1);

neo.deleteRelationshipProperty(relationshipId, property)

when valid

should delete relationships's property.

return neo.deleteRelationshipProperty(testRelationship._id, 'since').should.eventually.be["true"];

neo.deleteRelationshipProperty(relationshipId)

when valid

should delete all relationships's properties.

return neo.deleteRelationshipProperty(testRelationship._id).should.eventually.be["true"];

neo.deleteRelationship(relationshipId)

when valid

should delete relationship.

return neo.deleteRelationship(testRelationship._id).should.eventually.be["true"];

Traversal

neo.createPagedTraverse(nodeId, {properties})

when valid

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);

neo.traversePath(nodeId, {properties})

when valid

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);

neo.traverseNode(nodeId, {property})

when valid

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);

neo.traverseRelationship(nodeId, {property})

when valid

should return traversed node.

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);

neo.pagedTraverse(nodeId, {parameters})

when valid

should return paged traverse path.

return neo.pagedTraverse(testNode[0]._id, {
  pageSize: 1
}).should.eventually.have.length.of.at.least(1);

Utils

neo.objToStr({object})

when valid

should return stringified object.

return utils.objToStr({
  name: 'kieve',
  age: 18
}).should.equal("{ name : 'kieve', age : '18' }");

neo.get(url)

when valid

should return stringified object.

return utils.get('http://localhost:7474/db/data').then(function(result) {
  return result.ok.should.be["true"];
});