neography 0.0.31 → 1.0.0

data/spec/unit/connection_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module Neography
+  describe Connection do
+
+    subject(:connection)
+
+    context "defaults" do
+
+      it "intializes with defaults" do
+        connection.configuration.should == "http://localhost:7474/db/data"
+      end
+
+    end
+
+    context "custom options" do
+
+      subject(:connection) { Connection.new(options) }
+
+      context "hash options" do
+        let(:options) do
+          {
+            :protocol       => "https://",
+            :server         => "foobar",
+            :port           => 4242,
+            :directory      => "/dir",
+            :cypher_path    => "/cyph",
+            :gremlin_path   => "/grem",
+            :log_file       => "neo.log",
+            :log_enabled    => false,
+            :max_threads    => 10,
+            :parser         => Foo,
+            :authentication => "foo",
+            :username       => "bar",
+            :password       => "baz"
+          }
+        end
+
+        it "accepts all options in a hash" do
+          connection.configuration.should == "https://foobar:4242/dir/db/data"
+
+          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.max_threads.should  == 10
+          connection.parser.should       == Foo
+
+          connection.authentication.should == {
+            :foo_auth => {
+              :username => "bar",
+              :password => "baz"
+            }
+          }
+        end
+      end
+
+      context "string option" do
+        let(:options) { "https://user:pass@somehost:8585/path" }
+
+        it "accepts a string as configuration" do
+          connection.configuration.should == "https://somehost:8585/path/db/data"
+          connection.authentication.should == {
+            :basic_auth => {
+              :username => "user",
+              :password => "pass"
+            }
+          }
+        end
+      end
+
+    end
+
+    context "requests" do
+
+      it "does a GET request" do
+        HTTParty.should_receive(:get).with("http://localhost:7474/db/data/foo/bar", { :parser => MultiJsonParser }) { stub.as_null_object }
+        connection.get("/foo/bar")
+      end
+
+      it "does a POST request" do
+        HTTParty.should_receive(:post).with("http://localhost:7474/db/data/foo/bar", { :parser => MultiJsonParser }) { stub.as_null_object }
+        connection.post("/foo/bar")
+      end
+
+      it "does a PUT request" do
+        HTTParty.should_receive(:put).with("http://localhost:7474/db/data/foo/bar", { :parser => MultiJsonParser }) { stub.as_null_object }
+        connection.put("/foo/bar")
+      end
+
+      it "does a DELETE request" do
+        HTTParty.should_receive(:delete).with("http://localhost:7474/db/data/foo/bar", { :parser => MultiJsonParser }) { stub.as_null_object }
+        connection.delete("/foo/bar")
+      end
+
+      context "authentication" do
+        subject(:connection) do
+          Connection.new({
+            :authentication => "basic",
+            :username       => "foo",
+            :password       => "bar"
+          })
+        end
+
+        it "does requests with authentication" do
+          HTTParty.should_receive(:get).with(
+            "http://localhost:7474/db/data/foo/bar",
+            { :parser => MultiJsonParser,
+              :basic_auth => {
+                :username => "foo",
+                :password => "bar"
+              }
+            }) { stub.as_null_object }
+
+          connection.get("/foo/bar")
+        end
+      end
+
+      it "adds the User-Agent to the headers" do
+        HTTParty.should_receive(:get).with(
+          "http://localhost:7474/db/data/foo/bar",
+          { :parser => MultiJsonParser,
+            :headers => { "User-Agent" => "Neography/#{Neography::VERSION}" }
+          }) { stub.as_null_object }
+
+        connection.get("/foo/bar", :headers => {})
+      end
+
+      context "errors" do
+
+        it "raises NodeNotFoundException" do
+          response = error_response(code: 404, message: "a message", exception: "NodeNotFoundException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error NodeNotFoundException
+        end
+
+        it "raises OperationFailureException" do
+          response = error_response(code: 409, message: "a message", exception: "OperationFailureException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error OperationFailureException
+        end
+
+        it "raises PropertyValueException" do
+          response = error_response(code: 400, message: "a message", exception: "PropertyValueException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error PropertyValueException
+        end
+
+        it "raises NoSuchPropertyException" do
+          response = error_response(code: 404, message: "a message", exception: "NoSuchPropertyException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error NoSuchPropertyException
+        end
+
+        it "raises RelationshipNotFoundException" do
+          response = error_response(code: 404, message: "a message", exception: "RelationshipNotFoundException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error RelationshipNotFoundException
+        end
+
+        it "raises BadInputException" do
+          response = error_response(code: 400, message: "a message", exception: "BadInputException")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error BadInputException
+        end
+
+        it "raises UnauthorizedError" do
+          response = error_response(code: 401)
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error UnauthorizedError
+        end
+
+        it "raises NeographyError in all other cases" do
+          response = error_response(code: 418, message: "I'm a teapot.")
+          HTTParty.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error NeographyError
+        end
+
+      end
+
+    end
+  end
+end
+
+class Foo; end

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 = mock(Neography::Rest, :is_a? => true).as_null_object
+          Rest.stub(:new) { @db }
+        end
+
+        it "assigns a new Rest db by default" do
+          node = Node.create
+          node.neo_server.should == @db
+        end
+
+        it "creates without arguments" do
+          @db.should_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)
+          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" }
+          @other_server.should_not_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" }
+          @other_server.should_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 = stub(Rest).as_null_object
+          Rest.stub(:new) { @db }
+        end
+
+        it "load by id" do
+          @db.should_receive(:get_node).with(5)
+          Node.load(5)
+        end
+
+        it "loads by node" do
+          node = Node.new
+          @db.should_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")
+          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
+          @other_server.should_not_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
+          @other_server.should_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,136 @@
+require 'spec_helper'
+
+module Neography
+  describe "Properties" do
+
+    before do
+      @db = mock(Neography::Rest, :is_a? => true).as_null_object
+      Rest.stub(:new) { @db }
+    end
+
+    context "Node" do
+
+      subject(:node) do
+        node = Node.create
+        node.stub(:neo_id => 42)
+        node
+      end
+
+      it "sets properties as accessor" do
+        @db.should_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" })
+        node["key"] = "value"
+      end
+
+      it "gets properties as accessor" do
+        @db.stub(:"set_node_properties")
+        node.key = "value"
+        node.key.should == "value"
+      end
+
+      it "gets properties as array entry" do
+        @db.stub(:"set_node_properties")
+        node["key"] = "value"
+        node["key"].should == "value"
+      end
+
+      it "resets properties as accessor" do
+        @db.should_receive(:"remove_node_properties").with(42, ["key"])
+        node.key = nil
+      end
+
+      it "resets properties as array entry" do
+        @db.should_receive(:"remove_node_properties").with(42, ["key"])
+        node["key"] = nil
+      end
+
+      it "gets unknown properties as nil" do
+        node.unknown.should == nil
+      end
+
+      it "overwrites existing properties" do
+        @db.should_receive(:"set_node_properties").with(42, { "key" => "value1" })
+        node.key = "value1"
+
+        @db.should_receive(:"set_node_properties").with(42, { "key" => "value2" })
+        node.key = "value2"
+      end
+
+      it "knows its attributes" do
+        @db.stub(:"set_node_properties")
+        node.key = "value"
+        node["key2"] = "value"
+        node.attributes.should =~ [ :key, :key2 ]
+      end
+
+    end
+
+    context "Relationship" do
+
+      subject(:relationship) do
+        from = Node.create
+        to = Node.create
+
+        rel = Relationship.create(:type, from, to)
+        rel.stub(:neo_id => 42)
+        rel
+      end
+
+      it "sets properties as accessor" do
+        @db.should_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" })
+        relationship["key"] = "value"
+      end
+
+      it "gets properties as accessor" do
+        @db.stub(:"set_relationship_properties")
+        relationship.key = "value"
+        relationship.key.should == "value"
+      end
+
+      it "gets properties as array entry" do
+        @db.stub(:"set_relationship_properties")
+        relationship["key"] = "value"
+        relationship["key"].should == "value"
+      end
+
+      it "resets properties as accessor" do
+        @db.should_receive(:"remove_relationship_properties").with(42, ["key"])
+        relationship.key = nil
+      end
+
+      it "resets properties as array entry" do
+        @db.should_receive(:"remove_relationship_properties").with(42, ["key"])
+        relationship["key"] = nil
+      end
+
+      it "gets unknown properties as nil" do
+        relationship.unknown.should == nil
+      end
+
+      it "overwrites existing properties" do
+        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value1" })
+        relationship.key = "value1"
+
+        @db.should_receive(:"set_relationship_properties").with(42, { "key" => "value2" })
+        relationship.key = "value2"
+      end
+
+      it "knows its attributes" do
+        @db.stub(:"set_relationship_properties")
+        relationship.key = "value"
+        relationship["key2"] = "value"
+        relationship.attributes.should =~ [ :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) { stub(Rest).as_null_object }
+    let(:relationship_hash) do
+      {
+        "self" => "0",
+        "start" => "1",
+        "end" => "2",
+        "data" => {}
+      }
+    end
+
+    let(:from)  { stub(:neo_server => db) }
+    let(:to)    { stub(:neo_server => db) }
+    let(:props) { { :foo => "bar" } }
+
+    describe "::create" do
+      it "creates a new node through Rest" do
+        db.should_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)
+
+        rel = Relationship.create("type", from, to, props)
+
+        rel.start_node.should == from
+        rel.end_node.should   == to
+        rel.rel_type.should   == "type"
+      end
+    end
+
+    describe "::load" do
+      context "no explicit server" do
+
+        before do
+          # stub out actual connections
+          @db = stub(Rest).as_null_object
+          Rest.stub(:new) { @db }
+        end
+
+        it "load by id" do
+          @db.should_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)
+          Relationship.load(relationship)
+        end
+
+        it "loads by full server string" do
+          @db.should_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
+          @other_server.should_not_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
+          @other_server.should_receive(:get_relationship).with(42)
+          relationship = Relationship.load(42, @other_server)
+        end
+
+      end
+    end
+
+    describe "#del" do
+
+      before do
+        db.stub(: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")
+        relationship.del
+      end
+
+    end
+
+    describe "#other_node" do
+
+      before do
+        db.stub(: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
+      end
+
+      it "knows the other node based on to" do
+        relationship.other_node(to).should == from
+      end
+
+    end
+
+  end
+end