neography-calamitates 1.2.3.1

data/spec/integration/rest_relationship_types_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "list relationship types" do
+    it "can get a listing of relationship types" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      rel_types = @neo.list_relationship_types
+      rel_types.should_not be_nil
+      rel_types.should include("friends")
+    end
+  end
+end

data/spec/integration/rest_schema_index_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "create a schema index" do
+    it "can create a schema index" do
+      si = @neo.create_schema_index("person", ["name"]) 
+      si.should_not be_nil
+      si["property-keys"].should include("name")
+    end
+    
+  end
+
+  describe "list schema indexes" do
+    it "can get a listing of node indexes" do
+      si = @neo.get_schema_index("person")
+      si.should_not be_nil
+      si.first["label"].should include("person")
+      si.first["property-keys"].should include("name")
+    end
+  end
+  
+  describe "drop schema indexes" do
+    it "can drop an existing schema index" do
+      si = @neo.delete_schema_index("person", "name")
+      si.should be_nil
+    end
+  end
+end

data/spec/integration/rest_transaction_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "start a transaction" do
+    it "can start a transaction" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+    end
+
+    it "can start a transaction with statements" do
+      tx = @neo.begin_transaction("start n=node(0) return n")
+      tx.should have_key("transaction")
+      tx.should have_key("results")
+      tx["results"].should_not be_empty
+    end
+
+    it "can start a transaction with statements and represent them as a graph" do
+      tx = @neo.begin_transaction(["CREATE ( bike:Bike { weight: 10 } ) CREATE ( frontWheel:Wheel { spokes: 3 } ) CREATE ( backWheel:Wheel { spokes: 32 } ) CREATE p1 = bike -[:HAS { position: 1 } ]-> frontWheel CREATE p2 = bike -[:HAS { position: 2 } ]-> backWheel RETURN bike, p1, p2", 
+                                 ["row", "graph", "rest"]])
+      tx.should have_key("transaction")
+      tx.should have_key("results")
+      tx["results"].should_not be_empty
+      tx["results"].first["data"].first["row"].should_not be_empty
+      tx["results"].first["data"].first["graph"].should_not be_empty
+      tx["results"].first["data"].first["rest"].should_not be_empty
+    end
+
+
+  end
+
+  describe "keep a transaction" do
+    it "can keep a transaction" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      sleep(1)
+      existing_tx = @neo.keep_transaction(tx)
+      existing_tx.should have_key("transaction")
+      existing_tx["transaction"]["expires"].should > tx["transaction"]["expires"]
+    end
+  end
+
+  
+  describe "add to a transaction" do
+    it "can add to a transaction" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.in_transaction(tx, "start n=node(0) return n")
+      existing_tx.should have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should_not be_empty
+    end
+
+    it "can add to a transaction with parameters" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.in_transaction(tx, ["start n=node({id}) return n", {:id => 0}])
+      existing_tx.should have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should_not be_empty
+    end    
+
+    it "can add to a transaction with representation" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.in_transaction(tx, ["start n=node(0) return n", [:row,:rest]])
+      existing_tx.should have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should_not be_empty
+    end    
+
+    it "can add to a transaction with parameters and representation" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.in_transaction(tx, ["start n=node({id}) return n", {:id => 0}, [:row,:rest]])
+      existing_tx.should have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should_not be_empty
+    end    
+    
+  end
+
+  describe "commit a transaction" do
+    it "can commit an opened empty transaction" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.commit_transaction(tx)
+      existing_tx.should have_key("results")
+      existing_tx["results"].should be_empty
+    end
+
+    it "can commit an opened transaction" do
+      tx = @neo.begin_transaction("start n=node(0) return n")
+      tx.should have_key("transaction")
+      tx["results"].should_not be_empty
+      existing_tx = @neo.commit_transaction(tx)
+      existing_tx.should_not have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should be_empty
+    end
+    
+    it "can commit an opened transaction with new statements" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.commit_transaction(tx, "start n=node(0) return n")
+      existing_tx.should_not have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should_not be_empty
+    end
+
+    it "can commit an new transaction right away" do
+      tx = @neo.commit_transaction(["start n=node(0) return n"])
+      tx.should_not have_key("transaction")
+      tx.should have_key("results")
+      tx["results"].should_not be_empty
+    end
+    
+    it "can commit an new transaction right away with parameters" do
+      tx = @neo.commit_transaction(["start n=node({id}) return n", {:id => 0}])
+      tx.should_not have_key("transaction")
+      tx.should have_key("results")
+      tx["results"].should_not be_empty
+    end
+
+    it "can commit an new transaction right away without parameters" do
+      tx = @neo.commit_transaction("start n=node(0) return n")
+      tx.should_not have_key("transaction")
+      tx.should have_key("results")
+      tx["results"].should_not be_empty
+    end
+    
+  end
+
+  describe "rollback a transaction" do
+    it "can rollback an opened empty transaction" do
+      tx = @neo.begin_transaction
+      tx.should have_key("transaction")
+      tx["results"].should be_empty
+      existing_tx = @neo.rollback_transaction(tx)
+      existing_tx.should have_key("results")
+      existing_tx["results"].should be_empty
+    end
+
+    it "can rollback an opened transaction" do
+      tx = @neo.begin_transaction("start n=node(0) return n")
+      tx.should have_key("transaction")
+      tx["results"].should_not be_empty
+      existing_tx = @neo.rollback_transaction(tx)
+      existing_tx.should have_key("transaction")
+      existing_tx.should have_key("results")
+      existing_tx["results"].should be_empty
+    end
+  end  
+  
+end  

data/spec/integration/rest_traverse_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+    @new_node1 = @neo.create_node("age" => 31, "name" => "Max")
+    @new_node2 = @neo.create_node("age" => 30, "name" => "Helene")
+    @new_node3 = @neo.create_node("age" => 17, "name" => "Alex")
+    @new_node4 = @neo.create_node("age" => 24, "name" => "Eric")
+    @new_node5 = @neo.create_node("age" => 32, "name" => "Leslie")
+  end
+
+  describe "traverse" do
+    it "can traverse the graph and return nodes" do
+      @neo.create_relationship("friends", @new_node1, @new_node2)
+      @neo.create_relationship("friends", @new_node2, @new_node3)
+      @neo.create_relationship("friends", @new_node3, @new_node4)
+      @neo.create_relationship("friends", @new_node4, @new_node5)
+      @neo.create_relationship("friends", @new_node3, @new_node5)
+      nodes = @neo.traverse(@new_node1, "nodes", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      nodes.should_not be_nil
+      nodes[0]["self"].should == @new_node2["self"]
+      nodes[1]["self"].should == @new_node3["self"]
+      nodes[2]["self"].should == @new_node4["self"]
+      nodes[3]["self"].should == @new_node5["self"]
+    end
+    it "can traverse the graph and return relationships" do
+      new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node3)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      relationships = @neo.traverse(@new_node1, "relationships", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      relationships.should_not be_nil
+
+      relationships[0]["self"].should == new_relationship1["self"]
+      relationships[1]["self"].should == new_relationship2["self"]
+      relationships[2]["self"].should == new_relationship3["self"]
+      relationships[3]["self"].should == new_relationship4["self"]
+    end
+
+    it "can traverse the graph and return paths" do
+      new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node3)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      paths = @neo.traverse(@new_node1, "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      paths.should_not be_nil
+  
+      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
+      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
+      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
+      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"], @new_node5["self"]]
+    end
+
+    it "can traverse the graph up to a certain depth" do
+      new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node3)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      paths = @neo.traverse(@new_node1, "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 3} )
+      paths.should_not be_nil
+
+      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
+      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
+      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
+      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]]
+    end
+
+    it "can traverse the graph in a certain order" do
+      new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node3)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      paths = @neo.traverse(@new_node1, "paths", {"order" => "breadth first", "relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      paths.should_not be_nil
+    
+      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
+      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
+      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
+      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]]
+    end
+
+    it "can traverse the graph with a specific uniqueness" do
+      new_relationship1= @neo.create_relationship("roommates", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("roommates", @new_node2, @new_node3)
+      new_relationship1= @neo.create_relationship("friends", @new_node3, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node5)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      paths = @neo.traverse(@new_node1, "paths", {"order" => "breadth first", "uniqueness" => "node global", "relationships" => [{"type"=> "roommates", "direction" => "all"},{"type"=> "friends", "direction" => "out"}], "depth" => 4} )
+      paths.should_not be_nil
+    
+      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
+      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node5["self"]]
+      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
+      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
+    end
+
+    it "can traverse the graph with a prune evaluator" do
+      new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
+      new_relationship2= @neo.create_relationship("friends", @new_node2, @new_node3)
+      new_relationship3= @neo.create_relationship("friends", @new_node3, @new_node4)
+      new_relationship4= @neo.create_relationship("friends", @new_node4, @new_node5)
+      new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
+
+      paths = @neo.traverse(@new_node1,
+                            "paths",
+                            {"relationships" => {"type"=> "friends", "direction" => "out"}, 
+                             "depth" => 3,
+                             "prune evaluator" => {"language" => "javascript",  "body" => "position.endNode().getProperty('age') < 21;"
+                              }} )
+      paths.should_not be_nil
+      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
+      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
+      paths[2].should be_nil
+    end
+
+    it "can traverse the graph with a return filter" do
+      @neo.create_relationship("friends", @new_node1, @new_node2)
+      @neo.create_relationship("friends", @new_node2, @new_node3)
+      @neo.create_relationship("friends", @new_node3, @new_node4)
+      @neo.create_relationship("friends", @new_node4, @new_node5)
+      @neo.create_relationship("friends", @new_node3, @new_node5)
+      nodes = @neo.traverse(@new_node1, "node", {"relationships" => {"type"=> "friends", "direction" => "out"}, 
+                                                      "return filter" => {"language" => "builtin", "name" => "all"},
+                                                      "depth" => 4} )
+      nodes.should_not be_nil
+      nodes[0]["self"].should == @new_node1["self"]
+      nodes[1]["self"].should == @new_node2["self"]
+      nodes[2]["self"].should == @new_node3["self"]
+      nodes[3]["self"].should == @new_node4["self"]
+      nodes[4]["self"].should == @new_node5["self"]
+    end
+
+
+
+  end
+
+end

data/spec/matchers.rb

@@ -0,0 +1,33 @@
+# Convenience matcher for matching JSON fields with a hash
+RSpec::Matchers.define :json_match do |field, expected|
+
+  match do |actual|
+    expected == JSON.parse(actual[field])
+  end
+
+  failure_message_for_should do
+    "expected JSON in field '#{field}' to match '#{expected}'"
+  end
+
+  description do
+    "JSON in field '#{field}' should match '#{expected.inspect}'"
+  end
+
+end
+
+# Convenience matcher for matching fields in a hash
+RSpec::Matchers.define :hash_match do |field, expected|
+
+  match do |actual|
+    expected == actual[field]
+  end
+
+  failure_message_for_should do
+    "expected field '#{field}' to match '#{expected}'"
+  end
+
+  description do
+    "field '#{field}' should match '#{expected.inspect}'"
+  end
+
+end

data/spec/neography_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Neography do
+
+  describe "::configure" do
+
+    it "returns the same configuration" do
+      Neography.configuration.should == Neography.configuration
+    end
+
+    it "returns the Config" do
+      Neography.configuration.should be_a Neography::Config
+    end
+
+    it "yields the configuration" do
+      Neography.configure do |config|
+        config.should == Neography.configuration
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+require 'neography'
+require 'benchmark'
+require 'matchers'
+require 'coveralls'
+Coveralls.wear!
+
+# If you want to see more, uncomment the next few lines
+# require 'net-http-spy'
+# Net::HTTP.http_logger_options = {:body => true}    # just the body
+# Net::HTTP.http_logger_options = {:verbose => true} # see everything
+
+def generate_text(length=8)
+  chars = 'abcdefghjkmnpqrstuvwxyz'
+  key = ''
+  length.times { |i| key << chars[rand(chars.length)] }
+  key
+end
+
+RSpec.configure do |c|
+  c.filter_run_excluding :slow => true, :gremlin => true
+end
+
+
+def json_content_type
+  {"Content-Type"=>"application/json"}
+end
+
+def error_response(attributes)
+  request_uri = double()
+  request_uri.stub(:request_uri).and_return("")
+  
+  http_header = double()
+  http_header.stub(:request_uri).and_return(request_uri)
+  
+  double(
+    http_header: http_header,
+    code: attributes[:code],
+    body: {
+    message:   attributes[:message],
+    exception: attributes[:exception],
+    stacktrace: attributes[:stacktrace]
+  }.reject { |k,v| v.nil? }.to_json
+  )
+end
+