neography-calamitates 1.2.3.1

data/spec/unit/config_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Neography
+  describe Config do
+
+    subject(:config) { Config.new }
+
+    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(:max_threads)    { should == 20 }
+      its(:authentication) { should == nil }
+      its(:username)       { should == nil }
+      its(:password)       { should == nil }
+      its(:parser)         { should == MultiJsonParser}
+
+      it "has a hash representation" do
+        expected_hash = {
+          :protocol       => 'http://',
+          :server         => 'localhost',
+          :port           => 7474,
+          :directory      => '',
+          :cypher_path    => '/cypher',
+          :gremlin_path   => '/ext/GremlinPlugin/graphdb/execute_script',
+          :log_file       => 'neography.log',
+          :log_enabled    => false,
+          :max_threads    => 20,
+          :authentication => nil,
+          :username       => nil,
+          :password       => nil,
+          :parser         => MultiJsonParser
+        }
+        config.to_hash.should == expected_hash
+      end
+
+    end
+
+  end
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+module Neography
+  describe Connection do
+
+    subject(:connection) { Connection.new }
+
+    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
+        connection.client.should_receive(:get).with("http://localhost:7474/db/data/foo/bar", nil, nil) { double.as_null_object }
+        connection.get("/foo/bar")
+      end
+
+      it "does a POST request" do
+        connection.client.should_receive(:post).with("http://localhost:7474/db/data/foo/bar", nil, nil) { double.as_null_object }
+        connection.post("/foo/bar")
+      end
+
+      it "does a PUT request" do
+        connection.client.should_receive(:put).with("http://localhost:7474/db/data/foo/bar", nil, nil) { double.as_null_object }
+        connection.put("/foo/bar")
+      end
+
+      it "does a DELETE request" do
+        connection.client.should_receive(:delete).with("http://localhost:7474/db/data/foo/bar", nil, nil) { double.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
+          connection.client.should_receive(:set_auth).with(
+            "http://localhost:7474/db/data/foo/bar",
+             "foo",
+             "bar") { double.as_null_object }
+
+          connection.client.should_receive(:get).with(
+            "http://localhost:7474/db/data/foo/bar", nil, nil
+            ) { double.as_null_object }
+
+          connection.get("/foo/bar")
+        end
+      end
+
+      it "adds the User-Agent to the headers" do
+        connection.client.should_receive(:get).with(
+          "http://localhost:7474/db/data/foo/bar",
+          nil, { "User-Agent" => "Neography/#{Neography::VERSION}", "X-Stream"=>true}
+          ) { double.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")
+          connection.client.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")
+          connection.client.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")
+          connection.client.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")
+          connection.client.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")
+          connection.client.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")
+          connection.client.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error BadInputException
+        end
+
+        it "raises UnauthorizedError" do
+          response = error_response(code: 401)
+          connection.client.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.")
+          connection.client.stub(:get).and_return(response)
+          expect {
+            connection.get("/foo/bar")
+          }.to raise_error NeographyError
+        end
+
+        it "raises BadInputException" do
+          response = error_response(code: 500, message: "a message", exception: "JsonParseException")
+          connection.client.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 = double(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 = double(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_not_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,140 @@
+require 'spec_helper'
+
+module Neography
+  describe "Properties" do
+
+    before do
+      @db = double(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 = "value"
+        node.key = nil
+      end
+
+      it "resets properties as array entry" do
+        @db.should_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
+      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 = "value"
+        relationship.key = nil
+      end
+
+      it "resets properties as array entry" do
+        @db.should_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
+      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