couchrest 1.2.1 → 2.0.0.beta1

data/lib/couchrest/rest_api.rb

@@ -1,165 +1,64 @@
 module CouchRest
 
-  # CouchRest RestAPI
-  #
-  # The basic low-level interface for all REST requests to the database. Everything must pass
-  # through here before it is sent to the server.
-  #
-  # Six types of REST requests are supported: get, put, post, delete, copy and head.
-  #
-  # Requests that do not have a payload, get, delete and copy, accept the URI and options parameters,
-  # where as put and post both expect a document as the second parameter.
-  #
-  # The API will try to intelegently split the options between the JSON parser and RestClient API.
-  #
-  # The following options will be recognised as header options and automatically added
-  # to the header hash:
-  #
-  # * :content_type, type of content to be sent, especially useful when sending files as this will set the file type. The default is :json.
-  # * :accept, the content type to accept in the response. This should pretty much always be :json.
-  #
-  # The following request options are supported:
   #
-  # * :method override the requested method (should not be used!).
-  # * :url override the URL used in the request.
-  # * :payload override the document or data sent in the message body (only PUT or POST).
-  # * :headers any additional headers (overrides :content_type and :accept)
-  # * :timeout and :open_timeout the time in miliseconds to wait for the request, see RestClient API for more details.
-  # * :verify_ssl, :ssl_client_cert, :ssl_client_key, and :ssl_ca_file, SSL handling methods.
-  #
-  #
-  # Any other remaining options will be sent to the MultiJSON backend except for the :raw option.
-  #
-  # When :raw is true in PUT and POST requests, no attempt will be made to convert the document payload to JSON. This is
-  # not normally necessary as IO and Tempfile objects will not be parsed anyway. The result of the request will
-  # *always* be parsed.
+  # CouchRest RestAPI
   #
-  # For all other requests, mainly GET, the :raw option will make no attempt to parse the result. This
-  # is useful for receiving files from the database.
+  # Backwards compatible wrapper for instantiating a connection and performing
+  # a request on demand. Useful for quick requests, but not recommended for general
+  # usage due the extra overhead of establishing a connection.
   #
 
   module RestAPI
 
     # Send a GET request.
-    def get(uri, options = {})
-      execute(uri, :get, options)
+    def get(url, options = {})
+      connection(url, options) do |uri, conn|
+        conn.get(uri.request_uri, options)
+      end
     end
 
     # Send a PUT request.
-    def put(uri, doc = nil, options = {})
-      execute(uri, :put, options, doc)
+    def put(url, doc = nil, options = {})
+      connection(url, options) do |uri, conn|
+        conn.put(uri.request_uri, doc, options)
+      end
     end
 
     # Send a POST request.
-    def post(uri, doc = nil, options = {})
-      execute(uri, :post, options, doc)
+    def post(url, doc = nil, options = {})
+      connection(url, options) do |uri, conn|
+        conn.post(uri.request_uri, doc, options)
+      end
     end
 
     # Send a DELETE request.
-    def delete(uri, options = {})
-      execute(uri, :delete, options)
-    end
-
-    # Send a COPY request to the URI provided.
-    def copy(uri, destination, options = {})
-      opts = options.nil? ? {} : options.dup
-      # also copy headers!
-      opts[:headers] = options[:headers].nil? ? {} : options[:headers].dup
-      opts[:headers]['Destination'] = destination
-      execute(uri, :copy, opts)
-    end
-
-    # Send a HEAD request.
-    def head(uri, options = {})
-      execute(uri, :head, options)
-    end
-
-    # The default RestClient headers used in each request.
-    def default_headers
-      {
-        :content_type => :json,
-        :accept       => :json
-      }
-    end
-
-    private
-
-    # Perform the RestClient request by removing the parse specific options, ensuring the
-    # payload is prepared, and sending the request ready to parse the response.
-    def execute(url, method, options = {}, payload = nil)
-      request, parser = prepare_and_split_options(url, method, options)
-      # Prepare the payload if it is provided
-      request[:payload] = payload_from_doc(payload, parser) if payload
-      begin
-        parse_response(RestClient::Request.execute(request), parser)
-      rescue Exception => e
-        if $DEBUG
-          raise "Error while sending a #{method.to_s.upcase} request #{uri}\noptions: #{opts.inspect}\n#{e}"
-        else
-          raise e
-        end
+    def delete(url, options = {})
+      connection(url, options) do |uri, conn|
+        conn.delete(uri.request_uri, options)
       end
     end
 
-    # Prepare two hashes, one for the request to the REST backend and a second
-    # for the JSON parser.
-    #
-    # Returns an array of request and parser options.
-    #
-    def prepare_and_split_options(url, method, options)
-      request = {
-        :url => url,
-        :method => method,
-        :headers => default_headers.merge(options[:headers] || {})
-      }
-      parser = {
-        :raw => false,
-        :head => (method == :head)
-      }
-      # Split the options
-      (options || {}).each do |k,v|
-        k = k.to_sym
-        next if k == :headers # already dealt with
-        if restclient_option_keys.include?(k)
-          request[k] = v
-        elsif header_option_keys.include?(k)
-          request[:headers][k] = v
-        else
-          parser[k] = v
-        end
+    # Send a COPY request to the URI provided.
+    def copy(url, destination, options = {})
+      connection(url, options) do |uri, conn|
+        conn.copy(uri.request_uri, destination, options)
       end
-      [request, parser]
     end
 
-    # Check if the provided doc is nil or special IO device or temp file. If not,
-    # encode it into a string.
-    #
-    # The options supported are:
-    # * :raw TrueClass, if true the payload will not be altered.
-    #
-    def payload_from_doc(doc, opts = {})
-      if (opts.delete(:raw) || doc.nil? || doc.is_a?(IO) || doc.is_a?(Tempfile))
-        doc
-      else
-        MultiJson.encode(doc.respond_to?(:as_couch_json) ? doc.as_couch_json : doc)
+    # Send a HEAD request.
+    def head(url, options = {})
+      connection(url, options) do |uri, conn|
+        conn.head(uri.request_uri, options)
       end
     end
 
-    # Parse the response provided.
-    def parse_response(result, opts = {})
-      opts = opts.update(:create_additions => true) if decode_json_objects
-      (opts.delete(:raw) || opts.delete(:head)) ? result : MultiJson.decode(result, opts.update(:max_nesting => false))
-    end
-
-    # An array of all the options that should be passed through to restclient.
-    # Anything not in this list will be passed to the JSON parser.
-    def restclient_option_keys
-      [:method, :url, :payload, :headers, :timeout, :open_timeout,
-        :verify_ssl, :ssl_client_cert, :ssl_client_key, :ssl_ca_file]
-    end
+    protected
 
-    def header_option_keys
-      [ :content_type, :accept ]
+    def connection(url, options)
+      uri = URI url
+      conn = CouchRest::Connection.new(uri, options)
+      res = yield uri, conn
+      res
     end
 
   end

data/lib/couchrest/server.rb

@@ -1,53 +1,31 @@
 module CouchRest
   class Server
 
-    attr_accessor :uri, :uuid_batch_count, :available_databases
+    # URI object of the link to the server we're using.
+    attr_reader :uri
+    
+    # Number of UUIDs to fetch from the server when preparing to save new
+    # documents. Set to 1000 by default.
+    attr_reader :uuid_batch_count
+
+    # Accessor for the current internal array of UUIDs ready to be used when
+    # saving new documents. See also #next_uuid.
+    attr_reader :uuids
 
     def initialize(server = 'http://127.0.0.1:5984', uuid_batch_count = 1000)
-      @uri = server
+      @uri = prepare_uri(server).freeze
       @uuid_batch_count = uuid_batch_count
     end
 
-    # Lists all "available" databases.
-    # An available database, is a database that was specified
-    # as avaiable by your code.
-    # It allows to define common databases to use and reuse in your code
-    def available_databases
-      @available_databases ||= {}
-    end
-
-    # Adds a new available database and create it unless it already exists
-    #
-    # Example:
-    #
-    # @couch = CouchRest::Server.new
-    # @couch.define_available_database(:default, "tech-blog")
-    #
-    def define_available_database(reference, db_name, create_unless_exists = true)
-      available_databases[reference.to_sym] = create_unless_exists ? database!(db_name) : database(db_name)
-    end
-
-    # Checks that a database is set as available
-    #
-    # Example:
-    #
-    # @couch.available_database?(:default)
-    #
-    def available_database?(ref_or_name)
-      ref_or_name.is_a?(Symbol) ? available_databases.keys.include?(ref_or_name) : available_databases.values.map{|db| db.name}.include?(ref_or_name)
-    end
-
-    def default_database=(name, create_unless_exists = true)
-      define_available_database(:default, name, create_unless_exists = true)
-    end
-
-    def default_database
-      available_databases[:default]
+    # Lazy load the connection for the current thread
+    def connection
+      conns = (Thread.current['couchrest.connections'] ||= {})
+      conns[uri.to_s] ||= Connection.new(uri)
     end
 
     # Lists all databases on the server
     def databases
-      CouchRest.get "#{@uri}/_all_dbs"
+      connection.get "_all_dbs"
     end
 
     # Returns a CouchRest::Database for the given name
@@ -57,35 +35,44 @@ module CouchRest
 
     # Creates the database if it doesn't exist
     def database!(name)
-      CouchRest.head "#{@uri}/#{name}" # Check if the URL is valid
+      connection.head name # Check if the URL is valid
       database(name)
-    rescue RestClient::ResourceNotFound # Thrown if the HTTP HEAD fails
+    rescue CouchRest::NotFound # Thrown if the HTTP HEAD fails
       create_db(name)
     end
 
     # GET the welcome message
     def info
-      CouchRest.get "#{@uri}/"
+      connection.get ""
     end
 
     # Create a database
     def create_db(name)
-      CouchRest.put "#{@uri}/#{name}"
+      connection.put name
       database(name)
     end
 
     # Restart the CouchDB instance
     def restart!
-      CouchRest.post "#{@uri}/_restart"
+      connection.post "_restart"
     end
 
     # Retrive an unused UUID from CouchDB. Server instances manage caching a list of unused UUIDs.
     def next_uuid(count = @uuid_batch_count)
-      @uuids ||= []
-      if @uuids.empty?
-        @uuids = CouchRest.get("#{@uri}/_uuids?count=#{count}")["uuids"]
+      if uuids.nil? || uuids.empty?
+        @uuids = connection.get("_uuids?count=#{count}")["uuids"]
       end
-      @uuids.pop
+      uuids.pop
+    end
+
+    protected
+
+    def prepare_uri(url)
+      uri = URI(url)
+      uri.path     = ""
+      uri.query    = nil
+      uri.fragment = nil
+      uri
     end
 
   end

data/spec/couchrest/connection_spec.rb

@@ -0,0 +1,415 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CouchRest::Connection do
+
+  let(:simple_response) { "{\"ok\":true}" }
+  let(:parser) { MultiJson }
+  let(:parser_opts) { {:max_nesting => false} }
+
+  it "should exist" do
+    conn = CouchRest::Connection.new(URI "http://localhost:5984")
+    expect(conn).to respond_to :get
+    expect(conn).to respond_to :put
+    expect(conn).to respond_to :post
+    expect(conn).to respond_to :copy
+    expect(conn).to respond_to :delete
+    expect(conn).to respond_to :head
+  end
+
+  describe "initialization" do
+
+    it "should not modify the provided URI" do
+      uri = URI("http://localhost:5984/path/random?query=none#fragment")
+      s = uri.to_s
+      CouchRest::Connection.new(uri)
+      expect(uri.to_s).to eql(s)
+    end
+
+    it "should raise an error if not instantiated with a URI" do
+      expect { CouchRest::Connection.new("http://localhost:5984") }.to raise_error(/URI::HTTP/)
+    end
+
+    it "should clean the provided URI" do
+      conn = CouchRest::Connection.new(URI "http://localhost:5984/path/random?query=none#fragment")
+      expect(conn.uri.to_s).to eql("http://localhost:5984")
+    end
+
+    it "should have instantiated an HTTP connection" do
+      conn = CouchRest::Connection.new(URI "http://localhost:5984")
+      expect(conn.http).to be_a(HTTPClient)
+    end
+
+    it "should use the proxy if defined in parameters" do
+      conn = CouchRest::Connection.new(URI("http://localhost:5984"), :proxy => 'http://proxy')
+      expect(conn.http.proxy.to_s).to eql('http://proxy')
+    end
+
+    it "should use the proxy if defined in class" do
+      CouchRest::Connection.proxy = 'http://proxy'
+      conn = CouchRest::Connection.new(URI "http://localhost:5984")
+      expect(conn.http.proxy.to_s).to eql('http://proxy')
+      CouchRest::Connection.proxy = nil
+
+    end
+
+    it "should allow default proxy to be overwritten" do
+      CouchRest::Connection.proxy = 'http://proxy'
+      conn = CouchRest::Connection.new(URI("http://localhost:5984"), :proxy => 'http://proxy2')
+      expect(conn.http.proxy.to_s).to eql('http://proxy2')
+      CouchRest::Connection.proxy = nil
+    end
+    
+    describe "with SSL options" do
+      it "should leave the default if nothing set" do
+        default = HTTPClient.new.ssl_config.verify_mode
+        conn = CouchRest::Connection.new(URI "https://localhost:5984")
+        expect(conn.http.ssl_config.verify_mode).to eql(default)
+      end
+      it "should support disabling SSL verify mode" do
+        conn = CouchRest::Connection.new(URI("https://localhost:5984"), :verify_ssl => false)
+        expect(conn.http.ssl_config.verify_mode).to eql(OpenSSL::SSL::VERIFY_NONE)
+      end
+      it "should support enabling SSL verify mode" do
+        conn = CouchRest::Connection.new(URI("https://localhost:5984"), :verify_ssl => true)
+        expect(conn.http.ssl_config.verify_mode).to eql(OpenSSL::SSL::VERIFY_PEER)
+      end
+      it "should support setting specific cert, key, and ca" do
+        conn = CouchRest::Connection.new(URI("https://localhost:5984"),
+          :ssl_client_cert => 'cert',
+          :ssl_client_key  => 'key',
+        )
+        expect(conn.http.ssl_config.client_cert).to eql('cert')
+        expect(conn.http.ssl_config.client_key).to eql('key')
+      end
+
+    end
+
+    describe "with timeout options" do
+      it "should be set on the http object" do
+        conn = CouchRest::Connection.new(URI("https://localhost:5984"),
+                                         :timeout => 23,
+                                         :open_timeout => 26,
+                                         :read_timeout => 27
+                                        )
+
+        expect(conn.http.receive_timeout).to eql(23)
+        expect(conn.http.connect_timeout).to eql(26)
+        expect(conn.http.send_timeout).to eql(27)
+      end
+
+    end
+  end
+
+  describe "basic requests" do
+
+    let :doc do
+      { '_id' => 'test-doc', 'name' => 'test document' }
+    end
+    let :uri do
+      URI(DB.to_s + "/test-doc")
+    end
+    let :conn do
+      CouchRest::Connection.new(uri)
+    end
+    let :mock_conn do
+      CouchRest::Connection.new(URI "http://mock")
+    end
+
+    describe :get do
+
+      it "should send basic request" do
+        DB.save_doc(doc)
+        res = conn.get(uri.path)
+        expect(res['name']).to eql(doc['name'])
+      end
+
+      it "should raise exception if document missing" do
+        uri = URI(DB.to_s + "/missingdoc")
+        conn = CouchRest::Connection.new(uri)
+        res = nil
+        expect { res = conn.get(uri.path) }.to raise_error do |e|
+          expect(e).to be_a(CouchRest::RequestFailed)
+          expect(e).to be_a(CouchRest::NotFound)
+          expect(e.response).to eql(res)
+        end
+      end
+
+      it "should handle 'content_type' header" do
+        stub_request(:get, "http://mock/db/test")
+          .with(:headers => {'content-type' => 'fooo'})
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :content_type => 'fooo')
+      end
+
+      it "should handle 'accept' header" do
+        stub_request(:get, "http://mock/db/test")
+          .with(:headers => {'accept' => 'fooo'})
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :accept => 'fooo')
+      end
+
+      it "should not overwrite 'Content-Type' header if provided" do
+        stub_request(:get, "http://mock/db/test")
+          .with(:headers => {'Content-Type' => 'fooo'})
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :headers => { 'Content-Type' => 'fooo' })
+      end
+
+      it "should not overwrite 'Accept' header if provided in headers" do
+        stub_request(:get, "http://mock/db/test")
+          .with(:headers => {'Accept' => 'fooo'})
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :headers => { 'Accept' => 'fooo' })
+      end
+
+      it "should convert 'Content-Type' header options" do
+        stub_request(:get, "http://mock/db/test")
+          .with(:headers => {'Content-Type' => 'application/json'})
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :content_type => :json)
+      end
+
+      it "should maintain query parameters" do
+        stub_request(:get, "http://mock/db/test?q=a")
+          .to_return(:body => doc.to_json)
+        expect(mock_conn.get("db/test?q=a")).to eql(doc)
+      end
+
+      it "should not try to parse result with :raw parameter" do
+        json = doc.to_json
+        stub_request(:get, "http://mock/db/test")
+          .to_return(:body => json)
+        expect(mock_conn.get("db/test", :raw => true)).to eql(json)
+      end
+
+      it "should forward parser options" do
+        expect(MultiJson).to receive(:load).with(doc.to_json, hash_including(:max_nesting => true))
+        stub_request(:get, "http://mock/db/test")
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :max_nesting => true)
+      end
+
+      it "should forward parser options (2)" do
+        expect(MultiJson).to receive(:load).with(doc.to_json, hash_including(:quirks_mode => true))
+        stub_request(:get, "http://mock/db/test")
+          .to_return(:body => doc.to_json)
+        mock_conn.get("db/test", :quirks_mode => true)
+      end
+
+      context 'when decode_json_objects is true' do
+        class TestObject
+          def self.json_create(args)
+            new
+          end
+        end
+
+        before(:all) do
+          CouchRest.decode_json_objects = true
+          CouchRest.put "#{COUCHHOST}/#{TESTDB}/test", JSON.create_id => TestObject.to_s
+        end
+
+        after(:all) do
+          CouchRest.decode_json_objects = false
+        end
+
+        it 'should return the response as a Ruby object' do
+          conn = CouchRest::Connection.new(URI(COUCHHOST))
+          expect(conn.get("#{TESTDB}/test").class).to eql(TestObject)
+        end
+      end
+
+      context 'when decode_json_objects is false (the default)' do
+        class TestObject2
+          def self.json_create(args)
+            new
+          end
+        end
+
+        before(:all) do
+          CouchRest.decode_json_objects = false
+          CouchRest.put "#{COUCHHOST}/#{TESTDB}/test2", JSON.create_id => TestObject.to_s
+        end
+
+        it 'should not return the response as a Ruby object' do
+          conn = CouchRest::Connection.new(URI(COUCHHOST))
+          expect(conn.get("#{TESTDB}/test2").class).to eql(Hash)
+        end
+      end
+
+      describe "with block" do
+
+        let :sample_data do
+          <<-EOF
+            {
+              "total_rows": 3, "offset": 0, "rows": [
+                {"id": "doc1", "key": "doc1", "value": {"rev":"4324BB"}},
+                {"id": "doc2", "key": "doc2", "value": {"rev":"2441HF"}},
+                {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+              ]
+            }
+          EOF
+        end
+
+        it "should handle basic streaming request" do
+          stub_request(:get, "http://mock/db/test")
+            .to_return(:body => sample_data)
+          rows = []
+          head = mock_conn.get("db/test") do |row|
+            rows << row
+          end
+          expect(rows.length).to eql(3)
+          expect(head['total_rows']).to eql(3)
+          expect(rows.first['id']).to eql('doc1')
+        end
+
+      end
+
+    end
+
+    describe :put do
+
+      let :put_doc do
+        { '_id' => 'test-put-doc', 'name' => 'test put document' }
+      end
+
+      it "should put a document to the database" do
+        conn.put("#{TESTDB}/test-put-doc", put_doc)
+        res = conn.get("#{TESTDB}/test-put-doc")
+        expect(res['name']).to eql put_doc['name']
+        expect(res['_rev']).to_not be_nil
+      end
+
+      it "should convert hash into json data" do
+        stub_request(:put, "http://mock/db/test-put")
+          .with(:body => put_doc.to_json)
+          .to_return(:body => simple_response)
+        mock_conn.put("db/test-put", put_doc)
+      end
+
+      it "should send raw data" do
+        stub_request(:put, "http://mock/db/test-put")
+          .with(:body => 'raw')
+          .to_return(:body => simple_response)
+        mock_conn.put("db/test-put", 'raw', :raw => true)
+      end
+
+      it "should handle nil doc" do
+        stub_request(:put, "http://mock/db/test-put-nil")
+          .with(:body => '')
+          .to_return(:body => simple_response)
+        mock_conn.put("db/test-put-nil", nil)
+      end
+
+      it "should send data file and detect file type" do
+        f = File.open(FIXTURE_PATH + '/attachments/test.html')
+        stub_request(:put, "http://mock/db/test-put.html")
+          .with(:body => f.read, :headers => { 'Content-Type' => 'text/html' })
+          .to_return(:body => simple_response)
+        f.rewind
+        mock_conn.put("db/test-put.html", f)
+      end
+
+      it "should send tempfile and detect file type" do
+        f = Tempfile.new('test.png')
+        stub_request(:put, "http://mock/db/test-put-image.png")
+          .with(:body => f.read, :headers => { 'Content-Type' => 'image/png' })
+          .to_return(:body => simple_response)
+        f.rewind
+        mock_conn.put("db/test-put-image.png", f)
+      end
+
+      it "should send StringIO and detect file type" do
+        f = StringIO.new('this is a test file')
+        stub_request(:put, "http://mock/db/test-put-text.txt")
+          .with(:body => f.read, :headers => { 'Content-Type' => 'text/plain' })
+          .to_return(:body => simple_response)
+        f.rewind
+        mock_conn.put("db/test-put-text.txt", f)
+      end
+
+      it "should use as_couch_json method if available" do
+        doc = CouchRest::Document.new(put_doc)
+        expect(doc).to receive(:as_couch_json).and_return(put_doc)
+        stub_request(:put, "http://mock/db/test-put")
+          .to_return(:body => simple_response)
+        mock_conn.put('db/test-put', doc)
+      end
+
+    end
+
+    describe :post do
+
+      let :post_doc do
+        { '_id' => 'test-post-doc', 'name' => 'test post document' }
+      end
+
+      it "should put a document to the database" do
+        conn.put("#{TESTDB}/test-post-doc", post_doc)
+        res = conn.get("#{TESTDB}/test-post-doc")
+        expect(res['name']).to eql post_doc['name']
+        expect(res['_rev']).to_not be_nil
+      end
+
+      describe "with block" do
+
+        let :sample_data do
+          <<-EOF
+            {
+              "total_rows": 3, "offset": 0, "rows": [
+                {"id": "doc1", "key": "doc1", "value": {"rev":"4324BB"}},
+                {"id": "doc2", "key": "doc2", "value": {"rev":"2441HF"}},
+                {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+              ]
+            }
+          EOF
+        end
+
+        it "should handle basic streaming request" do
+          stub_request(:post, "http://mock/db/test")
+            .to_return(:body => sample_data)
+          rows = []
+          head = mock_conn.post("db/test") do |row|
+            rows << row
+          end
+          expect(rows.length).to eql(3)
+          expect(head['total_rows']).to eql(3)
+          expect(rows.first['id']).to eql('doc1')
+        end
+
+      end
+
+    end
+
+    describe :delete do
+      it "should delete a doc" do
+        stub_request(:delete, "http://mock/db/test-delete")
+          .to_return(:body => simple_response)
+        expect(mock_conn.delete('db/test-delete')).to eql('ok' => true)
+      end
+    end
+
+    describe :copy do
+      it "should copy a doc" do
+        stub_request(:copy, "http://mock/db/test-copy")
+          .with(:headers => { 'Destination' => "test-copy-dest" })
+          .to_return(:body => simple_response)
+        expect(mock_conn.copy('db/test-copy', 'test-copy-dest')).to eql('ok' => true)
+      end
+    end
+
+    describe :head do
+      it "should send head request" do
+        stub_request(:head, "http://mock/db/test-head")
+          .to_return(:body => "")
+        expect { mock_conn.head('db/test-head') }.to_not raise_error
+      end
+      it "should handle head request when document missing" do
+        stub_request(:head, "http://mock/db/test-missing-head")
+          .to_return(:status => 404)
+        expect { mock_conn.head('db/test-missing-head') }.to raise_error(CouchRest::NotFound)
+      end
+    end
+
+  end
+
+end