neography 1.5.0 → 1.5.1

data/spec/unit/rest/node_auto_indexes_spec.rb

@@ -7,61 +7,61 @@ module Neography
       subject { Neography::Rest.new }
 
       it "gets a node from an auto index" do
-        subject.connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/some_key/some_value")
         subject.get_node_auto_index("some_key", "some_value")
       end
 
       it "returns nil if nothing was found in the auto index" do
-        subject.connection.stub(:get).and_return(nil)
-        subject.get_node_auto_index("some_key", "some_value").should be_nil
+        allow(subject.connection).to receive(:get).and_return(nil)
+        expect(subject.get_node_auto_index("some_key", "some_value")).to be_nil
       end
 
       it "finds by key and value if value passed to #find_or_query" do
-        subject.connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/some_key/some_value")
         subject.find_node_auto_index("some_key", "some_value")
       end
 
       it "finds by query if no value passed to #find_or_query" do
-        subject.connection.should_receive(:get).with("/index/auto/node/?query=some_query")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/?query=some_query")
         subject.find_node_auto_index("some_query")
 
         query = "some_query AND another_one"
-        subject.connection.should_receive(:get).with("/index/auto/node/?query=#{URI.encode(query)}")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/?query=#{URI.encode(query)}")
         subject.find_node_auto_index(query)
       end
 
       it "finds by key and value" do
-        subject.connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/some_key/some_value")
         subject.find_node_auto_index("some_key", "some_value")
       end
 
       it "finds by query" do
-        subject.connection.should_receive(:get).with("/index/auto/node/?query=some_query")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/?query=some_query")
         subject.find_node_auto_index("some_query")
       end
 
       it "gets the status" do
-        subject.connection.should_receive(:get).with("/index/auto/node/status")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/status")
         subject.get_node_auto_index_status
       end
 
       it "sets the status" do
-        subject.connection.should_receive(:put).with("/index/auto/node/status", hash_match(:body, '"foo"'))
+        expect(subject.connection).to receive(:put).with("/index/auto/node/status", hash_match(:body, '"foo"'))
         subject.set_node_auto_index_status("foo")
       end
 
       it "gets auto index properties" do
-        subject.connection.should_receive(:get).with("/index/auto/node/properties")
+        expect(subject.connection).to receive(:get).with("/index/auto/node/properties")
         subject.get_node_auto_index_properties
       end
 
       it "adds a property to an auto index" do
-        subject.connection.should_receive(:post).with("/index/auto/node/properties", hash_match(:body, "foo"))
+        expect(subject.connection).to receive(:post).with("/index/auto/node/properties", hash_match(:body, "foo"))
         subject.add_node_auto_index_property("foo")
       end
 
       it "removes a property from an auto index" do
-        subject.connection.should_receive(:delete).with("/index/auto/node/properties/foo")
+        expect(subject.connection).to receive(:delete).with("/index/auto/node/properties/foo")
         subject.remove_node_auto_index_property("foo")
       end
 

data/spec/unit/rest/node_indexes_spec.rb

@@ -7,7 +7,7 @@ module Neography
       subject { Neography::Rest.new }
 
       it "lists all indexes" do
-        subject.connection.should_receive(:get).with("/index/node")
+        expect(subject.connection).to receive(:get).with("/index/node")
         subject.list_node_indexes
       end
 
@@ -19,13 +19,13 @@ module Neography
           },
           "name" => "some_index"
         }
-        subject.connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/index/node", json_match(:body, expected_body))
         subject.create_node_index("some_index", "some_type", "some_provider")
       end
 
       it "returns the post result after creation" do
-        subject.connection.stub(:post).and_return("foo")
-        subject.create_node_index("some_index", "some_type", "some_provider").should == "foo"
+        allow(subject.connection).to receive(:post).and_return("foo")
+        expect(subject.create_node_index("some_index", "some_type", "some_provider")).to eq("foo")
       end
 
       it "creates an auto-index" do
@@ -36,7 +36,7 @@ module Neography
           },
           "name" => "node_auto_index"
         }
-        subject.connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/index/node", json_match(:body, expected_body))
         subject.create_node_auto_index("some_type", "some_provider")
       end
 
@@ -46,7 +46,7 @@ module Neography
           "key" => "key",
           "value" => "value"
         }
-        subject.connection.should_receive(:post).with("/index/node/some_index?unique", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/index/node/some_index?unique", json_match(:body, expected_body))
         subject.create_unique_node("some_index", "key", "value", "properties")
       end
 
@@ -56,7 +56,7 @@ module Neography
           "key" => "key",
           "value" => "value"
         }
-        subject.connection.should_receive(:post).with("/index/node/some_index?uniqueness=get_or_create", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/index/node/some_index?uniqueness=get_or_create", json_match(:body, expected_body))
         subject.get_or_create_unique_node("some_index", "key", "value", "properties")
       end
 
@@ -66,72 +66,72 @@ module Neography
           "key" => "key",
           "value" => "value"
         }
-        subject.connection.should_receive(:post).with("/index/node/some_index", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/index/node/some_index", json_match(:body, expected_body))
         subject.add_node_to_index("some_index", "key", "value", "42")
       end
 
       it "gets a node from an index" do
-        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/node/some_index/some_key/some_value")
         subject.get_node_index("some_index", "some_key", "some_value")
       end
 
       it "returns nil if nothing was found in the index" do
-        subject.connection.stub(:get).and_return(nil)
-        subject.get_node_index("some_index", "some_key", "some_value").should be_nil
+        allow(subject.connection).to receive(:get).and_return(nil)
+        expect(subject.get_node_index("some_index", "some_key", "some_value")).to be_nil
       end
 
       it "finds by key and value if both passed to #find" do
-        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/node/some_index/some_key/some_value")
         subject.find_node_index("some_index", "some_key", "some_value")
       end
 
       it "finds by query if no value passed to #find" do
-        subject.connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        expect(subject.connection).to receive(:get).with("/index/node/some_index?query=some_query")
         subject.find_node_index("some_index", "some_query")
       end
 
       it "finds by key and value" do
-        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        expect(subject.connection).to receive(:get).with("/index/node/some_index/some_key/some_value")
         subject.find_node_index_by_key_value("some_index", "some_key", "some_value")
       end
 
       it "finds by query" do
-        subject.connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        expect(subject.connection).to receive(:get).with("/index/node/some_index?query=some_query")
         subject.find_node_index_by_query("some_index", "some_query")
       end
 
       it "removes a node from an index by id for #remove with two arguments" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/42")
         subject.remove_node_from_index("some_index", "42")
       end
 
       it "removes a node from an index by key for #remove with three arguments" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/some_key/42")
         subject.remove_node_from_index("some_index", "some_key", "42")
       end
 
       it "removes a node from an index by key and value for #remove with four arguments" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/some_key/some_value/42")
         subject.remove_node_from_index("some_index", "some_key", "some_value", "42")
       end
 
       it "removes a node from an index" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/42")
         subject.remove_node_index_by_id("some_index", "42")
       end
 
       it "removes a node from an index by key" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/some_key/42")
         subject.remove_node_index_by_key("some_index", "42", "some_key")
       end
 
       it "removes a node from an index by key and value" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index/some_key/some_value/42")
         subject.remove_node_index_by_value("some_index", "42", "some_key", "some_value")
       end
 
       it "drops an index" do
-        subject.connection.should_receive(:delete).with("/index/node/some_index")
+        expect(subject.connection).to receive(:delete).with("/index/node/some_index")
         subject.drop_node_index("some_index")
       end
 

data/spec/unit/rest/node_paths_spec.rb

@@ -14,7 +14,7 @@ module Neography
           "algorithm"     => "shortestPath"
         }
 
-        subject.connection.should_receive(:post).with("/node/42/path", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/node/42/path", json_match(:body, expected_body))
 
         subject.get_path("42", "43", "relationships", 3, "shortestPath")
       end
@@ -27,7 +27,7 @@ module Neography
           "algorithm"     => "shortestPath"
         }
 
-        subject.connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/node/42/paths", json_match(:body, expected_body))
 
         subject.get_paths("42", "43", "relationships", 3, "shortestPath")
       end
@@ -41,7 +41,7 @@ module Neography
           "algorithm"     => "shortestPath"
         }
 
-        subject.connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/node/42/paths", json_match(:body, expected_body))
 
         subject.get_shortest_weighted_path("42", "43", "relationships", "cost", 3, "shortestPath")
       end
@@ -50,24 +50,24 @@ module Neography
 
         [ :shortest, "shortest", :shortestPath, "shortestPath", :short, "short" ].each do |algorithm|
           it "parses shortestPath" do
-            subject.send(:get_algorithm, algorithm).should == "shortestPath"
+            expect(subject.send(:get_algorithm, algorithm)).to eq("shortestPath")
           end
         end
 
         [ :allSimplePaths, "allSimplePaths", :simple, "simple" ].each do |algorithm|
           it "parses allSimplePaths" do
-            subject.send(:get_algorithm, algorithm).should == "allSimplePaths"
+            expect(subject.send(:get_algorithm, algorithm)).to eq("allSimplePaths")
           end
         end
 
         [ :dijkstra, "dijkstra" ].each do |algorithm|
           it "parses dijkstra" do
-            subject.send(:get_algorithm, algorithm).should == "dijkstra"
+            expect(subject.send(:get_algorithm, algorithm)).to eq("dijkstra")
           end
         end
 
         it "parses allPaths by default" do
-          subject.send(:get_algorithm, "foo").should == "allPaths"
+          expect(subject.send(:get_algorithm, "foo")).to eq("allPaths")
         end
 
       end

data/spec/unit/rest/node_properties_spec.rb

@@ -15,8 +15,8 @@ module Neography
           :body    => '"qux"',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:put).with("/node/42/properties/foo", options1)
-        subject.connection.should_receive(:put).with("/node/42/properties/baz", options2)
+        expect(subject.connection).to receive(:put).with("/node/42/properties/foo", options1)
+        expect(subject.connection).to receive(:put).with("/node/42/properties/baz", options2)
         subject.set_node_properties("42", {:foo => "bar", :baz => "qux"})
       end
 
@@ -25,36 +25,36 @@ module Neography
           :body    => '{"foo":"bar"}',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:put).with("/node/42/properties", options)
+        expect(subject.connection).to receive(:put).with("/node/42/properties", options)
         subject.reset_node_properties("42", {:foo => "bar"})
       end
 
       context "getting properties" do
 
         it "gets all properties" do
-          subject.connection.should_receive(:get).with("/node/42/properties")
+          expect(subject.connection).to receive(:get).with("/node/42/properties")
           subject.get_node_properties("42")
         end
 
         it "gets multiple properties" do
-          subject.connection.should_receive(:get).with("/node/42/properties/foo")
-          subject.connection.should_receive(:get).with("/node/42/properties/bar")
+          expect(subject.connection).to receive(:get).with("/node/42/properties/foo")
+          expect(subject.connection).to receive(:get).with("/node/42/properties/bar")
           subject.get_node_properties("42", "foo", "bar")
         end
 
         it "returns multiple properties as a hash" do
-          subject.connection.stub(:get).and_return("baz", "qux")
-          subject.get_node_properties("42", "foo", "bar").should == { "foo" => "baz", "bar" => "qux" }
+          allow(subject.connection).to receive(:get).and_return("baz", "qux")
+          expect(subject.get_node_properties("42", "foo", "bar")).to eq({ "foo" => "baz", "bar" => "qux" })
         end
 
         it "returns nil if no properties were found" do
-          subject.connection.stub(:get).and_return(nil, nil)
-          subject.get_node_properties("42", "foo", "bar").should be_nil
+          allow(subject.connection).to receive(:get).and_return(nil, nil)
+          expect(subject.get_node_properties("42", "foo", "bar")).to be_nil
         end
 
         it "returns hash without nil return values" do
-          subject.connection.stub(:get).and_return("baz", nil)
-          subject.get_node_properties("42", "foo", "bar").should == { "foo" => "baz" }
+          allow(subject.connection).to receive(:get).and_return("baz", nil)
+          expect(subject.get_node_properties("42", "foo", "bar")).to eq({ "foo" => "baz" })
         end
 
       end
@@ -62,13 +62,13 @@ module Neography
       context "removing properties" do
 
         it "removes all properties" do
-          subject.connection.should_receive(:delete).with("/node/42/properties")
+          expect(subject.connection).to receive(:delete).with("/node/42/properties")
           subject.remove_node_properties("42")
         end
 
         it "removes multiple properties" do
-          subject.connection.should_receive(:delete).with("/node/42/properties/foo")
-          subject.connection.should_receive(:delete).with("/node/42/properties/bar")
+          expect(subject.connection).to receive(:delete).with("/node/42/properties/foo")
+          expect(subject.connection).to receive(:delete).with("/node/42/properties/bar")
           subject.remove_node_properties("42", "foo", "bar")
         end
 

data/spec/unit/rest/node_relationships_spec.rb

@@ -11,44 +11,44 @@ module Neography
           "to" => "http://localhost:7474/node/43",
           "data" => {"foo"=>"bar","baz"=>"qux"}
         }
-        subject.connection.should_receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
+        expect(subject.connection).to receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
 
         subject.create_relationship("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
       end
 
       it "returns the post results" do
-        subject.connection.stub(:post).and_return("foo")
+        allow(subject.connection).to receive(:post).and_return("foo")
 
-        subject.create_relationship("some_type", "42", "43", {}).should == "foo"
+        expect(subject.create_relationship("some_type", "42", "43", {})).to eq("foo")
       end
 
       it "gets relationships" do
-        subject.connection.should_receive(:get).with("/node/42/relationships/all")
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/all")
         subject.get_node_relationships("42")
       end
 
       it "gets relationships with direction" do
-        subject.connection.should_receive(:get).with("/node/42/relationships/in")
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/in")
         subject.get_node_relationships("42", :in)
       end
 
       it "gets relationships with direction and type" do
-        subject.connection.should_receive(:get).with("/node/42/relationships/in/foo")
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/in/foo")
         subject.get_node_relationships("42", :in, "foo")
       end
 
       it "gets relationships with direction and types" do
-        subject.connection.should_receive(:get).with("/node/42/relationships/in/foo%26bar")
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/in/foo%26bar")
         subject.get_node_relationships("42", :in, ["foo", "bar"])
       end
 
       it "returns empty array if no relationships were found" do
-        subject.connection.stub(:get).and_return([])
-        subject.get_node_relationships("42", :in).should be_empty
+        allow(subject.connection).to receive(:get).and_return([])
+        expect(subject.get_node_relationships("42", :in)).to be_empty
       end
 
       it "returns empty array if no relationships were found by type" do
-        subject.connection.stub(:get).and_return([])
+        allow(subject.connection).to receive(:get).and_return([])
         subject.get_node_relationships("42", :in, "foo")
       end
 

data/spec/unit/rest/node_traversal_spec.rb

@@ -25,7 +25,7 @@ module Neography
           "max_depth"       => 4
         }
 
-        subject.connection.should_receive(:post).with("/node/42/traverse/relationship", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/node/42/traverse/relationship", json_match(:body, expected_body))
 
         subject.traverse("42", :relationship, description)
       end      

data/spec/unit/rest/nodes_spec.rb

@@ -8,30 +8,30 @@ module Neography
 
       context "get nodes" do
         it "gets single nodes" do
-          subject.connection.should_receive(:get).with("/node/42")
+          expect(subject.connection).to receive(:get).with("/node/42")
           subject.get_node("42")
         end
 
         it "gets multiple nodes" do
-          subject.connection.should_receive(:get).with("/node/42")
-          subject.connection.should_receive(:get).with("/node/43")
+          expect(subject.connection).to receive(:get).with("/node/42")
+          expect(subject.connection).to receive(:get).with("/node/43")
           subject.get_nodes("42", "43")
         end
 
         it "returns multiple nodes in an array" do
-          subject.connection.stub(:get).and_return("foo", "bar")
-          subject.get_nodes("42", "43").should == [ "foo", "bar" ]
+          allow(subject.connection).to receive(:get).and_return("foo", "bar")
+          expect(subject.get_nodes("42", "43")).to eq([ "foo", "bar" ])
         end
 
         it "gets the root node" do
-          subject.connection.stub(:get).with("/").and_return({ "reference_node" => "42" })
-          subject.connection.should_receive(:get).with("/node/42")
+          allow(subject.connection).to receive(:get).with("/").and_return({ "reference_node" => "42" })
+          expect(subject.connection).to receive(:get).with("/node/42")
           subject.get_root
         end
 
         it "returns the root node" do
-          subject.connection.stub(:get).and_return({ "reference_node" => "42" }, "foo")
-          subject.get_root.should == "foo"
+          allow(subject.connection).to receive(:get).and_return({ "reference_node" => "42" }, "foo")
+          expect(subject.get_root).to eq("foo")
         end
       end
 
@@ -42,13 +42,13 @@ module Neography
             :body    => '{"foo":"bar","baz":"qux"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options)
+          expect(subject.connection).to receive(:post).with("/node", options)
           subject.create_node_with_attributes({:foo => "bar", :baz => "qux"})
         end
 
         it "returns the created node" do
-          subject.connection.stub(:post).and_return("foo")
-          subject.create_node_with_attributes({}).should == "foo"
+          allow(subject.connection).to receive(:post).and_return("foo")
+          expect(subject.create_node_with_attributes({})).to eq("foo")
         end
 
         it "creates with attributes using #create method" do
@@ -56,22 +56,22 @@ module Neography
             :body    => '{"foo":"bar","baz":"qux"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options)
+          expect(subject.connection).to receive(:post).with("/node", options)
           subject.create_node({:foo => "bar", :baz => "qux"})
         end
 
         it "creates empty nodes" do
-          subject.connection.should_receive(:post).with("/node")
+          expect(subject.connection).to receive(:post).with("/node")
           subject.create_empty_node
         end
 
         it "returns an empty node" do
-          subject.connection.stub(:post).and_return("foo")
-          subject.create_empty_node.should == "foo"
+          allow(subject.connection).to receive(:post).and_return("foo")
+          expect(subject.create_empty_node).to eq("foo")
         end
 
         it "creates empty nodes using #create method" do
-          subject.connection.should_receive(:post).with("/node")
+          expect(subject.connection).to receive(:post).with("/node")
           subject.create_node
         end
 
@@ -80,7 +80,7 @@ module Neography
       context "delete nodes" do
 
         it "deletes a node" do
-          subject.connection.should_receive(:delete).with("/node/42")
+          expect(subject.connection).to receive(:delete).with("/node/42")
           subject.delete_node("42")
         end
 
@@ -97,8 +97,8 @@ module Neography
             :body    => '{"foo2":"bar2","baz2":"qux2"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options1)
-          subject.connection.should_receive(:post).with("/node", options2)
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node", options2)
 
           subject.create_nodes([
             {:foo1 => "bar1", :baz1 => "qux1"},
@@ -107,8 +107,8 @@ module Neography
         end
 
         it "returns multiple nodes with attributes in an array" do
-          subject.connection.stub(:post).and_return("foo", "bar")
-          subject.create_nodes([{},{}]).should == ["foo", "bar"]
+          allow(subject.connection).to receive(:post).and_return("foo", "bar")
+          expect(subject.create_nodes([{},{}])).to eq(["foo", "bar"])
         end
 
         # exotic?
@@ -117,8 +117,8 @@ module Neography
             :body    => '{"foo1":"bar1","baz1":"qux1"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options1)
-          subject.connection.should_receive(:post).with("/node")
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node")
 
           subject.create_nodes([
             {:foo1 => "bar1", :baz1 => "qux1"},
@@ -127,13 +127,13 @@ module Neography
         end
 
         it "creates multiple empty nodes" do
-          subject.connection.should_receive(:post).with("/node").twice
+          expect(subject.connection).to receive(:post).with("/node").twice
           subject.create_nodes(2)
         end
 
         it "returns multiple empty nodes in an array" do
-          subject.connection.stub(:post).and_return("foo", "bar")
-          subject.create_nodes(2).should == ["foo", "bar"]
+          allow(subject.connection).to receive(:post).and_return("foo", "bar")
+          expect(subject.create_nodes(2)).to eq(["foo", "bar"])
         end
 
       end
@@ -151,8 +151,8 @@ module Neography
             :body    => '{"foo2":"bar2","baz2":"qux2"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options1)
-          subject.connection.should_receive(:post).with("/node", options2)
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node", options2)
 
           subject.create_nodes_threaded([
             {:foo1 => "bar1", :baz1 => "qux1"},
@@ -166,8 +166,8 @@ module Neography
             :body    => '{"foo1":"bar1","baz1":"qux1"}',
             :headers => json_content_type
           }
-          subject.connection.should_receive(:post).with("/node", options1)
-          subject.connection.should_receive(:post).with("/node")
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node")
 
           subject.create_nodes_threaded([
             {:foo1 => "bar1", :baz1 => "qux1"},
@@ -176,7 +176,7 @@ module Neography
         end
 
         it "creates multiple empty nodes" do
-          subject.connection.should_receive(:post).with("/node").twice
+          expect(subject.connection).to receive(:post).with("/node").twice
           subject.create_nodes_threaded(2)
         end