rscribd 1.0.3 → 1.0.4

data/.gitignore

@@ -0,0 +1,5 @@
+doc
+*.gemspec
+pkg
+.idea
+.DS_Store

data/History.txt

@@ -1,3 +1,8 @@
+=== 1.0.4 / 2009-7-24
+
+* Offset and limit parameters can now be used when fetching user documents.
+* Minor bug fixes.
+
 === 1.0.3 / 2009-7-13
 
 * Removed unnecessary post parameters from API calls.

data/Rakefile

@@ -1,29 +1,25 @@
 require 'rubygems'
-require 'hoe'
 require 'spec/rake/spectask'
 
-Hoe.spec('rscribd') do |p|
-  p.version = '1.0.3'
-  p.rubyforge_name = 'rscribd'
-  p.author = 'Jared Friedman, Tim Morgan'
-  p.email = 'api@scribd.com'
-  p.summary = 'Ruby client library for the Scribd API'
-  p.description = p.paragraphs_of('README.txt', 3).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-  p.extra_deps << [ 'mime-types', '>0.0.0' ]
-  p.remote_rdoc_dir = ''
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rscribd"
+    gemspec.summary = "Ruby client library for the Scribd API"
+    gemspec.description = "The official Ruby gem for the Scribd API. Scribd is a document-sharing website allowing people to upload and view documents online."
+    gemspec.email = "api@scribd.com"
+    gemspec.homepage = "http://www.scribd.com/developers"
+    gemspec.authors = [ "Tim Morgan", "Jared Friedman", "Mike Watts" ]
+    
+    gemspec.add_dependency 'mime-types'
+    gemspec.add_development_dependency "rspec"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
 end
 
-# desc "Verify gem specs"
-# Spec::Rake::SpecTask.new do |t|
-#   t.spec_files = FileList['spec/*.rb']
-#   t.spec_opts = [ '-cfs' ]
-# end
-
-namespace :github do
-  desc "Prepare for GitHub gem packaging"
-  task :prepare do
-    `rake debug_gem > rscribd.gemspec`
-  end
-end
+desc "Verify gem specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/*.rb']
+  t.spec_opts = [ '-cfs' ]
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.4

data/lib/scribddoc.rb

@@ -91,15 +91,16 @@ module Scribd
     def save
       if not created? and @attributes[:file].nil? then
         raise "'file' attribute must be specified for new documents"
-        return false
       end
       
       if created? and @attributes[:file] and (@attributes[:owner].nil? or @attributes[:owner].session_key.nil?) then
         raise PrivilegeError, "The current API user is not the owner of this document"
       end
-      
+
       # Make a request form
+      response = nil
       fields = @attributes.dup
+      fields[:session_key] = fields.delete(:owner).session_key if fields[:owner]
       if file = @attributes[:file] then
         fields.delete :file
         is_file_object = file.is_a?(File)
@@ -110,12 +111,7 @@ module Scribd
         fields[:doc_type] ||= ext
         fields[:doc_type].downcase! if fields[:doc_type]
         fields[:rev_id] = fields.delete(:doc_id)
-      end
-      fields[:session_key] = fields.delete(:owner).session_key if fields[:owner]
-      response = nil
-      
-      if @attributes[:file] then
-        uri = nil
+
         begin
           uri = URI.parse @attributes[:file]
         rescue URI::InvalidURIError
@@ -141,9 +137,9 @@ module Scribd
         @created = true
       end
       
+      fields.delete :access if fields[:file] # when uploading a doc, don't send access twice
       fields.delete :file
       fields.delete :type
-      fields.delete :access
       fields.delete :conversion_status
       
       changed_attributes = fields.dup # changed_attributes is what we will stick into @attributes once we update remotely
@@ -207,7 +203,7 @@ module Scribd
     # this manner.
     
     def self.find(scope, options={})
-      doc_id = scope if scope.kind_of?(Integer)
+      doc_id = scope.kind_of?(Integer) ? scope : nil
       raise ArgumentError, "You must specify a query or document ID" unless options[:query] or doc_id
       
       if doc_id then
@@ -247,7 +243,18 @@ module Scribd
       response = API.instance.send_request('docs.getConversionStatus', :doc_id => self.id)
       response.elements['/rsp/conversion_status'].text
     end
-    
+
+    # Returns the document read count. This is only retrieved from the server the first time it's queried.
+    # To force re-retrieval on subsequent calls include :force => true in the options parameter.
+
+    def reads(options = {})
+      if @reads.nil? || options[:force]
+        response = API.instance.send_request('docs.getStats', :doc_id => self.id)
+        @reads = response.elements['/rsp/reads'].text
+      end
+      @reads
+    end
+
     # Deletes a document. Returns true if successful.
     
     def destroy

data/lib/scribdmultiparthack.rb

@@ -12,14 +12,14 @@ module Net #:nodoc:all
       boundary_token = [Array.new(8) {rand(256)}].join
       self.content_type = "multipart/form-data; boundary=#{boundary_token}"
       boundary_marker = "--#{boundary_token}\r\n"
-      self.body = param_hash.map { |param_name, param_value|
+      self.body = param_hash.map do |param_name, param_value|
         boundary_marker + case param_value
         when File
           file_to_multipart(param_name, param_value)
         else
           text_to_multipart(param_name, param_value.to_s)
         end
-      }.join('') + "--#{boundary_token}--\r\n"
+      end.join('') + "--#{boundary_token}--\r\n"
     end
 
     protected

data/lib/scribduser.rb

@@ -56,7 +56,9 @@ module Scribd
       end
     end
     
-    # Returns a list of all documents owned by this user. This list is _not_
+    # Returns a list of documents owned by this user. By default, the size of the returned
+    # list is capped at 1000. Use the :limit and :offset parameters to page through this
+    # user's documents, however :limit cannot be greater than 1000. This list is _not_
     # backed by the server, so if you add or remove items from it, it will not
     # make those changes server-side. This also has some tricky consequences
     # when modifying a list of documents while iterating over it:
@@ -71,8 +73,8 @@ module Scribd
     # additional attributes are documented online at
     # http://www.scribd.com/publisher/api?method_name=docs.getSettings
     
-    def documents
-      response = API.instance.send_request('docs.getList', { :session_key => @attributes[:session_key] })
+    def documents(options = {})
+      response = API.instance.send_request('docs.getList', options.merge(:session_key => @attributes[:session_key]))
       documents = Array.new
       response.elements['/rsp/resultset'].elements.each do |doc|
         documents << Document.new(:xml => doc, :owner => self)

data/spec/api_spec.rb

@@ -0,0 +1,131 @@
+old_dir = Dir.getwd
+Dir.chdir(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rscribd'
+
+describe Scribd::API do
+  it "should be a singleton" do
+    Scribd::API.instance.should be_kind_of(Scribd::API)
+    lambda { Scribd::API.new }.should raise_error(NoMethodError)
+  end
+  
+  describe "with the API key and secret in ENV" do
+    before :each do
+      ENV['SCRIBD_API_KEY'] = 'env key'
+      ENV['SCRIBD_API_SECRET'] = 'env sec'
+      @api = Scribd::API.send(:new)
+    end
+    
+    it "should set the API key and secret accordingly" do
+      @api.key.should eql('env key')
+      @api.secret.should eql('env sec')
+    end
+    
+    it "should favor local API key and secret settings" do
+      @api.key = 'test key'
+      @api.secret = 'test sec'
+      @api.key.should eql('test key')
+      @api.secret.should eql('test sec')
+    end
+  end
+  
+  describe "freshly reset" do
+    before :each do
+      ENV['SCRIBD_API_KEY'] = nil
+      ENV['SCRIBD_API_SECRET'] = nil
+      # reset the singleton; total hack
+      @api = Scribd::API.send(:new)
+    end
+    
+    it "should raise NotReadyError when send_request is called" do
+      lambda { @api.send_request('blah', {}) }.should raise_error(Scribd::NotReadyError)
+    end
+    
+    describe "with a key and secret set" do
+      before :each do
+        @api.key = 'test key'
+        @api.secret = 'test sec'
+      end
+      
+      it "should have the correct API key and secret" do
+        @api.key.should eql('test key')
+        @api.secret.should eql('test sec')
+      end
+      
+      it "should raise ArgumentError if the method is empty" do
+        lambda { @api.send_request(nil, {}) }.should raise_error(ArgumentError)
+        lambda { @api.send_request('', {}) }.should raise_error(ArgumentError)
+      end
+      
+      describe "with a mocked Net::HTTP" do
+        before :each do
+          @response = mock('Net::HTTP::Response @response')
+          @response.stub!(:body).and_return("<rsp stat='ok'/>")
+          
+          @http = Net::HTTP.new('http://www.example.com', 80)
+          @http.stub!(:request).and_return(@response)
+          Net::HTTP.stub!(:new).and_return(@http)
+          
+          @request = Net::HTTP::Post.new('/test')
+          Net::HTTP::Post.stub!(:new).and_return(@request)
+        end
+        
+        it "should set a nice, long read timeout" do
+          @api.send_request('test', {})
+          @http.read_timeout.should >= 60
+        end
+        
+        it "should set the multipart parameters to the given fields" do
+          fields = { :field1 => 1, :field2 => 'hi' }
+          @api.send_request('test', fields)
+          body = @request.body
+          fields.each do |key, value|
+            serial_str = <<-EOF
+Content-Disposition: form-data; name=#{key.to_s.inspect}
+
+#{value.to_s}
+            EOF
+            body.should include(serial_str.gsub(/\n/, "\r\n"))
+          end
+        end
+        
+        # it "should attempt to make the request 3 times" do
+        #   @http.stub!(:request).and_raise Exception
+        #   @http.should_receive(:request).exactly(3).times
+        #   lambda { @api.send_request('test', {}) }.should raise_error
+        # end
+        
+        it "should raise MalformedResponseError if the response doesn't have an rsp tag as its root" do
+          @response.stub!(:body).and_return("<invalid/>")
+          lambda { @api.send_request('test', {}) }.should raise_error(Scribd::MalformedResponseError)
+        end
+        
+        it "should raise a ResponseError for error responses" do
+          @response.stub!(:body).and_return("<rsp stat='fail'><error code='123' message='testmsg' /></rsp>")
+          lambda { @api.send_request('testmeth', {}) }.should raise_error(Scribd::ResponseError) { |error|
+            error.code.should eql("123")
+            error.message.should eql('Method: testmeth Response: code=123 message=testmsg')
+          }
+        end
+        
+        it "should return the REXML doc for successful responses" do
+          @response.stub!(:body).and_return("<rsp stat='ok'><element attr='val'><otherelem>val2</otherelem></element></rsp>")
+          @api.send_request('testmeth', {}).should be_kind_of(REXML::Document)
+        end
+      end
+    end
+  end
+  
+  it "should not be asynchronous by default" do
+    Scribd::API.instance.asynchronous.should_not be_true
+  end
+  
+  it "should not be in debug mode by default" do
+    Scribd::API.instance.instance_variable_get(:@debug).should_not be_true
+  end
+  
+  it "should have a user by default" do
+    Scribd::API.instance.user.should_not be_nil
+  end
+end
+
+Dir.chdir old_dir

data/spec/document_spec.rb

@@ -0,0 +1,557 @@
+old_dir = Dir.getwd
+Dir.chdir(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rscribd'
+
+describe Scribd::Document do
+  before :each do
+    Scribd::API.instance.key = 'test key'
+    Scribd::API.instance.secret = 'test sec'
+  end
+  
+  describe "initialized from attributes" do
+    before :each do
+      @document = Scribd::Document.new(:access => 'private', :title => 'mytitle')
+    end
+    
+    it "should have its attributes set appropriately" do
+      @document.access.should eql('private')
+      @document.title.should eql('mytitle')
+    end
+    
+    it "should be unsaved" do
+      @document.should_not be_saved
+    end
+    
+    it "should be uncreated" do
+      @document.should_not be_created
+    end
+  end
+  
+  describe "initialized from XML" do
+    before :each do
+      @owner = mock('Scribd::User @owner')
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<rsp stat='ok'><attr1>val1</attr1><attr2>val2</attr2></rsp>").root, :owner => @owner)
+    end
+    
+    it "should have its attributes set appropriately" do
+      @document.attr1.should eql('val1')
+      @document.attr2.should eql('val2')
+    end
+    
+    it "should be saved" do
+      @document.should be_saved
+    end
+    
+    it "should be created" do
+      @document.should be_created
+    end
+    
+    it "should have its owner set appropriately" do
+      @document.owner.should eql(@owner)
+    end
+  end
+  
+  describe "not yet created" do
+    before :each do
+      @document = Scribd::Document.new(:access => 'private', :title => 'mytitle')
+    end
+    
+    it "should raise an exception if saved without a file" do
+      lambda { @document.save }.should raise_error
+    end
+  end
+  
+  describe "created" do
+    before :each do
+      @http = mock('Net::HTTP @http')
+      @http.stub! :read_timeout=
+      @response = mock('Net::HTTPResponse @response')
+      @response.stub!(:body).and_return "<rsp stat='ok'></rsp>"
+      @http.stub!(:request).and_return(@response)
+      Net::HTTP.stub!(:new).and_return(@http)
+    end
+    
+    it "should not raise an exception if saved" do
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<rsp stat='ok'><attr1>val1</attr1><attr2>val2</attr2></rsp>").root)
+      lambda { @document.save }.should_not raise_error
+    end
+    
+    describe "that we own" do
+      before :each do
+        @owner = mock('Scribd::User @owner')
+        @owner.stub!(:session_key).and_return('test session key')
+        @document = Scribd::Document.new(:xml => REXML::Document.new("<rsp stat='ok'><attr1>val1</attr1><attr2>val2</attr2></rsp>").root, :owner => @owner)
+      end
+    end
+    
+    describe "that we don't own" do
+      before :each do
+        @owner = mock('Scribd::User @owner')
+        @owner.stub!(:session_key)
+        @document = Scribd::Document.new(:xml => REXML::Document.new("<rsp stat='ok'><attr1>val1</attr1><attr2>val2</attr2></rsp>").root, :owner => @owner)
+      end
+      
+      it "should raise PrivilegeError when trying to change the file" do
+        @document.file = 'sample/test.txt'
+        lambda { @document.save }.should raise_error(Scribd::PrivilegeError)
+      end
+    end
+    
+    describe "with no owner" do
+      before :each do
+        @document = Scribd::Document.new(:xml => REXML::Document.new("<rsp stat='ok'><attr1>val1</attr1><attr2>val2</attr2></rsp>").root)
+      end
+      
+      it "should raise PrivilegeError when trying to change the file" do
+        @document.file = 'sample/test.txt'
+        lambda { @document.save }.should raise_error(Scribd::PrivilegeError)
+      end
+    end
+  end
+  
+  describe "to be uploaded from file" do
+    before :each do
+      @document = Scribd::Document.new(:file => 'sample/test.txt')
+    end
+    
+    it "should make a call to docs.upload" do
+      Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:file => an_instance_of(File)))
+      Scribd::API.instance.should_receive(:send_request).any_number_of_times
+      @document.save
+    end
+  end
+  
+  describe "to be uploaded from URL" do
+    before :each do
+      @document = Scribd::Document.new(:file => 'http://www.example.com/file.txt')
+    end
+    
+    it "should make a call to docs.uploadFromUrl" do
+      Scribd::API.instance.should_receive(:send_request).with('docs.uploadFromUrl', hash_including(:url => 'http://www.example.com/file.txt'))
+      Scribd::API.instance.should_receive(:send_request).any_number_of_times
+      @document.save
+    end
+    
+    it "should recognize HTTPS URLs" do
+      @document.file.gsub!(/http/, 'https')
+      Scribd::API.instance.should_receive(:send_request).with('docs.uploadFromUrl', hash_including(:url => 'https://www.example.com/file.txt'))
+      Scribd::API.instance.should_receive(:send_request).any_number_of_times
+      @document.save
+    end
+    
+    it "should recognize FTP URLs" do
+      @document.file.gsub!(/http/, 'ftp')
+      Scribd::API.instance.should_receive(:send_request).with('docs.uploadFromUrl', hash_including(:url => 'ftp://www.example.com/file.txt'))
+      Scribd::API.instance.should_receive(:send_request).any_number_of_times
+      @document.save
+    end
+  end
+  
+  describe "to be uploaded" do
+    describe "given a file path" do
+      before :each do
+        @document = Scribd::Document.new(:file => 'sample/test.txt')
+      end
+
+      it "should set the doc_type attribute to the file's extension" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'txt'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should prefer a doc_type set in the type attribute" do
+        @document.type = 'pdf'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'pdf'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should not raise an exception if the document does not have an extension" do
+        @document.file = 'Rakefile'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => nil))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        lambda { @document.save }.should_not raise_error
+      end
+
+      it "should downcase filename extensions" do
+        @document.file = 'sample/test.TXT'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'txt'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        lambda { @document.save }.should_not raise_error
+      end
+
+      it "should downcase attributed file extensions" do
+        @document.type = 'PDF'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'pdf'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+    end
+    
+    describe "given a file object" do
+      before :each do
+        @document = Scribd::Document.new(:file => File.new('sample/test.txt'))
+      end
+
+      it "should set the doc_type attribute to the file's extension" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'txt'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should prefer a doc_type set in the type attribute" do
+        @document.type = 'pdf'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'pdf'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should not raise an exception if the document does not have an extension" do
+        @document.file = File.open('Rakefile')
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => nil))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        lambda { @document.save }.should_not raise_error
+      end
+
+      it "should downcase filename extensions" do
+        @document.file = File.open('sample/test.TXT')
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'txt'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        lambda { @document.save }.should_not raise_error
+      end
+
+      it "should downcase attributed file extensions" do
+        @document.type = 'PDF'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:doc_type => 'pdf'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+    end
+    
+    describe "given a file to upload" do
+      before :each do
+        @document = Scribd::Document.new(:file => 'sample/test.txt')
+      end
+      
+      it "should set the rev_id field to the doc_id attribute" do
+        @document.doc_id = 123
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:rev_id => 123))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should set the access field to the access attribute" do
+        @document.access = 'private'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:access => 'private'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should set the session_key field to the owner's session key" do
+        owner = mock('Scribd::User owner')
+        owner.stub!(:session_key).and_return('his key')
+        @document.owner = owner
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:session_key => 'his key'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      it "should pass through any other attributes to the docs.upload call" do
+        @document.hello = 'there'
+        Scribd::API.instance.should_receive(:send_request).with('docs.upload', hash_including(:hello => 'there'))
+        Scribd::API.instance.should_receive(:send_request).any_number_of_times
+        @document.save
+      end
+
+      describe "successfully" do
+        before :each do
+          @document.stub!(:id).and_return(3)
+          @xml = REXML::Document.new("<rsp stat='ok'><access_key>abc123</access_key></rsp>")
+          Scribd::API.instance.should_receive(:send_request).with('docs.upload', an_instance_of(Hash)).and_return(@xml)
+        end
+
+        describe "without testing changeSettings" do
+          before :each do
+            Scribd::API.instance.should_receive(:send_request).with('docs.changeSettings', an_instance_of(Hash))
+          end
+
+          it "should load attributes from the response" do
+            @document.save
+            @document.access_key.should eql('abc123')
+          end
+
+          it "should set created to true" do
+            @document.save
+            @document.should be_created
+          end
+
+          it "should set saved to true" do
+            @document.save
+            @document.should be_saved
+          end
+
+          it "should return true" do
+            @document.save.should be_true
+          end
+        end
+
+        it "should not send the file, type, or access parameters to the changeSettings call" do
+          @document.type = 'pdf'
+          @document.access = 'private'
+          Scribd::API.instance.should_not_receive(:send_request).with('docs.changeSettings', hash_including(:file => 'sample/text.txt'))
+          Scribd::API.instance.should_not_receive(:send_request).with('docs.changeSettings', hash_including(:type => 'pdf'))
+          Scribd::API.instance.should_not_receive(:send_request).with('docs.changeSettings', hash_including(:access => 'private'))
+          @document.save
+        end
+
+        it "should pass all other attributes to the changeSettings call" do
+          @document.attr1 = 'val1'
+          Scribd::API.instance.should_receive(:send_request).with('docs.changeSettings', hash_including(:attr1 => 'val1'))
+          @document.save
+        end
+
+        it "should pass the owner's session key to changeSettings" do
+          owner = mock('Scribd::User owner')
+          owner.stub!(:session_key).and_return('his key')
+          @document.owner = owner
+          Scribd::API.instance.should_receive(:send_request).with('docs.changeSettings', hash_including(:session_key => 'his key'))
+          @document.save
+        end
+
+        it "should pass the document's ID to changeSettings" do
+          Scribd::API.instance.should_receive(:send_request).with('docs.changeSettings', hash_including(:doc_ids => 3))
+          @document.save
+        end
+      end
+    end
+  end
+  
+  describe ".update_all" do
+    before :each do
+      @owner1 = mock('Scribd::User @owner1')
+      @owner1.stub!(:session_key).and_return 'session1'
+      @docs = [
+        Scribd::Document.new(:owner => @owner1, :doc_id => 1),
+        Scribd::Document.new(:owner => @owner1, :doc_id => 2)
+      ]
+    end
+    
+    it "should raise ArgumentError if an array of docs is not provided" do
+      lambda { Scribd::Document.update_all 'string', {} }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise ArgumentError unless all array elements are Scribd::Documents" do
+      @docs << 'string'
+      lambda { Scribd::Document.update_all @docs, {} }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise ArgumentError unless all documents have session keys" do
+      @docs << Scribd::Document.new
+      lambda { Scribd::Document.update_all @docs, {} }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise ArgumentError unless options is a hash" do
+      lambda { Scribd::Document.update_all @docs, 'string' }.should raise_error(ArgumentError)
+    end
+    
+    it "should call changeSettings once for each session key" do
+      @owner2 = mock('Scribd::User @owner2')
+      @owner2.stub!(:session_key).and_return 'session2'
+      @docs << Scribd::Document.new(:owner => @owner2, :doc_id => 3)
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.changeSettings', hash_including(:session_key => 'session1'))
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.changeSettings', hash_including(:session_key => 'session2'))
+      Scribd::Document.update_all @docs, { :access => 'private' }
+    end
+    
+    it "should set the doc_ids field to a comma-delimited list of document IDs" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.changeSettings', hash_including(:doc_ids => '1,2'))
+      Scribd::Document.update_all @docs, { :access => 'private' }
+    end
+    
+    it "should pass all options to the changeSettings call" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.changeSettings', hash_including(:access => 'private', :bogus => 'test'))
+      Scribd::Document.update_all @docs, { :access => 'private', :bogus => 'test' }
+    end
+  end
+  
+  describe ".find" do
+    it "should raise an ArgumentError if an invalid doc ID is provided" do
+      lambda { Scribd::Document.find('oh hai') }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an ArgumentError if a query is not provided for scoped lookups" do
+      lambda { Scribd::Document.find(:all, :title => 'hi') }.should raise_error(ArgumentError)
+    end
+    
+    describe "by ID" do
+      before :each do
+        @xml = REXML::Document.new("<rsp stat='ok'><access_key>abc123</access_key></rsp>")
+      end
+      
+      it "should call getSettings with the doc ID" do
+        Scribd::API.instance.should_receive(:send_request).once.with('docs.getSettings', hash_including(:doc_id => 123)).and_return(@xml)
+        Scribd::Document.find 123
+      end
+      
+      it "should pass other options to the getSettings call" do
+        Scribd::API.instance.should_receive(:send_request).once.with('docs.getSettings', hash_including(:arg => 'val')).and_return(@xml)
+        Scribd::Document.find 123, :arg => 'val'
+      end
+      
+      it "should return a Document created from the resulting XML" do
+        Scribd::API.instance.stub!(:send_request).and_return(@xml)
+        doc = Scribd::Document.find(123)
+        doc.should be_kind_of(Scribd::Document)
+        doc.access_key.should eql('abc123')
+      end
+    end
+    
+    describe "by query" do
+      before :each do
+        @xml = REXML::Document.new("<rsp stat='ok'><result_set><result><access_key>abc123</access_key></result><result><access_key>abc321</access_key></result></result_set></rsp>")
+      end
+      
+      it "should set the scope field according to the parameter" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.search', hash_including(:scope => 'all')).and_return(@xml)
+        Scribd::Document.find(:all, :query => 'test')
+      end
+      
+      it "should return an ordered array of Document results" do
+        Scribd::API.instance.stub!(:send_request).and_return(@xml)
+        docs = Scribd::Document.find(:all, :query => 'test')
+        docs.should have(2).items
+        docs.first.access_key.should eql('abc123')
+        docs.last.access_key.should eql('abc321')
+      end
+      
+      it "should set the scope to 'all' and return the first result if :first is provided" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.search', hash_including(:scope => 'all')).and_return(@xml)
+        docs = Scribd::Document.find(:first, :query => 'test')
+        docs.should be_kind_of(Scribd::Document)
+        docs.access_key.should eql('abc123')
+      end
+      
+      it "should set the num_results field to the limit option" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.search', hash_including(:num_results => 10)).and_return(@xml)
+        docs = Scribd::Document.find(:all, :query => 'test', :limit => 10)
+      end
+      
+      it "should set the num_start field to the offset option" do
+        Scribd::API.instance.should_receive(:send_request).with('docs.search', hash_including(:num_start => 10)).and_return(@xml)
+        docs = Scribd::Document.find(:all, :query => 'test', :offset => 10)
+      end
+    end
+  end
+  
+  it "should have an upload synonym for the create method"
+  
+  describe ".conversion_status" do
+    before :each do
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+      @xml = REXML::Document.new("<rsp stat='ok'><conversion_status>EXAMPLE</conversion_status></rsp>")
+    end
+    
+    it "should call getConversionStatus with the correct doc_id" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getConversionStatus', :doc_id => 123).and_return(@xml)
+      @document.conversion_status
+    end
+    
+    it "should return the conversion status" do
+      Scribd::API.instance.stub!(:send_request).and_return(@xml)
+      @document.conversion_status.should eql('EXAMPLE')
+    end
+  end
+
+  describe ".reads" do
+    before :each do
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+      @xml = REXML::Document.new("<rsp stat='ok'><reads>12321</reads></rsp>")
+    end
+
+    it "should call getStats with the correct doc_id" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getStats', :doc_id => 123).and_return(@xml)
+      @document.reads
+    end
+
+    it "should return the read count" do
+      Scribd::API.instance.stub!(:send_request).and_return(@xml)
+      @document.reads.should eql('12321')
+    end
+
+    it "should call getStats only once when read call made more than once" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getStats', :doc_id => 123).and_return(@xml)
+      @document.reads
+      @document.reads
+    end
+
+    it "should call getStats everytime when read call made with :force => true" do
+      Scribd::API.instance.should_receive(:send_request).twice.with('docs.getStats', :doc_id => 123).and_return(@xml)
+      @document.reads
+      @document.reads(:force => true)
+    end
+  end
+
+  describe ".destroy" do
+    before :each do
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+      @success = REXML::Document.new("<rsp stat='ok' />")
+      @fail = REXML::Document.new("<rsp stat='fail' />")
+    end
+    
+    it "should call delete with the correct doc_id" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.delete', :doc_id => 123).and_return(@success)
+      @document.destroy
+    end
+    
+    it "should return true if successful" do
+      Scribd::API.instance.stub!(:send_request).and_return(@success)
+      @document.destroy.should be_true
+    end
+    
+    it "should return false if unsuccessful" do
+      Scribd::API.instance.stub!(:send_request).and_return(@fail)
+      @document.destroy.should be_false
+    end
+  end
+  
+  it "should have an id attribute that aliases doc_id" do
+    document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+    document.id.should eql(123)
+  end
+  
+  describe ".owner=" do
+    it "should raise NotImplementedError for saved docs" do
+      document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+      lambda { document.owner = Scribd::User.new }.should raise_error(NotImplementedError)
+    end
+  end
+  
+  describe ".download_url" do
+    before :each do
+      @document = Scribd::Document.new(:xml => REXML::Document.new("<doc_id type='integer'>123</doc_id>"))
+      @xml = REXML::Document.new("<rsp stat='ok'><download_link><![CDATA[http://www.example.com/doc.pdf]]></download_link></rsp>")
+    end
+    
+    it "should call docs.getDownloadUrl with the correct doc_id" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getDownloadUrl', hash_including(:doc_id => 123)).and_return(@xml)
+      @document.download_url
+    end
+    
+    it "should default to the original file format" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getDownloadUrl', hash_including(:doc_type => 'original')).and_return(@xml)
+      @document.download_url
+    end
+    
+    it "should allow custom file formats" do
+      Scribd::API.instance.should_receive(:send_request).once.with('docs.getDownloadUrl', hash_including(:doc_type => 'pdf')).and_return(@xml)
+      @document.download_url('pdf')
+    end
+    
+    it "should return the download link" do
+      Scribd::API.instance.stub!(:send_request).and_return(@xml)
+      @document.download_url.should eql("http://www.example.com/doc.pdf")
+    end
+  end
+end
+
+Dir.chdir old_dir