neography 1.5.0 → 1.5.1

data/spec/unit/node_spec.rb

@@ -8,22 +8,22 @@ module Neography
 
         before do
           @db = double(Neography::Rest, :is_a? => true).as_null_object
-          Rest.stub(:new) { @db }
+          allow(Rest).to receive(:new) { @db }
         end
 
         it "assigns a new Rest db by default" do
           node = Node.create
-          node.neo_server.should == @db
+          expect(node.neo_server).to eq(@db)
         end
 
         it "creates without arguments" do
-          @db.should_receive(:create_node).with(nil)
+          expect(@db).to receive(:create_node).with(nil)
           Node.create
         end
 
         it "creates with only a hash argument" do
           properties = { :foo => "bar" }
-          @db.should_receive(:create_node).with(properties)
+          expect(@db).to receive(:create_node).with(properties)
           Node.create(properties)
         end
 
@@ -34,7 +34,7 @@ module Neography
         it "cannot pass a server as the first argument, properties as the second (deprecated)" do
           @other_server = Neography::Rest.new
           properties = { :foo => "bar" }
-          @other_server.should_not_receive(:create_node).with(properties)
+          expect(@other_server).not_to receive(:create_node).with(properties)
           expect {
             Node.create(@other_server, properties)
           }.to raise_error(ArgumentError)
@@ -43,7 +43,7 @@ module Neography
         it "can pass properties as the first argument, a server as the second" do
           @other_server = Neography::Rest.new
           properties = { :foo => "bar" }
-          @other_server.should_receive(:create_node).with(properties)
+          expect(@other_server).to receive(:create_node).with(properties)
           Node.create(properties, @other_server)
         end
 
@@ -56,22 +56,22 @@ module Neography
         before do
           # stub out actual connections
           @db = double(Rest).as_null_object
-          Rest.stub(:new) { @db }
+          allow(Rest).to receive(:new) { @db }
         end
 
         it "load by id" do
-          @db.should_receive(:get_node).with(5)
+          expect(@db).to receive(:get_node).with(5)
           Node.load(5)
         end
 
         it "loads by node" do
           node = Node.new
-          @db.should_not_receive(:get_node).with(node)
+          expect(@db).not_to receive(:get_node).with(node)
           Node.load(node)
         end
 
         it "loads by full server string" do
-          @db.should_receive(:get_node).with("http://localhost:7474/db/data/node/2")
+          expect(@db).to receive(:get_node).with("http://localhost:7474/db/data/node/2")
           Node.load("http://localhost:7474/db/data/node/2")
         end
 
@@ -81,7 +81,7 @@ module Neography
 
         it "cannot pass a server as the first argument, node as the second (depracted)" do
           @other_server = Neography::Rest.new
-          @other_server.should_not_receive(:get_node).with(42)
+          expect(@other_server).not_to receive(:get_node).with(42)
           expect {
             node = Node.load(@other_server, 42)
           }.to raise_error(ArgumentError)
@@ -89,7 +89,7 @@ module Neography
 
         it "can pass a node as the first argument, server as the second" do
           @other_server = Neography::Rest.new
-          @other_server.should_receive(:get_node).with(42)
+          expect(@other_server).to receive(:get_node).with(42)
           node = Node.load(42, @other_server)
         end
 

data/spec/unit/properties_spec.rb

@@ -5,68 +5,213 @@ module Neography
 
     before do
       @db = double(Neography::Rest, :is_a? => true).as_null_object
-      Rest.stub(:new) { @db }
+      allow(Rest).to receive(:new) { @db }
     end
 
     context "Node" do
 
       subject(:node) do
         node = Node.create
-        node.stub(:neo_id => 42)
+        allow(node).to receive(:neo_id).and_return(42)
         node
       end
 
       it "sets properties as accessor" do
-        @db.should_receive(:"set_node_properties").with(42, { "key" => "value" })
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value" })
         node.key = "value"
       end
 
       it "sets properties as array entry" do
-        @db.should_receive(:"set_node_properties").with(42, { "key" => "value" })
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value" })
         node["key"] = "value"
       end
 
       it "gets properties as accessor" do
-        @db.stub(:"set_node_properties")
+        allow(@db).to receive(:"set_node_properties")
         node.key = "value"
-        node.key.should == "value"
+        expect(node.key).to eq("value")
       end
 
       it "gets properties as array entry" do
-        @db.stub(:"set_node_properties")
+        allow(@db).to receive(:"set_node_properties")
         node["key"] = "value"
-        node["key"].should == "value"
+        expect(node["key"]).to eq("value")
       end
 
       it "resets properties as accessor" do
-        @db.should_receive(:"remove_node_properties").with(42, ["key"])
+        expect(@db).to receive(:"remove_node_properties").with(42, ["key"])
         node.key = "value"
         node.key = nil
       end
 
       it "resets properties as array entry" do
-        @db.should_receive(:"remove_node_properties").with(42, ["key"])
+        expect(@db).to receive(:"remove_node_properties").with(42, ["key"])
         node["key"] = "value"
         node["key"] = nil
       end
 
       it "gets unknown properties as nil" do
-        node.unknown.should == nil
+        expect(node.unknown).to eq(nil)
       end
 
       it "overwrites existing properties" do
-        @db.should_receive(:"set_node_properties").with(42, { "key" => "value1" })
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value1" })
         node.key = "value1"
 
-        @db.should_receive(:"set_node_properties").with(42, { "key" => "value2" })
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value2" })
         node.key = "value2"
       end
 
       it "knows its attributes" do
-        @db.stub(:"set_node_properties")
+        allow(@db).to receive(:"set_node_properties")
         node.key = "value"
         node["key2"] = "value"
-        node.attributes.should =~ [ :key, :key2 ]
+        expect(node.attributes).to match_array([ :key, :key2 ])
+      end
+
+      describe "resets all node properties with one http request" do
+        before(:each) do
+          @change_node = Node.create
+
+          # A property that we will overwrite
+          @change_node[:old_key] = 'value'
+
+          # Stub neo id
+          allow(@change_node).to receive(:neo_id).and_return(22)
+
+          # What we call set_properties with
+          @new_data = { new_key: "new value"}
+
+          # Make sure the request is dispatched to the rest layer
+          expect(@db).to receive(:reset_node_properties).with(22, @new_data)
+        end
+
+        it "removes the old property getter" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node.respond_to?(:old_key)}.from(true).to(false)
+        end
+
+        it "removes the old property setter" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node.respond_to?('old_key=')}.from(true).to(false)
+        end
+
+        it "removes the property from the underlying openstruct" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node['old_key']}.from('value').to(nil)
+        end
+
+        it "adds the new property getter" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node.respond_to?(:new_key)}.from(false).to(true)
+        end
+
+        it "adds the new property setter" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node.respond_to?('new_key=')}.from(false).to(true)
+        end
+
+        it "adds the new property to the underlying openstruct" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node['new_key']}.from(nil).to('new value')
+        end
+
+        it "updates its attributes" do
+          expect{
+            @change_node.reset_properties(@new_data)
+          }.to change{@change_node.attributes}.from([:old_key]).to([:new_key])
+        end
+      end
+
+
+      describe "sets all node properties with one http request" do
+        before(:each) do
+          @change_node = Node.create
+
+          # A property that we will overwrite
+          @change_node[:old_key] = 'value'
+
+          # A property that we will not overwrite and that must stay
+          @change_node[:old_remaining_key] = 'remaining value'
+
+          # Stub neo id
+          allow(@change_node).to receive(:neo_id).and_return(22)
+
+          # What we call set_properties with
+          @new_data = { "new_key" => "new value", 'old_key' => nil }
+
+          # What we expect neography to send as the new properties
+          update_data = { new_key: 'new value', old_remaining_key: 'remaining value'}
+
+          # Make sure the request is dispatched to the rest layer
+          expect(@db).to receive(:reset_node_properties).with(22, update_data)
+        end
+
+        it "removes the old property getter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node.respond_to?(:old_key)}.from(true).to(false)
+        end
+
+        it "removes the old property setter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node.respond_to?('old_key=')}.from(true).to(false)
+        end
+
+        it "removes the property from the underlying openstruct" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node['old_key']}.from('value').to(nil)
+        end
+
+        it "doesn't touch the remaining property in the openstruct" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to_not change{@change_node['old_remaining_key']}
+        end
+
+        it "doesn't touch the remaining property getter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to_not change{@change_node.respond_to?(:old_remaining_key)}
+        end
+
+        it "doesn't touch the remaining property setter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to_not change{@change_node.respond_to?('old_remaining_key=')}
+        end
+
+        it "adds the new property getter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node.respond_to?(:new_key)}.from(false).to(true)
+        end
+
+        it "adds the new property setter" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node.respond_to?('new_key=')}.from(false).to(true)
+        end
+
+        it "adds the new property to the underlying openstruct" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node['new_key']}.from(nil).to('new value')
+        end
+
+        it "updates its attributes" do
+          expect{
+            @change_node.set_properties(@new_data)
+          }.to change{@change_node.attributes}.from([:old_key, :old_remaining_key]).to([:old_remaining_key, :new_key])
+        end
       end
 
     end
@@ -78,61 +223,61 @@ module Neography
         to = Node.create
 
         rel = Relationship.create(:type, from, to)
-        rel.stub(:neo_id => 42)
+        allow(rel).to receive(:neo_id).and_return(42)
         rel
       end
 
       it "sets properties as accessor" do
-        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value" })
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value" })
         relationship.key = "value"
       end
 
       it "sets properties as array entry" do
-        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value" })
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value" })
         relationship["key"] = "value"
       end
 
       it "gets properties as accessor" do
-        @db.stub(:"set_relationship_properties")
+        allow(@db).to receive(:"set_relationship_properties")
         relationship.key = "value"
-        relationship.key.should == "value"
+        expect(relationship.key).to eq("value")
       end
 
       it "gets properties as array entry" do
-        @db.stub(:"set_relationship_properties")
+        allow(@db).to receive(:"set_relationship_properties")
         relationship["key"] = "value"
-        relationship["key"].should == "value"
+        expect(relationship["key"]).to eq("value")
       end
 
       it "resets properties as accessor" do
-        @db.should_receive(:"remove_relationship_properties").with(42, ["key"])
+        expect(@db).to receive(:"remove_relationship_properties").with(42, ["key"])
         relationship.key = "value"
         relationship.key = nil
       end
 
       it "resets properties as array entry" do
-        @db.should_receive(:"remove_relationship_properties").with(42, ["key"])
+        expect(@db).to receive(:"remove_relationship_properties").with(42, ["key"])
         relationship["key"] = "value"
         relationship["key"] = nil
       end
 
       it "gets unknown properties as nil" do
-        relationship.unknown.should == nil
+        expect(relationship.unknown).to eq(nil)
       end
 
       it "overwrites existing properties" do
-        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value1" })
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value1" })
         relationship.key = "value1"
 
-        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value2" })
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value2" })
         relationship.key = "value2"
       end
 
       it "knows its attributes" do
-        @db.stub(:"set_relationship_properties")
+        allow(@db).to receive(:"set_relationship_properties")
         relationship.key = "value"
         relationship["key2"] = "value"
-        relationship.attributes.should =~ [ :key, :key2 ]
+        expect(relationship.attributes).to match_array([ :key, :key2 ])
       end
 
     end

data/spec/unit/relationship_spec.rb

@@ -19,19 +19,19 @@ module Neography
 
     describe "::create" do
       it "creates a new node through Rest" do
-        db.should_receive(:create_relationship).with("type", from, to, props)
+        expect(db).to receive(:create_relationship).with("type", from, to, props)
 
         Relationship.create("type", from, to, props)
       end
 
       it "assigns fields" do
-        db.stub(:create_relationship).and_return(relationship_hash)
+        allow(db).to receive(:create_relationship).and_return(relationship_hash)
 
         rel = Relationship.create("type", from, to, props)
 
-        rel.start_node.should == from
-        rel.end_node.should   == to
-        rel.rel_type.should   == "type"
+        expect(rel.start_node).to eq(from)
+        expect(rel.end_node).to   eq(to)
+        expect(rel.rel_type).to   eq("type")
       end
     end
 
@@ -41,22 +41,22 @@ module Neography
         before do
           # stub out actual connections
           @db = double(Rest).as_null_object
-          Rest.stub(:new) { @db }
+          allow(Rest).to receive(:new) { @db }
         end
 
         it "load by id" do
-          @db.should_receive(:get_relationship).with(5)
+          expect(@db).to receive(:get_relationship).with(5)
           Relationship.load(5)
         end
 
         it "loads by relationship" do
           relationship = Relationship.new(relationship_hash)
-          @db.should_receive(:get_relationship).with(relationship)
+          expect(@db).to receive(:get_relationship).with(relationship)
           Relationship.load(relationship)
         end
 
         it "loads by full server string" do
-          @db.should_receive(:get_relationship).with("http://localhost:7474/db/data/relationship/2")
+          expect(@db).to receive(:get_relationship).with("http://localhost:7474/db/data/relationship/2")
           Relationship.load("http://localhost:7474/db/data/relationship/2")
         end
 
@@ -66,7 +66,7 @@ module Neography
 
         it "cannot pass a server as the first argument, relationship as the second" do
           @other_server = Neography::Rest.new
-          @other_server.should_not_receive(:get_relationship).with(42)
+          expect(@other_server).not_to receive(:get_relationship).with(42)
           expect {
             relationship = Relationship.load(@other_server, 42)
           }.to raise_error(ArgumentError)
@@ -74,7 +74,7 @@ module Neography
 
         it "can pass a relationship as the first argument, server as the second" do
           @other_server = Neography::Rest.new
-          @other_server.should_receive(:get_relationship).with(42)
+          expect(@other_server).to receive(:get_relationship).with(42)
           relationship = Relationship.load(42, @other_server)
         end
 
@@ -84,13 +84,13 @@ module Neography
     describe "#del" do
 
       before do
-        db.stub(:create_relationship) { relationship_hash }
+        allow(db).to receive(:create_relationship) { relationship_hash }
       end
 
       subject(:relationship) { Relationship.create("type", from, to, props) }
 
       it "deletes a node" do
-        db.should_receive(:delete_relationship).with("0")
+        expect(db).to receive(:delete_relationship).with("0")
         relationship.del
       end
 
@@ -99,17 +99,17 @@ module Neography
     describe "#other_node" do
 
       before do
-        db.stub(:create_relationship) { relationship_hash }
+        allow(db).to receive(:create_relationship) { relationship_hash }
       end
 
       subject(:relationship) { Relationship.create("type", from, to, props) }
 
       it "knows the other node based on from" do
-        relationship.other_node(from).should == to
+        expect(relationship.other_node(from)).to eq(to)
       end
 
       it "knows the other node based on to" do
-        relationship.other_node(to).should == from
+        expect(relationship.other_node(to)).to eq(from)
       end
 
     end