neography 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 019b250080905755da04979dfb0073f6fa7a5794
-  data.tar.gz: 5eae513cb7e9ca6dcfebfda920219217e436b587
+  metadata.gz: ae76679128738baf8ce0f7e770abda5aab5f5391
+  data.tar.gz: e1da52e3ce0cf1f8182cdb5dc109b70ffb084487
 SHA512:
-  metadata.gz: 1a1add73720dec8732b633a70901e2eb9ee68aa3b7bd47d5560d897a87df04b1c1a92c9206067626892db7684c33aefc991c2bb38386c4e56b5da16b3e2f411e
-  data.tar.gz: 1adb3519a08080d05ea3ff43329b46673667df8d840cd98974aec1cbd75e6a3cbbbd81a7aa89c90d19dc6b3a27110ba5fed34811c2aa9c39373c227cd1388d59
+  metadata.gz: 94a8a3375f463c3cf7d036f8d06f82e15971dfc3723cff255701d135d634d42ad31128c3839d58b09defa92723e0563898925f16298ee8fd548abfa19589a3f5
+  data.tar.gz: ca5a8a40e7fca44bd8c478eb3e6f1a6e4254dbdd55737156224a85aad6dd3c712c5a53ca27495d352aacbc1182f0cfb37649abee31048d6f36473fca7d721a6f

data/ChangeLog

@@ -1,3 +1,8 @@
+v1.4.2
+=======
+ee25406 Bump to 1.4.2
+c56574f Add batch_no_streaming method
+
 v1.3.11
 =======
 49e310d  Bump to 1.3.11

data/lib/neography.rb

@@ -1,5 +1,5 @@
 require 'cgi'
-require 'httpclient'
+require 'excon'
 require 'json'
 require 'multi_json'
 require 'logger'

data/lib/neography/config.rb

@@ -7,7 +7,7 @@ module Neography
       :max_threads,
       :authentication, :username, :password,
       :parser, :max_execution_time,
-      :proxy
+      :proxy, :http_send_timeout, :http_receive_timeout
 
     def initialize
       set_defaults
@@ -15,45 +15,49 @@ module Neography
 
     def to_hash
       {
-        :protocol           => @protocol,
-        :server             => @server,
-        :port               => @port,
-        :directory          => @directory,
-        :cypher_path        => @cypher_path,
-        :gremlin_path       => @gremlin_path,
-        :log_file           => @log_file,
-        :log_enabled        => @log_enabled,
-        :logger             => @logger,
-        :slow_log_threshold => @slow_log_threshold,
-        :max_threads        => @max_threads,
-        :authentication     => @authentication,
-        :username           => @username,
-        :password           => @password,
-        :parser             => @parser,
-        :max_execution_time => @max_execution_time,
-        :proxy              => @proxy
+        :protocol              => @protocol,
+        :server                => @server,
+        :port                  => @port,
+        :directory             => @directory,
+        :cypher_path           => @cypher_path,
+        :gremlin_path          => @gremlin_path,
+        :log_file              => @log_file,
+        :log_enabled           => @log_enabled,
+        :logger                => @logger,
+        :slow_log_threshold    => @slow_log_threshold,
+        :max_threads           => @max_threads,
+        :authentication        => @authentication,
+        :username              => @username,
+        :password              => @password,
+        :parser                => @parser,
+        :max_execution_time    => @max_execution_time,
+        :proxy                 => @proxy,
+        :http_send_timeout     => @http_send_timeout,
+        :http_receive_timeout  => @http_receive_timeout
       }
     end
 
     private
 
     def set_defaults
-      @protocol           = "http://"
-      @server             = "localhost"
-      @port               = 7474
-      @directory          = ""
-      @cypher_path        = "/cypher"
-      @gremlin_path       = "/ext/GremlinPlugin/graphdb/execute_script"
-      @log_file           = "neography.log"
-      @log_enabled        = false
-      @slow_log_threshold = 0
-      @max_threads        = 20
-      @authentication     = nil
-      @username           = nil
-      @password           = nil
-      @parser             = MultiJsonParser
-      @max_execution_time = 6000
-      @proxy              = nil
+      @protocol             = "http://"
+      @server               = "localhost"
+      @port                 = 7474
+      @directory            = ""
+      @cypher_path          = "/cypher"
+      @gremlin_path         = "/ext/GremlinPlugin/graphdb/execute_script"
+      @log_file             = "neography.log"
+      @log_enabled          = false
+      @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
       end
 
   end

data/lib/neography/connection.rb

@@ -4,22 +4,25 @@ module Neography
   class Connection
     USER_AGENT = "Neography/#{Neography::VERSION}"
     ACTIONS = ["get", "post", "put", "delete"]
-    
-    attr_accessor :protocol, :server, :port, :directory,
+
+    attr_reader :protocol, :server, :port, :directory,
       :cypher_path, :gremlin_path,
       :log_file, :log_enabled, :logger, :slow_log_threshold,
       :max_threads,
       :authentication, :username, :password,
       :parser, :client,
-      :proxy
+      :proxy, :http_send_timeout, :http_receive_timeout
 
     def initialize(options = ENV['NEO4J_URL'] || {})
       config = merge_configuration(options)
       save_local_configuration(config)
-      @client ||= HTTPClient.new(config[:proxy])
-      @client.send_timeout = 1200 # 10 minutes
-      @client.receive_timeout = 1200
-      authenticate
+      @client ||= Excon.new(config[:proxy] || "#{@protocol}#{@server}:#{@port}", 
+                            :read_timeout => config[:http_receive_timeout],
+                            :write_timeout => config[:http_send_timeout],
+                            :persistent => true,
+                            :user =>  config[:username],
+                            :password => config[:password])
+      #authenticate
     end
 
     def configure(protocol, server, port, directory)
@@ -35,23 +38,39 @@ module Neography
 
     def merge_options(options)
       merged_options = options.merge!(@authentication)
-      merged_options[:headers].merge!(@user_agent) if merged_options[:headers]
-      merged_options[:headers].merge!('X-Stream' => true) if merged_options[:headers]
-      merged_options[:headers].merge!(@max_execution_time) if merged_options[:headers]
+      if merged_options[:headers]
+        merged_options[:headers].merge!(@user_agent)
+        merged_options[:headers].merge!('X-Stream' => true) unless merged_options[:headers].key?('X-Stream')
+        merged_options[:headers].merge!(@max_execution_time)
+      end
       merged_options
     end
 
     ACTIONS.each do |action|
-      define_method(action) do |path, options = {}| 
+      define_method(action) do |path, options = {}|
         # This ugly hack is required because internal Batch paths do not start with "/db/data"
         # if somebody has a cleaner solution... pull request please!
-        path = "/db/data" + path if ["node", "relationship", "transaction", "cypher", "propertykeys", "schema", "label", "labels", "batch", "index", "ext"].include?(path.split("/")[1].split("?").first)
-        query_path = configuration + path
-        query_body = merge_options(options)[:body] 
+        partial_path = path.split("/") 
+        if partial_path.size > 0
+          partial_path = partial_path[1].split("?").first
+        end
+        reserved = ["node", "relationship", "transaction", "cypher", "propertykeys", "schema", "label", "labels", "batch", "index", "ext"]
+        path = "/db/data" + path if reserved.include?(partial_path)
+        query_body = options[:body]
+        stream = ""
+        headers = merge_options(options)[:headers]
         log path, query_body do
-          evaluate_response(@client.send(action.to_sym, query_path, query_body, merge_options(options)[:headers]), path, query_body)    
+          req_params = {:method => action.to_sym, :path => path, :body => query_body, :headers => headers}
+          is_streaming = headers && (headers['X-Stream'] == true)
+          if is_streaming
+            streamer = lambda { |chunk, _, _| stream += chunk }
+            req_params.merge!({:persistent => false, :response_block => streamer,
+                               :read_timeout => 100000000, :write_timeout => 100000000})
+          end
+          response = @client.request(req_params)
+          evaluate_response(response, path, query_body, is_streaming, (partial_path == "batch"), stream)
         end
-      end 
+      end
     end
 
     def log(path, body)
@@ -80,7 +99,7 @@ module Neography
         @client.www_auth.basic_auth.challenge(configuration) if auth_type == 'basic_auth'
       end
     end
-    
+
     private
 
     def merge_configuration(options)
@@ -127,29 +146,31 @@ module Neography
       return_result(code, result)
     end
 
-    def evaluate_response(response, path, query_body)
-      if response.http_header.request_uri.request_uri == "/db/data/batch"
-        code, body, parsed = handle_batch(response)
+    def evaluate_response(response, path, query_body, streaming, batching, stream = nil)
+      code = response.status
+      parsed = false
+      if streaming && batching
+        code, body, parsed = handle_batch(stream)
+      elsif streaming
+        body = (stream || '').force_encoding("UTF-8")
       else
-        code = response.code
         body = response.body.force_encoding("UTF-8")
-        parsed = false
       end
       return_result(response, code, body, parsed, path, query_body)
     end
 
-    def handle_batch(response)
+    def handle_batch(stream)
       code = 200
-      body = @parser.json(response.body.force_encoding("UTF-8"))
+      body = @parser.json(stream.force_encoding("UTF-8"))
       body.each do |result|
         if result["status"] >= 400
-          code = result["status"] 
+          code = result["status"]
           break
         end
       end
       return code, body, true
     end
-    
+
     def return_result(response, code, body, parsed, path, query_body)
       case code
       when 200
@@ -166,7 +187,7 @@ module Neography
       when 400..500
         handle_4xx_500_response(response, code, body, path, query_body)
         nil
-      end      
+      end
     end
 
     def handle_4xx_500_response(response, code, body, path, query_body)
@@ -184,7 +205,7 @@ module Neography
             parsed_body = result["body"] || result
             break
           end
-        end        
+        end
       else
         parsed_body = @parser.json(body)
       end
@@ -195,7 +216,7 @@ module Neography
       @logger.error "#{response.dump} error: #{body}" if @log_enabled
       raise_errors(code, parsed_body["exception"], message, stacktrace, request, index)
     end
-    
+
     def raise_errors(code, exception, message, stacktrace, request, index)
       error = nil
       case code
@@ -215,12 +236,12 @@ module Neography
         when /RelationshipNotFoundException/ ; RelationshipNotFoundException
         when /NotFoundException/             ; NotFoundException
         when /UniquePathNotUniqueException/  ; UniquePathNotUniqueException
-        when /DeadlockDetectedException/     ; DeadlockDetectedException          
+        when /DeadlockDetectedException/     ; DeadlockDetectedException
         else
           NeographyError
       end
-      
-      raise error.new(message, code, stacktrace, request, index)      
+
+      raise error.new(message, code, stacktrace, request, index)
     end
 
     def parse_string_options(options)

data/lib/neography/errors.rb

@@ -51,4 +51,7 @@ module Neography
   # Signals that a deadlock between two or more transactions has been detected
   class DeadlockDetectedException < NeographyError; end
 
+  # Unknown batch option exception detected
+  class UnknownBatchOptionException < NeographyError; end
+
 end

data/lib/neography/rest/batch.rb

@@ -7,25 +7,35 @@ module Neography
         do_batch(*args)
       end
 
+      def batch_no_streaming(*args)
+        do_batch_no_streaming(*args)
+      end
+
       private
 
       def do_batch(*args)
+        @connection.post("/batch", compute_batch_options(*args))
+      end
+
+      def do_batch_no_streaming(*args)
+        options = compute_batch_options(*args)
+        options[:headers].merge!({ 'X-Stream' => false })
+        @connection.post("/batch", options)
+      end
+
+      def compute_batch_options(*args)
         batch = []
         Array(args).each_with_index do |c, i|
           batch << {:id => i }.merge(get_batch(c))
         end
-        options = {
-          :body => batch.to_json,
-          :headers => json_content_type
-        }
-        @connection.post("/batch", options)
+        {:body => batch.to_json, :headers => json_content_type}
       end
 
       def get_batch(args)
         begin
           send("batch_#{args[0]}".to_sym, *args[1..-1])
         rescue
-          raise "Unknown option #{args[0]} - #{args}"
+          raise UnknownBatchOptionException.new("Unknown option #{args[0]} - #{args}")
         end
       end
 

data/lib/neography/rest/node_auto_indexes.rb

@@ -23,7 +23,7 @@ module Neography
       end
 
       def query_node_auto_index(query_expression)
-        @connection.get("/index/auto/node/?query=%{query}" % {:query => query_expression}) || []
+        @connection.get("/index/auto/node/?query=%{query}" % {:query => encode(query_expression)}) || []
       end
 
       def get_node_auto_index_status

data/lib/neography/rest/node_indexes.rb

@@ -1,6 +1,6 @@
 module Neography
   class Rest
-    module NodeIndexes 
+    module NodeIndexes
       include Neography::Rest::Helpers
 
       def list_node_indexes
@@ -117,7 +117,21 @@ module Neography
           :headers => json_content_type
         }
         @connection.post("/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'get_or_create'}, options)
-        
+
+      end
+
+      def create_or_fail_unique_node(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'create_or_fail'}, options)
+
       end
 
     end

data/lib/neography/rest/relationship_indexes.rb

@@ -1,6 +1,6 @@
 module Neography
   class Rest
-    module RelationshipIndexes 
+    module RelationshipIndexes
       include Neography::Rest::Helpers
 
       def list_relationship_indexes
@@ -118,7 +118,21 @@ module Neography
           :headers => json_content_type
         }
         @connection.post("/index/relationship/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'get_or_create'}, options)
-        
+
+      end
+
+      def create_or_fail_unique_relationship(index, key, value, properties = {})
+        options = {
+          :body => (
+            { :properties => properties,
+              :key => key,
+              :value => value
+            }
+          ).to_json,
+          :headers => json_content_type
+        }
+        @connection.post("/index/relationship/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'create_or_fail'}, options)
+
       end
 
     end

data/lib/neography/tasks.rb

@@ -1,13 +1,12 @@
 # borrowed from architect4r
 require 'os'
-require 'httpclient'
 require 'zip'
 require 'net/http'
 
 namespace :neo4j do
   desc "Install Neo4j"
   task :install, :edition, :version do |t, args|
-    args.with_defaults(:edition => "community", :version => "2.0.1")
+    args.with_defaults(:edition => "community", :version => "2.0.3")
     puts "Installing Neo4j-#{args[:edition]}-#{args[:version]}"
     
     if OS::Underlying.windows?

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/neography.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec", ">= 2.11"
   s.add_development_dependency "net-http-spy", "0.2.1"
   s.add_development_dependency "coveralls"
-  s.add_dependency "httpclient", ">= 2.3.3"
+  s.add_dependency "excon", "~> 0.33.0"
   s.add_dependency "json", ">= 1.7.7"
   s.add_dependency "os", ">= 0.9.6"
   s.add_dependency "rubyzip", ">= 1.0.0"

data/spec/integration/rest_batch_no_streaming_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+  
+  describe "no streaming" do
+  
+    it "can send a 1000 item batch" do
+      commands = []
+      1000.times do |x|
+        commands << [:create_node, {"name" => "Max " + x.to_s}]
+      end
+      batch_result = @neo.batch_no_streaming *commands
+      batch_result.first["body"]["data"]["name"].should == "Max 0"
+      batch_result.last["body"]["data"]["name"].should == "Max 999"
+    end
+
+    it "can send a 5000 item batch" do
+      commands = []
+      5000.times do |x|
+        commands << [:get_node, 0]
+      end
+      batch_result = @neo.batch_no_streaming *commands
+      batch_result.first["body"]["self"].split('/').last.should == "0"
+      batch_result.last["body"]["self"].split('/').last.should == "0"
+    end
+
+    it "can send a 20000 item batch" do
+      commands = []
+      20000.times do |x|
+        commands << [:create_node, {"name" => "Max " + x.to_s}]
+      end
+      batch_result = @neo.batch_no_streaming *commands
+      batch_result.first["body"]["data"]["name"].should == "Max 0"
+      batch_result.last["body"]["data"]["name"].should == "Max 19999"
+    end
+  end
+
+end

data/spec/integration/rest_batch_spec.rb

@@ -566,4 +566,18 @@ describe Neography::Rest do
     end
   end
 
+  describe "batch unknown option" do
+    it "should raise Neography::UnknownBatchOptionException when bad option is passed in batch" do
+      batch_commands = []
+
+      batch_commands << [ :bad_option, "start person_n=node:person(ssn = '000-00-0002')
+                                           set bar1 = {foo}"]
+
+      expect {
+        batch_result = @neo.batch *batch_commands
+      }.to raise_exception Neography::UnknownBatchOptionException
+
+    end
+  end
+
 end

data/spec/integration/rest_batch_streaming_spec.rb

@@ -15,7 +15,7 @@ describe Neography::Rest do
       batch_result = @neo.batch *commands
       batch_result.first["body"]["data"]["name"].should == "Max 0"
       batch_result.last["body"]["data"]["name"].should == "Max 999"
-    end  
+    end
 
     it "can send a 5000 item batch" do
       commands = []
@@ -25,8 +25,27 @@ describe Neography::Rest do
       batch_result = @neo.batch *commands
       batch_result.first["body"]["self"].split('/').last.should == "0"
       batch_result.last["body"]["self"].split('/').last.should == "0"
-    end  
+    end
 
-  end
+    it "can send a 7000 get item batch" do
+      commands = []
+      7000.times do |x|
+        commands << [:get_node, 0]
+      end
+      batch_result = @neo.batch *commands
+      batch_result.first["body"]["self"].split('/').last.should == "0"
+      batch_result.last["body"]["self"].split('/').last.should == "0"
+    end
 
+    it "can send a 5000 create item batch" do
+      commands = []
+      5000.times do |x|
+        commands << [:create_node, {"name" => "Max " + x.to_s}]
+      end
+      batch_result = @neo.batch *commands
+      batch_result.first["body"]["data"]["name"].should == "Max 0"
+      batch_result.last["body"]["data"]["name"].should == "Max 4999"
+    end
+
+  end
 end

data/spec/integration/rest_index_spec.rb

@@ -420,7 +420,10 @@ describe Neography::Rest do
     it "can query a node from an automatic index" do
       new_node = @neo.create_node("name" => "Max")
       existing_nodes = @neo.find_node_auto_index("name:Max")
-      existing_nodes.collect{|n| n["self"]}.include?(new_node["self"]).should be_true 
+      existing_nodes.collect{|n| n["self"]}.include?(new_node["self"]).should be_true
+      # check that more complex queries are correctly handled
+      existing_nodes = @neo.find_node_auto_index("name:Max OR name:Max")
+      existing_nodes.collect{|n| n["self"]}.include?(new_node["self"]).should be_true
     end
 
     it "can get a relationship from an automatic index" do

data/spec/spec_helper.rb

@@ -34,7 +34,7 @@ def error_response(attributes)
   
   double(
     http_header: http_header,
-    code: attributes[:code],
+    status: attributes[:code],
     body: {
     message:   attributes[:message],
     exception: attributes[:exception],
@@ -42,4 +42,3 @@ def error_response(attributes)
   }.reject { |k,v| v.nil? }.to_json
   )
 end
-

data/spec/unit/config_spec.rb

@@ -7,44 +7,49 @@ module Neography
 
     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(:logger)             { should == nil }
-      its(:slow_log_threshold) { should == 0 }
-      its(:max_threads)        { should == 20 }
-      its(:authentication)     { should == nil }
-      its(:username)           { should == nil }
-      its(:password)           { should == nil }
-      its(:parser)             { should == MultiJsonParser}
-      its(:max_execution_time) { should == 6000 }
-      its(:proxy)              { should == nil }
+      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(:logger)                { should == nil }
+      its(:slow_log_threshold)    { should == 0 }
+      its(:max_threads)           { should == 20 }
+      its(:authentication)        { should == nil }
+      its(:username)              { should == nil }
+      its(:password)              { should == nil }
+      its(:parser)                { should == MultiJsonParser}
+      its(:max_execution_time)    { should == 6000 }
+      its(:proxy)                 { should == nil }
+      its(:http_send_timeout)     { should == 1200 }
+      its(:http_receive_timeout)  { should == 1200 }
 
 
       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
+          :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
+
         }
         config.to_hash.should == expected_hash
       end

data/spec/unit/connection_spec.rb

@@ -59,8 +59,30 @@ module Neography
             }
           }
         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
+            Excon.should_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" }
 
@@ -80,22 +102,22 @@ module Neography
     context "requests" do
 
       it "does a GET request" do
-        connection.client.should_receive(:get).with("http://localhost:7474/db/data/node/bar", nil, nil) { double.as_null_object }
+        connection.client.should_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
-        connection.client.should_receive(:post).with("http://localhost:7474/db/data/node/bar", nil, nil) { double.as_null_object }
+        connection.client.should_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
-        connection.client.should_receive(:put).with("http://localhost:7474/db/data/node/bar", nil, nil) { double.as_null_object }
+        connection.client.should_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
-        connection.client.should_receive(:delete).with("http://localhost:7474/db/data/node/bar", nil, nil) { double.as_null_object }
+        connection.client.should_receive(:request).with(:method => :delete, :path => "/db/data/node/bar", :body => nil, :headers => nil) { double.as_null_object }
         connection.delete("/node/bar")
       end
 
@@ -114,19 +136,20 @@ module Neography
              "foo",
              "bar") { double.as_null_object }
 
-          connection.client.should_receive(:get).with(
-            "http://localhost:7474/db/data/node/bar", nil, nil
-            ) { double.as_null_object }
+          connection.client.should_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
-        connection.client.should_receive(:get).with(
-          "http://localhost:7474/db/data/node/bar",
-          nil, { "User-Agent" => "Neography/#{Neography::VERSION}", "X-Stream"=>true, "max-execution-time"=>6000}
-          ) { double.as_null_object }
+        connection.client.should_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
@@ -135,7 +158,7 @@ module Neography
 
         it "raises NodeNotFoundException" do
           response = error_response(code: 404, message: "a message", exception: "NodeNotFoundException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NodeNotFoundException
@@ -143,7 +166,7 @@ module Neography
 
         it "raises OperationFailureException" do
           response = error_response(code: 409, message: "a message", exception: "OperationFailureException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error OperationFailureException
@@ -151,7 +174,7 @@ module Neography
 
         it "raises PropertyValueException" do
           response = error_response(code: 400, message: "a message", exception: "PropertyValueException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error PropertyValueException
@@ -159,7 +182,7 @@ module Neography
 
         it "raises NoSuchPropertyException" do
           response = error_response(code: 404, message: "a message", exception: "NoSuchPropertyException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NoSuchPropertyException
@@ -167,7 +190,7 @@ module Neography
 
         it "raises RelationshipNotFoundException" do
           response = error_response(code: 404, message: "a message", exception: "RelationshipNotFoundException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error RelationshipNotFoundException
@@ -175,7 +198,7 @@ module Neography
 
         it "raises BadInputException" do
           response = error_response(code: 400, message: "a message", exception: "BadInputException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error BadInputException
@@ -183,7 +206,7 @@ module Neography
 
         it "raises UnauthorizedError" do
           response = error_response(code: 401)
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error UnauthorizedError
@@ -191,7 +214,7 @@ module Neography
 
         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)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NeographyError
@@ -199,7 +222,7 @@ module Neography
 
         it "raises BadInputException" do
           response = error_response(code: 500, message: "a message", exception: "JsonParseException")
-          connection.client.stub(:get).and_return(response)
+          connection.client.stub(:request).and_return(response)
           expect {
             connection.get("/node/bar")
           }.to raise_error NeographyError
@@ -208,52 +231,54 @@ module Neography
       end
 
       context "query logging" do
-        before do
-          @logger = Logger.new(nil)
-          connection.logger = @logger
-          connection.log_enabled = true
-        end
 
-        let(:expected_response) {"expected_response"}
+        subject(:connection) do
 
-        let(:request_body) { {key1: :val1} }
+          Connection.new({
+            :logger => Logger.new(nil),
+            :log_enabled => true
+          })
+        
+          let(:expected_response) {"expected_response"}
 
-        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
+          let(:request_body) { {key1: :val1} }
 
-        it "should return original response" do
-          connection.stub(:evaluate_response).and_return expected_response
-          connection.get("/node/bar").should eq expected_response
-        end
+          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
 
-        describe "slow_log_threshold" do
-          before do
+          it "should return original response" do
             connection.stub(:evaluate_response).and_return expected_response
+            connection.get("/node/bar").should eq expected_response
           end
 
-          context "default value" do
-            it "should have output" do
-              @logger.should_receive(:info).once
+          describe "slow_log_threshold" do
+            before do
+              connection.stub(:evaluate_response).and_return expected_response
             end
-          end
 
-          context "high value" do
-            before { connection.slow_log_threshold = 100_000 }
-            it "should not have output" do
-              @logger.should_not_receive(:info)
+            context "default value" do
+              it "should have output" do
+                @logger.should_receive(:info).once
+              end
             end
-          end
 
-          after do
-            connection.get("/node/bar", {body: request_body})
+            context "high value" do
+              before { connection.slow_log_threshold = 100_000 }
+              it "should not have output" do
+                @logger.should_not_receive(:info)
+              end
+            end
+
+            after do
+              connection.get("/node/bar", {body: request_body})
+            end
           end
         end
-
       end
     end
   end
 end
 
-class Foo; end
+class Foo; end

data/spec/unit/rest/node_auto_indexes_spec.rb

@@ -24,6 +24,10 @@ module Neography
       it "finds by query if no value passed to #find_or_query" do
         subject.connection.should_receive(:get).with("/index/auto/node/?query=some_query")
         subject.find_node_auto_index("some_query")
+
+        query = "some_query AND another_one"
+        subject.connection.should_receive(:get).with("/index/auto/node/?query=#{URI.encode(query)}")
+        subject.find_node_auto_index(query)
       end
 
       it "finds by key and value" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neography
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Max De Marzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: httpclient
+  name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.3
+        version: 0.33.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.3
+        version: 0.33.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -217,6 +217,7 @@ files:
 - spec/integration/parsing_spec.rb
 - spec/integration/performance_spec.rb
 - spec/integration/relationship_spec.rb
+- spec/integration/rest_batch_no_streaming_spec.rb
 - spec/integration/rest_batch_spec.rb
 - spec/integration/rest_batch_streaming_spec.rb
 - spec/integration/rest_bulk_spec.rb
@@ -303,6 +304,7 @@ test_files:
 - spec/integration/parsing_spec.rb
 - spec/integration/performance_spec.rb
 - spec/integration/relationship_spec.rb
+- spec/integration/rest_batch_no_streaming_spec.rb
 - spec/integration/rest_batch_spec.rb
 - spec/integration/rest_batch_streaming_spec.rb
 - spec/integration/rest_bulk_spec.rb