neography 0.0.1

data/lib/neography/version.rb

@@ -0,0 +1,3 @@
+module Neography
+  VERSION = "0.0.1"
+end

data/neography.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "neography/version"
+
+Gem::Specification.new do |s|
+  s.name        = "neography"
+  s.version     = Neography::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = "Max De Marzi"
+  s.email       = "maxdemarzi@gmail.com"
+  s.homepage    = "http://rubygems.org/gems/neography"
+  s.summary     = "ruby wrapper to Neo4j Rest API"
+  s.description = "A Ruby wrapper to the Neo4j Rest API see http://components.neo4j.org/neo4j-rest/ for more details."
+
+  s.rubyforge_project = "neography"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.0.0.beta.22"
+  s.add_development_dependency "net-http-spy", "~> 0.2.1"
+  s.add_development_dependency "fakeweb", "~> 1.3.0"
+  s.add_dependency "httparty", "~> 0.6.1"
+  s.add_dependency "json"
+end

data/spec/integration/rest_index_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "list indexes" do
+    it "can get a listing of indexes" do
+      @neo.list_indexes.should_not be_nil
+    end
+  end
+
+  describe "add to index" do
+    it "can add a node to an index" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_to_index(key, value, new_node[:id]) 
+      new_index = @neo.get_index(key, value) 
+      new_index.should_not be_nil
+      @neo.remove_from_index(key, value, new_node[:id]) 
+    end
+  end
+
+  describe "remove from index" do
+    it "can remove a node from an index" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_to_index(key, value, new_node[:id]) 
+      new_index = @neo.get_index(key, value) 
+      new_index.should_not be_nil
+      @neo.remove_from_index(key, value, new_node[:id]) 
+      new_index = @neo.get_index(key, value) 
+      new_index.should be_nil
+    end
+  end
+
+  describe "get index" do
+    it "can get an index" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_to_index(key, value, new_node[:id]) 
+      new_index = @neo.get_index(key, value) 
+      new_index.should_not be_nil
+      @neo.remove_from_index(key, value, new_node[:id]) 
+    end
+  end
+
+end

data/spec/integration/rest_node_spec.rb

@@ -0,0 +1,241 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "get_root" do
+    it "can get the root node" do
+      root_node = @neo.get_root
+      root_node.should have_key("reference_node")
+    end
+  end
+
+  describe "create_node" do
+    it "can create an empty node" do
+      new_node = @neo.create_node
+      new_node.should_not be_nil
+    end
+
+    it "can create a node with one property" do
+      new_node = @neo.create_node("name" => "Max")
+      new_node["data"]["name"].should == "Max"
+    end
+
+    it "can create a node with more than one property" do
+      new_node = @neo.create_node("age" => 31, "name" => "Max")
+      new_node["data"]["name"].should == "Max"
+      new_node["data"]["age"].should == 31
+    end
+  end
+
+  describe "get_node" do
+    it "can get a node that exists" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should_not be_nil
+      existing_node.should have_key("self")
+      existing_node["self"].split('/').last.should == new_node[:id]
+    end
+
+    it "returns nil if it tries to get a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      existing_node.should be_nil
+    end
+  end
+
+  describe "set_node_properties" do
+    it "can set a node's properties" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.set_node_properties(new_node[:id], {"weight" => 200, "eyes" => "brown"})
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node["data"]["weight"].should == 200
+      existing_node["data"]["eyes"].should == "brown"
+    end
+
+    it "it fails to set properties on a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.set_node_properties(new_node[:id].to_i + 1000, {"weight" => 150, "hair" => "blonde"})
+      node_properties = @neo.get_node_properties(new_node[:id].to_i + 1000)
+      node_properties.should be_nil
+    end
+  end
+
+  describe "reset_node_properties" do
+    it "can reset a node's properties" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.set_node_properties(new_node[:id], {"weight" => 200, "eyes" => "brown", "hair" => "black"})
+      @neo.reset_node_properties(new_node[:id], {"weight" => 190, "eyes" => "blue"})
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node["data"]["weight"].should == 190
+      existing_node["data"]["eyes"].should == "blue"
+      existing_node["data"]["hair"].should be_nil
+    end
+
+    it "it fails to reset properties on a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.reset_node_properties(new_node[:id].to_i + 1000, {"weight" => 170, "eyes" => "green"})
+      node_properties = @neo.get_node_properties(new_node[:id].to_i + 1000)
+      node_properties.should be_nil
+    end
+  end
+
+  describe "get_node_properties" do
+    it "can get all of a node's properties" do
+      new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
+      new_node[:id] = new_node["self"].split('/').last
+      node_properties = @neo.get_node_properties(new_node[:id])
+      node_properties["weight"].should == 200
+      node_properties["eyes"].should == "brown"
+    end
+
+    it "can get some of a node's properties" do
+      new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
+      new_node[:id] = new_node["self"].split('/').last
+      node_properties = @neo.get_node_properties(new_node[:id], ["weight", "height"])
+      node_properties["weight"].should == 200
+      node_properties["height"].should == "2m"
+      node_properties["eyes"].should be_nil
+    end
+
+    it "returns nil if it gets the properties on a node that does not have any" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.get_node_properties(new_node[:id]).should be_nil
+    end
+
+    it "returns nil if it tries to get some of the properties on a node that does not have any" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.get_node_properties(new_node[:id], ["weight", "height"]).should be_nil
+    end
+
+    it "returns nil if it fails to get properties on a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.get_node_properties(new_node[:id].to_i + 10000).should be_nil
+    end
+  end
+
+  describe "remove_node_properties" do
+    it "can remove a node's properties" do
+      new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.remove_node_properties(new_node[:id])
+      @neo.get_node_properties(new_node[:id]).should be_nil
+    end
+
+    it "returns nil if it fails to remove the properties of a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.remove_node_properties(new_node[:id].to_i + 10000).should be_nil
+    end
+
+    it "can remove a specific node property" do
+      new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.remove_node_properties(new_node[:id], "weight")
+      node_properties = @neo.get_node_properties(new_node[:id])
+      node_properties["weight"].should be_nil
+      node_properties["eyes"].should == "brown"
+    end
+
+    it "can remove more than one property" do
+      new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.remove_node_properties(new_node[:id], ["weight", "eyes"])
+      node_properties = @neo.get_node_properties(new_node[:id])
+      node_properties["weight"].should be_nil
+      node_properties["eyes"].should be_nil
+    end
+  end
+
+  describe "delete_node" do
+    it "can delete an unrelated node" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+    end
+
+    it "cannot delete a node that has relationships" 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
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.delete_node(new_node1[:id]).should be_nil
+      existing_node = @neo.get_node(new_node1[:id])
+      existing_node.should_not be_nil
+    end
+
+    it "returns nil if it tries to delete a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node(new_node[:id].to_i + 1000).should be_nil
+      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      existing_node.should be_nil
+    end
+
+    it "returns nil if it tries to delete a node that has already been deleted" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+      @neo.delete_node(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+    end
+  end
+
+  describe "delete_node!" do
+    it "can delete an unrelated node" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node!(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+    end
+
+    it "can delete a node that has relationships" 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
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.delete_node!(new_node1[:id]).should be_nil
+      existing_node = @neo.get_node(new_node1[:id])
+      existing_node.should be_nil
+    end
+
+    it "returns nil if it tries to delete a node that does not exist" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node!(new_node[:id].to_i + 1000).should be_nil
+      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      existing_node.should be_nil
+    end
+
+    it "returns nil if it tries to delete a node that has already been deleted" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      @neo.delete_node!(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+      @neo.delete_node!(new_node[:id]).should be_nil
+      existing_node = @neo.get_node(new_node[:id])
+      existing_node.should be_nil
+    end
+  end
+
+end

data/spec/integration/rest_path_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), '..', '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_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[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      path = @neo.get_path(new_node1[:id], new_node2[:id], {"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
+      pending
+    end
+
+    it "can get a simple path between two nodes" do
+      pending
+    end
+
+    it "can get a path between two nodes of max depth 3" do
+      pending
+    end
+
+    it "can get a path between two nodes of a specific relationship" do
+      pending
+    end
+  end
+
+  describe "get paths" do
+    it "can get the shortest paths between two nodes" do
+      pending
+    end
+
+    it "can get all paths between two nodes" do
+      pending
+    end
+
+    it "can get all simple paths between two nodes" do
+      pending
+    end
+
+    it "can get paths between two nodes of max depth 3" do
+      pending
+    end
+
+    it "can get paths between two nodes of a specific relationship" do
+      pending
+    end
+
+  end
+
+
+end

data/spec/integration/rest_relationship_spec.rb

@@ -0,0 +1,372 @@
+require File.join(File.dirname(__FILE__), '..', '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_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[:id], new_node2[:id])
+      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[:id], new_node2[:id], {"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_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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship["data"]["since"].should == '10-1-2010'
+      new_relationship["data"]["met"].should == "college"
+    end
+  end
+
+  describe "set_relationship_properties" do
+    it "can set a relationship's properties" 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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.set_relationship_properties(new_relationship[:id], {"since" => '10-1-2010', "met" => "college"})
+      @neo.set_relationship_properties(new_relationship[:id], {"roommates" => "no"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id])
+      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_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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.set_relationship_properties(new_relationship[:id].to_i + 10000, {"since" => '10-1-2010', "met" => "college"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id].to_i + 10000)
+      relationship_properties.should be_nil
+    end
+  end
+
+  describe "reset_relationship_properties" do
+    it "can reset a relationship's properties" 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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.set_relationship_properties(new_relationship[:id], {"since" => '10-1-2010', "met" => "college"})
+      @neo.reset_relationship_properties(new_relationship[:id], {"roommates" => "no"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id])
+      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_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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.reset_relationship_properties(new_relationship[:id].to_i + 10000, {"since" => '10-1-2010', "met" => "college"})
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id].to_i + 10000)
+      relationship_properties.should be_nil
+    end
+  end
+
+  describe "get_relationship_properties" do
+    it "can get all of a relationship's properties" 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id])
+      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_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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id], ["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_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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id])
+      relationship_properties.should be_nil
+    end
+
+    it "returns nil if it tries to get some of the properties on a relationship that does not have any" 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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id], ["since", "roommates"])
+      relationship_properties.should be_nil
+    end
+
+    it "returns nil if it fails to get properties on a relationship that does not exist" 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[:id], new_node2[:id])
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id].to_i + 10000)
+      relationship_properties.should be_nil
+    end
+  end
+
+  describe "remove_relationship_properties" do
+    it "can remove a relationship's properties" 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.remove_relationship_properties(new_relationship[:id])
+      @neo.get_relationship_properties(new_relationship[:id]).should be_nil
+    end
+
+    it "returns nil if it fails to remove the properties of a relationship that does not exist" 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.remove_relationship_properties(new_relationship[:id])
+      @neo.get_relationship_properties(new_relationship[:id].to_i + 10000).should be_nil
+    end
+
+    it "can remove a specific relationship 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.remove_relationship_properties(new_relationship[:id], "met")
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id], ["met", "since"])
+      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_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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.remove_relationship_properties(new_relationship[:id], ["met", "since"])
+      relationship_properties = @neo.get_relationship_properties(new_relationship[:id], ["since", "met", "roommates"])
+      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_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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      @neo.delete_relationship(new_relationship[:id])
+      relationships = @neo.get_node_relationships(new_node1[:id])
+      relationships.should be_nil
+    end
+
+    it "returns nil if it tries to delete a relationship that does not exist" 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      existing_relationship = @neo.delete_relationship(new_relationship[:id].to_i + 1000)
+      existing_relationship.should be_nil
+    end
+
+    it "returns nil if it tries to delete a relationship that has already been deleted" 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[:id], new_node2[:id], {"since" => '10-1-2010', "met" => "college"})
+      new_relationship[:id] = new_relationship["self"].split('/').last
+      existing_relationship = @neo.delete_relationship(new_relationship[:id])
+      existing_relationship.should be_nil
+      existing_relationship = @neo.delete_relationship(new_relationship[:id])
+      existing_relationship.should be_nil
+    end
+  end
+
+  describe "get_node_relationships" do
+    it "can get a node's relationship" 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[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      relationships = @neo.get_node_relationships(new_node1[:id])
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node1[:id]
+      relationships[0]["end"].split('/').last.should == new_node2[:id]
+      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_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1[:id], new_node3[:id], {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1[:id])
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node1[:id]
+      relationships[0]["end"].split('/').last.should == new_node2[:id]
+      relationships[0]["type"].should == "friends"
+      relationships[0]["data"]["met"].should == "college"
+      relationships[0]["data"]["since"].should == '10-1-2005'
+      relationships[1]["start"].split('/').last.should == new_node1[:id]
+      relationships[1]["end"].split('/').last.should == new_node3[:id]
+      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_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node3[:id], new_node1[:id], {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1[:id], "out")
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node1[:id]
+      relationships[0]["end"].split('/').last.should == new_node2[:id]
+      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_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node3[:id], new_node1[:id], {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1[:id], "in")
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node3[:id]
+      relationships[0]["end"].split('/').last.should == new_node1[:id]
+      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_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1[:id], new_node3[:id], {"since" => '10-2-2010', "met" => "work"})
+      relationships = @neo.get_node_relationships(new_node1[:id], "all", "friends")
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node1[:id]
+      relationships[0]["end"].split('/').last.should == new_node2[:id]
+      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_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_relationship = @neo.create_relationship("friends", new_node1[:id], new_node2[:id], {"since" => '10-1-2005', "met" => "college"})
+      new_relationship = @neo.create_relationship("enemies", new_node1[:id], new_node3[:id], {"since" => '10-2-2010', "met" => "work"})
+      new_relationship = @neo.create_relationship("enemies", new_node4[:id], new_node1[:id], {"since" => '10-3-2010', "met" => "gym"})
+      relationships = @neo.get_node_relationships(new_node1[:id], "in", "enemies")
+      relationships.should_not be_nil
+      relationships[0]["start"].split('/').last.should == new_node4[:id]
+      relationships[0]["end"].split('/').last.should == new_node1[:id]
+      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
+      new_node1[:id] = new_node1["self"].split('/').last
+      relationships = @neo.get_node_relationships(new_node1[:id])
+      relationships.should be_nil
+    end
+  end
+
+end