neography-calamitates 1.2.3.1

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"})
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node2["self"]
+      path["nodes"].should == [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")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [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"})
+      path.first["start"].should == new_node1["self"]
+      path.first["end"].should == new_node5["self"]
+      path.first["nodes"].should == [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")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [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")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [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")
+      paths.length.should == 2
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == 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")
+      paths.length.should == 3
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 3
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]
+      paths[2]["length"].should == 2
+      paths[2]["start"].should == new_node1["self"]
+      paths[2]["end"].should == 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")
+      paths.length.should == 3
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 3
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]
+      paths[2]["length"].should == 2
+      paths[2]["start"].should == new_node1["self"]
+      paths[2]["end"].should == 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")
+      paths.length.should == 2
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == 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")
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == 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)")
+      root_node.should have_key("self")
+      root_node["self"].split('/').last.should == "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})")
+      existing_node.should_not be_nil
+      existing_node.should have_key("self")
+      existing_node["self"].split('/').last.should == 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})
+      existing_node.should_not be_nil
+      existing_node.should have_key("self")
+      existing_node["self"].split('/').last.should == 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")
+      root_node.should have_key("data")
+      root_node.should have_key("columns")
+      root_node["data"][0][0].should have_key("self")
+      root_node["data"][0][0]["self"].split('/').last.should == "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")
+      existing_node.should_not be_nil
+      existing_node.should have_key("data")
+      existing_node.should have_key("columns")
+      existing_node["data"][0][0].should have_key("self")
+      existing_node["data"][0][0]["self"].split('/').last.should == 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]")
+      existing_node.first["self"].should == new_node["self"]
+      existing_node.first.should_not be_nil
+      existing_node.first["data"]["number"].should == 3
+      existing_node = @neo.execute_query("start n=node:#{name}(\"number:[1 TO 5]\") return n")
+      existing_node.should have_key("data")
+      existing_node.should have_key("columns")
+      existing_node["data"][0][0].should have_key("self")
+      existing_node["data"][0][0]["self"].split('/').last.should == 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]")
+      existing_node.first["self"].should == new_node["self"]
+      existing_node.first.should_not be_nil
+      existing_node.first["data"]["number"].should == 3
+      existing_node.first["data"]["name"].should == "Max"
+      existing_node = @neo.execute_query("start n=node:#{name}(\"name:max AND number:[1 TO 5]\") return n")
+      existing_node.should have_key("data")
+      existing_node.should have_key("columns")
+      existing_node["data"][0][0].should have_key("self")
+      existing_node["data"][0][0]["self"].split('/').last.should == 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")
+      existing_node.should_not be_nil
+      existing_node.should have_key("data")
+      existing_node.should have_key("columns")
+      existing_node["data"][0][0]["self"].split('/').last.should == id
+      existing_node["data"][0][0]["data"]["name"].should == "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})
+      existing_node.should_not be_nil
+      existing_node.should have_key("data")
+      existing_node.should have_key("columns")
+      existing_node["data"][0][0].should have_key("self")
+      existing_node["data"][0][0]["self"].split('/').last.should == 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})
+      root_node.should have_key("data")
+      root_node.should have_key("columns")
+      root_node.should have_key("stats")
+      root_node["data"][0][0].should have_key("self")
+      root_node["data"][0][0]["self"].split('/').last.should == "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})
+      root_node.should have_key("data")
+      root_node.should have_key("columns")
+      root_node.should have_key("plan")
+      root_node["data"][0][0].should have_key("self")
+      root_node["data"][0][0]["self"].split('/').last.should == "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})
+      root_node.should have_key("data")
+      root_node.should have_key("columns")
+      root_node.should have_key("stats")
+      root_node.should have_key("plan")
+      root_node["data"][0][0].should have_key("self")
+      root_node["data"][0][0]["self"].split('/').last.should == "0"
+    end
+
+
+    it "can delete everything but start node" 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})
+      root_node.should_not 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)
+      new_relationship["start"].should_not be_nil
+      new_relationship["end"].should_not 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'})
+      new_relationship["data"]["since"].should == '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"})
+      new_relationship["data"]["since"].should == '10-1-2010'
+      new_relationship["data"]["met"].should == "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"})
+      new_node["data"]["name"].should == "Max"
+      new_node["data"]["age"].should == 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)
+      new_relationship["data"][key].should == 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)
+      existing_relationship.should_not be_nil
+      existing_relationship.should have_key("self")
+      existing_relationship["self"].should == 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)
+      relationship_properties["since"].should == '10-1-2010'
+      relationship_properties["met"].should == "college"
+      relationship_properties["roommates"].should == "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)
+      relationship_properties["since"].should be_nil
+      relationship_properties["met"].should be_nil
+      relationship_properties["roommates"].should == "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)
+      relationship_properties["since"].should == '10-1-2010'
+      relationship_properties["met"].should == "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"])
+      relationship_properties["since"].should == '10-1-2010'
+      relationship_properties["met"].should be_nil
+      relationship_properties["roommates"].should == "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)
+      relationship_properties.should 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)
+      @neo.get_relationship_properties(new_relationship).should 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)
+      relationship_properties["met"].should be_nil
+      relationship_properties["since"].should == '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)
+      relationship_properties["met"].should be_nil
+      relationship_properties["since"].should be_nil
+      relationship_properties["roommates"].should == "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)
+      relationships.should be_nil
+    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)
+      existing_relationship.should 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)
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node1["self"]
+      relationships[0]["end"].should == new_node2["self"]
+      relationships[0]["type"].should == "friends"
+      relationships[0]["data"]["met"].should == "college"
+      relationships[0]["data"]["since"].should == '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)
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node1["self"]
+      relationships[0]["end"].should == new_node2["self"]
+      relationships[0]["type"].should == "friends"
+      relationships[0]["data"]["met"].should == "college"
+      relationships[0]["data"]["since"].should == '10-1-2005'
+      relationships[1]["start"].should == new_node1["self"]
+      relationships[1]["end"].should == new_node3["self"]
+      relationships[1]["type"].should == "enemies"
+      relationships[1]["data"]["met"].should == "work"
+      relationships[1]["data"]["since"].should == '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")
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node1["self"]
+      relationships[0]["end"].should == new_node2["self"]
+      relationships[0]["type"].should == "friends"
+      relationships[0]["data"]["met"].should == "college"
+      relationships[0]["data"]["since"].should == '10-1-2005'
+      relationships[1].should 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")
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node3["self"]
+      relationships[0]["end"].should == new_node1["self"]
+      relationships[0]["type"].should == "enemies"
+      relationships[0]["data"]["met"].should == "work"
+      relationships[0]["data"]["since"].should == '10-2-2010'
+      relationships[1].should 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")
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node1["self"]
+      relationships[0]["end"].should == new_node2["self"]
+      relationships[0]["type"].should == "friends"
+      relationships[0]["data"]["met"].should == "college"
+      relationships[0]["data"]["since"].should == '10-1-2005'
+      relationships[1].should 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")
+      relationships.should_not be_nil
+      relationships[0]["start"].should == new_node4["self"]
+      relationships[0]["end"].should == new_node1["self"]
+      relationships[0]["type"].should == "enemies"
+      relationships[0]["data"]["met"].should == "gym"
+      relationships[0]["data"]["since"].should == '10-3-2010'
+      relationships[1].should be_nil
+    end
+
+    it "returns nil if there are no relationships" do
+      new_node1 = @neo.create_node
+      relationships = @neo.get_node_relationships(new_node1)
+      relationships.should be_nil
+    end
+  end
+
+end