neography 1.5.0 → 1.5.1

data/spec/integration/node_spec.rb

@@ -5,25 +5,25 @@ describe Neography::Node do
   describe "create and new" do
     it "can create an empty node" do
       new_node = Neography::Node.create
-      new_node.should_not be_nil
+      expect(new_node).not_to be_nil
     end
 
     it "can create a node with one property" do
       new_node = Neography::Node.create("name" => "Max")
-      new_node.name.should == "Max"
+      expect(new_node.name).to eq("Max")
     end
 
     it "can create a node with more than one property" do
       new_node = Neography::Node.create("age" => 31, "name" => "Max")
-      new_node.name.should == "Max"
-      new_node.age.should == 31
+      expect(new_node.name).to eq("Max")
+      expect(new_node.age).to eq(31)
     end
 
     it "can create a node with more than one property not on the default rest server" do
       @neo = Neography::Rest.new
       new_node = Neography::Node.create({"age" => 31, "name" => "Max"}, @neo)
-      new_node.name.should == "Max"
-      new_node.age.should == 31
+      expect(new_node.name).to eq("Max")
+      expect(new_node.age).to eq(31)
     end
 
     it "cannot create a node with more than one property not on the default rest server the other way" do
@@ -39,9 +39,9 @@ describe Neography::Node do
     it "can get a node that exists" do
       new_node = Neography::Node.create
       existing_node = Neography::Node.load(new_node)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
     end
 
     it "raises an error if it tries to load a node that does not exist" do
@@ -56,9 +56,9 @@ describe Neography::Node do
       @neo = Neography::Rest.new
       new_node = Neography::Node.create({}, @neo)
       existing_node = Neography::Node.load(new_node, @neo)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
     end
 
     it "cannot load a node that exists not on the default rest server the other way" do
@@ -77,9 +77,9 @@ describe Neography::Node do
       @neo.add_node_to_index("test_node_index", key, value, new_node) 
       node_from_index = @neo.get_node_index("test_node_index", key, value) 
       existing_node = Neography::Node.load(node_from_index)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
     end
 
     it "can get a node that exists via cypher" do
@@ -88,9 +88,9 @@ describe Neography::Node do
       @neo = Neography::Rest.new
       results = @neo.execute_query(cypher, {:id => new_node.neo_id.to_i})
       existing_node = Neography::Node.load(results)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
     end
 
 
@@ -110,13 +110,13 @@ describe Neography::Node do
   describe "exists?" do
     it "can tell if it exists" do
       new_node = Neography::Node.create
-      new_node.exist?.should be_true
+      expect(new_node.exist?).to be true
     end
 
     it "can tell if does not exists" do
       new_node = Neography::Node.create
       new_node.del
-      new_node.exist?.should be_false
+      expect(new_node.exist?).to be false
     end
   end
 
@@ -124,19 +124,19 @@ describe Neography::Node do
     it "can tell two nodes are the same with equal?" do
       new_node = Neography::Node.create
       another_node = Neography::Node.load(new_node)
-      new_node.equal?(another_node).should be_true 
+      expect(new_node.equal?(another_node)).to be true 
     end
 
     it "can tell two nodes are the same with eql?" do
       new_node = Neography::Node.create
       another_node = Neography::Node.load(new_node)
-      new_node.eql?(another_node).should be_true 
+      expect(new_node.eql?(another_node)).to be true 
     end
 
     it "can tell two nodes are the same with ==" do
       new_node = Neography::Node.create
       another_node = Neography::Node.load(new_node)
-      (new_node == another_node).should be_true 
+      expect(new_node == another_node).to be true 
     end
   end
 
@@ -148,8 +148,8 @@ describe Neography::Node do
       new_node[:eyes] = "brown"
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.weight.should == 200
-      existing_node.eyes.should == "brown"
+      expect(existing_node.weight).to eq(200)
+      expect(existing_node.eyes).to eq("brown")
     end
 
     it "can change a node's properties that already exist" do
@@ -159,8 +159,8 @@ describe Neography::Node do
       new_node.eyes = "brown"
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.weight.should == 200
-      existing_node.eyes.should == "brown"
+      expect(existing_node.weight).to eq(200)
+      expect(existing_node.eyes).to eq("brown")
     end
 
     it "can change a node's properties that does not already exist using []=" do
@@ -171,9 +171,9 @@ describe Neography::Node do
       new_node[:hair] = "black"
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.weight.should == 200
-      existing_node.eyes.should == "brown"
-      existing_node.hair.should == "black"
+      expect(existing_node.weight).to eq(200)
+      expect(existing_node.eyes).to eq("brown")
+      expect(existing_node.hair).to eq("black")
     end
 
     it "can change a node's properties that does not already exist" do
@@ -182,23 +182,23 @@ describe Neography::Node do
       new_node.hair = "black"
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.hair.should == "black"
+      expect(existing_node.hair).to eq("black")
     end
 
     it "can pass issue 18" do
       n = Neography::Node.create("name" => "Test")
       n.prop = 1
-      n.prop.should == 1           
+      expect(n.prop).to eq(1)           
       n.prop = 1                   
-      n.prop.should == 1           
-      n[:prop].should == 1         
+      expect(n.prop).to eq(1)           
+      expect(n[:prop]).to eq(1)         
       n[:prop2] = 2                  
-      n[:prop2].should == 2          
+      expect(n[:prop2]).to eq(2)          
       n[:prop2] = 2                  
-      n[:prop2].should == 2          
+      expect(n[:prop2]).to eq(2)          
       n.name                         
       n.name = "New Name"            
-      n.name.should == "New Name"
+      expect(n.name).to eq("New Name")
     end
 
   end
@@ -206,14 +206,14 @@ describe Neography::Node do
   describe "get node properties" do
     it "can get node properties using []" do
       new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
-      new_node[:weight].should == 150
-      new_node[:eyes].should == "green"
+      expect(new_node[:weight]).to eq(150)
+      expect(new_node[:eyes]).to eq("green")
     end
 
     it "can get node properties" do
       new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
-      new_node.weight.should == 150
-      new_node.eyes.should == "green"
+      expect(new_node.weight).to eq(150)
+      expect(new_node.eyes).to eq("green")
     end
   end
 
@@ -224,12 +224,12 @@ describe Neography::Node do
       new_node[:weight] = nil
       new_node[:eyes] = nil
 
-      new_node[:weight].should be_nil
-      new_node[:eyes].should be_nil
+      expect(new_node[:weight]).to be_nil
+      expect(new_node[:eyes]).to be_nil
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.weight.should be_nil
-      existing_node.eyes.should be_nil
+      expect(existing_node.weight).to be_nil
+      expect(existing_node.eyes).to be_nil
     end
 
     it "can delete node properties" do
@@ -238,12 +238,12 @@ describe Neography::Node do
       new_node.weight = nil
       new_node.eyes = nil
 
-      new_node.weight.should be_nil
-      new_node.eyes.should be_nil
+      expect(new_node.weight).to be_nil
+      expect(new_node.eyes).to be_nil
 
       existing_node = Neography::Node.load(new_node)
-      existing_node.weight.should be_nil
-      existing_node.eyes.should be_nil
+      expect(existing_node.weight).to be_nil
+      expect(existing_node.eyes).to be_nil
     end
   end
 
@@ -255,6 +255,6 @@ describe Neography::Node do
       node
     }
 
-    it { subject.labels.should == %w(Label Label2) }
+    it { expect(subject.labels).to eq(%w(Label Label2)) }
   end
 end

data/spec/integration/parsing_spec.rb

@@ -6,8 +6,8 @@ describe Neography do
     it 'should not convert strings to symbol' do
       node = subject.create_node({:text => ':1456'})
 
-      node['data']['text'].class.should == String # fails! expected: String got: Symbol (using ==)
-      node['data']['text'].should == ':1456'
+      expect(node['data']['text'].class).to eq(String) # fails! expected: String got: Symbol (using ==)
+      expect(node['data']['text']).to eq(':1456')
     end
   end
 end

data/spec/integration/relationship_spec.rb

@@ -7,8 +7,8 @@ describe Neography::Relationship do
       p2 = Neography::Node.create
 
       Neography::Relationship.create(:family, p1, p2)
-      p1.outgoing(:family).should include(p2)
-      p2.incoming(:family).should include(p1)
+      expect(p1.outgoing(:family)).to include(p2)
+      expect(p2.incoming(:family)).to include(p1)
     end
 
     it "#new(:family, p1, p2, :since => '1998', :colour => 'blue') creates relationship and sets its properties" do
@@ -16,10 +16,10 @@ describe Neography::Relationship do
       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'
+      expect(rel[:since]).to eq(1998)
+      expect(rel[:colour]).to eq('blue')
+      expect(rel.since).to eq(1998)
+      expect(rel.colour).to eq('blue')
     end
 
     it "#outgoing(:friends).create(other) creates a new relationship between self and other node" do
@@ -27,10 +27,10 @@ describe Neography::Relationship do
       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)
+      expect(rel).to be_kind_of(Neography::Relationship)
+      expect(p1.outgoing(:foo).first).to eq(p2)
+      expect(p1.outgoing(:foo)).to include(p2)
+      expect(p2.incoming(:foo)).to include(p1)
     end
   end
 

data/spec/integration/rest_batch_no_streaming_spec.rb

@@ -13,8 +13,8 @@ describe Neography::Rest do
         commands << [:create_node, {"name" => "Max " + x.to_s}]
       end
       batch_result = @neo.batch_no_streaming *commands
-      batch_result.first["body"]["data"]["name"].should == "Max 0"
-      batch_result.last["body"]["data"]["name"].should == "Max 999"
+      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
@@ -23,8 +23,8 @@ describe Neography::Rest do
         commands << [:get_node, 0]
       end
       batch_result = @neo.batch_no_streaming *commands
-      batch_result.first["body"]["self"].split('/').last.should == "0"
-      batch_result.last["body"]["self"].split('/').last.should == "0"
+      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 20000 item batch" do
@@ -33,8 +33,8 @@ describe Neography::Rest do
         commands << [:create_node, {"name" => "Max " + x.to_s}]
       end
       batch_result = @neo.batch_no_streaming *commands
-      batch_result.first["body"]["data"]["name"].should == "Max 0"
-      batch_result.last["body"]["data"]["name"].should == "Max 19999"
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max 0")
+      expect(batch_result.last["body"]["data"]["name"]).to eq("Max 19999")
     end
   end
 

data/spec/integration/rest_batch_spec.rb

@@ -10,11 +10,11 @@ describe Neography::Rest 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]
+      expect(batch_result.first).not_to be_nil
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("body")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["self"].split('/').last).to eq(new_node[:id])
     end
 
     it "can get multiple nodes" do
@@ -24,33 +24,33 @@ describe Neography::Rest do
       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]
+      expect(batch_result.first).not_to be_nil
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("body")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["self"].split('/').last).to eq(node1[:id])
+      expect(batch_result.last).to have_key("id")
+      expect(batch_result.last).to have_key("body")
+      expect(batch_result.last).to have_key("from")
+      expect(batch_result.last["body"]["self"].split('/').last).to eq(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"
+      expect(batch_result.first["body"]["data"]["name"]).to eq("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"
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result.last["body"]["data"]["name"]).to eq("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"
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result.last["body"]["data"]["name"]).to eq("Marc")
     end
 
     it "can create a unique node" do
@@ -59,94 +59,108 @@ describe Neography::Rest do
       value = generate_text
       @neo.create_node_index(index_name)
       batch_result = @neo.batch [:create_unique_node, index_name, key, value, {"age" => 31, "name" => "Max"}]
-      batch_result.first["body"]["data"]["name"].should == "Max"
-      batch_result.first["body"]["data"]["age"].should == 31
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result.first["body"]["data"]["age"]).to eq(31)
       new_node_id = batch_result.first["body"]["self"].split('/').last
       batch_result = @neo.batch [:create_unique_node, index_name, key, value, {"age" => 31, "name" => "Max"}]
-      batch_result.first["body"]["self"].split('/').last.should == new_node_id
-      batch_result.first["body"]["data"]["name"].should == "Max"
-      batch_result.first["body"]["data"]["age"].should == 31
+      expect(batch_result.first["body"]["self"].split('/').last).to eq(new_node_id)
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result.first["body"]["data"]["age"]).to eq(31)
 
       #Sanity Check
       existing_node = @neo.create_unique_node(index_name, key, value, {"age" => 31, "name" => "Max"})
-      existing_node["self"].split('/').last.should == new_node_id
-      existing_node["data"]["name"].should == "Max"
-      existing_node["data"]["age"].should == 31
+      expect(existing_node["self"].split('/').last).to eq(new_node_id)
+      expect(existing_node["data"]["name"]).to eq("Max")
+      expect(existing_node["data"]["age"]).to eq(31)
     end
 
+    it "can create or fail a unique node" do
+      index_name = generate_text(6)
+      key = generate_text(6)
+      value = generate_text
+      @neo.create_node_index(index_name)
+      batch_result = @neo.batch [:create_or_fail_unique_node, index_name, key, value, {"age" => 31, "name" => "Max"}]
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result.first["body"]["data"]["age"]).to eq(31)
+      new_node_id = batch_result.first["body"]["self"].split('/').last
+      expect {
+        batch_result = @neo.batch [:create_or_fail_unique_node, index_name, key, value, {"age" => 31, "name" => "Max"}]
+      }.to raise_error Neography::OperationFailureException
+
+    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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_node = @neo.get_node(new_node)
-      existing_node["data"]["name"].should == "Marc"
+      expect(existing_node["data"]["name"]).to eq("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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.last).to have_key("id")
+      expect(batch_result.last).to have_key("from")
       existing_node = @neo.get_node(node1)
-      existing_node["data"]["name"].should == "Tom"
+      expect(existing_node["data"]["name"]).to eq("Tom")
       existing_node = @neo.get_node(node2)
-      existing_node["data"]["name"].should == "Jerry"
+      expect(existing_node["data"]["name"]).to eq("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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_node = @neo.get_node(new_node)
-      existing_node["data"]["name"].should == "Marc"
-      existing_node["data"]["weight"].should be_nil
+      expect(existing_node["data"]["name"]).to eq("Marc")
+      expect(existing_node["data"]["weight"]).to 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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.last).to have_key("id")
+      expect(batch_result.last).to have_key("from")
       existing_node = @neo.get_node(node1)
-      existing_node["data"]["name"].should == "Tom"
-      existing_node["data"]["weight"].should be_nil
+      expect(existing_node["data"]["name"]).to eq("Tom")
+      expect(existing_node["data"]["weight"]).to be_nil
       existing_node = @neo.get_node(node2)
-      existing_node["data"]["name"].should == "Jerry"
-      existing_node["data"]["weight"].should be_nil
+      expect(existing_node["data"]["name"]).to eq("Jerry")
+      expect(existing_node["data"]["weight"]).to be_nil
     end
 
     it "can remove a property of a node" do
       new_node = @neo.create_node("name" => "Max", "weight" => 200)
       batch_result = @neo.batch [:remove_node_property, new_node, "weight"]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_node = @neo.get_node(new_node)
-      existing_node["data"]["name"].should == "Max"
-      existing_node["data"]["weight"].should be_nil
+      expect(existing_node["data"]["name"]).to eq("Max")
+      expect(existing_node["data"]["weight"]).to be_nil
     end
 
     it "can remove a property of multiple nodes" do
       node1 = @neo.create_node("name" => "Max", "weight" => 200)
       node2 = @neo.create_node("name" => "Marc", "weight" => 180)
       batch_result = @neo.batch [:remove_node_property, node1, "name"], [:remove_node_property, node2, "name"]
-      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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.last).to have_key("id")
+      expect(batch_result.last).to have_key("from")
       existing_node = @neo.get_node(node1)
-      existing_node["data"]["name"].should be_nil
-      existing_node["data"]["weight"].should == 200
+      expect(existing_node["data"]["name"]).to be_nil
+      expect(existing_node["data"]["weight"]).to eq(200)
       existing_node = @neo.get_node(node2)
-      existing_node["data"]["name"].should be_nil
-      existing_node["data"]["weight"].should == 180
+      expect(existing_node["data"]["name"]).to be_nil
+      expect(existing_node["data"]["weight"]).to eq(180)
     end
 
     it "can get a single relationship" do
@@ -154,42 +168,42 @@ describe Neography::Rest do
       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"]
+      expect(batch_result.first["body"]["type"]).to eq("friends")
+      expect(batch_result.first["body"]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"]["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(batch_result.first["body"]["self"]).to eq(new_relationship["self"])
     end
 
     it "can create a single relationship without properties" do
       node1 = @neo.create_node
       node2 = @neo.create_node
       batch_result = @neo.batch [:create_relationship, "friends", node1, node2]
-      batch_result.first["body"]["type"].should == "friends"
-      batch_result.first["body"]["data"]["since"].should be_nil
-      batch_result.first["body"]["start"].split('/').last.should == node1["self"].split('/').last
-      batch_result.first["body"]["end"].split('/').last.should == node2["self"].split('/').last
+      expect(batch_result.first["body"]["type"]).to eq("friends")
+      expect(batch_result.first["body"]["data"]["since"]).to be_nil
+      expect(batch_result.first["body"]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"]["end"].split('/').last).to eq(node2["self"].split('/').last)
     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
+      expect(batch_result.first["body"]["type"]).to eq("friends")
+      expect(batch_result.first["body"]["data"]["since"]).to eq("high school")
+      expect(batch_result.first["body"]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"]["end"].split('/').last).to eq(node2["self"].split('/').last)
     end
 
     it "can delete a single relationship" do
       node1 = @neo.create_node
       node2 = @neo.create_node
       batch_result = @neo.batch [:create_relationship, "friends", node1, node2, {:since => "time immemorial"}]
-      batch_result.should_not be_nil
-      batch_result[0]["status"].should == 201
+      expect(batch_result).not_to be_nil
+      expect(batch_result[0]["status"]).to eq(201)
       id = batch_result.first["body"]["self"].split("/").last
       batch_result = @neo.batch [:delete_relationship, id]
-      batch_result[0]["status"].should == 204
-      batch_result[0]["from"].should == "/relationship/#{id}"
+      expect(batch_result[0]["status"]).to eq(204)
+      expect(batch_result[0]["from"]).to eq("/relationship/#{id}")
     end
 
     it "can create a unique relationship" do
@@ -200,9 +214,9 @@ describe Neography::Rest do
       node1 = @neo.create_node
       node2 = @neo.create_node
       batch_result = @neo.batch [:create_unique_relationship, index_name, key, value, "friends", node1, node2]
-      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
+      expect(batch_result.first["body"]["type"]).to eq("friends")
+      expect(batch_result.first["body"]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"]["end"].split('/').last).to eq(node2["self"].split('/').last)
     end
 
     it "can update a single relationship" do
@@ -210,14 +224,14 @@ describe Neography::Rest do
       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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to 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"]
+      expect(existing_relationship["type"]).to eq("friends")
+      expect(existing_relationship["data"]["since"]).to eq("college")
+      expect(existing_relationship["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(existing_relationship["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(existing_relationship["self"]).to eq(new_relationship["self"])
     end
 
     it "can reset the properties of a relationship" do
@@ -225,22 +239,22 @@ describe Neography::Rest do
       node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", node1, node2, {:since => "high school"})
       batch_result = @neo.batch [:reset_relationship_properties, new_relationship, {"since" => "college", "dated" => "yes"}]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_relationship = @neo.get_relationship(batch_result.first["from"].split('/')[2])
-      existing_relationship["type"].should == "friends"
-      existing_relationship["data"]["since"].should == "college"
-      existing_relationship["data"]["dated"].should == "yes"
-      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"]
+      expect(existing_relationship["type"]).to eq("friends")
+      expect(existing_relationship["data"]["since"]).to eq("college")
+      expect(existing_relationship["data"]["dated"]).to eq("yes")
+      expect(existing_relationship["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(existing_relationship["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(existing_relationship["self"]).to eq(new_relationship["self"])
     end
 
     it "can drop a node index" do
       index_name = generate_text(6)
       @neo.create_node_index(index_name)
       @neo.batch [:drop_node_index, index_name]
-      @neo.list_node_indexes[index_name].should be_nil
+      expect(@neo.list_node_indexes[index_name]).to be_nil
     end
 
     it "can create a node index" do
@@ -248,9 +262,9 @@ describe Neography::Rest do
       @neo.batch [:create_node_index, index_name, "fulltext", "lucene"]
       indexes = @neo.list_node_indexes
       index = indexes[index_name]
-      index.should_not be_nil
-      index["provider"].should == "lucene"
-      index["type"].should == "fulltext"
+      expect(index).not_to be_nil
+      expect(index["provider"]).to eq("lucene")
+      expect(index["type"]).to eq("fulltext")
     end
 
     it "can add a node to an index" do
@@ -259,11 +273,11 @@ describe Neography::Rest do
       key = generate_text(6)
       value = generate_text
       batch_result = @neo.batch [:add_node_to_index, index_name, key, value, new_node]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_index = @neo.find_node_index(index_name, key, value)
-      existing_index.should_not be_nil
-      existing_index.first["self"].should == new_node["self"]
+      expect(existing_index).not_to be_nil
+      expect(existing_index.first["self"]).to eq(new_node["self"])
       @neo.remove_node_from_index(index_name, key, value, new_node)
     end
 
@@ -275,9 +289,9 @@ describe Neography::Rest do
       new_node = @neo.create_node
       @neo.add_node_to_index(index_name, key, value, new_node)
       batch_result = @neo.batch [:get_node_index, index_name, key, value]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"].first["self"].should == new_node["self"]
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"].first["self"]).to eq(new_node["self"])
       @neo.remove_node_from_index(index_name, key, value, new_node)
     end
 
@@ -291,43 +305,50 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", node1, node2, {:since => "high school"})
       @neo.add_relationship_to_index(index_name, key, value, new_relationship)
       batch_result = @neo.batch [:get_relationship_index, index_name, key, value]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"].first["type"].should == "friends"
-      batch_result.first["body"].first["start"].split('/').last.should == node1["self"].split('/').last
-      batch_result.first["body"].first["end"].split('/').last.should == node2["self"].split('/').last
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"].first["type"]).to eq("friends")
+      expect(batch_result.first["body"].first["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"].first["end"].split('/').last).to eq(node2["self"].split('/').last)
     end
 
     it "can batch gremlin", :gremlin => true  do
       batch_result = @neo.batch [:execute_script, "g.v(0)"]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"]["self"].split('/').last.should == "0"
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["self"].split('/').last).to eq("0")
     end
 
     it "can batch gremlin with parameters", :gremlin => true  do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       batch_result = @neo.batch [:execute_script, "g.v(id)", {:id => id.to_i}]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"]["self"].split('/').last.should == id
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["self"].split('/').last).to eq(id)
     end
 
     it "can batch cypher" do
       batch_result = @neo.batch [:execute_query, "start n=node(0) return n"]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"]["data"][0][0]["self"].split('/').last.should == "0"
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["data"][0][0]["self"].split('/').last).to eq("0")
     end
 
     it "can batch cypher with parameters" do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       batch_result = @neo.batch [:execute_query, "start n=node({id}) return n", {:id => id.to_i}]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
-      batch_result.first["body"]["data"][0][0]["self"].split('/').last.should == id
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
+      expect(batch_result.first["body"]["data"][0][0]["self"].split('/').last).to eq(id)
+    end
+
+    it "raises ParameterNotFoundException when a cypher parameter is missing and ORDER BY is used" do
+      q = "MATCH n WHERE n.x>{missing_parameter} RETURN n ORDER BY n"
+      expect{
+        @neo.batch [:execute_query, q, {}]
+      }.to raise_error Neography::ParameterNotFoundException
     end
 
   	it "can delete a node in batch" do
@@ -337,10 +358,10 @@ describe Neography::Rest do
   		id2 = node2['self'].split('/').last
   		batch_result = @neo.batch [:delete_node, id1 ], [:delete_node, id2]
       expect {
-        @neo.get_node(node1).should be_nil
+        expect(@neo.get_node(node1)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
       expect {
-        @neo.get_node(node2).should be_nil
+        expect(@neo.get_node(node2)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
   	end
 
@@ -359,9 +380,9 @@ describe Neography::Rest do
   		                          [:remove_node_from_index, index, key, node2 ],
   		                          [:remove_node_from_index, index, node3 ]
 
-  		@neo.get_node_index(index, key, value1).should be_nil
-  		@neo.get_node_index(index, key, value2).should be_nil
-  		@neo.get_node_index(index, key, value3).should be_nil
+  		expect(@neo.get_node_index(index, key, value1)).to be_nil
+  		expect(@neo.get_node_index(index, key, value2)).to be_nil
+  		expect(@neo.get_node_index(index, key, value3)).to be_nil
   	end
 
     it "can remove a relationship from an index in batch" do
@@ -378,8 +399,8 @@ describe Neography::Rest do
        batch_result = @neo.batch [:remove_relationship_from_index, index, key, relationship1],
          [:remove_relationship_from_index, index, key, relationship2]
 
-       @neo.get_relationship_index(index, key, value1).should be_nil
-       @neo.get_relationship_index(index, key, value2).should be_nil
+       expect(@neo.get_relationship_index(index, key, value1)).to be_nil
+       expect(@neo.get_relationship_index(index, key, value2)).to be_nil
      end
     
     it "can do spatial via Cypher in batch" do
@@ -390,47 +411,47 @@ describe Neography::Rest do
                                 [:execute_query, "start n = node:geobatchcypher({withinDistance}) return n", {:withinDistance => "withinDistance:[60.0,15.0,100.0]"}],
                                 [:execute_query, "start n = node:geobatchcypher({bbox}) return n", {:bbox => "bbox:[15.0,15.3,60.0,60.2]"}]
 
-      batch_result[0]["body"]["provider"].should == "spatial"
-      batch_result[0]["body"]["geometry_type"].should == "point"
-      batch_result[0]["body"]["lat"].should == "lat"
-      batch_result[0]["body"]["lon"].should == "lon"
-      batch_result[1]["from"].should == "/index/node/geobatchcypher"
-      batch_result[1]["body"]["data"].should == {"lat" => 60.1, "lon" => 15.2}
-      batch_result[2]["body"]["data"].should_not be_empty
-      batch_result[3]["body"]["data"].should_not be_empty
+      expect(batch_result[0]["body"]["provider"]).to eq("spatial")
+      expect(batch_result[0]["body"]["geometry_type"]).to eq("point")
+      expect(batch_result[0]["body"]["lat"]).to eq("lat")
+      expect(batch_result[0]["body"]["lon"]).to eq("lon")
+      expect(batch_result[1]["from"]).to eq("/index/node/geobatchcypher")
+      expect(batch_result[1]["body"]["data"]).to eq({"lat" => 60.1, "lon" => 15.2})
+      expect(batch_result[2]["body"]["data"]).not_to be_empty
+      expect(batch_result[3]["body"]["data"]).not_to be_empty
     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
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Max")
+      expect(batch_result[1]["body"]["data"]["name"]).to eq("Marc")
+      expect(batch_result.last["body"]["type"]).to eq("friends")
+      expect(batch_result.last["body"]["data"]["since"]).to eq("high school")
+      expect(batch_result.last["body"]["start"].split('/').last).to eq(batch_result.first["body"]["self"].split('/').last)
+      expect(batch_result.last["body"]["end"].split('/').last).to eq(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
+      expect(batch_result.first["body"]["data"]["name"]).to eq("Marc")
+      expect(batch_result.last["body"]["type"]).to eq("friends")
+      expect(batch_result.last["body"]["data"]["since"]).to eq("high school")
+      expect(batch_result.last["body"]["start"].split('/').last).to eq(batch_result.first["body"]["self"].split('/').last)
+      expect(batch_result.last["body"]["end"].split('/').last).to eq(node1["self"].split('/').last)
     end
 
     it "can add a newly created node to an index" do
       key = generate_text(6)
       value = generate_text
       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")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to 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"]
+      expect(existing_index).not_to be_nil
+      expect(existing_index.first["self"]).to eq(batch_result.first["body"]["self"])
       @neo.remove_node_from_index("test_node_index", key, value, batch_result.first["body"]["self"].split('/').last)
     end
 
@@ -440,28 +461,28 @@ describe Neography::Rest do
       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
+      expect(batch_result.first["body"]["type"]).to eq("friends")
+      expect(batch_result.first["body"]["data"]["since"]).to eq("high school")
+      expect(batch_result.first["body"]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"]["end"].split('/').last).to eq(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"]
+      expect(existing_index).not_to be_nil
+      expect(existing_index.first["self"]).to eq(batch_result.first["body"]["self"])
     end
 
     it "can reset the properties of a newly created relationship" do
       node1 = @neo.create_node
       node2 = @neo.create_node
       batch_result = @neo.batch [:create_relationship, "friends", node1, node2, {:since => "high school"}], [:reset_relationship_properties, "{0}", {"since" => "college", "dated" => "yes"}]
-      batch_result.first.should have_key("id")
-      batch_result.first.should have_key("from")
+      expect(batch_result.first).to have_key("id")
+      expect(batch_result.first).to have_key("from")
       existing_relationship = @neo.get_relationship(batch_result.first["body"]["self"].split('/').last)
-      existing_relationship["type"].should == "friends"
-      existing_relationship["data"]["since"].should == "college"
-      existing_relationship["data"]["dated"].should == "yes"
-      existing_relationship["start"].split('/').last.should == node1["self"].split('/').last
-      existing_relationship["end"].split('/').last.should == node2["self"].split('/').last
-      existing_relationship["self"].should == batch_result.first["body"]["self"]
+      expect(existing_relationship["type"]).to eq("friends")
+      expect(existing_relationship["data"]["since"]).to eq("college")
+      expect(existing_relationship["data"]["dated"]).to eq("yes")
+      expect(existing_relationship["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(existing_relationship["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(existing_relationship["self"]).to eq(batch_result.first["body"]["self"])
     end
 
     it "can kitchen sink" do
@@ -474,7 +495,7 @@ describe Neography::Rest do
                                 [: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
+      expect(batch_result).not_to be_nil
     end
 
     it "can get multiple relationships" do
@@ -484,15 +505,15 @@ describe Neography::Rest do
       new_relationship1 = @neo.create_relationship("friends", node1, node2)
       new_relationship2 = @neo.create_relationship("brothers", node1, node3)
       batch_result = @neo.batch [:get_node_relationships, node1]
-      batch_result.first["body"].length.should be(2)
-      batch_result.first["body"][0]["type"].should == "friends"
-      batch_result.first["body"][0]["start"].split('/').last.should == node1["self"].split('/').last
-      batch_result.first["body"][0]["end"].split('/').last.should == node2["self"].split('/').last
-      batch_result.first["body"][0]["self"].should == new_relationship1["self"]
-      batch_result.first["body"][1]["type"].should == "brothers"
-      batch_result.first["body"][1]["start"].split('/').last.should == node1["self"].split('/').last
-      batch_result.first["body"][1]["end"].split('/').last.should == node3["self"].split('/').last
-      batch_result.first["body"][1]["self"].should == new_relationship2["self"]
+      expect(batch_result.first["body"].length).to be(2)
+      expect(batch_result.first["body"][0]["type"]).to eq("friends")
+      expect(batch_result.first["body"][0]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"][0]["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(batch_result.first["body"][0]["self"]).to eq(new_relationship1["self"])
+      expect(batch_result.first["body"][1]["type"]).to eq("brothers")
+      expect(batch_result.first["body"][1]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"][1]["end"].split('/').last).to eq(node3["self"].split('/').last)
+      expect(batch_result.first["body"][1]["self"]).to eq(new_relationship2["self"])
     end
 
     it "can get relationships of specific type" do
@@ -502,11 +523,11 @@ describe Neography::Rest do
       new_relationship1 = @neo.create_relationship("friends", node1, node2)
       new_relationship2 = @neo.create_relationship("brothers", node1, node3)
       batch_result = @neo.batch [:get_node_relationships, node1, "out", "friends"]
-      batch_result.first["body"].length.should be(1)
-      batch_result.first["body"][0]["type"].should == "friends"
-      batch_result.first["body"][0]["start"].split('/').last.should == node1["self"].split('/').last
-      batch_result.first["body"][0]["end"].split('/').last.should == node2["self"].split('/').last
-      batch_result.first["body"][0]["self"].should == new_relationship1["self"]
+      expect(batch_result.first["body"].length).to be(1)
+      expect(batch_result.first["body"][0]["type"]).to eq("friends")
+      expect(batch_result.first["body"][0]["start"].split('/').last).to eq(node1["self"].split('/').last)
+      expect(batch_result.first["body"][0]["end"].split('/').last).to eq(node2["self"].split('/').last)
+      expect(batch_result.first["body"][0]["self"]).to eq(new_relationship1["self"])
     end
 
     it "can create a relationship from a unique node" do
@@ -514,7 +535,7 @@ describe Neography::Rest do
                                 [:add_node_to_index, "person_ssn", "ssn", "000-00-0001", "{0}"],
                                 [:create_unique_node, "person", "ssn", "000-00-0001", {:first_name=>"Jane", :last_name=>"Doe", :ssn=>"000-00-0001", :_type=>"Person", :created_at=>1335269478}],
                                 [:create_relationship, "has", "{0}", "{2}", {}]
-      batch_result.should_not be_nil
+      expect(batch_result).not_to be_nil
 
       # create_unique_node is returning an index result, not a node, so we can't do this yet.
       # See https://github.com/neo4j/community/issues/697
@@ -532,12 +553,12 @@ describe Neography::Rest do
                                   [:create_node, {:street1=>"94437 Kemmer Crossing", :street2=>"Apt. 333", :city=>"Abshireton", :state=>"AA", :zip=>"65820", :_type=>"Address", :created_at=>1335269478}],
                                   [:create_relationship, "has", "{0}", "{2}", {}]
       rescue Neography::NeographyError => e
-        e.message.should == "Not Found"
-        e.code.should == 404
-        e.stacktrace.should be_nil
-        e.request[:path].should == "/db/data/batch"
-        e.request[:body].should_not be_nil
-        e.index.should == 3
+        expect(e.message).to eq("Not Found")
+        expect(e.code).to eq(404)
+        expect(e.stacktrace).to be_nil
+        expect(e.request[:path]).to eq("/db/data/batch")
+        expect(e.request[:body]).not_to be_nil
+        expect(e.index).to eq(3)
       end            
     end