neography 1.5.0 → 1.5.1

data/spec/unit/rest/batch_spec.rb

@@ -12,7 +12,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/node/bar" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:get_node, "foo"], [:get_node, "bar"]
       end
 
@@ -22,7 +22,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/node/bar" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch ["get_node", "foo"], [:get_node, "bar"]
       end
       
@@ -32,7 +32,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/node", "body" => { "baz" => "qux" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:create_node, { "foo" => "bar" }], [:create_node, { "baz" => "qux" }]
       end
 
@@ -42,7 +42,7 @@ module Neography
           { "id" => 1, "method" => "DELETE", "to" => "/node/bar" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:delete_node, "foo"], [:delete_node, "bar"]
       end
 
@@ -52,7 +52,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/node/quux?unique", "body" => { "key" => "corge", "value" => "grault", "properties" => "garply" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:create_unique_node, "foo", "bar", "baz", "qux" ],
                         [:create_unique_node, "quux", "corge", "grault", "garply"]
       end
@@ -63,7 +63,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/node/quux", "body" => { "uri" => "{0}", "key" => "corge", "value" => "grault" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:add_node_to_index, "foo", "bar", "baz", "qux" ],
                         [:add_node_to_index, "quux", "corge", "grault", "{0}"]
       end
@@ -74,7 +74,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/index/node/qux/quux/corge" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:get_node_index, "foo", "bar", "baz" ],
                         [:get_node_index, "qux", "quux", "corge" ]
       end
@@ -86,7 +86,7 @@ module Neography
           { "id" => 2, "method" => "DELETE", "to" => "/index/node/index3/key3/value3/id3" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:remove_node_from_index, "index1", "id1", ],
                         [:remove_node_from_index, "index2", "key2", "id2" ],
                         [:remove_node_from_index, "index3", "key3", "value3", "id3" ]
@@ -98,7 +98,7 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/node/index2/properties/key2", "body" => "value2" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:set_node_property, "index1", { "key1" => "value1" } ],
                         [:set_node_property, "index2", { "key2" => "value2" } ]
       end
@@ -109,7 +109,7 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/node/index2/properties", "body" => { "key2" => "value2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:reset_node_properties, "index1", { "key1" => "value1" } ],
                         [:reset_node_properties, "index2", { "key2" => "value2" } ]
       end
@@ -119,7 +119,7 @@ module Neography
           { "id" => 0, "method" => "POST", "to" => "{0}/labels", "body" => "foo" },
           { "id" => 1, "method" => "POST", "to" => "{0}/labels", "body" => "bar" },
         ]
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:add_label, "{0}", "foo"],
                         [:add_label, "{0}", "bar"]
       end
@@ -130,7 +130,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/node/id2/relationships/all" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:get_node_relationships, "id1", "direction1" ],
                         [:get_node_relationships, "id2" ]
       end
@@ -141,7 +141,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/relationship/bar" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:get_relationship, "foo"], [:get_relationship, "bar"]
       end
 
@@ -151,7 +151,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "{0}/relationships", "body" => { "to" => "{1}", "type" => "type2", "data" => "data2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:create_relationship, "type1", "from1", "to1", "data1" ],
                         [:create_relationship, "type2", "{0}", "{1}", "data2" ]
       end
@@ -162,7 +162,7 @@ module Neography
           { "id" => 1, "method" => "DELETE", "to" => "/relationship/bar" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:delete_relationship, "foo"], [:delete_relationship, "bar"]
       end
 
@@ -172,7 +172,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2?unique", "body" => { "key" => "key2", "value" => "value2", "type" => "type2", "start" => "{0}", "end" => "{1}", "properties" => "properties" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:create_unique_relationship, "index1", "key1", "value1", "type1", "node1", "node2","properties"  ],
                         [:create_unique_relationship, "index2", "key2", "value2", "type2", "{0}", "{1}", "properties" ]
       end
@@ -183,7 +183,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2", "body" => { "uri" => "{0}", "key" => "key2", "value" => "value2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:add_relationship_to_index, "index1", "key1", "value1", "rel1" ],
                         [:add_relationship_to_index, "index2", "key2", "value2", "{0}"]
       end
@@ -194,7 +194,7 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/index/relationship/qux/quux/corge" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:get_relationship_index, "foo", "bar", "baz" ],
                         [:get_relationship_index, "qux", "quux", "corge" ]
       end
@@ -206,7 +206,7 @@ module Neography
           { "id" => 2, "method" => "DELETE", "to" => "/index/relationship/index3/key3/value3/id3" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:remove_relationship_from_index, "index1", "id1", ],
                         [:remove_relationship_from_index, "index2", "key2", "id2" ],
                         [:remove_relationship_from_index, "index3", "key3", "value3", "id3" ]
@@ -218,7 +218,7 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/relationship/index2/properties/key2", "body" => "value2" }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:set_relationship_property, "index1", { "key1" => "value1" } ],
                         [:set_relationship_property, "index2", { "key2" => "value2" } ]
       end
@@ -229,7 +229,7 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "{0}/properties", "body" => { "key2" => "value2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:reset_relationship_properties, "index1", { "key1" => "value1" } ],
                         [:reset_relationship_properties, "{0}", { "key2" => "value2" } ]
       end
@@ -240,7 +240,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/ext/GremlinPlugin/graphdb/execute_script", "body" => { "script" => "script2", "params" => "params2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:execute_script, "script1", "params1"],
                         [:execute_script, "script2", "params2"]
       end
@@ -251,7 +251,7 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/cypher", "body" => { "query" => "query2" } }
         ]
 
-        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
         subject.batch [:execute_query, "query1", "params1"],
                         [:execute_query, "query2" ]
       end

data/spec/unit/rest/clean_spec.rb

@@ -7,7 +7,7 @@ module Neography
       subject { Neography::Rest.new }
 
       it "cleans the database" do
-        subject.connection.should_receive(:delete).with("/cleandb/secret-key")
+        expect(subject.connection).to receive(:delete).with("/cleandb/secret-key")
         subject.clean_database("yes_i_really_want_to_clean_the_database")
       end
 

data/spec/unit/rest/constraints_spec.rb

@@ -7,12 +7,12 @@ module Neography
       subject { Neography::Rest.new }
 
       it "list constraints" do
-        subject.connection.should_receive(:get).with("/schema/constraint/")
+        expect(subject.connection).to receive(:get).with("/schema/constraint/")
         subject.get_constraints
       end
 
       it "get constraints for a label" do
-        subject.connection.should_receive(:get).with("/schema/constraint/label")
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label")
         subject.get_constraints("label")
       end
 
@@ -21,22 +21,22 @@ module Neography
             :body    => '{"property_keys":["property"]}',
             :headers => json_content_type
           }
-        subject.connection.should_receive(:post).with("/schema/constraint/label/uniqueness/", options)
+        expect(subject.connection).to receive(:post).with("/schema/constraint/label/uniqueness/", options)
         subject.create_unique_constraint("label", "property")
       end
       
       it "get unique constraints for a label" do
-        subject.connection.should_receive(:get).with("/schema/constraint/label/uniqueness/")
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label/uniqueness/")
         subject.get_uniqueness("label")
       end
 
       it "get a specific unique constraint for a label" do
-        subject.connection.should_receive(:get).with("/schema/constraint/label/uniqueness/property")
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label/uniqueness/property")
         subject.get_unique_constraint("label", "property")
       end
       
       it "can delete a constraint for a label" do
-        subject.connection.should_receive(:delete).with("/schema/constraint/label/uniqueness/property")
+        expect(subject.connection).to receive(:delete).with("/schema/constraint/label/uniqueness/property")
         subject.drop_constraint("label","property")
       end
       

data/spec/unit/rest/cypher_spec.rb

@@ -11,7 +11,7 @@ module Neography
           :body=>"{\"query\":\"SOME QUERY\",\"params\":{\"foo\":\"bar\",\"baz\":\"qux\"}}",
           :headers=>{"Content-Type"=>"application/json", "Accept"=>"application/json;stream=true;charset=UTF-8"}
         }
-        subject.connection.should_receive(:post).with("/cypher", options)
+        expect(subject.connection).to receive(:post).with("/cypher", options)
         subject.execute_query("SOME QUERY", { :foo => "bar", :baz => "qux" })
       end
 

data/spec/unit/rest/extensions_spec.rb

@@ -9,7 +9,7 @@ module Neography
       it "executes an extensions get query" do
         path = "/unmanaged_extension/test"
 
-        subject.connection.should_receive(:get).with(path)
+        expect(subject.connection).to receive(:get).with(path)
         subject.get_extension("/unmanaged_extension/test")
       end
 
@@ -19,7 +19,7 @@ module Neography
           :body=>"{\"foo\":\"bar\",\"baz\":\"qux\"}",
           :headers=>{"Content-Type"=>"application/json", "Accept"=>"application/json;stream=true"}
         }
-        subject.connection.should_receive(:post).with(path, options)
+        expect(subject.connection).to receive(:post).with(path, options)
         subject.post_extension("/unmanaged_extension/test", { :foo => "bar", :baz => "qux" })
       end
 

data/spec/unit/rest/gremlin_spec.rb

@@ -11,13 +11,13 @@ module Neography
           :body=>"{\"script\":\"SOME SCRIPT\",\"params\":{\"foo\":\"bar\",\"baz\":\"qux\"}}",
           :headers=>{"Content-Type"=>"application/json"}
         }
-        subject.connection.should_receive(:post).with("/ext/GremlinPlugin/graphdb/execute_script", options)
+        expect(subject.connection).to receive(:post).with("/ext/GremlinPlugin/graphdb/execute_script", options)
         subject.execute_script("SOME SCRIPT", { :foo => "bar", :baz => "qux" })
       end
 
       it "returns nil if script result is null" do
-        subject.connection.stub(:post).and_return("null")
-        subject.execute_script("", {}).should be_nil
+        allow(subject.connection).to receive(:post).and_return("null")
+        expect(subject.execute_script("", {})).to be_nil
       end
 
     end

data/spec/unit/rest/helpers_spec.rb

@@ -10,18 +10,18 @@ module Neography
 
         [ :incoming, "incoming", :in, "in" ].each do |direction|
           it "parses 'in' direction" do
-            subject.parse_direction(direction).should == "in"
+            expect(subject.parse_direction(direction)).to eq("in")
           end
         end
 
         [ :outgoing, "outgoing", :out, "out" ].each do |direction|
           it "parses 'out' direction" do
-            subject.parse_direction(direction).should == "out"
+            expect(subject.parse_direction(direction)).to eq("out")
           end
         end
 
         it "parses 'all' direction by default" do
-          subject.parse_direction("foo").should == "all"
+          expect(subject.parse_direction("foo")).to eq("all")
         end
 
       end
@@ -32,88 +32,88 @@ context "options" do
         context "order" do
           [ :breadth, "breadth", "breadth first", "breadthFirst", :wide, "wide" ].each do |order|
             it "parses breadth first" do
-              subject.send(:parse_order, order).should == "breadth first"
+              expect(subject.send(:parse_order, order)).to eq("breadth first")
             end
           end
 
           it "parses depth first by default" do
-            subject.send(:parse_order, "foo").should == "depth first"
+            expect(subject.send(:parse_order, "foo")).to eq("depth first")
           end
         end
 
         context "uniqueness" do
           [ :nodeglobal, "node global", "nodeglobal", "node_global" ].each do |order|
             it "parses node global" do
-              subject.send(:parse_uniqueness, order).should == "node global"
+              expect(subject.send(:parse_uniqueness, order)).to eq("node global")
             end
           end
 
           [ :nodepath, "node path", "nodepath", "node_path" ].each do |order|
             it "parses node path" do
-              subject.send(:parse_uniqueness, order).should == "node path"
+              expect(subject.send(:parse_uniqueness, order)).to eq("node path")
             end
           end
 
           [ :noderecent, "node recent", "noderecent", "node_recent" ].each do |order|
             it "parses node recent" do
-              subject.send(:parse_uniqueness, order).should == "node recent"
+              expect(subject.send(:parse_uniqueness, order)).to eq("node recent")
             end
           end
 
           [ :relationshipglobal, "relationship global", "relationshipglobal", "relationship_global" ].each do |order|
             it "parses relationship global" do
-              subject.send(:parse_uniqueness, order).should == "relationship global"
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship global")
             end
           end
 
           [ :relationshippath, "relationship path", "relationshippath", "relationship_path" ].each do |order|
             it "parses relationship path" do
-              subject.send(:parse_uniqueness, order).should == "relationship path"
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship path")
             end
           end
 
           [ :relationshiprecent, "relationship recent", "relationshiprecent", "relationship_recent" ].each do |order|
             it "parses relationship recent" do
-              subject.send(:parse_uniqueness, order).should == "relationship recent"
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship recent")
             end
           end
 
           it "parses none by default" do
-            subject.send(:parse_uniqueness, "foo").should == "none"
+            expect(subject.send(:parse_uniqueness, "foo")).to eq("none")
           end
         end
 
         context "depth" do
           it "parses nil as nil" do
-            subject.send(:parse_depth, nil).should be_nil
+            expect(subject.send(:parse_depth, nil)).to be_nil
           end
           it "parses 0 as 1" do
-            subject.send(:parse_depth, "0").should == 1
+            expect(subject.send(:parse_depth, "0")).to eq(1)
           end
           it "parses integers" do
-            subject.send(:parse_depth, "42").should == 42
+            expect(subject.send(:parse_depth, "42")).to eq(42)
           end
         end
 
         context "type" do
           [ :relationship, "relationship", :relationships, "relationships" ].each do |type|
             it "parses relationship" do
-              subject.send(:parse_type, type).should == "relationship"
+              expect(subject.send(:parse_type, type)).to eq("relationship")
             end
           end
           [ :path, "path", :paths, "paths" ].each do |type|
             it "parses path" do
-              subject.send(:parse_type, type).should == "path"
+              expect(subject.send(:parse_type, type)).to eq("path")
             end
           end
           [ :fullpath, "fullpath", :fullpaths, "fullpaths" ].each do |type|
             it "parses fullpath" do
-              subject.send(:parse_type, type).should == "fullpath"
+              expect(subject.send(:parse_type, type)).to eq("fullpath")
             end
           end
 
           it "parses node by default" do
-            subject.send(:parse_type, "foo").should == "node"
+            expect(subject.send(:parse_type, "foo")).to eq("node")
           end
         end
       end      

data/spec/unit/rest/labels_spec.rb

@@ -7,27 +7,27 @@ module Neography
       subject { Neography::Rest.new }
 
       it "list node labels" do
-        subject.connection.should_receive(:get).with("/labels")
+        expect(subject.connection).to receive(:get).with("/labels")
         subject.list_labels
       end
 
       it "get labels for node" do
-        subject.connection.should_receive(:get).with("/node/0/labels")
+        expect(subject.connection).to receive(:get).with("/node/0/labels")
         subject.get_node_labels(0)
       end
 
       it "get nodes for labels" do
-        subject.connection.should_receive(:get).with("/label/person/nodes")
+        expect(subject.connection).to receive(:get).with("/label/person/nodes")
         subject.get_nodes_labeled("person")
       end
 
       it "find nodes for labels and property string" do
-        subject.connection.should_receive(:get).with("/label/person/nodes?name=%22max%22")
+        expect(subject.connection).to receive(:get).with("/label/person/nodes?name=%22max%22")
         subject.find_nodes_labeled("person", {:name => "max"})
       end
 
       it "find nodes for labels and property integer" do
-        subject.connection.should_receive(:get).with("/label/person/nodes?age=26")
+        expect(subject.connection).to receive(:get).with("/label/person/nodes?age=26")
         subject.find_nodes_labeled("person", {:age => 26})
       end
 
@@ -36,7 +36,7 @@ module Neography
           :body    => '["Actor"]',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:post).with("/node/0/labels", options)
+        expect(subject.connection).to receive(:post).with("/node/0/labels", options)
         subject.add_label(0, ["Actor"])
       end
 
@@ -45,7 +45,7 @@ module Neography
           :body    => '["Actor","Director"]',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:post).with("/node/0/labels", options)
+        expect(subject.connection).to receive(:post).with("/node/0/labels", options)
         subject.add_label(0, ["Actor", "Director"])
       end
 
@@ -54,7 +54,7 @@ module Neography
           :body    => '["Actor"]',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:put).with("/node/0/labels", options)
+        expect(subject.connection).to receive(:put).with("/node/0/labels", options)
         subject.set_label(0, ["Actor"])
       end
 
@@ -63,12 +63,12 @@ module Neography
           :body    => '["Actor","Director"]',
           :headers => json_content_type
         }
-        subject.connection.should_receive(:put).with("/node/0/labels", options)
+        expect(subject.connection).to receive(:put).with("/node/0/labels", options)
         subject.set_label(0, ["Actor", "Director"])
       end
       
       it "can delete a label from a node" do
-        subject.connection.should_receive(:delete).with("/node/0/labels/Actor")
+        expect(subject.connection).to receive(:delete).with("/node/0/labels/Actor")
         subject.delete_label(0,"Actor")
       end