neography-down 1.6.4

data/spec/integration/rest_path_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "get path" do
+    it "can get a path between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      path = @neo.get_path(new_node1, new_node2, {"type"=> "friends", "direction" => "out"})
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node2["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"]])
+    end
+
+    it "can get the shortest path between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @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)
+      path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="shortestPath")
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]])
+    end
+
+    it "can get the shortest weighted path between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      rel1_2 = @neo.create_relationship("friends", new_node1, new_node2)
+      rel2_3 = @neo.create_relationship("friends", new_node2, new_node3)
+      rel3_4 = @neo.create_relationship("friends", new_node3, new_node4)
+      rel4_5 = @neo.create_relationship("friends", new_node4, new_node5)
+      rel3_5 = @neo.create_relationship("friends", new_node3, new_node5)
+      @neo.set_relationship_properties(rel1_2, {:weight => 1})
+      @neo.set_relationship_properties(rel2_3, {:weight => 1})
+      @neo.set_relationship_properties(rel3_4, {:weight => 1})
+      @neo.set_relationship_properties(rel4_5, {:weight => 1})
+      @neo.set_relationship_properties(rel3_5, {:weight => 3})
+      path = @neo.get_shortest_weighted_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"})
+      expect(path.first["start"]).to eq(new_node1["self"])
+      expect(path.first["end"]).to eq(new_node5["self"])
+      expect(path.first["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]])
+    end
+
+    it "can get a simple path between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @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)
+      path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="simplePaths")
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]])
+    end
+
+    it "fails to get a path between two nodes 3 nodes apart when using max depth of 2" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @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)
+      expect {
+        @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=2, algorithm="shortestPath")
+      }.to raise_error Neography::NotFoundException
+    end
+
+    it "can get a path between two nodes of a specific relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("classmates", new_node1, new_node2)
+      @neo.create_relationship("classmates", new_node2, new_node5)
+      @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)
+      path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]])
+    end
+  end
+
+  describe "get paths" do
+    it "can get the shortest paths between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.create_relationship("friends", new_node2, new_node5)
+      @neo.create_relationship("friends", new_node1, 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)
+      paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
+      expect(paths.length).to eq(2)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
+    end
+
+    it "can get all paths between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.create_relationship("friends", new_node2, new_node5)
+      @neo.create_relationship("friends", new_node1, 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)
+      paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allPaths")
+      expect(paths.length).to eq(3)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(3)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
+      expect(paths[2]["length"]).to eq(2)
+      expect(paths[2]["start"]).to eq(new_node1["self"])
+      expect(paths[2]["end"]).to eq(new_node5["self"])
+    end
+
+    it "can get all simple paths between two nodes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.create_relationship("friends", new_node2, new_node1)
+      @neo.create_relationship("friends", new_node2, new_node5)
+      @neo.create_relationship("friends", new_node1, 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)
+      paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allSimplePaths")
+      expect(paths.length).to eq(3)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(3)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
+      expect(paths[2]["length"]).to eq(2)
+      expect(paths[2]["start"]).to eq(new_node1["self"])
+      expect(paths[2]["end"]).to eq(new_node5["self"])
+    end
+
+    it "can get paths between two nodes of max depth 2" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.create_relationship("friends", new_node2, new_node5)
+      @neo.create_relationship("friends", new_node1, 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)
+      paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=2, algorithm="allPaths")
+      expect(paths.length).to eq(2)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])    end
+
+    it "can get paths between two nodes of a specific relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_node5 = @neo.create_node
+      @neo.create_relationship("classmates", new_node1, new_node2)
+      @neo.create_relationship("classmates", new_node2, new_node5)
+      @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("classmates", new_node1, new_node3)
+      @neo.create_relationship("classmates", new_node3, new_node5)
+      paths = @neo.get_paths(new_node1, new_node5, {"type"=> "classmates", "direction" => "out"}, depth=4, algorithm="allPaths")
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])    
+    end
+
+  end
+
+
+end

data/spec/integration/rest_plugin_spec.rb

@@ -0,0 +1,177 @@
+# Encoding: utf-8
+
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "execute gremlin script" do
+    it "can get the root node id", :gremlin => true do
+      root_node = @neo.execute_script("g.v(0)")
+      expect(root_node).to have_key("self")
+      expect(root_node["self"].split('/').last).to eq("0")
+    end
+
+    it "can get the a node", :gremlin => true do
+      new_node = @neo.create_node
+      id = new_node["self"].split('/').last
+      existing_node = @neo.execute_script("g.v(#{id})")
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(id)
+    end
+
+    it "can get the a node with a variable", :gremlin => true do
+      new_node = @neo.create_node
+      id = new_node["self"].split('/').last
+      existing_node = @neo.execute_script("g.v(id)", {:id => id.to_i})
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(id)
+    end
+  end
+
+  describe "execute cypher query" do
+    it "can get the root node id" do
+      root_node = @neo.execute_query("start n=node(0) return n")
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
+    end
+
+    it "can get the a node" do
+      new_node = @neo.create_node
+      id = new_node["self"].split('/').last
+      existing_node = @neo.execute_query("start n=node(#{id}) return n")
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+    end
+
+    it "can perform a range query" do
+      name = generate_text(6)
+      new_node = @neo.create_node({:number => 3})
+      id = new_node["self"].split('/').last
+      @neo.create_node_index(name, "fulltext","lucene")
+      @neo.add_node_to_index(name, "number", 3, new_node) 
+      existing_node = @neo.find_node_index(name, "number:[1 TO 5]")
+      expect(existing_node.first["self"]).to eq(new_node["self"])
+      expect(existing_node.first).not_to be_nil
+      expect(existing_node.first["data"]["number"]).to eq(3)
+      existing_node = @neo.execute_query("start n=node:#{name}(\"number:[1 TO 5]\") return n")
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+    end
+
+    it "can perform a range query with a term" do
+      name = generate_text(6)
+      new_node = @neo.create_node({:number => 3, :name => "Max"})
+      id = new_node["self"].split('/').last
+      @neo.create_node_index(name, "fulltext","lucene")
+      @neo.add_node_to_index(name, "number", 3, new_node) 
+      @neo.add_node_to_index(name, "name", "max", new_node) 
+      existing_node = @neo.find_node_index(name, "name:max AND number:[1 TO 5]")
+      expect(existing_node.first["self"]).to eq(new_node["self"])
+      expect(existing_node.first).not_to be_nil
+      expect(existing_node.first["data"]["number"]).to eq(3)
+      expect(existing_node.first["data"]["name"]).to eq("Max")
+      existing_node = @neo.execute_query("start n=node:#{name}(\"name:max AND number:[1 TO 5]\") return n")
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+    end
+
+
+    it "can get a node with a tilde" do
+      new_node = @neo.create_node("name" => "Ateísmo Sureño")
+      id = new_node["self"].split('/').last
+      existing_node = @neo.execute_query("start n=node(#{id}) return n")
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+      expect(existing_node["data"][0][0]["data"]["name"]).to eq("Ateísmo Sureño")
+    end
+
+    it "can get the a node with a variable" do
+      new_node = @neo.create_node
+      id = new_node["self"].split('/').last
+      existing_node = @neo.execute_query("start n=node({id}) return n", {:id => id.to_i})
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+    end
+
+    it "can get the stats of a cypher query" do
+      root_node = @neo.execute_query("start n=node(0) return n", nil, {:stats => true})
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("stats")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
+    end
+
+    it "can get the profile of a cypher query" do
+      root_node = @neo.execute_query("start n=node(0) return n", nil, {:profile => true})
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("plan")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
+    end
+
+    it "can get the stats and profile of a cypher query" do
+      root_node = @neo.execute_query("start n=node(0) return n", nil, {:stats => true, :profile => true})
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("stats")
+      expect(root_node).to have_key("plan")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
+    end
+
+
+    it "can delete everything but start node", :reference => true do
+      @neo.execute_query("START n=node(*) MATCH n-[r?]-() WHERE ID(n) <> 0 DELETE n,r")
+      expect {
+        @neo.execute_query("start n=node({id}) return n", {:id => 1})
+      }.to raise_error(Neography::BadInputException)
+      root_node = @neo.execute_query("start n=node({id}) return n", {:id => 0})
+      expect(root_node).not_to be_nil
+    end
+
+    it "throws an error for an invalid query" do
+      expect {
+        @neo.execute_query("this is not a query")
+      }.to raise_error(Neography::SyntaxException)
+    end
+
+    it "throws an error for not unique paths in unique path creation" do
+      node1 = @neo.create_node
+      node2 = @neo.create_node
+
+      id1 = node1["self"].split('/').last.to_i
+      id2 = node2["self"].split('/').last.to_i
+
+      # create two 'FOO' relationships
+      @neo.execute_query("START a=node({id1}), b=node({id2}) CREATE a-[r:FOO]->b RETURN r", { :id1 => id1, :id2 => id2 })
+      @neo.execute_query("START a=node({id1}), b=node({id2}) CREATE a-[r:FOO]->b RETURN r", { :id1 => id1, :id2 => id2 })
+
+      expect {
+        @neo.execute_query("START a=node({id1}), b=node({id2}) CREATE UNIQUE a-[r:FOO]->b RETURN r", { :id1 => id1, :id2 => id2 })
+      }.to raise_error(Neography::UniquePathNotUniqueException)
+    end
+
+  end
+
+end

data/spec/integration/rest_relationship_spec.rb

@@ -0,0 +1,354 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "create_relationship" do
+    it "can create an empty relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      expect(new_relationship["start"]).not_to be_nil
+      expect(new_relationship["end"]).not_to be_nil
+    end
+
+    it "can create a relationship with one property" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010'})
+      expect(new_relationship["data"]["since"]).to eq('10-1-2010')
+    end
+
+    it "can create a relationship with more than one property" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      expect(new_relationship["data"]["since"]).to eq('10-1-2010')
+      expect(new_relationship["data"]["met"]).to eq("college")
+    end
+
+    it "can create a unique node with more than one property" do
+      index_name = generate_text(6)
+      key = generate_text(6)
+      value = generate_text
+      @neo.create_node_index(index_name)
+      new_node = @neo.create_unique_node(index_name, key, value, {"age" => 31, "name" => "Max"})
+      expect(new_node["data"]["name"]).to eq("Max")
+      expect(new_node["data"]["age"]).to eq(31)
+    end
+
+    it "can create a unique relationship" do
+      index_name = generate_text(6)
+      key = generate_text(6)
+      value = generate_text
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_unique_relationship(index_name, key, value, "friends", new_node1, new_node2)
+      expect(new_relationship["data"][key]).to eq(value)
+    end
+
+  end
+
+  describe "get_relationship" do
+    it "can get a relationship that exists" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      existing_relationship = @neo.get_relationship(new_relationship)
+      expect(existing_relationship).not_to be_nil
+      expect(existing_relationship).to have_key("self")
+      expect(existing_relationship["self"]).to eq(new_relationship["self"])
+    end
+
+    it "raises error if it tries to get a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        existing_relationship = @neo.get_relationship(fake_relationship)
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+  end
+
+  describe "set_relationship_properties" do
+    it "can set a relationship's properties" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.set_relationship_properties(new_relationship, {"since" => '10-1-2010', "met" => "college"})
+      @neo.set_relationship_properties(new_relationship, {"roommates" => "no"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to eq("college")
+      expect(relationship_properties["roommates"]).to eq("no")
+    end
+
+    it "it fails to set properties on a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        @neo.set_relationship_properties(fake_relationship, {"since" => '10-1-2010', "met" => "college"})
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+  end
+
+  describe "reset_relationship_properties" do
+    it "can reset a relationship's properties" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.set_relationship_properties(new_relationship, {"since" => '10-1-2010', "met" => "college"})
+      @neo.reset_relationship_properties(new_relationship, {"roommates" => "no"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties["since"]).to be_nil
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
+    end
+
+    it "it fails to reset properties on a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        @neo.reset_relationship_properties(fake_relationship, {"since" => '10-1-2010', "met" => "college"})
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+  end
+
+  describe "get_relationship_properties" do
+    it "can get all of a relationship's properties" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to eq("college")
+    end
+
+    it "can get some of a relationship's properties" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship, ["since", "roommates"])
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
+    end
+
+    it "returns nil if it gets the properties on a relationship that does not have any" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties).to be_nil
+    end
+
+    it "raises error if it tries to get some of the properties on a relationship that does not have any" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      expect {
+        @neo.get_relationship_properties(new_relationship, ["since", "roommates"])
+      }.to raise_error Neography::NoSuchPropertyException
+    end
+
+    it "raises error if it fails to get properties on a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        @neo.get_relationship_properties(fake_relationship)
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+  end
+
+  describe "remove_relationship_properties" do
+    it "can remove a relationship's properties" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      @neo.remove_relationship_properties(new_relationship)
+      expect(@neo.get_relationship_properties(new_relationship)).to be_nil
+    end
+
+    it "raises error if it fails to remove the properties of a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        @neo.remove_relationship_properties(fake_relationship)
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+
+    it "can remove a specific relationship property" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      @neo.remove_relationship_properties(new_relationship, "met")
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+    end
+
+    it "can remove more than one relationship property" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
+      @neo.remove_relationship_properties(new_relationship, ["met", "since"])
+      relationship_properties = @neo.get_relationship_properties(new_relationship)
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["since"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
+    end
+  end
+
+  describe "delete_relationship" do
+    it "can delete an existing relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      @neo.delete_relationship(new_relationship)
+      relationships = @neo.get_node_relationships(new_node1)
+      expect(relationships).to be_empty
+    end
+
+    it "raises error if it tries to delete a relationship that does not exist" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      fake_relationship = new_relationship["self"].split('/').last.to_i + 1000
+      expect {
+        existing_relationship = @neo.delete_relationship(fake_relationship)
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+
+    it "returns nil if it tries to delete a relationship that has already been deleted" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
+      existing_relationship = @neo.delete_relationship(new_relationship)
+      expect(existing_relationship).to be_nil
+      expect {
+        existing_relationship = @neo.delete_relationship(new_relationship)
+      }.to raise_error Neography::RelationshipNotFoundException
+    end
+  end
+
+  describe "get_node_relationships" do
+    it "can get a node's relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      relationships = @neo.get_node_relationships(new_node1)
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+    end
+
+    it "can get a node's multiple relationships" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1)
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]["start"]).to eq(new_node1["self"])
+      expect(relationships[1]["end"]).to eq(new_node3["self"])
+      expect(relationships[1]["type"]).to eq("enemies")
+      expect(relationships[1]["data"]["met"]).to eq("work")
+      expect(relationships[1]["data"]["since"]).to eq('10-2-2010')
+    end
+
+    it "can get a node's outgoing relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node3, new_node1, {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1, "out")
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]).to be_nil
+    end
+
+    it "can get a node's incoming relationship" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node3, new_node1, {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1, "in")
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node3["self"])
+      expect(relationships[0]["end"]).to eq(new_node1["self"])
+      expect(relationships[0]["type"]).to eq("enemies")
+      expect(relationships[0]["data"]["met"]).to eq("work")
+      expect(relationships[0]["data"]["since"]).to eq('10-2-2010')
+      expect(relationships[1]).to be_nil
+    end
+
+    it "can get a specific type of node relationships" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1, "all", "friends")
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]).to be_nil
+    end
+
+    it "can get a specific type and direction of a node relationships" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_node3 = @neo.create_node
+      new_node4 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
+      new_relationship = @neo.create_relationship("enemies", new_node4, new_node1, {"since" => '10-3-2010', "met" => "gym"})
+      relationships = @neo.get_node_relationships(new_node1, "in", "enemies")
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node4["self"])
+      expect(relationships[0]["end"]).to eq(new_node1["self"])
+      expect(relationships[0]["type"]).to eq("enemies")
+      expect(relationships[0]["data"]["met"]).to eq("gym")
+      expect(relationships[0]["data"]["since"]).to eq('10-3-2010')
+      expect(relationships[1]).to be_nil
+    end
+
+    it "returns nil if there are no relationships" do
+      new_node1 = @neo.create_node
+      relationships = @neo.get_node_relationships(new_node1)
+      expect(relationships).to be_empty
+    end
+  end
+
+end