neography-down 1.6.4

data/spec/unit/node_spec.rb

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

data/spec/unit/properties_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+module Neography
+  describe "Properties" do
+
+    before do
+      @db = double(Neography::Rest, :is_a? => true).as_null_object
+      allow(Rest).to receive(:new) { @db }
+    end
+
+    context "Node" do
+
+      subject(:node) do
+        node = Node.create
+        allow(node).to receive(:neo_id).and_return(42)
+        node
+      end
+
+      it "sets properties as accessor" do
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value" })
+        node.key = "value"
+      end
+
+      it "sets properties as array entry" do
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value" })
+        node["key"] = "value"
+      end
+
+      it "gets properties as accessor" do
+        allow(@db).to receive(:"set_node_properties")
+        node.key = "value"
+        expect(node.key).to eq("value")
+      end
+
+      it "gets properties as array entry" do
+        allow(@db).to receive(:"set_node_properties")
+        node["key"] = "value"
+        expect(node["key"]).to eq("value")
+      end
+
+      it "resets properties as accessor" do
+        expect(@db).to receive(:"remove_node_properties").with(42, ["key"])
+        node.key = "value"
+        node.key = nil
+      end
+
+      it "resets properties as array entry" do
+        expect(@db).to receive(:"remove_node_properties").with(42, ["key"])
+        node["key"] = "value"
+        node["key"] = nil
+      end
+
+      it "gets unknown properties as nil" do
+        expect(node.unknown).to eq(nil)
+      end
+
+      it "overwrites existing properties" do
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value1" })
+        node.key = "value1"
+
+        expect(@db).to receive(:"set_node_properties").with(42, { "key" => "value2" })
+        node.key = "value2"
+      end
+
+      it "knows its attributes" do
+        allow(@db).to receive(:"set_node_properties")
+        node.key = "value"
+        node["key2"] = "value"
+        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
+
+    context "Relationship" do
+
+      subject(:relationship) do
+        from = Node.create
+        to = Node.create
+
+        rel = Relationship.create(:type, from, to)
+        allow(rel).to receive(:neo_id).and_return(42)
+        rel
+      end
+
+      it "sets properties as accessor" do
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value" })
+        relationship.key = "value"
+      end
+
+      it "sets properties as array entry" do
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value" })
+        relationship["key"] = "value"
+      end
+
+      it "gets properties as accessor" do
+        allow(@db).to receive(:"set_relationship_properties")
+        relationship.key = "value"
+        expect(relationship.key).to eq("value")
+      end
+
+      it "gets properties as array entry" do
+        allow(@db).to receive(:"set_relationship_properties")
+        relationship["key"] = "value"
+        expect(relationship["key"]).to eq("value")
+      end
+
+      it "resets properties as accessor" do
+        expect(@db).to receive(:"remove_relationship_properties").with(42, ["key"])
+        relationship.key = "value"
+        relationship.key = nil
+      end
+
+      it "resets properties as array entry" do
+        expect(@db).to receive(:"remove_relationship_properties").with(42, ["key"])
+        relationship["key"] = "value"
+        relationship["key"] = nil
+      end
+
+      it "gets unknown properties as nil" do
+        expect(relationship.unknown).to eq(nil)
+      end
+
+      it "overwrites existing properties" do
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value1" })
+        relationship.key = "value1"
+
+        expect(@db).to receive(:"set_relationship_properties").with(42, { "key" => "value2" })
+        relationship.key = "value2"
+      end
+
+      it "knows its attributes" do
+        allow(@db).to receive(:"set_relationship_properties")
+        relationship.key = "value"
+        relationship["key2"] = "value"
+        expect(relationship.attributes).to match_array([ :key, :key2 ])
+      end
+
+    end
+  end
+end

data/spec/unit/relationship_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Neography
+  describe Relationship do
+
+    let(:db) { double(Rest).as_null_object }
+    let(:relationship_hash) do
+      {
+        "self" => "0",
+        "start" => "1",
+        "end" => "2",
+        "data" => {}
+      }
+    end
+
+    let(:from)  { double(:neo_server => db) }
+    let(:to)    { double(:neo_server => db) }
+    let(:props) { { :foo => "bar" } }
+
+    describe "::create" do
+      it "creates a new node through Rest" do
+        expect(db).to receive(:create_relationship).with("type", from, to, props)
+
+        Relationship.create("type", from, to, props)
+      end
+
+      it "assigns fields" do
+        allow(db).to receive(:create_relationship).and_return(relationship_hash)
+
+        rel = Relationship.create("type", from, to, props)
+
+        expect(rel.start_node).to eq(from)
+        expect(rel.end_node).to   eq(to)
+        expect(rel.rel_type).to   eq("type")
+      end
+    end
+
+    describe "::load" do
+      context "no explicit server" do
+
+        before do
+          # stub out actual connections
+          @db = double(Rest).as_null_object
+          allow(Rest).to receive(:new) { @db }
+        end
+
+        it "load by id" do
+          expect(@db).to receive(:get_relationship).with(5)
+          Relationship.load(5)
+        end
+
+        it "loads by relationship" do
+          relationship = Relationship.new(relationship_hash)
+          expect(@db).to receive(:get_relationship).with(relationship)
+          Relationship.load(relationship)
+        end
+
+        it "loads by full server string" do
+          expect(@db).to receive(:get_relationship).with("http://localhost:7474/db/data/relationship/2")
+          Relationship.load("http://localhost:7474/db/data/relationship/2")
+        end
+
+      end
+
+      context "explicit server" do
+
+        it "cannot pass a server as the first argument, relationship as the second" do
+          @other_server = Neography::Rest.new
+          expect(@other_server).not_to receive(:get_relationship).with(42)
+          expect {
+            relationship = Relationship.load(@other_server, 42)
+          }.to raise_error(ArgumentError)
+        end
+
+        it "can pass a relationship as the first argument, server as the second" do
+          @other_server = Neography::Rest.new
+          expect(@other_server).to receive(:get_relationship).with(42)
+          relationship = Relationship.load(42, @other_server)
+        end
+
+      end
+    end
+
+    describe "#del" do
+
+      before do
+        allow(db).to receive(:create_relationship) { relationship_hash }
+      end
+
+      subject(:relationship) { Relationship.create("type", from, to, props) }
+
+      it "deletes a node" do
+        expect(db).to receive(:delete_relationship).with("0")
+        relationship.del
+      end
+
+    end
+
+    describe "#other_node" do
+
+      before do
+        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
+        expect(relationship.other_node(from)).to eq(to)
+      end
+
+      it "knows the other node based on to" do
+        expect(relationship.other_node(to)).to eq(from)
+      end
+
+    end
+
+  end
+end