neography-down 1.6.4

data/spec/integration/rest_batch_streaming_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+  
+  describe "streaming" do
+  
+    it "can send a 1000 item batch" do
+      commands = []
+      1000.times do |x|
+        commands << [:create_node, {"name" => "Max " + x.to_s}]
+      end
+      batch_result = @neo.batch *commands
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max 0")
+      expect(batch_result.last["body"]["data"]["name"]).to eq("Max 999")
+    end
+
+    it "can send a 5000 item batch" do
+      commands = []
+      5000.times do |x|
+        commands << [:get_node, 0]
+      end
+      batch_result = @neo.batch *commands
+      expect(batch_result.first["body"]["self"].split('/').last).to eq("0")
+      expect(batch_result.last["body"]["self"].split('/').last).to eq("0")
+    end
+
+    it "can send a 7000 get item batch" do
+      commands = []
+      7000.times do |x|
+        commands << [:get_node, 0]
+      end
+      batch_result = @neo.batch *commands
+      expect(batch_result.first["body"]["self"].split('/').last).to eq("0")
+      expect(batch_result.last["body"]["self"].split('/').last).to eq("0")
+    end
+
+    it "can send a 5000 create item batch" do
+      commands = []
+      5000.times do |x|
+        commands << [:create_node, {"name" => "Max " + x.to_s}]
+      end
+      batch_result = @neo.batch *commands
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max 0")
+      expect(batch_result.last["body"]["data"]["name"]).to eq("Max 4999")
+    end
+
+  end
+end

data/spec/integration/rest_bulk_spec.rb

@@ -0,0 +1,106 @@
+require '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)
+      expect(new_nodes).not_to be_nil
+      expect(new_nodes.size).to eq(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
+
+      expect(@not_threaded[99]).not_to be_nil
+      expect(@threaded[99]).not_to be_nil
+      expect(@threaded2c[199]).not_to be_nil
+    end
+
+  end
+
+  describe "can create many nodes" do
+    it "can create empty nodes" do
+      new_nodes = @neo.create_nodes(2)
+      expect(new_nodes).not_to be_nil
+      expect(new_nodes.size).to eq(2)
+    end
+
+    it "can create nodes with one property" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"name" => "Alex"}])
+      expect(new_nodes[0]["data"]["name"]).to eq("Max")
+      expect(new_nodes[1]["data"]["name"]).to eq("Alex")
+    end
+
+    it "can create nodes with one property that are different" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"age" => 24}])
+      expect(new_nodes[0]["data"]["name"]).to eq("Max")
+      expect(new_nodes[1]["data"]["age"]).to eq(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"}])
+      expect(new_nodes[0]["data"]["name"]).to eq("Max")
+      expect(new_nodes[0]["data"]["age"]).to eq(31)
+      expect(new_nodes[1]["data"]["name"]).to eq("Alex")
+      expect(new_nodes[1]["data"]["age"]).to eq(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}])
+      expect(new_nodes[0]["data"]["name"]).to eq("Max")
+      expect(new_nodes[0]["data"]["age"]).to eq(31)
+      expect(new_nodes[1]["data"]["height"]).to eq("5-11")
+      expect(new_nodes[1]["data"]["weight"]).to eq(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)
+      expect(existing_nodes).not_to be_nil
+      expect(existing_nodes.size).to eq(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)
+      expect(existing_nodes).not_to be_nil
+      expect(existing_nodes.size).to eq(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_constraints_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "create unique constraint" do
+    it "can create a unique constraint" do
+      label = "User"
+      property = "user_id"
+      uc = @neo.create_unique_constraint(label, property)
+      expect(uc).not_to be_nil
+      expect(uc["label"]).to eq(label)
+      expect(uc["property_keys"]).to eq([property])
+    end
+  end
+
+  describe "get a unique constraint" do
+    it "can get a unique constraint" do
+      label = "User"
+      property = "user_id"
+      uc = @neo.get_unique_constraint(label, property)
+      expect(uc).not_to be_nil
+      expect(uc.first["label"]).to eq(label)
+      expect(uc.first["property_keys"]).to eq([property])
+    end
+  end
+
+  describe "get unique constraints" do
+    it "can get unique constraints for a label" do
+      label = "User"
+      property = "user_id"
+      uc = @neo.get_uniqueness(label)
+      expect(uc).not_to be_nil
+      expect(uc.first["label"]).to eq(label)
+      expect(uc.first["property_keys"]).to eq([property])
+    end
+  end
+  
+  describe "list constraints" do
+    it "can get a list of constraints" do
+      label = "User"
+      property = "user_id"
+      cs = @neo.get_constraints
+      expect(cs).not_to be_nil
+      expect(cs.first["label"]).to eq(label)
+      expect(cs.first["property_keys"]).to eq([property])
+    end
+
+    it "can get a list of constraints for a specifc label" do
+      label = "User"
+      property = "user_id"
+      cs = @neo.get_constraints(label)
+      expect(cs).not_to be_nil
+      expect(cs.first["label"]).to eq(label)
+      expect(cs.first["property_keys"]).to eq([property])
+    end
+  end
+  
+  describe "drop a constraint" do
+    it "can drop a constraint" do
+      label = "User"
+      property = "user_id"
+      uc = @neo.drop_constraint(label, property)
+      expect(uc).to be_nil
+      cs = @neo.get_constraints(label)
+      expect(cs).to be_empty
+    end
+  end
+    
+end

data/spec/integration/rest_experimental_spec.rb

@@ -0,0 +1,22 @@
+require '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
+      expect(existing_nodes).not_to 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)
+      expect(existing_nodes).not_to be_nil
+    end
+  end
+end

data/spec/integration/rest_gremlin_fail_spec.rb

@@ -0,0 +1,46 @@
+require '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", :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_index", key, value, new_node1)
+      @neo.add_relationship_to_index("test_index2", key, value, new_relationship) 
+    end
+
+    it "gremlin works", :gremlin => true  do
+      root_node = @neo.execute_script("g.v(0)")
+      expect(root_node).to have_key("self")
+      expect(root_node["self"].split('/').last).to eq("0")
+    end
+  end
+
+
+  describe "break gremlin" do
+    it "can can't handle node and relationship indexes with the same name", :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", :gremlin => true  do
+      root_node = @neo.execute_script("g.v(0)")
+      expect(root_node).to have_key("self")
+      expect(root_node["self"].split('/').last).to eq("0")
+    end
+  end
+
+
+end

data/spec/integration/rest_header_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Neography::Connection do
+
+  it "should not add a content-type header if there's no existing headers" do
+    expect(subject.merge_options({}).keys).to eq([])
+  end
+
+  it "should add a content type if there's existing headers" do
+    expect(subject.merge_options({:headers => {'Content-Type' => 'foo/bar'}})[:headers]).to eq(
+      {'Content-Type' => "foo/bar",  "User-Agent"   => "Neography/#{Neography::VERSION}" , "X-Stream"=>true, "max-execution-time"=>6000}
+    )
+  end
+
+end

data/spec/integration/rest_index_spec.rb

@@ -0,0 +1,481 @@
+require '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) 
+      expect(@neo.list_indexes).not_to 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) 
+      expect(@neo.list_relationship_indexes).not_to 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)
+      expect(new_index).not_to be_nil
+      expect(new_index["template"]).to eq("#{@neo.configuration}/db/data/index/node/#{name}/{key}/{value}")
+      expect(new_index["provider"]).to eq("lucene")
+      expect(new_index["type"]).to eq("exact")
+    end
+
+    it "can create a node index with options" do
+      name = generate_text(6)
+      new_index = @neo.create_node_index(name, "fulltext","lucene")
+      expect(new_index).not_to be_nil
+      expect(new_index["template"]).to eq("#{@neo.configuration}/db/data/index/node/#{name}/{key}/{value}")
+      expect(new_index["provider"]).to eq("lucene")
+      expect(new_index["type"]).to eq("fulltext")
+    end
+
+    it "can create a node index with extra configuration options" do
+      name = generate_text(6)
+      new_index = @neo.create_node_index(name, "fulltext","lucene", extra: 'extra-value')
+      expect(new_index).not_to be_nil
+      expect(new_index["template"]).to eq("#{@neo.configuration}/db/data/index/node/#{name}/{key}/{value}")
+      expect(new_index["provider"]).to eq("lucene")
+      expect(new_index["extra"]).to eq("extra-value")
+      expect(new_index["type"]).to eq("fulltext")
+    end
+
+    it "can create a relationship index" do
+      name = generate_text(6)
+      new_index = @neo.create_relationship_index(name)
+      expect(new_index).not_to be_nil
+      expect(new_index["template"]).to eq("#{@neo.configuration}/db/data/index/relationship/#{name}/{key}/{value}")
+      expect(new_index["provider"]).to eq("lucene")
+      expect(new_index["type"]).to eq("exact")
+    end
+
+    it "can create a relationship index with options" do
+      name = generate_text(6)
+      new_index = @neo.create_relationship_index(name, "fulltext","lucene")
+      expect(new_index).not_to be_nil
+      expect(new_index["template"]).to eq("#{@neo.configuration}/db/data/index/relationship/#{name}/{key}/{value}")
+      expect(new_index["provider"]).to eq("lucene")
+      expect(new_index["type"]).to eq("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) 
+      expect(new_index).not_to 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) 
+      expect(new_index).not_to 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) 
+      expect(new_index).not_to 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) 
+      expect(new_index).to 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) 
+      expect(new_index).not_to be_nil
+      @neo.remove_node_from_index("test_node_index", key, new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      expect(new_index).to 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) 
+      expect(new_index).not_to be_nil
+      @neo.remove_node_from_index("test_node_index", new_node) 
+      new_index = @neo.get_node_index("test_node_index", key, value) 
+      expect(new_index).to 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) 
+      expect(new_index).not_to 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) 
+      expect(new_index).to 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) 
+      expect(new_index).not_to be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", key, new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      expect(new_index).to 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) 
+      expect(new_index).not_to be_nil
+      @neo.remove_relationship_from_index("test_relationship_index", new_relationship) 
+      new_index = @neo.get_relationship_index("test_relationship_index", key, value) 
+      expect(new_index).to be_nil
+    end
+
+    it "throws an error when there is an empty string in the value when removing a node" 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) 
+      expect(new_index).not_to be_nil
+      expect { @neo.remove_node_from_index("test_node_index", key, "", new_node) }.to raise_error Neography::NeographyError
+    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) 
+      expect(new_index).not_to be_nil
+      @neo.remove_node_from_index("test_node_index", key, value, new_node) 
+    end
+
+    it "can get a node index with a space in the value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text + " " + 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)
+      expect(new_index).not_to be_nil
+      @neo.remove_node_from_index("test_node_index", key, value, new_node)
+    end
+
+    it "can get a node index with a slash in the value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text + "/" + 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)
+      expect(new_index).not_to 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) 
+      expect(new_index).not_to 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) 
+      expect(new_index.first["self"]).to eq(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) 
+      expect(new_index.first["self"]).to eq(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}")
+      expect(new_index.first["self"]).to eq(new_node["self"])
+      @neo.remove_node_from_index("test_node_index", key, value, new_node)
+    end
+
+    it "can find a node index with spaces in the value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text + ' ' + 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)
+      expect(new_index).not_to be_nil
+      expect(new_index.first["self"]).to eq(new_node["self"])
+      @neo.remove_node_from_index("test_node_index", key, value, new_node)
+    end
+
+    it "can find a node index with slashes in the value" do
+      new_node = @neo.create_node
+      key = generate_text(6)
+      value = generate_text + '/' + 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)
+      expect(new_index).not_to be_nil
+      expect(new_index.first["self"]).to eq(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) 
+      expect(new_index.first["self"]).to eq(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) 
+      expect(new_index.first["self"]).to eq(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) 
+      expect(new_index.first["self"]).to eq(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}")
+      expect(new_index.first["self"]).to eq(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)
+      expect(new_relationship["start"]).not_to be_nil
+      expect(new_relationship["start"]).to eq(new_node1["self"])
+      expect(new_relationship["end"]).not_to be_nil
+      expect(new_relationship["end"]).to eq(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
+
+  describe "auto indexes" do
+
+    it "can check the status of node auto index" do
+      expect(@neo.get_node_auto_index_status).to satisfy{|status| [true, false].include?(status)}
+    end
+  
+    it "can check the status of relationship auto index" do
+      expect(@neo.get_relationship_auto_index_status).to satisfy{|status| [true, false].include?(status)}
+    end
+
+    it "can change the node auto index status" do
+      @neo.set_node_auto_index_status(true)
+      expect(@neo.get_node_auto_index_status).to be true
+    end
+
+    it "can change the relationship auto index status" do
+      @neo.set_relationship_auto_index_status(true)
+      expect(@neo.get_relationship_auto_index_status).to be true
+    end
+
+    it "can get a list of auto indexed node properties" do
+      @neo.set_node_auto_index_status(true)
+      @neo.create_node_auto_index
+      @neo.add_node_auto_index_property("name")
+      expect(@neo.get_node_auto_index_properties).to eq(["name"])
+    end
+
+    it "can get a list of auto indexed relationship properties" do
+      @neo.set_relationship_auto_index_status(true)
+      @neo.create_relationship_auto_index
+      @neo.add_relationship_auto_index_property("weight")
+      expect(@neo.get_relationship_auto_index_properties).to eq(["weight"])
+    end
+
+   it "can remove a property from the auto indexed node properties" do
+      @neo.add_node_auto_index_property("name")
+      @neo.add_node_auto_index_property("label")
+      expect(@neo.get_node_auto_index_properties).to eq(["name", "label"])
+      @neo.remove_node_auto_index_property("label")   
+      expect(@neo.get_node_auto_index_properties).to eq(["name"])
+   end
+
+   it "can remove a property from the auto indexed relationship properties" do
+      @neo.add_relationship_auto_index_property("weight")
+      @neo.add_relationship_auto_index_property("strength")
+      expect(@neo.get_relationship_auto_index_properties).to match_array(["weight", "strength"])
+      @neo.remove_relationship_auto_index_property("strength")   
+      expect(@neo.get_relationship_auto_index_properties).to eq(["weight"])
+   end
+
+    it "can get a node from an automatic index" do
+      new_node = @neo.create_node("name" => "Max")
+      existing_nodes = @neo.get_node_auto_index("name", "Max")
+      expect(existing_nodes.collect{|n| n["self"]}.include?(new_node["self"])).to be true 
+    end
+
+    it "can query a node from an automatic index using key value" do
+      new_node = @neo.create_node("name" => "Max")
+      existing_nodes = @neo.find_node_auto_index("name", "Max")
+      expect(existing_nodes.collect{|n| n["self"]}.include?(new_node["self"])).to be true 
+    end
+
+    it "can query a node from an automatic index" do
+      new_node = @neo.create_node("name" => "Max")
+      existing_nodes = @neo.find_node_auto_index("name:Max")
+      expect(existing_nodes.collect{|n| n["self"]}.include?(new_node["self"])).to be true
+      # check that more complex queries are correctly handled
+      existing_nodes = @neo.find_node_auto_index("name:Max OR name:Max")
+      expect(existing_nodes.collect{|n| n["self"]}.include?(new_node["self"])).to be true
+    end
+
+    it "can get a relationship from an automatic index" do
+      new_node1 = @neo.create_node("name" => "Max")
+      new_node2 = @neo.create_node("name" => "Peter")
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"weight" => 5})
+      existing_rels = @neo.get_relationship_auto_index("weight", 5)
+      expect(existing_rels.collect{|n| n["self"]}.include?(new_relationship["self"])).to be true 
+    end
+
+    it "can query a relationship from an automatic index using key value" do
+      new_node1 = @neo.create_node("name" => "Max")
+      new_node2 = @neo.create_node("name" => "Peter")
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"weight" => 5})
+      existing_rels = @neo.find_relationship_auto_index("weight", 5)
+      expect(existing_rels.collect{|n| n["self"]}.include?(new_relationship["self"])).to be true 
+    end
+
+    it "can query a relationship from an automatic index" do
+      new_node1 = @neo.create_node("name" => "Max")
+      new_node2 = @neo.create_node("name" => "Peter")
+      new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"weight" => 5})
+      existing_rels = @neo.find_relationship_auto_index("weight:5")
+      expect(existing_rels.collect{|n| n["self"]}.include?(new_relationship["self"])).to be true 
+    end
+
+  end
+
+  describe "drop index" do
+    it "can drop 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) 
+      expect(new_index).not_to be_nil
+      @neo.drop_node_index("test_node_index")
+      expect { @neo.get_node_index("test_node_index", key, value) }.to raise_error Neography::NotFoundException
+    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) 
+      expect(new_index).not_to be_nil
+      @neo.drop_relationship_index("test_relationship_index") 
+      expect { @neo.get_relationship_index("test_relationship_index", key, value) }.to raise_error Neography::NotFoundException
+    end
+  end
+
+end