neography 1.5.0 → 1.5.1

data/spec/integration/rest_traverse_spec.rb

@@ -18,11 +18,11 @@ describe Neography::Rest do
       @neo.create_relationship("friends", @new_node4, @new_node5)
       @neo.create_relationship("friends", @new_node3, @new_node5)
       nodes = @neo.traverse(@new_node1, "nodes", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
-      nodes.should_not be_nil
-      nodes[0]["self"].should == @new_node2["self"]
-      nodes[1]["self"].should == @new_node3["self"]
-      nodes[2]["self"].should == @new_node4["self"]
-      nodes[3]["self"].should == @new_node5["self"]
+      expect(nodes).not_to be_nil
+      expect(nodes[0]["self"]).to eq(@new_node2["self"])
+      expect(nodes[1]["self"]).to eq(@new_node3["self"])
+      expect(nodes[2]["self"]).to eq(@new_node4["self"])
+      expect(nodes[3]["self"]).to eq(@new_node5["self"])
     end
     it "can traverse the graph and return relationships" do
       new_relationship1= @neo.create_relationship("friends", @new_node1, @new_node2)
@@ -32,12 +32,12 @@ describe Neography::Rest do
       new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
 
       relationships = @neo.traverse(@new_node1, "relationships", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
-      relationships.should_not be_nil
+      expect(relationships).not_to be_nil
 
-      relationships[0]["self"].should == new_relationship1["self"]
-      relationships[1]["self"].should == new_relationship2["self"]
-      relationships[2]["self"].should == new_relationship3["self"]
-      relationships[3]["self"].should == new_relationship4["self"]
+      expect(relationships[0]["self"]).to eq(new_relationship1["self"])
+      expect(relationships[1]["self"]).to eq(new_relationship2["self"])
+      expect(relationships[2]["self"]).to eq(new_relationship3["self"])
+      expect(relationships[3]["self"]).to eq(new_relationship4["self"])
     end
 
     it "can traverse the graph and return paths" do
@@ -48,12 +48,12 @@ describe Neography::Rest do
       new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
 
       paths = @neo.traverse(@new_node1, "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
-      paths.should_not be_nil
+      expect(paths).not_to be_nil
   
-      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
-      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
-      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
-      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"], @new_node5["self"]]
+      expect(paths[0]["nodes"]).to eq([@new_node1["self"], @new_node2["self"]])
+      expect(paths[1]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"]])
+      expect(paths[2]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]])
+      expect(paths[3]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"], @new_node5["self"]])
     end
 
     it "can traverse the graph up to a certain depth" do
@@ -64,12 +64,12 @@ describe Neography::Rest do
       new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
 
       paths = @neo.traverse(@new_node1, "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 3} )
-      paths.should_not be_nil
+      expect(paths).not_to be_nil
 
-      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
-      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
-      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
-      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]]
+      expect(paths[0]["nodes"]).to eq([@new_node1["self"], @new_node2["self"]])
+      expect(paths[1]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"]])
+      expect(paths[2]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]])
+      expect(paths[3]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]])
     end
 
     it "can traverse the graph in a certain order" do
@@ -80,12 +80,12 @@ describe Neography::Rest do
       new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
 
       paths = @neo.traverse(@new_node1, "paths", {"order" => "breadth first", "relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
-      paths.should_not be_nil
+      expect(paths).not_to be_nil
     
-      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
-      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
-      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
-      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]]
+      expect(paths[0]["nodes"]).to eq([@new_node1["self"], @new_node2["self"]])
+      expect(paths[1]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"]])
+      expect(paths[2]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]])
+      expect(paths[3]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node5["self"]])
     end
 
     it "can traverse the graph with a specific uniqueness" do
@@ -98,12 +98,12 @@ describe Neography::Rest do
       new_relationship5= @neo.create_relationship("friends", @new_node3, @new_node5)
 
       paths = @neo.traverse(@new_node1, "paths", {"order" => "breadth first", "uniqueness" => "node global", "relationships" => [{"type"=> "roommates", "direction" => "all"},{"type"=> "friends", "direction" => "out"}], "depth" => 4} )
-      paths.should_not be_nil
+      expect(paths).not_to be_nil
     
-      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
-      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node5["self"]]
-      paths[2]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
-      paths[3]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]]
+      expect(paths[0]["nodes"]).to eq([@new_node1["self"], @new_node2["self"]])
+      expect(paths[1]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node5["self"]])
+      expect(paths[2]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"]])
+      expect(paths[3]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"], @new_node4["self"]])
     end
 
     it "can traverse the graph with a prune evaluator" do
@@ -119,10 +119,10 @@ describe Neography::Rest do
                              "depth" => 3,
                              "prune evaluator" => {"language" => "javascript",  "body" => "position.endNode().getProperty('age') < 21;"
                               }} )
-      paths.should_not be_nil
-      paths[0]["nodes"].should == [@new_node1["self"], @new_node2["self"]]
-      paths[1]["nodes"].should == [@new_node1["self"], @new_node2["self"], @new_node3["self"]]
-      paths[2].should be_nil
+      expect(paths).not_to be_nil
+      expect(paths[0]["nodes"]).to eq([@new_node1["self"], @new_node2["self"]])
+      expect(paths[1]["nodes"]).to eq([@new_node1["self"], @new_node2["self"], @new_node3["self"]])
+      expect(paths[2]).to be_nil
     end
 
     it "can traverse the graph with a return filter" do
@@ -134,12 +134,12 @@ describe Neography::Rest do
       nodes = @neo.traverse(@new_node1, "node", {"relationships" => {"type"=> "friends", "direction" => "out"}, 
                                                       "return filter" => {"language" => "builtin", "name" => "all"},
                                                       "depth" => 4} )
-      nodes.should_not be_nil
-      nodes[0]["self"].should == @new_node1["self"]
-      nodes[1]["self"].should == @new_node2["self"]
-      nodes[2]["self"].should == @new_node3["self"]
-      nodes[3]["self"].should == @new_node4["self"]
-      nodes[4]["self"].should == @new_node5["self"]
+      expect(nodes).not_to be_nil
+      expect(nodes[0]["self"]).to eq(@new_node1["self"])
+      expect(nodes[1]["self"]).to eq(@new_node2["self"])
+      expect(nodes[2]["self"]).to eq(@new_node3["self"])
+      expect(nodes[3]["self"]).to eq(@new_node4["self"])
+      expect(nodes[4]["self"]).to eq(@new_node5["self"])
     end
 
 

data/spec/integration/unmanaged_spec.rb

@@ -8,18 +8,18 @@ describe Neography::Rest do
   describe "call unmanaged extensions", :unmanaged_extensions => true  do
     it "can call a get based unmanaged extension" do
       results = @neo.get_extension('/example/service/queries/fofof/13343')
-      results.should_not be_null
+      expect(results).not_to be_null
     end
     
     it "can call a POST based unmanaged extension" do 
       results = @neo.post_extention('/movie/recommend', {"title" => "Rambo"})
-      results.should_not be_null
+      expect(results).not_to be_null
     end
     
     it "can call a POST based unmanaged extension that uses form-urlencoded" do
       headers = {'Content-Type' =>'application/x-www-form-urlencoded'}
       results = @neo.post_extention('/music/recommend', {"artist" => "Ministry", "song" => "Just one Fix"}, headers)    
-      results.should_not be_null
+      expect(results).not_to be_null
     end
 
   end

data/spec/matchers.rb

@@ -5,7 +5,7 @@ RSpec::Matchers.define :json_match do |field, expected|
     expected == JSON.parse(actual[field])
   end
 
-  failure_message_for_should do
+  failure_message do
     "expected JSON in field '#{field}' to match '#{expected}'"
   end
 
@@ -22,7 +22,7 @@ RSpec::Matchers.define :hash_match do |field, expected|
     expected == actual[field]
   end
 
-  failure_message_for_should do
+  failure_message do
     "expected field '#{field}' to match '#{expected}'"
   end
 

data/spec/neography_spec.rb

@@ -5,16 +5,16 @@ describe Neography do
   describe "::configure" do
 
     it "returns the same configuration" do
-      Neography.configuration.should == Neography.configuration
+      expect(Neography.configuration).to eq(Neography.configuration)
     end
 
     it "returns the Config" do
-      Neography.configuration.should be_a Neography::Config
+      expect(Neography.configuration).to be_a Neography::Config
     end
 
     it "yields the configuration" do
       Neography.configure do |config|
-        config.should == Neography.configuration
+        expect(config).to eq(Neography.configuration)
       end
     end
 

data/spec/spec_helper.rb

@@ -27,10 +27,10 @@ end
 
 def error_response(attributes)
   request_uri = double()
-  request_uri.stub(:request_uri).and_return("")
+  allow(request_uri).to receive(:request_uri).and_return("")
   
   http_header = double()
-  http_header.stub(:request_uri).and_return(request_uri)
+  allow(http_header).to receive(:request_uri).and_return(request_uri)
   
   double(
     http_header: http_header,

data/spec/unit/config_spec.rb

@@ -7,25 +7,100 @@ module Neography
 
     context "defaults" do
 
-      its(:protocol)              { should == 'http://' }
-      its(:server)                { should == 'localhost' }
-      its(:port)                  { should == 7474 }
-      its(:directory)             { should == '' }
-      its(:cypher_path)           { should == '/cypher' }
-      its(:gremlin_path)          { should == '/ext/GremlinPlugin/graphdb/execute_script' }
-      its(:log_file)              { should == 'neography.log' }
-      its(:log_enabled)           { should == false }
-      its(:logger)                { should == nil }
-      its(:slow_log_threshold)    { should == 0 }
-      its(:max_threads)           { should == 20 }
-      its(:authentication)        { should == nil }
-      its(:username)              { should == nil }
-      its(:password)              { should == nil }
-      its(:parser)                { should == MultiJsonParser}
-      its(:max_execution_time)    { should == 6000 }
-      its(:proxy)                 { should == nil }
-      its(:http_send_timeout)     { should == 1200 }
-      its(:http_receive_timeout)  { should == 1200 }
+      describe '#protocol' do
+        subject { super().protocol }
+        it              { should == 'http://' }
+      end
+
+      describe '#server' do
+        subject { super().server }
+        it                { should == 'localhost' }
+      end
+
+      describe '#port' do
+        subject { super().port }
+        it                  { should == 7474 }
+      end
+
+      describe '#directory' do
+        subject { super().directory }
+        it             { should == '' }
+      end
+
+      describe '#cypher_path' do
+        subject { super().cypher_path }
+        it           { should == '/cypher' }
+      end
+
+      describe '#gremlin_path' do
+        subject { super().gremlin_path }
+        it          { should == '/ext/GremlinPlugin/graphdb/execute_script' }
+      end
+
+      describe '#log_file' do
+        subject { super().log_file }
+        it              { should == 'neography.log' }
+      end
+
+      describe '#log_enabled' do
+        subject { super().log_enabled }
+        it           { should == false }
+      end
+
+      describe '#logger' do
+        subject { super().logger }
+        it                { should == nil }
+      end
+
+      describe '#slow_log_threshold' do
+        subject { super().slow_log_threshold }
+        it    { should == 0 }
+      end
+
+      describe '#max_threads' do
+        subject { super().max_threads }
+        it           { should == 20 }
+      end
+
+      describe '#authentication' do
+        subject { super().authentication }
+        it        { should == nil }
+      end
+
+      describe '#username' do
+        subject { super().username }
+        it              { should == nil }
+      end
+
+      describe '#password' do
+        subject { super().password }
+        it              { should == nil }
+      end
+
+      describe '#parser' do
+        subject { super().parser }
+        it                { should == MultiJsonParser}
+      end
+
+      describe '#max_execution_time' do
+        subject { super().max_execution_time }
+        it    { should == 6000 }
+      end
+
+      describe '#proxy' do
+        subject { super().proxy }
+        it                 { should == nil }
+      end
+
+      describe '#http_send_timeout' do
+        subject { super().http_send_timeout }
+        it     { should == 1200 }
+      end
+
+      describe '#http_receive_timeout' do
+        subject { super().http_receive_timeout }
+        it  { should == 1200 }
+      end
 
 
       it "has a hash representation" do
@@ -51,7 +126,7 @@ module Neography
           :http_receive_timeout => 1200
 
         }
-        config.to_hash.should == expected_hash
+        expect(config.to_hash).to eq(expected_hash)
       end
 
     end

data/spec/unit/connection_spec.rb

@@ -8,7 +8,7 @@ module Neography
     context "defaults" do
 
       it "intializes with defaults" do
-        connection.configuration.should == "http://localhost:7474"
+        expect(connection.configuration).to eq("http://localhost:7474")
       end
 
     end
@@ -38,26 +38,26 @@ module Neography
         end
 
         it "accepts all options in a hash" do
-          connection.configuration.should == "https://foobar:4242/dir"
-
-          connection.protocol.should           == "https://"
-          connection.server.should             == "foobar"
-          connection.port.should               == 4242
-          connection.directory.should          == "/dir"
-          connection.cypher_path.should        == "/cyph"
-          connection.gremlin_path.should       == "/grem"
-          connection.log_file.should           == "neo.log"
-          connection.log_enabled.should        == false
-          connection.slow_log_threshold.should == 0
-          connection.max_threads.should        == 10
-          connection.parser.should             == Foo
-
-          connection.authentication.should == {
+          expect(connection.configuration).to eq("https://foobar:4242/dir")
+
+          expect(connection.protocol).to           eq("https://")
+          expect(connection.server).to             eq("foobar")
+          expect(connection.port).to               eq(4242)
+          expect(connection.directory).to          eq("/dir")
+          expect(connection.cypher_path).to        eq("/cyph")
+          expect(connection.gremlin_path).to       eq("/grem")
+          expect(connection.log_file).to           eq("neo.log")
+          expect(connection.log_enabled).to        eq(false)
+          expect(connection.slow_log_threshold).to eq(0)
+          expect(connection.max_threads).to        eq(10)
+          expect(connection.parser).to             eq(Foo)
+
+          expect(connection.authentication).to eq({
             :foo_auth => {
               :username => "bar",
               :password => "baz"
             }
-          }
+          })
         end
 
         context "httpclient" do
@@ -70,7 +70,7 @@ module Neography
           end
 
           it 'configures send/receive timeout' do
-            Excon.should_receive(:new).with("http://localhost:7474", 
+            expect(Excon).to receive(:new).with("http://localhost:7474", 
                                     :read_timeout => 100, 
                                     :write_timeout => 120,
                                     :persistent=>true, 
@@ -87,13 +87,13 @@ module Neography
         let(:options) { "https://user:pass@somehost:8585/path" }
 
         it "accepts a string as configuration" do
-          connection.configuration.should == "https://somehost:8585/path"
-          connection.authentication.should == {
+          expect(connection.configuration).to eq("https://somehost:8585/path")
+          expect(connection.authentication).to eq({
             :basic_auth => {
               :username => "user",
               :password => "pass"
             }
-          }
+          })
         end
       end
 
@@ -102,22 +102,22 @@ module Neography
     context "requests" do
 
       it "does a GET request" do
-        connection.client.should_receive(:request).with(:method => :get, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
+        expect(connection.client).to receive(:request).with(:method => :get, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
         connection.get("/node/bar")
       end
 
       it "does a POST request" do
-        connection.client.should_receive(:request).with(:method => :post, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
+        expect(connection.client).to receive(:request).with(:method => :post, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
         connection.post("/node/bar")
       end
 
       it "does a PUT request" do
-        connection.client.should_receive(:request).with(:method => :put, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
+        expect(connection.client).to receive(:request).with(:method => :put, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
         connection.put("/node/bar")
       end
 
       it "does a DELETE request" do
-        connection.client.should_receive(:request).with(:method => :delete, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
+        expect(connection.client).to receive(:request).with(:method => :delete, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
         connection.delete("/node/bar")
       end
 
@@ -131,12 +131,12 @@ module Neography
         end
 
         it "does requests with authentication" do
-          connection.client.should_not_receive(:set_auth).with(
+          expect(connection.client).not_to receive(:set_auth).with(
             "http://localhost:7474/db/data/node/bar",
              "foo",
              "bar") { double.as_null_object }
 
-          connection.client.should_receive(:request).with(
+          expect(connection.client).to receive(:request).with(
             :method => :get, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
 
           connection.get("/node/bar")
@@ -144,7 +144,7 @@ module Neography
       end
 
       it "adds the User-Agent to the headers" do
-        connection.client.should_receive(:request).with(
+        expect(connection.client).to receive(:request).with(
             hash_including(
                 {:method => :get, :path => "/db/data/node/bar", :body => nil,
                  :headers => {"User-Agent" => "Neography/#{Neography::VERSION}", "X-Stream"=>true, "max-execution-time" => 6000}}
@@ -158,7 +158,7 @@ module Neography
 
         it "raises NodeNotFoundException" do
           response = error_response(code: 404, message: "a message", exception: "NodeNotFoundException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NodeNotFoundException
@@ -166,7 +166,7 @@ module Neography
 
         it "raises OperationFailureException" do
           response = error_response(code: 409, message: "a message", exception: "OperationFailureException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error OperationFailureException
@@ -174,7 +174,7 @@ module Neography
 
         it "raises PropertyValueException" do
           response = error_response(code: 400, message: "a message", exception: "PropertyValueException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error PropertyValueException
@@ -182,7 +182,7 @@ module Neography
 
         it "raises NoSuchPropertyException" do
           response = error_response(code: 404, message: "a message", exception: "NoSuchPropertyException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NoSuchPropertyException
@@ -190,7 +190,7 @@ module Neography
 
         it "raises RelationshipNotFoundException" do
           response = error_response(code: 404, message: "a message", exception: "RelationshipNotFoundException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error RelationshipNotFoundException
@@ -198,7 +198,7 @@ module Neography
 
         it "raises BadInputException" do
           response = error_response(code: 400, message: "a message", exception: "BadInputException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error BadInputException
@@ -206,7 +206,7 @@ module Neography
 
         it "raises UnauthorizedError" do
           response = error_response(code: 401)
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error UnauthorizedError
@@ -214,7 +214,7 @@ module Neography
 
         it "raises NeographyError in all other cases" do
           response = error_response(code: 418, message: "I'm a teapot.")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NeographyError
@@ -222,7 +222,7 @@ module Neography
 
         it "raises BadInputException" do
           response = error_response(code: 500, message: "a message", exception: "JsonParseException")
-          connection.client.stub(:request).and_return(response)
+          allow(connection.client).to receive(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NeographyError
@@ -255,19 +255,19 @@ module Neography
 
           describe "slow_log_threshold" do
             before do
-              connection.stub(:evaluate_response).and_return expected_response
+              allow(connection).to receive(:evaluate_response).and_return expected_response
             end
 
             context "default value" do
               it "should have output" do
-                @logger.should_receive(:info).once
+                expect(@logger).to receive(:info).once
               end
             end
 
             context "high value" do
               before { connection.slow_log_threshold = 100_000 }
               it "should not have output" do
-                @logger.should_not_receive(:info)
+                expect(@logger).not_to receive(:info)
               end
             end