jgre-couchrest 0.12.6

data/lib/couchrest/core/server.rb

@@ -0,0 +1,51 @@
+module CouchRest
+  class Server
+    attr_accessor :uri, :uuid_batch_count
+    def initialize server = 'http://127.0.0.1:5984', uuid_batch_count = 1000
+      @uri = server
+      @uuid_batch_count = uuid_batch_count
+    end
+  
+    # List all databases on the server
+    def databases
+      CouchRest.get "#{@uri}/_all_dbs"
+    end
+  
+    # Returns a CouchRest::Database for the given name
+    def database name
+      CouchRest::Database.new(self, name)
+    end
+  
+    # Creates the database if it doesn't exist
+    def database! name
+      create_db(name) rescue nil
+      database name
+    end
+  
+    # GET the welcome message
+    def info
+      CouchRest.get "#{@uri}/"
+    end
+
+    # Create a database
+    def create_db name
+      CouchRest.put "#{@uri}/#{name}"
+      database name
+    end
+
+    # Restart the CouchDB instance
+    def restart!
+      CouchRest.post "#{@uri}/_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.post("#{@uri}/_uuids?count=#{count}")["uuids"]
+      end
+      @uuids.pop
+    end
+
+  end
+end

data/lib/couchrest/core/view.rb

@@ -0,0 +1,4 @@
+module CouchRest
+  class View
+  end
+end

data/lib/couchrest/helper/pager.rb

@@ -0,0 +1,103 @@
+module CouchRest
+  class Pager
+    attr_accessor :db
+    def initialize db
+      @db = db
+    end
+    
+    def all_docs(limit=100, &block)
+      startkey = nil
+      oldend = nil
+      
+      while docrows = request_all_docs(limit+1, startkey)        
+        startkey = docrows.last['key']
+        docrows.pop if docrows.length > limit
+        if oldend == startkey
+          break
+        end
+        yield(docrows)
+        oldend = startkey
+      end
+    end
+    
+    def key_reduce(view, limit=2000, firstkey = nil, lastkey = nil, &block)
+      # start with no keys
+      startkey = firstkey
+      # lastprocessedkey = nil
+      keepgoing = true
+      
+      while keepgoing && viewrows = request_view(view, limit, startkey)
+        startkey = viewrows.first['key']
+        endkey = viewrows.last['key']
+
+        if (startkey == endkey)
+          # we need to rerequest to get a bigger page
+          # so we know we have all the rows for that key
+          viewrows = @db.view(view, :key => startkey)['rows']
+          # we need to do an offset thing to find the next startkey
+          # otherwise we just get stuck
+          lastdocid = viewrows.last['id']
+          fornextloop = @db.view(view, :startkey => startkey, :startkey_docid => lastdocid, :limit => 2)['rows']
+
+          newendkey = fornextloop.last['key']
+          if (newendkey == endkey)
+            keepgoing = false
+          else
+            startkey = newendkey
+          end
+          rows = viewrows
+        else
+          rows = []
+          for r in viewrows
+            if (lastkey && r['key'] == lastkey)
+              keepgoing = false
+              break
+            end
+            break if (r['key'] == endkey)
+            rows << r
+          end   
+          startkey = endkey
+        end
+        
+        key = :begin
+        values = []
+
+        rows.each do |r|
+          if key != r['key']
+            # we're on a new key, yield the old first and then reset
+            yield(key, values) if key != :begin
+            key = r['key']
+            values = []
+          end
+          # keep accumulating
+          values << r['value']
+        end
+        yield(key, values)
+
+      end
+    end
+
+    private
+    
+    def request_all_docs limit, startkey = nil
+      opts = {}
+      opts[:limit] = limit if limit
+      opts[:startkey] = startkey if startkey      
+      results = @db.documents(opts)
+      rows = results['rows']
+      rows unless rows.length == 0
+    end
+
+    def request_view view, limit = nil, startkey = nil, endkey = nil
+      opts = {}
+      opts[:limit] = limit if limit
+      opts[:startkey] = startkey if startkey
+      opts[:endkey] = endkey if endkey
+      
+      results = @db.view(view, opts)
+      rows = results['rows']
+      rows unless rows.length == 0
+    end
+
+  end
+end

data/lib/couchrest/helper/streamer.rb

@@ -0,0 +1,44 @@
+module CouchRest
+  class Streamer
+    attr_accessor :db
+    def initialize db
+      @db = db
+    end
+    
+    # Stream a view, yielding one row at a time. Shells out to <tt>curl</tt> to keep RAM usage low when you have millions of rows.
+    def view name, params = nil, &block
+      urlst = /^_/.match(name) ? "#{@db.root}/#{name}" : "#{@db.root}/_view/#{name}"
+      url = CouchRest.paramify_url urlst, params
+      # puts "stream #{url}"
+      first = nil
+      IO.popen("curl --silent #{url}") do |view|
+        first = view.gets # discard header
+        while line = view.gets 
+          row = parse_line(line)
+          block.call row
+        end
+      end
+      parse_first(first)
+    end
+    
+    private
+    
+    def parse_line line
+      return nil unless line
+      if /(\{.*\}),?/.match(line.chomp)
+        JSON.parse($1)
+      end
+    end
+
+    def parse_first first
+      return nil unless first
+      parts = first.split(',')
+      parts.pop
+      line = parts.join(',')
+      JSON.parse("#{line}}")
+    rescue
+      nil
+    end
+    
+  end
+end

data/lib/couchrest/monkeypatches.rb

@@ -0,0 +1,38 @@
+# This file must be loaded after the JSON gem and any other library that beats up the Time class.
+class Time
+  # This date format sorts lexicographically
+  # and is compatible with Javascript's <tt>new Date(time_string)</tt> constructor.
+  # Note this this format stores all dates in UTC so that collation 
+  # order is preserved. (There's no longer a need to set <tt>ENV['TZ'] = 'UTC'</tt>
+  # in your application.)
+
+  def to_json(options = nil)
+    u = self.utc
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+  end
+
+  # Decodes the JSON time format to a UTC time.
+  # Based on Time.parse from ActiveSupport. ActiveSupport's version
+  # is more complete, returning a time in your current timezone, 
+  # rather than keeping the time in UTC. YMMV.
+  # def self.parse string, fallback=nil
+  #   d = DateTime.parse(string).new_offset
+  #   self.utc(d.year, d.month, d.day, d.hour, d.min, d.sec)
+  # rescue
+  #   fallback
+  # end
+end
+
+module RestClient
+  def self.copy(url, headers={})
+    Request.execute(:method => :copy,
+      :url => url,
+      :headers => headers)
+  end
+  
+  def self.move(url, headers={})
+    Request.execute(:method => :move,
+    :url => url,
+    :headers => headers)
+  end
+end

data/spec/couchrest/core/couchrest_spec.rb

@@ -0,0 +1,201 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest do
+
+  before(:each) do
+    @cr = CouchRest.new(COUCHHOST)
+    begin
+      @db = @cr.database(TESTDB)
+      @db.delete! rescue nil      
+    end
+  end
+
+  after(:each) do
+    begin
+      @db.delete! rescue nil
+    end
+  end
+
+  describe "getting info" do
+    it "should list databases" do
+      @cr.databases.should be_an_instance_of(Array)
+    end
+    it "should get info" do
+      @cr.info["couchdb"].should == "Welcome"
+      @cr.info.class.should == Hash   
+    end
+  end
+  
+  it "should restart" do
+    @cr.restart!
+  end
+
+  it "should provide one-time access to uuids" do
+    @cr.next_uuid.should_not be_nil
+  end
+
+  describe "initializing a database" do
+    it "should return a db" do
+      db = @cr.database(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == @cr.uri
+    end
+  end
+
+  describe "parsing urls" do
+    it "should parse just a dbname" do
+      db = CouchRest.parse "my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5984"
+    end
+    it "should parse a host and db" do
+      db = CouchRest.parse "127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host and db with http" do
+      db = CouchRest.parse "http://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host with a port and db" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host" do
+      db = CouchRest.parse "http://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host no slash" do
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should get docid" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+
+    it "should parse a host and db" do
+      db = CouchRest.parse "127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host and db with http" do
+      db = CouchRest.parse "http://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host with a port and db" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host" do
+      db = CouchRest.parse "http://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host no slash" do
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should get docid" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+  end
+
+  describe "easy initializing a database adapter" do
+    it "should be possible without an explicit CouchRest instantiation" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == "127.0.0.1:5984"
+    end
+    # TODO add https support (need test environment...)
+    # it "should work with https" # do
+    #      db = CouchRest.database "https://127.0.0.1:5984/couchrest-test"
+    #      db.host.should == "https://127.0.0.1:5984"
+    #    end
+    it "should not create the database automatically" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
+    end
+  end
+
+  describe "ensuring the db exists" do
+    it "should be super easy" do
+      db = CouchRest.database! "http://127.0.0.1:5984/couchrest-test-2"
+      db.name.should == 'couchrest-test-2'
+      db.info["db_name"].should == 'couchrest-test-2'
+    end
+  end
+
+  describe "successfully creating a database" do
+    it "should start without a database" do
+      @cr.databases.should_not include(TESTDB)
+    end
+    it "should return the created database" do
+      db = @cr.create_db(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+    end
+    it "should create the database" do
+      db = @cr.create_db(TESTDB)
+      @cr.databases.should include(TESTDB)
+    end
+  end
+
+  describe "failing to create a database because the name is taken" do
+    before(:each) do
+      db = @cr.create_db(TESTDB)
+    end
+    it "should start with the test database" do
+      @cr.databases.should include(TESTDB)
+    end
+    it "should PUT the database and raise an error" do
+      lambda{
+        @cr.create_db(TESTDB)
+      }.should raise_error(RestClient::Request::RequestFailed)
+    end
+  end
+
+  describe "using a proxy for RestClient connections" do
+    it "should set proxy url for RestClient" do
+      CouchRest.proxy 'http://localhost:8888/'
+      proxy_uri = URI.parse(RestClient.proxy)
+      proxy_uri.host.should eql( 'localhost' )
+      proxy_uri.port.should eql( 8888 )
+      CouchRest.proxy nil
+    end
+  end
+
+end

data/spec/couchrest/core/database_spec.rb

@@ -0,0 +1,629 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest::Database do
+  before(:each) do
+    @cr = CouchRest.new(COUCHHOST)
+    @db = @cr.database(TESTDB)
+    @db.delete! rescue nil
+    @db = @cr.create_db(TESTDB) rescue nil
+  end
+    
+  describe "map query with _temp_view in Javascript" do
+    before(:each) do
+      @db.bulk_save([
+          {"wild" => "and random"},
+          {"mild" => "yet local"},
+          {"another" => ["set","of","keys"]}
+        ])
+      @temp_view = {:map => "function(doc){for(var w in doc){ if(!w.match(/^_/))emit(w,doc[w])}}"}
+    end
+    it "should return the result of the temporary function" do
+      rs = @db.temp_view(@temp_view)
+      rs['rows'].select{|r|r['key'] == 'wild' && r['value'] == 'and random'}.length.should == 1
+    end
+    it "should work with a range" do
+      rs = @db.temp_view(@temp_view, :startkey => "b", :endkey => "z")
+      rs['rows'].length.should == 2
+    end
+    it "should work with a key" do
+      rs = @db.temp_view(@temp_view, :key => "wild")
+      rs['rows'].length.should == 1
+    end
+    it "should work with a limit" do
+      rs = @db.temp_view(@temp_view, :limit => 1)
+      rs['rows'].length.should == 1
+    end
+    it "should work with multi-keys" do
+      rs = @db.temp_view(@temp_view, :keys => ["another", "wild"])
+      rs['rows'].length.should == 2
+    end
+  end
+
+  describe "map/reduce query with _temp_view in Javascript" do
+    before(:each) do
+      @db.bulk_save([
+          {"beverage" => "beer", :count => 4},
+          {"beverage" => "beer", :count => 2},
+          {"beverage" => "tea", :count => 3}
+        ])
+    end
+    it "should return the result of the temporary function" do
+      rs = @db.temp_view(:map => "function(doc){emit(doc.beverage, doc.count)}", :reduce =>  "function(beverage,counts){return sum(counts)}")
+      # rs.should == 'x'
+      rs['rows'][0]['value'].should == 9
+    end
+  end
+  
+  describe "saving a view" do
+    before(:each) do
+      @view = {'test' => {'map' => 'function(doc) {
+        if (doc.word && !/\W/.test(doc.word)) {
+          emit(doc.word,null);
+        }
+      }'}}
+      @db.save({
+        "_id" => "_design/test",
+        :views => @view
+      })
+    end
+    it "should work properly" do
+      @db.bulk_save([
+        {"word" => "once"},
+        {"word" => "and again"}
+      ])
+      @db.view('test/test')['total_rows'].should == 1
+    end
+    it "should round trip" do
+      @db.get("_design/test")['views'].should == @view
+    end
+  end
+  
+  describe "select from an existing view" do
+    before(:each) do
+      r = @db.save({
+        "_id" => "_design/first", 
+        :views => {
+          :test => {
+            :map => "function(doc){for(var w in doc){ if(!w.match(/^_/))emit(w,doc[w])}}"
+            }
+          }
+        })
+      @db.bulk_save([
+          {"wild" => "and random"},
+          {"mild" => "yet local"},
+          {"another" => ["set","of","keys"]}
+        ])
+    end
+    it "should have the view" do
+      @db.get('_design/first')['views']['test']['map'].should include("for(var w in doc)")
+    end
+    it "should list from the view" do
+      rs = @db.view('first/test')
+      rs['rows'].select{|r|r['key'] == 'wild' && r['value'] == 'and random'}.length.should == 1
+    end
+    it "should work with a range" do
+      rs = @db.view('first/test', :startkey => "b", :endkey => "z")
+      rs['rows'].length.should == 2
+    end
+    it "should work with a key" do
+      rs = @db.view('first/test', :key => "wild")
+      rs['rows'].length.should == 1
+    end
+    it "should work with a limit" do
+      rs = @db.view('first/test', :limit => 1)
+      rs['rows'].length.should == 1
+    end
+    it "should work with multi-keys" do
+      rs = @db.view('first/test', :keys => ["another", "wild"])
+      rs['rows'].length.should == 2
+    end
+    it "should accept a block" do
+      rows = []
+      rs = @db.view('first/test', :include_docs => true) do |row|
+        rows << row
+      end
+      rows.length.should == 4
+      rs["total_rows"].should == 3
+    end
+  end
+
+  describe "GET (document by id) when the doc exists" do
+    before(:each) do
+      @r = @db.save({'lemons' => 'from texas', 'and' => 'spain'})
+      @docid = "http://example.com/stuff.cgi?things=and%20stuff"
+      @db.save({'_id' => @docid, 'will-exist' => 'here'})
+    end
+    it "should get the document" do
+      doc = @db.get(@r['id'])
+      doc['lemons'].should == 'from texas'
+    end
+    it "should work with a funky id" do
+      @db.get(@docid)['will-exist'].should == 'here'
+    end
+  end
+  
+  describe "POST (adding bulk documents)" do
+    it "should add them without ids" do
+      rs = @db.bulk_save([
+          {"wild" => "and random"},
+          {"mild" => "yet local"},
+          {"another" => ["set","of","keys"]}
+        ])
+      rs['new_revs'].each do |r|
+        @db.get(r['id'])
+      end
+    end
+    
+    it "should use uuids when ids aren't provided" do
+      @db.server.stub!(:next_uuid).and_return('asdf6sgadkfhgsdfusdf')
+      
+      docs = [{'key' => 'value'}, {'_id' => 'totally-uniq'}]
+      id_docs = [{'key' => 'value', '_id' => 'asdf6sgadkfhgsdfusdf'}, {'_id' => 'totally-uniq'}]
+      CouchRest.should_receive(:post).with("http://127.0.0.1:5984/couchrest-test/_bulk_docs", {:docs => id_docs})
+      
+      @db.bulk_save(docs)
+    end
+    
+    it "should add them with uniq ids" do
+      rs = @db.bulk_save([
+          {"_id" => "oneB", "wild" => "and random"},
+          {"_id" => "twoB", "mild" => "yet local"},
+          {"another" => ["set","of","keys"]}
+        ])
+      rs['new_revs'].each do |r|
+        @db.get(r['id'])
+      end
+    end
+    
+    it "in the case of an id conflict should not insert anything" do
+      @r = @db.save({'lemons' => 'from texas', 'and' => 'how', "_id" => "oneB"})
+      
+      lambda do
+      rs = @db.bulk_save([
+          {"_id" => "oneB", "wild" => "and random"},
+          {"_id" => "twoB", "mild" => "yet local"},
+          {"another" => ["set","of","keys"]}
+        ])
+      end.should raise_error(RestClient::RequestFailed)
+    
+      lambda do
+        @db.get('twoB')
+      end.should raise_error(RestClient::ResourceNotFound)
+    end
+
+    it "should empty the bulk save cache if no documents are given" do
+      @db.save({"_id" => "bulk_cache_1", "val" => "test"}, true)
+      lambda do
+        @db.get('bulk_cache_1')
+      end.should raise_error(RestClient::ResourceNotFound)
+      @db.bulk_save
+      @db.get("bulk_cache_1")["val"].should == "test"
+    end
+
+    it "should raise an error that is useful for recovery" do
+      @r = @db.save({"_id" => "taken", "field" => "stuff"})
+      begin
+        rs = @db.bulk_save([
+            {"_id" => "taken", "wild" => "and random"},
+            {"_id" => "free", "mild" => "yet local"},
+            {"another" => ["set","of","keys"]}
+          ])
+      rescue RestClient::RequestFailed => e
+        # soon CouchDB will provide _which_ docs conflicted
+        JSON.parse(e.response.body)['error'].should == 'conflict'
+      end
+    end
+  end
+  
+  describe "new document without an id" do
+    it "should start empty" do
+      @db.documents["total_rows"].should == 0
+    end
+    it "should create the document and return the id" do
+      r = @db.save({'lemons' => 'from texas', 'and' => 'spain'})
+      r2 = @db.get(r['id'])
+      r2["lemons"].should == "from texas"
+    end
+    it "should use PUT with UUIDs" do
+      CouchRest.should_receive(:put).and_return({"ok" => true, "id" => "100", "rev" => "55"})
+      r = @db.save({'just' => ['another document']})      
+    end
+    
+  end
+
+  describe "PUT attachment from file" do
+    before(:each) do
+      filename = FIXTURE_PATH + '/attachments/couchdb.png'
+      @file = File.open(filename)
+    end
+    after(:each) do
+      @file.close
+    end
+    it "should save the attachment to a new doc" do
+      r = @db.put_attachment({'_id' => 'attach-this'}, 'couchdb.png', image = @file.read, {:content_type => 'image/png'})
+      r['ok'].should == true
+      attachment = @db.fetch_attachment("attach-this","couchdb.png")
+      attachment.should == image
+    end
+  end
+
+  describe "PUT document with attachment" do
+    before(:each) do
+      @attach = "<html><head><title>My Doc</title></head><body><p>Has words.</p></body></html>"
+      @doc = {
+        "_id" => "mydocwithattachment",
+        "field" => ["some value"],
+        "_attachments" => {
+          "test.html" => {
+            "type" => "text/html",
+            "data" => @attach
+          }
+        }
+      }
+      @db.save(@doc)
+    end
+    it "should save and be indicated" do
+      doc = @db.get("mydocwithattachment")
+      doc['_attachments']['test.html']['length'].should == @attach.length
+    end
+    it "should be there" do
+      attachment = @db.fetch_attachment("mydocwithattachment","test.html")
+      attachment.should == @attach
+    end
+  end
+  
+  describe "PUT document with attachment stub" do
+    before(:each) do
+      @attach = "<html><head><title>My Doc</title></head><body><p>Has words.</p></body></html>"
+      doc = {
+        '_id' => 'mydocwithattachment',
+        'field' => ['some_value'],
+        '_attachments' => {
+          'test.html' => {
+            'type' => 'text/html', 'data' => @attach
+          }
+        }
+      }
+      @db.save(doc)
+      doc = @db.get('mydocwithattachment')
+      doc['field'] << 'another value'
+      @db.save(doc)
+    end
+    
+    it 'should be there' do
+      attachment = @db.fetch_attachment('mydocwithattachment', 'test.html')
+      attachment.should == @attach
+    end
+  end
+
+  describe "PUT document with multiple attachments" do
+    before(:each) do
+      @attach = "<html><head><title>My Doc</title></head><body><p>Has words.</p></body></html>"
+      @attach2 = "<html><head><title>Other Doc</title></head><body><p>Has more words.</p></body></html>"
+      @doc = {
+        "_id" => "mydocwithattachment",
+        "field" => ["some value"],
+        "_attachments" => {
+          "test.html" => {
+            "type" => "text/html",
+            "data" => @attach
+          },
+          "other.html" => {
+            "type" => "text/html",
+            "data" => @attach2
+          }
+        }
+      }
+      @db.save(@doc)
+    end
+    it "should save and be indicated" do
+      doc = @db.get("mydocwithattachment")
+      doc['_attachments']['test.html']['length'].should == @attach.length
+      doc['_attachments']['other.html']['length'].should == @attach2.length
+    end
+    it "should be there" do
+      attachment = @db.fetch_attachment("mydocwithattachment","test.html")
+      attachment.should == @attach
+    end
+    it "should be there" do
+      attachment = @db.fetch_attachment("mydocwithattachment","other.html")
+      attachment.should == @attach2
+    end
+  end
+
+  describe "POST document with attachment (with funky name)" do
+    before(:each) do
+      @attach = "<html><head><title>My Funky Doc</title></head><body><p>Has words.</p></body></html>"
+      @doc = {
+        "field" => ["some other value"],
+        "_attachments" => {
+          "http://example.com/stuff.cgi?things=and%20stuff" => {
+            "type" => "text/html",
+            "data" => @attach
+          }
+        }
+      }
+      @docid = @db.save(@doc)['id']
+    end
+    it "should save and be indicated" do
+      doc = @db.get(@docid)
+      doc['_attachments']['http://example.com/stuff.cgi?things=and%20stuff']['length'].should == @attach.length
+    end
+    it "should be there" do
+      attachment = @db.fetch_attachment(@docid,"http://example.com/stuff.cgi?things=and%20stuff")
+      attachment.should == @attach
+    end
+  end
+
+  describe "PUT (new document with url id)" do
+    it "should create the document" do
+      @docid = "http://example.com/stuff.cgi?things=and%20stuff"
+      @db.save({'_id' => @docid, 'will-exist' => 'here'})
+      lambda{@db.save({'_id' => @docid})}.should raise_error(RestClient::Request::RequestFailed)
+      @db.get(@docid)['will-exist'].should == 'here'
+    end
+  end
+  
+  describe "PUT (new document with id)" do
+    it "should start without the document" do
+      # r = @db.save({'lemons' => 'from texas', 'and' => 'spain'})
+      @db.documents['rows'].each do |doc|
+        doc['id'].should_not == 'my-doc'
+      end
+      # should_not include({'_id' => 'my-doc'})
+      # this needs to be a loop over docs on content with the post
+      # or instead make it return something with a fancy <=> method
+    end
+    it "should create the document" do
+      @db.save({'_id' => 'my-doc', 'will-exist' => 'here'})
+      lambda{@db.save({'_id' => 'my-doc'})}.should raise_error(RestClient::Request::RequestFailed)
+    end
+  end
+  
+  describe "PUT (existing document with rev)" do
+    before(:each) do
+      @db.save({'_id' => 'my-doc', 'will-exist' => 'here'})
+      @doc = @db.get('my-doc')
+      @docid = "http://example.com/stuff.cgi?things=and%20stuff"
+      @db.save({'_id' => @docid, 'now' => 'save'})
+    end
+    it "should start with the document" do
+      @doc['will-exist'].should == 'here'
+      @db.get(@docid)['now'].should == 'save'
+    end
+    it "should save with url id" do
+      doc = @db.get(@docid)
+      doc['yaml'] = ['json', 'word.']
+      @db.save doc
+      @db.get(@docid)['yaml'].should == ['json', 'word.']
+    end
+    it "should fail to resave without the rev" do
+      @doc['them-keys'] = 'huge'
+      @doc['_rev'] = 'wrong'
+      # @db.save(@doc)
+      lambda {@db.save(@doc)}.should raise_error
+    end
+    it "should update the document" do
+      @doc['them-keys'] = 'huge'
+      @db.save(@doc)
+      now = @db.get('my-doc')
+      now['them-keys'].should == 'huge'
+    end
+  end
+
+  describe "cached bulk save" do
+    it "stores documents in a database-specific cache" do
+      td = {"_id" => "btd1", "val" => "test"}
+      @db.save(td, true)
+      @db.instance_variable_get("@bulk_save_cache").should == [td]
+      
+    end
+
+    it "doesn't save to the database until the configured cache size is exceded" do
+      @db.bulk_save_cache_limit = 3
+      td1 = {"_id" => "td1", "val" => true}
+      td2 = {"_id" => "td2", "val" => 4}
+      @db.save(td1, true)
+      @db.save(td2, true)
+      lambda do
+        @db.get(td1["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      lambda do
+        @db.get(td2["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      td3 = {"_id" => "td3", "val" => "foo"}
+      @db.save(td3, true)
+      @db.get(td1["_id"])["val"].should == td1["val"]
+      @db.get(td2["_id"])["val"].should == td2["val"]
+      @db.get(td3["_id"])["val"].should == td3["val"]
+    end
+
+    it "clears the bulk save cache the first time a non bulk save is requested" do
+      td1 = {"_id" => "blah", "val" => true}
+      td2 = {"_id" => "steve", "val" => 3}
+      @db.bulk_save_cache_limit = 50
+      @db.save(td1, true)
+      lambda do
+        @db.get(td1["_id"])
+      end.should raise_error(RestClient::ResourceNotFound)
+      @db.save(td2)
+      @db.get(td1["_id"])["val"].should == td1["val"]
+      @db.get(td2["_id"])["val"].should == td2["val"]
+    end
+  end
+
+  describe "DELETE existing document" do
+    before(:each) do
+      @r = @db.save({'lemons' => 'from texas', 'and' => 'spain'})
+      @docid = "http://example.com/stuff.cgi?things=and%20stuff"
+      @db.save({'_id' => @docid, 'will-exist' => 'here'})
+    end
+    it "should work" do
+      doc = @db.get(@r['id'])
+      doc['and'].should == 'spain'
+      @db.delete doc
+      lambda{@db.get @r['id']}.should raise_error
+    end
+    it "should work with uri id" do
+      doc = @db.get(@docid)
+      @db.delete doc
+      lambda{@db.get @docid}.should raise_error
+    end
+    it "should fail without an _id" do
+      lambda{@db.delete({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+    end
+    it "should defer actual deletion when using bulk save" do
+      doc = @db.get(@docid)
+      @db.delete doc, true
+      lambda{@db.get @docid}.should_not raise_error
+      @db.bulk_save
+      lambda{@db.get @docid}.should raise_error
+    end
+    
+  end
+  
+  describe "COPY existing document" do
+    before :each do
+      @r = @db.save({'artist' => 'Zappa', 'title' => 'Muffin Man'})
+      @docid = 'tracks/zappa/muffin-man'
+      @doc = @db.get(@r['id'])
+    end
+    describe "to a new location" do
+      it "should work" do
+        @db.copy @doc, @docid
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+      end
+      it "should fail without an _id" do
+        lambda{@db.copy({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+      end
+    end
+    describe "to an existing location" do
+      before :each do
+        @db.save({'_id' => @docid, 'will-exist' => 'here'})
+      end
+      it "should fail without a rev" do
+        lambda{@db.copy @doc, @docid}.should raise_error(RestClient::RequestFailed)
+      end
+      it "should succeed with a rev" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.copy @doc, "#{@docid}?rev=#{@to_be_overwritten['_rev']}"
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+      end
+      it "should succeed given the doc to overwrite" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.copy @doc, @to_be_overwritten
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+      end
+    end
+  end
+  
+  describe "MOVE existing document" do
+    before :each do
+      @r = @db.save({'artist' => 'Zappa', 'title' => 'Muffin Man'})
+      @docid = 'tracks/zappa/muffin-man'
+      @doc = @db.get(@r['id'])
+    end
+    describe "to a new location" do
+      it "should work" do
+        @db.move @doc, @docid
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+      it "should fail without an _id or _rev" do
+        lambda{@db.move({"not"=>"a real doc"})}.should raise_error(ArgumentError)
+        lambda{@db.move({"_id"=>"not a real doc"})}.should raise_error(ArgumentError)
+      end
+    end
+    describe "to an existing location" do
+      before :each do
+        @db.save({'_id' => @docid, 'will-exist' => 'here'})
+      end
+      it "should fail without a rev" do
+        lambda{@db.move @doc, @docid}.should raise_error(RestClient::RequestFailed)
+        lambda{@db.get(@r['id'])}.should_not raise_error
+      end
+      it "should succeed with a rev" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.move @doc, "#{@docid}?rev=#{@to_be_overwritten['_rev']}"
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+      it "should succeed given the doc to overwrite" do
+        @to_be_overwritten = @db.get(@docid)
+        @db.move @doc, @to_be_overwritten
+        newdoc = @db.get(@docid)
+        newdoc['artist'].should == 'Zappa'
+        lambda {@db.get(@r['id'])}.should raise_error(RestClient::ResourceNotFound)
+      end
+    end
+  end
+  
+  
+  it "should list documents" do
+    5.times do
+      @db.save({'another' => 'doc', 'will-exist' => 'anywhere'})
+    end
+    ds = @db.documents
+    ds['rows'].should be_an_instance_of(Array)
+    ds['rows'][0]['id'].should_not be_nil
+    ds['total_rows'].should == 5
+  end
+  
+  describe "documents / _all_docs" do
+    before(:each) do
+      9.times do |i|
+        @db.save({'_id' => "doc#{i}",'another' => 'doc', 'will-exist' => 'here'})
+      end
+    end
+    it "should list documents with keys and such" do
+      ds = @db.documents
+      ds['rows'].should be_an_instance_of(Array)
+      ds['rows'][0]['id'].should == "doc0"
+      ds['total_rows'].should == 9      
+    end
+    it "should take query params" do
+      ds = @db.documents(:startkey => 'doc0', :endkey => 'doc3')
+      ds['rows'].length.should == 4
+      ds = @db.documents(:key => 'doc0')
+      ds['rows'].length.should == 1
+    end
+    it "should work with multi-key" do
+      rs = @db.documents :keys => ["doc0", "doc7"]
+      rs['rows'].length.should == 2
+    end
+    it "should work with include_docs" do
+      ds = @db.documents(:startkey => 'doc0', :endkey => 'doc3', :include_docs => true)
+      ds['rows'][0]['doc']['another'].should == "doc"
+    end
+  end
+  
+
+  describe "compacting a database" do
+    it "should compact the database" do
+      db = @cr.database('couchrest-test')
+      # r = 
+      db.compact!
+      # r['ok'].should == true
+    end
+  end
+
+  describe "deleting a database" do
+    it "should start with the test database" do
+      @cr.databases.should include('couchrest-test')
+    end
+    it "should delete the database" do
+      db = @cr.database('couchrest-test')
+      # r = 
+      db.delete!
+      # r['ok'].should == true
+      @cr.databases.should_not include('couchrest-test')
+    end
+  end
+
+
+end