neography-down 1.6.4

data/spec/integration/unmanaged_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  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')
+      expect(results).not_to be_null
+    end
+    
+    it "can call a POST based unmanaged extension" do 
+      results = @neo.post_extention('/movie/recommend', {"title" => "Rambo"})
+      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)    
+      expect(results).not_to be_null
+    end
+
+  end
+
+end

data/spec/matchers.rb

@@ -0,0 +1,33 @@
+# Convenience matcher for matching JSON fields with a hash
+RSpec::Matchers.define :json_match do |field, expected|
+
+  match do |actual|
+    expected == JSON.parse(actual[field])
+  end
+
+  failure_message do
+    "expected JSON in field '#{field}' to match '#{expected}'"
+  end
+
+  description do
+    "JSON in field '#{field}' should match '#{expected.inspect}'"
+  end
+
+end
+
+# Convenience matcher for matching fields in a hash
+RSpec::Matchers.define :hash_match do |field, expected|
+
+  match do |actual|
+    expected == actual[field]
+  end
+
+  failure_message do
+    "expected field '#{field}' to match '#{expected}'"
+  end
+
+  description do
+    "field '#{field}' should match '#{expected.inspect}'"
+  end
+
+end

data/spec/neography_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Neography do
+
+  describe "::configure" do
+
+    it "returns the same configuration" do
+      expect(Neography.configuration).to eq(Neography.configuration)
+    end
+
+    it "returns the Config" do
+      expect(Neography.configuration).to be_a Neography::Config
+    end
+
+    it "yields the configuration" do
+      Neography.configure do |config|
+        expect(config).to eq(Neography.configuration)
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'neography'
+require 'benchmark'
+require 'matchers'
+require 'coveralls'
+Coveralls.wear!
+
+# If you want to see more, uncomment the next few lines
+# require 'net-http-spy'
+# Net::HTTP.http_logger_options = {:body => true}    # just the body
+# Net::HTTP.http_logger_options = {:verbose => true} # see everything
+
+def generate_text(length=8)
+  chars = 'abcdefghjkmnpqrstuvwxyz'
+  key = ''
+  length.times { |i| key << chars[rand(chars.length)] }
+  key
+end
+
+RSpec.configure do |c|
+  c.filter_run_excluding :slow => true, :gremlin => true, :reference => true, :neo_is_broken => true, :unmanaged_extensions => true
+end
+
+
+def json_content_type
+  {"Content-Type"=>"application/json"}
+end
+
+def error_response(attributes)
+  request_uri = double()
+  allow(request_uri).to receive(:request_uri).and_return("")
+  
+  http_header = double()
+  allow(http_header).to receive(:request_uri).and_return(request_uri)
+  
+  double(
+    http_header: http_header,
+    status: attributes[:code],
+    body: {
+    message:   attributes[:message],
+    exception: attributes[:exception],
+    stacktrace: attributes[:stacktrace]
+  }.reject { |k,v| v.nil? }.to_json
+  )
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+module Neography
+  describe Config do
+
+    subject(:config) { Config.new }
+
+    context "defaults" do
+
+      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
+        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,
+          :logger               => nil,
+          :slow_log_threshold   => 0,
+          :max_threads          => 20,
+          :authentication       => nil,
+          :username             => nil,
+          :password             => nil,
+          :parser               => MultiJsonParser,
+          :max_execution_time   => 6000,
+          :proxy                => nil,
+          :http_send_timeout    => 1200,
+          :http_receive_timeout => 1200
+
+        }
+        expect(config.to_hash).to eq(expected_hash)
+      end
+
+    end
+
+  end
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+
+module Neography
+  describe Connection do
+
+    subject(:connection) { Connection.new }
+
+    context "defaults" do
+
+      it "intializes with defaults" do
+        expect(connection.configuration).to eq("http://localhost:7474")
+      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,
+            :slow_log_threshold => 0,
+            :max_threads        => 10,
+            :parser             => Foo,
+            :authentication     => "foo",
+            :username           => "bar",
+            :password           => "baz"
+          }
+        end
+
+        it "accepts all options in a hash" do
+          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
+          let(:httpclient) { double(:http_client) }
+          let(:options) do
+            {
+              :http_send_timeout     => 120,
+              :http_receive_timeout  => 100
+            }
+          end
+
+          it 'configures send/receive timeout' do
+            expect(Excon).to receive(:new).with("http://localhost:7474", 
+                                    :read_timeout => 100, 
+                                    :write_timeout => 120,
+                                    :persistent=>true, 
+                                    :user=>nil, 
+                                    :password=>nil).and_return(httpclient)
+            connection
+          end
+        end
+      end
+
+
+
+      context "string option" do
+        let(:options) { "https://user:pass@somehost:8585/path" }
+
+        it "accepts a string as configuration" do
+          expect(connection.configuration).to eq("https://somehost:8585/path")
+          expect(connection.authentication).to eq({
+            :basic_auth => {
+              :username => "user",
+              :password => "pass"
+            }
+          })
+        end
+      end
+
+    end
+
+    context "requests" do
+
+      it "does a GET request" do
+        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
+        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
+        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
+        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
+
+      context "authentication" do
+        subject(:connection) do
+          Connection.new({
+            :authentication => "basic",
+            :username       => "foo",
+            :password       => "bar"
+          })
+        end
+
+        it "does requests with authentication" do
+          expect(connection.client).not_to receive(:set_auth).with(
+            "http://localhost:7474/db/data/node/bar",
+             "foo",
+             "bar") { 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
+      end
+
+      it "adds the User-Agent to the headers" do
+        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}}
+            )
+        ) { double.as_null_object }
+
+        connection.get("/node/bar", :headers => {})
+      end
+
+      context "errors" do
+
+        it "raises NodeNotFoundException" do
+          response = error_response(code: 404, message: "a message", exception: "NodeNotFoundException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error NodeNotFoundException
+        end
+
+        it "raises OperationFailureException" do
+          response = error_response(code: 409, message: "a message", exception: "OperationFailureException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error OperationFailureException
+        end
+
+        it "raises PropertyValueException" do
+          response = error_response(code: 400, message: "a message", exception: "PropertyValueException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error PropertyValueException
+        end
+
+        it "raises NoSuchPropertyException" do
+          response = error_response(code: 404, message: "a message", exception: "NoSuchPropertyException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error NoSuchPropertyException
+        end
+
+        it "raises RelationshipNotFoundException" do
+          response = error_response(code: 404, message: "a message", exception: "RelationshipNotFoundException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error RelationshipNotFoundException
+        end
+
+        it "raises BadInputException" do
+          response = error_response(code: 400, message: "a message", exception: "BadInputException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error BadInputException
+        end
+
+        it "raises UnauthorizedError" do
+          response = error_response(code: 401)
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error UnauthorizedError
+        end
+
+        it "raises NeographyError in all other cases" do
+          response = error_response(code: 418, message: "I'm a teapot.")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error NeographyError
+        end
+
+        it "raises BadInputException" do
+          response = error_response(code: 500, message: "a message", exception: "JsonParseException")
+          allow(connection.client).to receive(:request).and_return(response)
+          expect {
+            connection.get("/node/bar")
+          }.to raise_error NeographyError
+        end
+
+      end
+
+      context "query logging" do
+
+        subject(:connection) do
+
+          Connection.new({
+            :logger => Logger.new(nil),
+            :log_enabled => true
+          })
+        
+          let(:expected_response) {"expected_response"}
+
+          let(:request_body) { {key1: :val1} }
+
+          it "should log query" do
+            connection.should_receive(:log).with("/db/data/node/bar", request_body).once
+            connection.get("/node/bar", {body: request_body})
+          end
+
+          it "should return original response" do
+            connection.stub(:evaluate_response).and_return expected_response
+            connection.get("/node/bar").should eq expected_response
+          end
+
+          describe "slow_log_threshold" do
+            before do
+              allow(connection).to receive(:evaluate_response).and_return expected_response
+            end
+
+            context "default value" do
+              it "should have output" do
+                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
+                expect(@logger).not_to receive(:info)
+              end
+            end
+
+            after do
+              connection.get("/node/bar", {body: request_body})
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class Foo; end