akdubya-cushion 0.5.2 → 0.6.0

data/lib/cushion/design.rb

@@ -1,10 +1,9 @@
 module Cushion  
   class Design < Document
-    def view(view_name, query={})
-      view_name = view_name.to_s
-      view_slug = "#{name}/#{view_name}"
-      defaults = (self['views'][view_name] && self['views'][view_name]["couchrest-defaults"]) || {}
-      database.view(view_slug, defaults.merge(query))
+    # Queries a view rooted at this document. See Database#view.
+    def view(view_name, options = {})
+      slug = "#{name}/#{view_name}"
+      database.view(slug, options)
     end
 
     def name

data/lib/cushion/document.rb

@@ -1,59 +1,92 @@
 module Cushion
-  class Response < Hash
-    def initialize(keys = {})
-      keys.each do |k,v|
-        self[k.to_s] = v
+  class Document
+    attr_accessor :database, :headers
+
+    # Sets the default database for the document class.
+    def self.set_database(db)
+      @database = db
+    end
+
+    def self.database
+      @database
+    end
+
+    def initialize(atts = {})
+      @attributes = {}
+      @headers = {}
+      merge!(atts)
+      if atts.respond_to?(:headers)
+        atts.headers.each do |h,v|
+          @headers[h] = v
+        end
       end
     end
 
     def []=(key, value)
-      super(key.to_s, value)
+      @attributes[key.to_s] = value
+    end
+
+    def merge!(atts)
+      atts.each do |k,v|
+        self[k.to_s] = v
+      end
     end
-    
+
     def [](key)
-      super(key.to_s)
+      @attributes[key.to_s]
     end
-  end
-  
-  class Document < Response
-    attr_accessor :database
 
-    class << self
-      def use_database(db)
-        @database = db
-      end
+    def delete(key)
+      @attributes.delete(key.to_s)
+    end
 
-      def database
-        @database
-      end
+    def key?(key)
+      @attributes.key?(key.to_s)
+    end
+    alias_method :has_key?, :key?
+    alias_method :attribute?, :key?
+
+    def database
+      @database || self.class.database
     end
 
     def id
       self[:_id]
     end
-    
+
+    def id?
+      (id && !id.empty?) ? true : false
+    end
+    alias_method :has_id?, :id?
+
     def rev
       self[:_rev]
     end
+    alias_method :etag, :rev
+
+    def rev?
+      (rev && !rev.empty?) ? true : false
+    end
+    alias_method :has_rev?, :rev?
 
-    # Returns true if this document has never been saved
+    def attachments
+      self[:_attachments] ||= {}
+    end
+
+    # Returns true if the document is unsaved.
     def new_document?
-      !rev
+      !rev?
     end
+    alias_method :new_doc?, :new_document?
 
-    # Saves this document to the database.
+    # Save this document. TODO: Change attachments to stubs on save?
     def save
-      result = database.save_doc(self)
-      if result['ok']
-        self[:_rev] = result['rev']
-        self[:_id] = result['id']
-      end
-      result['ok']
+      database.store(self)["ok"]
     end
 
-    # Deletes this document from the database.
+    # Deletes this document.
     def destroy
-      result = database.delete_doc(id, rev)
+      result = database.destroy(id, :rev => rev)
       if result['ok']
         self[:_rev] = nil
         self[:_id] = nil
@@ -61,57 +94,74 @@ module Cushion
       result['ok']
     end
 
-    # Reloads this document from the database.
-    def reload
-      result = database.open_doc(id)
-      initialize(result)
-      self
-    end
-    
-    # Copies the document to a new id. If +dest_id+ currently exists then
-    # +dest_rev+ must be provided.
-    def copy(dest_id, dest_rev = nil)
-      result = database.copy_doc(id, dest_id, :dest_rev => dest_rev)
+    # Attach a file to this document.
+    def attach(filename, data, content_type = "application/octet-stream")
+      result = database.attach(id, filename, data, :rev => rev,
+        :headers => { :content_type => content_type })
+      if result['ok']
+        self[:_rev] = result['rev']
+        attachments[filename] = {
+          "stub" => true,
+          "content_type" => content_type,
+          "length" => "<not loaded>"
+        }
+      end
       result['ok']
     end
-    
-    # Moves the document to a new id. If +dest_id+ currently exists then
-    # +dest_rev+ must be provided.
-    def move(dest_id, dest_rev = nil)
-      result = database.move_doc(id, dest_id, rev, :dest_rev => dest_rev)
+
+    # Deletes the attachment identified by +filename+.
+    def detach(filename)
+      result = database.destroy(id, filename, :rev => rev)
+      if result['ok']
+        self[:_rev] = result['rev']
+        attachments.delete(filename)
+      end
       result['ok']
     end
-    
-    # Returns this document's database.
-    def database
-      @database || self.class.database
-    end
 
-    # Opens the attachment identified by +filename+. Returns an IO object.
-    def open_attachment(filename)
-      database.open_attachment(id, filename)
+    # Opens the attachment identified by +filename+. Returns either a String or
+    # a Tempfile, depending on the database setup.
+    def fetch(filename)
+      database.fetch(id, filename)
     end
-    
-    # Attaches a file to this document under +filename+.
-    def save_attachment(filename, data, options={})
-      result = database.save_attachment(id, rev, filename, data, options)
-      self[:_rev] = result['rev']
+
+    # Renames an attachment. +oldname+ is the name of the existing attachment
+    # and +newname+ is the desired name.
+    def rename(oldname, newname)
+      result = database.move_attachment(id, oldname, newname)
+      if result['ok']
+        self[:_rev] = result['rev']
+        attachments[newname] = attachments.delete(oldname)
+      end
       result['ok']
     end
-    
-    # Deletes the attachment identified by +filename+.
-    def delete_attachment(filename)
-      result = database.delete_attachment(id, rev, filename)
-      self[:_rev] = result['rev']
+
+    # Reloads this document.
+    def reload
+      initialize(database.fetch(id))
+      self
+    end
+
+    # Copies this document to a new id. If +dest_id+ currently exists then
+    # the +dest_rev+ option must be provided.
+    def copy_to(dest_id, opts = {})
+      result = database.copy(id, dest_id, :dest_rev => opts[:rev])
       result['ok']
     end
 
-    # Renames an attachment. +oldname+ is the name of the existing attachment
-    # and +newname+ is the desired name.
-    def rename_attachment(oldname, newname)
-      result = database.rename_attachment(id, rev, oldname, newname)
-      self[:_rev] = result['rev']
+    # Moves this document to a new id. If +dest_id+ currently exists then
+    # the +dest_rev+ option must be provided.
+    def move_to(dest_id, opts = {})
+      result = database.move(id, dest_id, :rev => rev, :dest_rev => opts[:rev])
+      if result['ok']
+        self[:_rev] = nil
+        self[:_id] = nil
+      end
       result['ok']
     end
+
+    def to_json
+      @attributes.to_json
+    end
   end
 end

data/lib/cushion/server.rb

@@ -4,10 +4,10 @@ module Cushion
   class Server
     attr_accessor :uri, :uuid_batch_count
 
-    # Initialize a Cushion::Server to the uri at +server+.
-    def initialize(server = DEFAULT_COUCH_HOST, uuid_batch_count = 1000)
-      @uri = server
-      @uuid_batch_count = uuid_batch_count
+    # Initializes a Cushion::Server.
+    def initialize(options = {})
+      @uri = options[:uri] || DEFAULT_COUCH_HOST
+      @uuid_batch_count = options[:uuid_batch_count] || 1000
     end
 
     # Retrieves the server's welcome message.
@@ -66,12 +66,7 @@ module Cushion
     # Returns a Cushion::Database.
     def recreate(name)
       rdb = db(name)
-      begin
-        rdb.drop
-      rescue RestClient::ResourceNotFound
-        nil
-      end
-      rdb.create
+      rdb.recreate
       rdb
     end
 
@@ -86,7 +81,7 @@ module Cushion
     # not attempt to create the database if it does not already exist on the
     # server.
     def db(name)
-      Cushion::Database.new(self, name)
+      Cushion::Database.new(name, :server => self)
     end
     alias_method :database, :db
 
@@ -171,7 +166,8 @@ module Cushion
       )
     end
 
-    # Opens the attachment located at +path+. Returns a Tempfile.
+    # Opens the attachment located at +path+. Returns an <tt>OpenURI</tt> <tt>IO</tt>
+    # object.
     def open_attachment(path)
       open("#{@uri}/#{path}")
     rescue OpenURI::HTTPError
@@ -192,7 +188,7 @@ module Cushion
 
     def parse_response(result)
       if result.headers[:content_type] == "application/json"
-        JSON.parse(result)
+        Meta.init(JSON.parse(result), result)
       else
         result
       end

data/spec/cushion_spec.rb

@@ -1,9 +1,7 @@
 require File.dirname(__FILE__) + '/helpers'
 
 describe Cushion do
-
   it "should instantiate a Cushion::Server" do
     Cushion.new.should.be.a.kind_of Cushion::Server
   end
-
 end

data/spec/database_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/helpers'
 
-describe "Cushion::Database" do
-
+describe "A Cushion database" do
   before do
     @db = Cushion.db!('http://127.0.0.1:5984/cushion_test')
   end
@@ -10,143 +9,213 @@ describe "Cushion::Database" do
     @db.drop rescue nil
   end
 
-  describe "Operations" do
-
-    it "should properly initialize a database instance" do
-      badname = Cushion::Database.new(Cushion.new, "my/database")
-      badname.name.should == "my%2Fdatabase"
-      lambda { Cushion::Database.new( :foo, "mydb" ) }.should.raise ArgumentError
-    end
-
-    it "should create and drop a database" do
-      newdb = Cushion.db('http://127.0.0.1:5984/foo_test')
-      newdb.create["ok"].should.be.true
-      newdb.drop["ok"].should.be.true
-    end
-
-    it "should retrieve database info" do
-      @db.info["db_name"].should == "cushion_test"
-    end
+  it "should properly initialize" do
+    badname = Cushion::Database.new("my/database", :server => Cushion.new)
+    badname.name.should == "my%2Fdatabase"
+    lambda { Cushion::Database.new("mydb") }.should.raise ArgumentError
+  end
 
-    it "should compact a database" do
-      @db.save_doc("foo" => "bar")
-      @db.compact["ok"].should.be.true
-    end
+  it "should create and drop a database" do
+    newdb = Cushion.db('http://127.0.0.1:5984/foo_test')
+    newdb.create["ok"].should.be.true
+    newdb.drop["ok"].should.be.true
+  end
 
-    it "should pass requests to external handlers" do
-      # This is kind of lame, but installing an external handler to run a "real"
-      # external test seems like overkill.
-      lambda { @db.external(:get, "all_docs") }.should.not.raise
-    end
+  it "should retrieve database info with #info" do
+    @db.info["db_name"].should == "cushion_test"
+  end
 
+  it "should compact a database with #compact" do
+    @db.store("foo" => "bar")
+    @db.compact["ok"].should.be.true
   end
 
-  describe "Saving" do
+  it "should pass requests to external handlers with #external" do
+    # This is kind of lame, but installing an external handler to run a "real"
+    # external test seems like overkill.
+    lambda { @db.external(:get, "all_docs") }.should.not.raise
+  end
 
-    it "should save a document" do
-      @db.save_doc("_id" => "123")["ok"].should.be.true
-    end
+  it "should save a document with #store" do
+    saved = @db.store("_id" => "123")
+    saved["ok"].should.be.true
+    saved["rev"].should.not.be.nil
+  end
 
-    it "should automatically generate an id if none provided on save" do
-      saved = @db.save_doc("foo" => "bar")
+  describe "when storing documents" do
+    it "should automatically generate an id if none provided" do
+      saved = @db.store("foo" => "bar")
       saved["ok"].should.be.true
       saved["rev"].should.not.be.nil
     end
 
-    it "should bulk save documents" do
-      count = @db.info["doc_count"]
-      @db.bulk_docs([{"_id" => "456"},{"_id" => "789"}])["ok"].should.be.true
-      @db.info["doc_count"].should == count + 2
+    it "should update a document if a rev is supplied" do
+      res = @db.store("_id" => "mydoc", "foo" => "bar")
+      updated = @db.store("_id" => "mydoc", "_rev" => res["rev"], "foo" => "bar")
+      updated["ok"].should.be.true
     end
 
+    it "should raise a request failed error when trying to update a document without a rev" do
+      @db.store("_id" => "mydoc", "foo" => "bar")
+      lambda { @db.store("_id" => "mydoc", "foo" => "bar") }.should.raise RestClient::RequestFailed
+    end
+
+    it "should save encoded inline attachments" do
+      inline = { "_id" => "inline", "_attachments" => { "foo.txt" => {
+        "content_type" => "text/plain", "data" => "Hello World!" } } }
+
+      @db.store(inline)["ok"].should.be.true
+      inline["_attachments"]["foo.txt"]["data"].should == "SGVsbG8gV29ybGQh"
+      @db.fetch("inline", "foo.txt").should == "Hello World!"
+    end
   end
 
-  describe "Deleting" do
+  it "should retrieve a document with #fetch" do
+    @db.store("_id" => "123")
+    @db.fetch("123")["_id"].should == "123"
+  end
 
-    before do
-      @db.save_doc("_id" => "123")
-      @db.save_doc("_id" => "456")
+  describe "when fetching documents" do
+    it "should raise a resource not found error if the doc does not exist" do
+      lambda { @db.fetch("bogus") }.should.raise RestClient::ResourceNotFound
     end
 
-    it "should delete a document" do
-      doc = @db.open_doc("123")
-      @db.delete_doc("123", doc['_rev'])["ok"].should.be.true
+    it "should pass extra parameters to CouchDB" do
+      @db.store("_id" => "123")
+      @db.fetch("123", :revs => true)["_revs"].should.not.be.nil
     end
 
-    it "should bulk delete documents" do
-      count = @db.info["doc_count"]
-      docs = @db.all_docs(:keys => ["123", "456"], :include_docs => true)
-      @db.bulk_delete(docs["rows"].map{ |row| row["doc"] })["ok"].should.be.true
-      @db.info["doc_count"].should == count - 2
+    it "should pass headers to CouchDB" do
+      @db.store("_id" => "123")
+      @db.fetch("123", :headers => { :accept => "text/plain" }).should.be.kind_of String
     end
 
+    it "should perform a conditional GET" do
+      res = @db.store("_id" => "123")
+      lambda {
+        @db.fetch("123", :etag => res['rev'])
+      }.should.raise RestClient::NotModified
+    end
   end
 
-  describe "Copying" do
+  it "should return false from #key? if a document is not available" do
+    @db.key?("foo").should.be.false
+  end
 
-    before do
-      @abc = @db.save_doc("_id" => "abc")
-      @ghi = @db.save_doc("_id" => "ghi")
-    end
+  it "should return false from #key? if an attachment is not available" do
+    @db.key?("foo", "bar.txt").should.be.false
+  end
 
-    it "should copy an existing doc to a new/existing doc" do
-      res = @db.copy_doc("abc", "def")
-      res["id"].should == "def"
-      @db.copy_doc("abc", "def", :dest_rev => res["rev"])["ok"].should.be.true
-    end
+  it "should return true from #key? if a document is available" do
+    @db.store("_id" => "foo")
+    @db.key?("foo").should.be.true
+  end
 
-    it "should move an existing doc to a new/existing doc" do
-      @db.move_doc("abc", "def", @abc["rev"])["ok"].should.be.true
-      lambda { @db.open_doc("abc") }.should.raise RestClient::ResourceNotFound
-      doc = @db.open_doc("def")
-      @db.move_doc("def", "ghi", doc["_rev"], :dest_rev => @ghi["rev"])["ok"].should.be.true
-    end
+  it "should return true from #key? if an attachment is available" do
+    @db.store("_id" => "foo", "_attachments" => {
+        "bar.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }})
+    @db.key?("foo", "bar.txt").should.be.true
+  end
 
+  it "should load a Cushion::Document instance with #doc" do
+    @db.store("_id" => "123")
+    @db.doc("123").should.be.kind_of Cushion::Document
+    @db.store("_id" => "_design/123")
+    @db.doc("_design/123").should.be.kind_of Cushion::Design
   end
 
-  describe "Reading" do
+  it "should delete a document with #destroy" do
+    res = @db.store("_id" => "123")
+    @db.destroy("123", :rev => res["rev"])["ok"].should.be.true
+  end
 
-    before do
-      @db.save_doc("_id" => "123")
-      @db.save_doc("_id" => "456")
-    end
+  it "should raise a request error if attempting to destroy without a rev" do
+    res = @db.store("_id" => "123")
+    lambda { @db.destroy("123") }.should.raise RestClient::RequestFailed
+  end
 
-    it "should open a document" do
-      @db.open_doc("123")["_id"].should == "123"
-    end
+  it "should open attachments with #fetch" do
+    @db.store("_id" => "fetchme", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }})
+    @db.fetch("fetchme", "foo.txt").should == "Hello World!"
+  end
 
-    it "should load a Cushion::Document" do
-      @db.doc("123").should.be.kind_of Cushion::Document
-    end
+  it "should save standalone attachments with #attach" do
+    res = @db.store("_id" => "attachable")
+    @db.attach("attachable", "foo.txt", "Hello World!", :rev => res['rev'],
+      :content_type => "text/plain")["ok"].should.be.true
+    @db.fetch("attachable")["_attachments"]["foo.txt"]["content_type"].should == "text/plain"
+  end
 
-    it "should retrieve all documents" do
-      @db.all_docs["total_rows"].should == 2
+  describe "when fetching attachments" do
+    it "should return tempfiles if use_tempfiles is set" do
+      @db.use_tempfiles = true
+      @db.store("_id" => "usetemp", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }})
+      @db.fetch("usetemp", "foo.txt").read.should == "Hello World!"
     end
+  end
 
-    it "should retrieve all documents by keys" do
-      @db.all_docs(:keys => ["123"])["rows"].length.should == 1
-    end
+  it "should delete attachments with #destroy" do
+    res = @db.store("_id" => "deleteme", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }})
+    @db.destroy("deleteme", "foo.txt", :rev => res['rev'])["ok"].should.be.true
+  end
 
+  it "should bulk save documents with #bulk" do
+    count = @db.info["doc_count"]
+    @db.bulk([{"_id" => "456"},{"_id" => "789"}])["ok"].should.be.true
+    @db.info["doc_count"].should == count + 2
   end
 
-  describe "Views" do
+  it "should bulk delete documents" do
+    @db.store("_id" => "123")
+    @db.store("_id" => "456")
+    count = @db.info["doc_count"]
+    docs = @db.all(:keys => ["123", "456"], :include_docs => true)
+    @db.bulk(docs["rows"].map{ |row| row["doc"] }, :delete => true)["ok"].should.be.true
+    @db.info["doc_count"].should == count - 2
+  end
 
+  describe "with views" do
     before do
-      @db.save_doc("_id" => "gomer", "name" => "gomer pyle")
-      @db.save_doc("_id" => "vince", "name" => "vince carter")
+      @db.store("_id" => "gomer", "name" => "gomer pyle")
+      @db.store("_id" => "vince", "name" => "vince carter")
       @view = {:map => "function(doc){emit(doc.name,null)}"}
-      @db.save_doc("_id" => "_design/foo", "views" => { "bar" => @view })
+      @db.store("_id" => "_design/foo", "views" => { "bar" => @view })
+    end
+
+    it "should retrieve all documents with #view and #all" do
+      @db.all["total_rows"].should == 3
+      @db.view(:all)["total_rows"].should == 3
     end
 
-    it "should retrieve docs from temp views" do
-      @db.temp_view(@view, :key => "gomer pyle")["rows"].length.should == 1
+    it "should retrieve all documents by keys" do
+      @db.all(:keys => ["vince"])["rows"].length.should == 1
+    end
+
+    it "should retrieve docs from temp views with #view and #temp" do
+      @db.temp(@view, :key => "gomer pyle")["rows"].length.should == 1
+      @db.view(:temp, :funcs => @view, :key => "gomer pyle")["rows"].length.should == 1
     end
 
     it "should retrieve docs from temp views by keys" do
-      @db.temp_view(@view, :keys => ["vince carter"])["rows"].length.should == 1
+      @db.temp(@view, :keys => ["vince carter"])["rows"].length.should == 1
     end
 
-    it "should retrieve docs from regular views" do
+    it "should retrieve docs from regular views with #view" do
       @db.view("foo/bar", :key => "gomer pyle")["rows"].length.should == 1
     end
 
@@ -154,68 +223,82 @@ describe "Cushion::Database" do
       @db.view("foo/bar", :keys => ["vince carter"])["rows"].length.should == 1
     end
 
-    it "should retrieve a doc from a show function" do
-      design = @db.open_doc("_design/foo")
+    it "should perform a conditional GET" do
+      etag = @db.view("foo/bar").etag
+      lambda {
+        @db.view("foo/bar", :etag => etag)
+      }.should.raise RestClient::NotModified
+    end
+
+    it "should retrieve a doc from a show function with #show" do
+      design = @db.fetch("_design/foo")
       design["shows"] = { "people" => "function(doc, req) { var response = {'code':200, 'headers':{}, 'body':'Hello World'}; return response; }" }
-      @db.save_doc(design)
+      @db.store(design)
       @db.show("foo", "people", "gomer").should == "Hello World"
     end
 
-    it "should retrieve docs from a list function" do
-      design = @db.open_doc("_design/foo")
+    it "should retrieve docs from a list function with #list" do
+      design = @db.fetch("_design/foo")
       design["lists"] = { "people" => "function(head, row, req, row_info) { var response = {'code':200, 'headers':{}, 'body':'x'}; return response; }" }
-      @db.save_doc(design)
+      @db.store(design)
       @db.list("foo", "people", "bar").should == "xxxx"
     end
-
   end
 
-  describe "Attachments" do
-
-    it "should save and open inline attachments" do
-      @db.save_doc("_id" => "inline", "_attachments" => {
-        "foo.txt" => {
-          "content_type" => "text/plain",
-          "data" => "Hello World!"
-        }
-      })["ok"].should.be.true
+  describe "when copying and moving documents" do
+    before do
+      @source = @db.store("_id" => "source", "_attachments" => {
+          "foo.txt" => {
+            "content_type" => "text/plain",
+            "data" => "Hello World!"
+          }
+        })
+      @dest = @db.store("_id" => "dest")
+    end
 
-      @db.open_attachment("inline", "foo.txt").read.should == "Hello World!"
+    it "should copy a doc to a new id with #copy" do
+      @db.copy("source", "source_1")["ok"].should.be.true
+      lambda { @db.fetch("source_1") }.should.not.raise
     end
 
-    it "should save and open standalone attachments" do
-      res = @db.save_doc("_id" => "attachable")
-      @db.save_attachment(res['id'], res['rev'],
-        "foo.txt", "Hello World!",
-        :content_type => "text/plain"
-      )["ok"].should.be.true
+    it "should copy a doc to an existing doc" do
+      @db.copy("source", "dest", :dest_rev => @dest["rev"])["ok"].should.be.true
+      @db.fetch("dest")["_attachments"].should.not.be.nil
+    end
 
-      @db.open_attachment("attachable", "foo.txt").read.should == "Hello World!"
+    it "should move a doc to a new id with #move" do
+      @db.move("source", "source_1", :rev => @source["rev"])["ok"].should.be.true
+      lambda { @db.fetch("source_1") }.should.not.raise
+      lambda { @db.fetch("source") }.should.raise RestClient::ResourceNotFound
     end
 
-    it "should delete attachments" do
-      res = @db.save_doc("_id" => "deleteme", "_attachments" => {
-        "foo.txt" => {
-          "content_type" => "text/plain",
-          "data" => "Hello World!"
-        }
-      })
+    it "should move a doc to an existing doc" do
+      @db.move("source", "dest", :rev => @source["rev"], :dest_rev => @dest["rev"])["ok"].should.be.true
+      @db.fetch("dest")["_attachments"].should.not.be.nil
+    end
 
-      @db.delete_attachment("deleteme", res["rev"], "foo.txt")["ok"].should.be.true
+    it "should copy a file to a new key under the same doc with #copy_attachment" do
+      @db.copy_attachment("source", "foo.txt", "bar.txt")["ok"].should.be.true
+      @db.fetch("source", "bar.txt").should == "Hello World!"
     end
 
-    it "should rename attachments" do
-      res = @db.save_doc("_id" => "rename", "_attachments" => {
-        "foo.txt" => {
-          "content_type" => "text/plain",
-          "data" => "Hello World!"
-        }
-      })
+    it "should copy a file to a new key in another doc with #copy_attachment" do
+      @db.copy_attachment("source", "foo.txt", "bar.txt", :dest_id => "dest",
+        :dest_rev => @dest["rev"])["ok"].should.be.true
+      @db.fetch("dest", "bar.txt").should == "Hello World!"
+    end
 
-      @db.rename_attachment("rename", res["rev"], "foo.txt", "bar.txt")["ok"].should.be.true
-      @db.open_doc("rename")["_attachments"]["bar.txt"].should.not.be.nil
+    it "should move a file to a new key under the same doc with #move_attachment" do
+      @db.move_attachment("source", "foo.txt", "bar.txt")["ok"].should.be.true
+      @db.fetch("source", "bar.txt").should == "Hello World!"
+      lambda { @db.fetch("source", "foo.txt") }.should.raise RestClient::ResourceNotFound
     end
 
+    it "should move a file to a new key in another doc with #move_attachment" do
+      @db.move_attachment("source", "foo.txt", "bar.txt", :dest_id => "dest",
+        :dest_rev => @dest["rev"])["ok"].should.be.true
+      @db.fetch("dest", "bar.txt").should == "Hello World!"
+      lambda { @db.fetch("source", "foo.txt") }.should.raise RestClient::ResourceNotFound
+    end
   end
-
 end