neography-ajaycb 0.0.21

data/spec/integration/relationship_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Relationship do
+  describe "create relationship" do
+    it "#new(:family, p1, p2) creates a new relationship between to nodes of given type" do
+      p1 = Neography::Node.create
+      p2 = Neography::Node.create
+
+      Neography::Relationship.create(:family, p1, p2)
+      p1.outgoing(:family).should include(p2)
+      p2.incoming(:family).should include(p1)
+    end
+
+    it "#new(:family, p1, p2, :since => '1998', :colour => 'blue') creates relationship and sets its properties" do
+      p1 = Neography::Node.create
+      p2 = Neography::Node.create
+      rel = Neography::Relationship.create(:family, p1, p2, :since => 1998, :colour => 'blue')
+
+      rel[:since].should == 1998
+      rel[:colour].should == 'blue'
+      rel.since.should == 1998
+      rel.colour.should == 'blue'
+    end
+
+    it "#outgoing(:friends).create(other) creates a new relationship between self and other node" do
+      p1 = Neography::Node.create
+      p2 = Neography::Node.create
+      rel = p1.outgoing(:foo).create(p2)
+
+      rel.should be_kind_of(Neography::Relationship)
+      p1.outgoing(:foo).first.should == p2
+      p1.outgoing(:foo).should include(p2)
+      p2.incoming(:foo).should include(p1)
+    end
+  end
+
+end

data/spec/integration/rest_batch_spec.rb

@@ -0,0 +1,221 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "simple batch" do
+    it "can get a single node" do
+      new_node = @neo.create_node
+      new_node[:id] = new_node["self"].split('/').last
+      batch_result = @neo.batch [:get_node, new_node]
+      batch_result.first.should_not be_nil
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("body")
+      batch_result.first.should have_key("from")
+      batch_result.first["body"]["self"].split('/').last.should == new_node[:id]
+    end
+    
+    it "can get multiple nodes" do
+      node1 = @neo.create_node
+      node1[:id] = node1["self"].split('/').last
+      node2 = @neo.create_node
+      node2[:id] = node2["self"].split('/').last
+
+      batch_result = @neo.batch [:get_node, node1], [:get_node, node2]
+      batch_result.first.should_not be_nil
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("body")
+      batch_result.first.should have_key("from")
+      batch_result.first["body"]["self"].split('/').last.should == node1[:id]
+      batch_result.last.should have_key("id")
+      batch_result.last.should have_key("body")
+      batch_result.last.should have_key("from")
+      batch_result.last["body"]["self"].split('/').last.should == node2[:id]
+
+    end
+
+    it "can create a single node" do
+      batch_result = @neo.batch [:create_node, {"name" => "Max"}]
+      batch_result.first["body"]["data"]["name"].should == "Max"
+    end
+
+    it "can create multiple nodes" do
+      batch_result = @neo.batch [:create_node, {"name" => "Max"}], [:create_node, {"name" => "Marc"}]
+      batch_result.first["body"]["data"]["name"].should == "Max"
+      batch_result.last["body"]["data"]["name"].should == "Marc"
+    end
+
+    it "can create multiple nodes given an *array" do
+      batch_result = @neo.batch *[[:create_node, {"name" => "Max"}], [:create_node, {"name" => "Marc"}]]
+      batch_result.first["body"]["data"]["name"].should == "Max"
+      batch_result.last["body"]["data"]["name"].should == "Marc"
+    end
+
+
+    it "can update a property of a node" do
+      new_node = @neo.create_node("name" => "Max")
+      batch_result = @neo.batch [:set_node_property, new_node, {"name" => "Marc"}]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      existing_node = @neo.get_node(new_node)
+      existing_node["data"]["name"].should == "Marc"
+    end
+
+    it "can update a property of multiple nodes" do
+      node1 = @neo.create_node("name" => "Max")
+      node2 = @neo.create_node("name" => "Marc")
+      batch_result = @neo.batch [:set_node_property, node1, {"name" => "Tom"}], [:set_node_property, node2, {"name" => "Jerry"}]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      batch_result.last.should have_key("id")
+      batch_result.last.should have_key("from")
+      existing_node = @neo.get_node(node1)
+      existing_node["data"]["name"].should == "Tom"
+      existing_node = @neo.get_node(node2)
+      existing_node["data"]["name"].should == "Jerry"
+    end
+
+    it "can reset the properties of a node" do
+      new_node = @neo.create_node("name" => "Max", "weight" => 200)
+      batch_result = @neo.batch [:reset_node_properties, new_node, {"name" => "Marc"}]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      existing_node = @neo.get_node(new_node)
+      existing_node["data"]["name"].should == "Marc"
+      existing_node["data"]["weight"].should be_nil
+    end
+
+    it "can reset the properties of multiple nodes" do
+      node1 = @neo.create_node("name" => "Max", "weight" => 200)
+      node2 = @neo.create_node("name" => "Marc", "weight" => 180)
+      batch_result = @neo.batch [:reset_node_properties, node1, {"name" => "Tom"}], [:reset_node_properties, node2, {"name" => "Jerry"}]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      batch_result.last.should have_key("id")
+      batch_result.last.should have_key("from")
+      existing_node = @neo.get_node(node1)
+      existing_node["data"]["name"].should == "Tom"
+      existing_node["data"]["weight"].should be_nil
+      existing_node = @neo.get_node(node2)
+      existing_node["data"]["name"].should == "Jerry"
+      existing_node["data"]["weight"].should be_nil
+    end
+
+    it "can get a single relationship" do
+      node1 = @neo.create_node
+      node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", node1, node2)
+      batch_result = @neo.batch [:get_relationship, new_relationship]
+      batch_result.first["body"]["type"].should == "friends"
+      batch_result.first["body"]["start"].split('/').last.should == node1["self"].split('/').last
+      batch_result.first["body"]["end"].split('/').last.should == node2["self"].split('/').last
+      batch_result.first["body"]["self"].should == new_relationship["self"]
+    end
+    
+    it "can create a single relationship" do
+      node1 = @neo.create_node
+      node2 = @neo.create_node
+      batch_result = @neo.batch [:create_relationship, "friends", node1, node2, {:since => "high school"}]
+      batch_result.first["body"]["type"].should == "friends"
+      batch_result.first["body"]["data"]["since"].should == "high school"
+      batch_result.first["body"]["start"].split('/').last.should == node1["self"].split('/').last
+      batch_result.first["body"]["end"].split('/').last.should == node2["self"].split('/').last
+    end
+
+    it "can update a single relationship" do
+      node1 = @neo.create_node
+      node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", node1, node2, {:since => "high school"})
+      batch_result = @neo.batch [:set_relationship_property, new_relationship, {:since => "college"}]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      existing_relationship = @neo.get_relationship(new_relationship)
+      existing_relationship["type"].should == "friends"
+      existing_relationship["data"]["since"].should == "college"
+      existing_relationship["start"].split('/').last.should == node1["self"].split('/').last
+      existing_relationship["end"].split('/').last.should == node2["self"].split('/').last
+      existing_relationship["self"].should == new_relationship["self"]
+    end
+
+    it "can add a node to an index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      batch_result = @neo.batch [:add_node_to_index, "test_node_index", key, value, new_node]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      existing_index = @neo.find_node_index("test_node_index", key, value) 
+      existing_index.should_not be_nil
+      existing_index.first["self"].should == new_node["self"]
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+  end
+
+  describe "referenced batch" do
+    it "can create a relationship from two newly created nodes" do
+      batch_result = @neo.batch [:create_node, {"name" => "Max"}], [:create_node, {"name" => "Marc"}], [:create_relationship, "friends", "{0}", "{1}", {:since => "high school"}]
+      batch_result.first["body"]["data"]["name"].should == "Max"
+      batch_result[1]["body"]["data"]["name"].should == "Marc"
+      batch_result.last["body"]["type"].should == "friends"
+      batch_result.last["body"]["data"]["since"].should == "high school"
+      batch_result.last["body"]["start"].split('/').last.should == batch_result.first["body"]["self"].split('/').last
+      batch_result.last["body"]["end"].split('/').last.should == batch_result[1]["body"]["self"].split('/').last
+    end
+
+    it "can create a relationship from an existing node and a newly created node" do
+      node1 = @neo.create_node("name" => "Max", "weight" => 200)
+      batch_result = @neo.batch [:create_node, {"name" => "Marc"}], [:create_relationship, "friends", "{0}", node1, {:since => "high school"}]
+      batch_result.first["body"]["data"]["name"].should == "Marc"
+      batch_result.last["body"]["type"].should == "friends"
+      batch_result.last["body"]["data"]["since"].should == "high school"
+      batch_result.last["body"]["start"].split('/').last.should == batch_result.first["body"]["self"].split('/').last
+      batch_result.last["body"]["end"].split('/').last.should == node1["self"].split('/').last
+    end
+
+    it "can add a newly created node to an index" do
+      key = generate_text(6)
+      value = generate_text
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      batch_result = @neo.batch [:create_node, {"name" => "Max"}], [:add_node_to_index, "test_node_index", key, value, "{0}"]
+      batch_result.first.should have_key("id")
+      batch_result.first.should have_key("from")
+      existing_index = @neo.find_node_index("test_node_index", key, value) 
+      existing_index.should_not be_nil
+      existing_index.first["self"].should == batch_result.first["body"]["self"]
+      @neo.remove_node_from_index("test_node_index", key, value, batch_result.first["body"]["self"].split('/').last) 
+    end
+
+    it "can add a newly created relationship to an index" do
+      key = generate_text(6)
+      value = generate_text
+      node1 = @neo.create_node
+      node2 = @neo.create_node
+      batch_result = @neo.batch [:create_relationship, "friends", node1, node2, {:since => "high school"}], [:add_relationship_to_index, "test_relationship_index", key, value, "{0}"]
+      batch_result.first["body"]["type"].should == "friends"
+      batch_result.first["body"]["data"]["since"].should == "high school"
+      batch_result.first["body"]["start"].split('/').last.should == node1["self"].split('/').last
+      batch_result.first["body"]["end"].split('/').last.should == node2["self"].split('/').last
+      existing_index = @neo.find_relationship_index("test_relationship_index", key, value) 
+      existing_index.should_not be_nil
+      existing_index.first["self"].should == batch_result.first["body"]["self"]
+
+    end
+
+    it "can kitchen sink" do
+      key = generate_text(6)
+      value = generate_text
+
+      batch_result = @neo.batch [:create_node, {"name" => "Max"}], 
+                                [:create_node, {"name" => "Marc"}],                           
+                                [:add_node_to_index, "test_node_index", key, value, "{0}"]
+                                [:add_node_to_index, "test_node_index", key, value, "{1}"]
+                                [:create_relationship, "friends", "{0}", "{1}", {:since => "college"}]                        
+                                [:add_relationship_to_index, "test_relationship_index", key, value, "{4}"] 
+      batch_result.should_not be_nil
+    end
+  end
+  
+end

data/spec/integration/rest_bulk_spec.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "can create many nodes threaded" do
+    it "can create empty nodes threaded" do
+      new_nodes = @neo.create_nodes_threaded(2)
+      new_nodes.should_not be_nil
+      new_nodes.size.should == 2
+    end
+
+    it "is faster than non-threaded?" , :slow => true do
+      Benchmark.bm do |x|
+        x.report("create 500 nodes         ") { @not_threaded = @neo.create_nodes(500) }
+        x.report("create 500 nodes threaded") { @threaded     = @neo.create_nodes_threaded(500) }
+        x.report("create 1000 nodes threaded") { @threaded2c   = @neo.create_nodes_threaded(1000) }
+      end
+
+      @not_threaded[99].should_not be_nil
+      @threaded[99].should_not be_nil
+      @threaded2c[199].should_not be_nil
+    end
+
+  end
+
+  describe "can create many nodes" do
+    it "can create empty nodes" do
+      new_nodes = @neo.create_nodes(2)
+      new_nodes.should_not be_nil
+      new_nodes.size.should == 2
+    end
+
+    it "can create nodes with one property" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"name" => "Alex"}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[1]["data"]["name"].should == "Alex"
+    end
+
+    it "can create nodes with one property that are different" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"age" => 24}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[1]["data"]["age"].should == 24
+    end
+
+    it "can create nodes with more than one property" do
+      new_nodes = @neo.create_nodes([{"age" => 31, "name" => "Max"}, {"age" => 24, "name" => "Alex"}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[0]["data"]["age"].should == 31
+      new_nodes[1]["data"]["name"].should == "Alex"
+      new_nodes[1]["data"]["age"].should == 24
+    end
+
+    it "can create nodes with more than one property that are different" do
+      new_nodes = @neo.create_nodes([{"age" => 31, "name" => "Max"}, {"height" => "5-11", "weight" => 215}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[0]["data"]["age"].should == 31
+      new_nodes[1]["data"]["height"].should == "5-11"
+      new_nodes[1]["data"]["weight"].should == 215
+    end
+
+    it "is not super slow?" , :slow => true do
+      Benchmark.bm do |x|
+        x.report(  "create 1 node" ) { @neo.create_nodes(  1) }
+        x.report( "create 10 nodes") { @neo.create_nodes( 10) }
+        x.report("create 100 nodes") { @neo.create_nodes(100) }
+      end
+    end
+  end
+
+  describe "can get many nodes" do
+    it "can get 2 nodes passed in as an array" do
+      new_nodes = @neo.create_nodes(2)
+      existing_nodes = @neo.get_nodes(new_nodes)
+      existing_nodes.should_not be_nil
+      existing_nodes.size.should == 2
+    end
+
+    it "can get 2 nodes passed in by commas" do
+      new_nodes = @neo.create_nodes(2)
+      new_node1 = new_nodes[0]["self"].split('/').last
+      new_node2 = new_nodes[1]["self"].split('/').last
+      existing_nodes = @neo.get_nodes(new_node1, new_node2)
+      existing_nodes.should_not be_nil
+      existing_nodes.size.should == 2
+      existing_nodes[0]["self"] == new_node1["self"]
+      existing_nodes[1]["self"] == new_node2["self"]
+    end
+
+    it "is not super slow?" , :slow => true do
+               one_node  = @neo.create_nodes(  1)
+              ten_nodes =  @neo.create_nodes( 10)
+      one_hundred_nodes =  @neo.create_nodes(100)
+
+      Benchmark.bm do |x|
+        x.report(  "get 1 node ") { @neo.get_nodes(one_node) }
+        x.report( "get 10 nodes") { @neo.get_nodes(ten_nodes) }
+        x.report("get 100 nodes") { @neo.get_nodes(one_hundred_nodes) }
+      end
+    end
+
+  end
+
+end

data/spec/integration/rest_experimental_spec.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+
+  describe "get_nodes", :slow => true do
+    it "can get nodes that exists" do
+      existing_nodes = @neo.get_nodes
+      existing_nodes.should_not be_nil
+    end
+
+    it "can get all nodes that exists the ugly way" do
+      new_node = @neo.create_node
+      last_node_id = new_node["self"].split('/').last.to_i
+      existing_nodes = @neo.get_nodes((1..last_node_id).to_a)
+      existing_nodes.should_not be_nil
+    end
+  end
+end

data/spec/integration/rest_gremlin_fail_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "don't break gremlin" do
+    it "can handle node and relationship indexes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_index", key, value, new_node1)
+      @neo.add_relationship_to_index("test_index2", key, value, new_relationship) 
+    end
+
+    it "gremlin works" do
+      root_node = @neo.execute_script("g.v(0)")
+      root_node.should have_key("self")
+      root_node["self"].split('/').last.should == "0"
+    end
+  end
+
+
+  describe "break gremlin" do
+    it "can can't handle node and relationship indexes with the same name", :break_gremlin => true do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_index3", key, value, new_node1)
+      @neo.add_relationship_to_index("test_index3", key, value, new_relationship) 
+    end
+
+    it "gremlin works" do
+      root_node = @neo.execute_script("g.v(0)")
+      root_node.should have_key("self")
+      root_node["self"].split('/').last.should == "0"
+    end
+  end
+
+
+end

data/spec/integration/rest_index_spec.rb

@@ -0,0 +1,297 @@
+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 node indexes" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      @neo.list_indexes.should_not be_nil
+    end
+
+    it "can get a listing of relationship indexes" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      @neo.list_relationship_indexes.should_not be_nil
+    end
+  end
+
+  describe "create an index" do
+    it "can create a node index" do
+      name = generate_text(6)
+      new_index = @neo.create_node_index(name)
+      new_index.should_not be_nil
+      new_index["template"].should == "#{@neo.configuration}/index/node/#{name}/{key}/{value}"
+      new_index["provider"].should == "lucene"
+      new_index["type"].should == "exact"
+    end
+
+    it "can create a node index with options" do
+      name = generate_text(6)
+      new_index = @neo.create_node_index(name, "fulltext","lucene")
+      new_index.should_not be_nil
+      new_index["template"].should == "#{@neo.configuration}/index/node/#{name}/{key}/{value}"
+      new_index["provider"].should == "lucene"
+      new_index["type"].should == "fulltext"
+    end
+
+    it "can create a relationship index" do
+      name = generate_text(6)
+      new_index = @neo.create_relationship_index(name)
+      new_index.should_not be_nil
+      new_index["template"].should == "#{@neo.configuration}/index/relationship/#{name}/{key}/{value}"
+      new_index["provider"].should == "lucene"
+      new_index["type"].should == "exact"
+    end
+
+    it "can create a relationship index with options" do
+      name = generate_text(6)
+      new_index = @neo.create_relationship_index(name, "fulltext","lucene")
+      new_index.should_not be_nil
+      new_index["template"].should == "#{@neo.configuration}/index/relationship/#{name}/{key}/{value}"
+      new_index["provider"].should == "lucene"
+      new_index["type"].should == "fulltext"
+    end
+
+
+  end
+
+  describe "add to index" do
+    it "can add a node to an index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+  
+    it "can add a relationship to an index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship) 
+    end
+  end
+
+  describe "remove from index" do
+    it "can remove a node from an index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should be_nil
+    end
+
+    it "can remove a node from an index without supplying value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_node_from_index("test_node_index", key, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should be_nil
+    end
+
+    it "can remove a node from an index without supplying key nor value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_node_from_index("test_node_index", new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should be_nil
+    end
+
+    it "can remove a relationship from an index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should be_nil
+    end
+
+    it "can remove a relationship from an index without supplying value" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", key, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should be_nil
+    end
+
+    it "can remove a relationship from an index without supplying key nor value" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should be_nil
+    end
+  end
+
+  describe "get index" do
+    it "can get a node index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+
+    it "can get a relationship index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.should_not be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship)
+    end
+  end
+
+  describe "query index" do
+    it "can query a node index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      new_index.first["self"].should == new_node["self"]
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+
+    it "can find a node index" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node) 
+      new_index = @neo.find_node_index("test_node_index", key, value) 
+      new_index.first["self"].should == new_node["self"]
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+
+    it "can find a node index using generic query" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_node_to_index("test_node_index", key, value, new_node)
+      new_index = @neo.find_node_index("test_node_index", "#{key}: #{value}")
+      new_index.first["self"].should == new_node["self"]
+      @neo.remove_node_from_index("test_node_index", key, value, new_node)
+    end
+
+    it "can get a relationship index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.first["self"].should == new_relationship["self"]
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship)
+    end
+
+    it "can get a relationship index with empty spaces" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text + " " + generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      new_index.first["self"].should == new_relationship["self"]
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship)
+    end
+
+    it "can find a relationship index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship) 
+      new_index = @neo.find_relationship_index("test_relationship_index", key, value) 
+      new_index.first["self"].should == new_relationship["self"]
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship)
+    end
+
+    it "can find a relationship index using generic query" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
+      key = generate_text(6)
+      value = generate_text
+      @neo.add_relationship_to_index("test_relationship_index", key, value, new_relationship)
+      new_index = @neo.find_relationship_index("test_relationship_index", "#{key}: #{value}")
+      new_index.first["self"].should == new_relationship["self"]
+      @neo.remove_relationship_from_index("test_relationship_index", key, value, new_relationship)
+    end
+
+    it "can find use the results of a node index" do
+      new_node1 = @neo.create_node
+      new_node2 = @neo.create_node
+      key = generate_text(6)
+      value1 = generate_text
+      value2 = generate_text
+      @neo.add_node_to_index("test_node_index", key, value1, new_node1) 
+      @neo.add_node_to_index("test_node_index", key, value2, new_node2) 
+      existing_node1 = @neo.get_node_index("test_node_index", key, value1)
+      existing_node2 = @neo.get_node_index("test_node_index", key, value2)
+      new_relationship = @neo.create_relationship("friends", existing_node1, existing_node2)
+      new_relationship["start"].should_not be_nil
+      new_relationship["start"].should == new_node1["self"]
+      new_relationship["end"].should_not be_nil
+      new_relationship["end"].should == new_node2["self"]
+      @neo.remove_node_from_index("test_node_index", new_node1) 
+      @neo.remove_node_from_index("test_node_index", new_node2) 
+    end
+
+  end
+
+
+end