dpla-couchrest 1.2.1.pre.dpla

data/spec/couchrest/helpers/pager_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe CouchRest::Pager do
+  before(:all) do
+    @cr = CouchRest.new(COUCHHOST)
+    @db = @cr.database(TESTDB)
+    @db.delete! rescue nil
+    @db = @cr.create_db(TESTDB) rescue nil
+    @pager = CouchRest::Pager.new(@db)
+    @docs = []
+    100.times do |i|
+      @docs << ({:number => (i % 10)})
+    end
+    @db.bulk_save(@docs)
+  end
+  
+  after(:all) do
+    begin
+      @db.delete!
+    rescue RestClient::Request::RequestFailed
+    end
+  end
+  
+  it "should store the db" do
+    @pager.db.should == @db
+  end
+  
+  describe "paging all docs" do
+    it "should yield total_docs / limit times" do
+      n = 0
+      @pager.all_docs(10) do |doc|
+        n += 1
+      end
+      n.should == 10
+    end
+    it "should yield each docrow group without duplicate docs" do
+      docids = {}
+      @pager.all_docs(10) do |docrows|
+        docrows.each do |row|
+          docids[row['id']].should be_nil
+          docids[row['id']] = true
+        end
+      end      
+      docids.keys.length.should == 100
+    end
+    it "should yield each docrow group" do
+      @pager.all_docs(10) do |docrows|
+        doc = @db.get(docrows[0]['id'])
+        doc['number'].class.should == Fixnum
+      end      
+    end
+  end
+  
+  describe "Pager with a view and docs" do
+    before(:all) do
+      @db.save_doc({
+        '_id' => '_design/magic',
+        'views' => {
+          'number' => {
+            'map' => 'function(doc){emit(doc.number,null)}'
+          }
+        }
+      })
+    end
+    
+    it "should have docs" do
+      @docs.length.should == 100
+      @db.documents['rows'].length.should == 101
+    end
+    
+    it "should have a view" do
+      @db.view('magic/number', :limit => 10)['rows'][0]['key'].should == 0
+    end
+    
+    it "should yield once per key" do
+      results = {}
+      @pager.key_reduce('magic/number', 20) do |k,vs|
+        results[k] = vs.length
+      end
+      results[0].should == 10
+      results[3].should == 10
+    end
+    
+    it "with a small step size should yield once per key" do
+      results = {}
+      @pager.key_reduce('magic/number', 7) do |k,vs|
+        results[k] = vs.length
+      end
+      results[0].should == 10
+      results[3].should == 10
+      results[9].should == 10
+    end
+    it "with a large step size should yield once per key" do
+      results = {}
+      @pager.key_reduce('magic/number', 1000) do |k,vs|
+        results[k] = vs.length
+      end
+      results[0].should == 10
+      results[3].should == 10
+      results[9].should == 10
+    end
+    it "with a begin and end should only yield in the range (and leave out the lastkey)" do
+      results = {}
+      @pager.key_reduce('magic/number', 1000, 4, 7) do |k,vs|
+        results[k] = vs.length
+      end
+      results[0].should be_nil
+      results[4].should == 10
+      results[6].should == 10
+      results[7].should be_nil
+      results[8].should be_nil
+      results[9].should be_nil
+    end
+  end
+end

data/spec/couchrest/helpers/streamer_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe CouchRest::Streamer do
+  before(:all) do
+    @cr = CouchRest.new(COUCHHOST)
+    @db = @cr.database(TESTDB)
+    @db.delete! rescue nil
+    @db = @cr.create_db(TESTDB) rescue nil
+    @streamer = CouchRest::Streamer.new()
+    @docs = (1..1000).collect{|i| {:integer => i, :string => i.to_s}}
+    @db.bulk_save(@docs)
+    @db.save_doc({
+      "_id" => "_design/first",
+      :views => {
+        :test => {
+	  :map => "function(doc){for(var w in doc){ if(!w.match(/^_/))emit(w,doc[w])}}"
+        }
+      }
+    })
+  end
+
+  it "should raise error on #view as deprecated" do
+    lambda { @streamer.view }.should raise_error(/deprecated/)
+  end
+
+  it "should GET each row in a view" do
+    count = 0
+    header = @streamer.get("#{@db.root}/_all_docs") do |row|
+      count += 1
+    end
+    count.should == 1001
+    header.should == {"total_rows" => 1001, "offset" => 0}
+  end
+
+  it "should GET each row in a view with params" do
+    count = 0
+    header = @streamer.get("#{@db.root}/_all_docs?include_docs=true&limit=5") do |row|
+      count += 1
+    end
+    count.should == 5
+    header.should == {"total_rows" => 1001, "offset" => 0}
+  end
+
+  it "should GET no rows in a view with limit=0" do
+    count = 0
+    header = @streamer.get("#{@db.root}/_all_docs?include_docs=true&limit=0") do |row|
+      count += 1
+    end
+    count.should == 0
+    header.should == {"total_rows" => 1001, "offset" => 0}
+  end
+
+  it "should raise an exception if it receives malformed data" do
+    IO.stub(:popen) do |cmd, block|
+      class F
+        def initialize
+          @lines = [
+            '{"total_rows": 123, "offset": "0", "rows": [',
+            '{"foo": 1},',
+            '{"foo": 2},',
+          ]
+        end
+
+        def gets
+          @lines.shift
+        end
+      end
+
+      f = F.new
+      block.call f
+
+      IO.unstub(:popen)
+      IO.popen 'true' do; end
+    end
+
+    count = 0
+    expect do
+      @streamer.get("#{@db.root}/_all_docs?include_docs=true&limit=0") do |row|
+        count += 1
+      end
+    end.should raise_error(MultiJson::DecodeError)
+  end
+
+  it "should raise an exception if the couch connection fails" do
+    IO.stub(:popen) do |cmd, block|
+      class F
+        def initialize
+          @lines = [
+            '{"total_rows": 123, "offset": "0", "rows": [',
+            '{"foo": 1},',
+            '{"foo": 2},',
+          ]
+        end
+
+        def gets
+          @lines.shift
+        end
+      end
+
+      block.call F.new
+
+      IO.unstub(:popen)
+      IO.popen 'false' do; end
+    end
+
+    count = 0
+
+    expect do
+      @streamer.get("#{@db.root}/_all_docs?include_docs=true&limit=0") do |row|
+        count += 1
+      end
+    end.should raise_error(RestClient::ServerBrokeConnection)
+
+    count.should == 2
+  end
+
+  it "should POST for each row in a view" do
+    # First grab a pair of IDs
+    ids = []
+    @streamer.get("#{@db.root}/_design/first/_view/test?limit=2") do |row|
+      ids << row['id']
+    end
+    count = 0
+    @streamer.post("#{@db.root}/_all_docs?include_docs=true", :keys => ids) do |row|
+      count += 1
+    end
+    count.should == 2
+  end
+
+  it "should escape quotes" do
+    @streamer.send(:escape_quotes, "keys: [\"sams's test\"]").should eql("keys: [\\\"sams's test\\\"]")
+  end
+
+end

data/spec/couchrest/rest_api_spec.rb

@@ -0,0 +1,241 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CouchRest::RestAPI do
+
+  describe "class methods" do
+
+    subject { CouchRest }
+
+    let(:request) { RestClient::Request }
+    let(:simple_response) { "{\"ok\":true}" }
+    let(:parser) { MultiJson }
+    let(:parser_opts) { {:max_nesting => false} }
+
+    it "should exist" do
+      should respond_to :get
+      should respond_to :put
+      should respond_to :post
+      should respond_to :copy
+      should respond_to :delete
+      should respond_to :head
+    end
+
+    it "should provide default headers" do
+      should respond_to :default_headers
+      CouchRest.default_headers.should be_a(Hash)
+    end
+
+
+    describe :get do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo')
+      end
+
+      it "should never modify options" do
+        options = {:timeout => 1000}
+        options.freeze
+        request.should_receive(:execute).and_return(simple_response)
+        parser.should_receive(:decode)
+        expect { CouchRest.get('foo', options) }.to_not raise_error
+      end
+
+
+      it "should accept 'content_type' header" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers.merge(:content_type => :foo)}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :content_type => :foo)
+      end
+
+      it "should accept 'accept' header" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers.merge(:accept => :foo)}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :accept => :foo)
+      end
+
+      it "should forward RestClient options" do
+        req = {:url => 'foo', :method => :get, :timeout => 1000, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :timeout => 1000)
+      end
+
+      it "should forward parser options" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts.merge(:random => 'foo'))
+        CouchRest.get('foo', :random => 'foo')
+      end
+
+      it "should accept raw option" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:decode)
+        CouchRest.get('foo', :raw => true).should eql(simple_response)
+      end
+
+      it "should allow override of method (not that you'd want to!)" do
+        req = {:url => 'foo', :method => :fubar, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :method => :fubar)
+      end
+
+      it "should allow override of url (not that you'd want to!)" do
+        req = {:url => 'foobardom', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :url => 'foobardom')
+      end
+
+
+      it "should forward an exception if raised" do
+        request.should_receive(:execute).and_raise(RestClient::Exception)
+        expect { CouchRest.get('foo') }.to raise_error(RestClient::Exception)
+      end
+
+      context 'when decode_json_objects is true' do
+        class TestObject
+          def self.json_create(args)
+            new
+          end
+        end
+
+        before(:each) do
+          CouchRest.decode_json_objects = true
+        end
+
+        after(:each) do
+          CouchRest.decode_json_objects = false
+        end
+
+        it 'should return the response as a Ruby object' do
+          CouchRest.put "#{COUCHHOST}/#{TESTDB}/test", JSON.create_id => TestObject.to_s
+
+          CouchRest.get("#{COUCHHOST}/#{TESTDB}/test").class.should eql(TestObject)
+        end
+      end
+    end
+
+    describe :post do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data')
+      end
+
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data')
+      end
+
+      it "should send raw request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data', :raw => true)
+      end
+
+      it "should not encode nil request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', nil)
+      end
+
+      it "should send raw request automatically if file provided" do
+        f = File.open(FIXTURE_PATH + '/attachments/couchdb.png')
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => f}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', f)
+        f.close
+      end
+
+      it "should send raw request automatically if Tempfile provided" do
+        f = Tempfile.new('couchrest')
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => f}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', f)
+        f.close
+      end
+
+      it "should use as_couch_json method if available" do
+        h = {'foo' => 'bar'}
+        doc = CouchRest::Document.new(h)
+        doc.should_receive(:as_couch_json).and_return(h)
+        request.should_receive(:execute).and_return(simple_response)
+        parser.should_receive(:encode).with(h)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', doc)
+      end
+    end
+
+
+    describe :put do
+      # Only test basic as practically same as post
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :put, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.put('foo', 'data')
+      end
+
+    end
+
+    describe :delete do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :delete, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.delete('foo')
+      end
+    end
+
+    describe :copy do
+      it "should send basic request" do
+        headers = CouchRest.default_headers.merge(
+          'Destination' => 'fooobar'
+        )
+        req = {:url => 'foo', :method => :copy, :headers => headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.copy('foo', 'fooobar')
+      end
+
+      it "should never modify header options" do
+        options = {:headers => {:content_type => :foo}}
+        options.freeze
+        request.should_receive(:execute).and_return(simple_response)
+        parser.should_receive(:decode)
+        expect { CouchRest.copy('foo', 'foobar', options) }.to_not raise_error
+      end
+
+    end
+
+    describe :head do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :head, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        CouchRest.head('foo')
+      end
+    end
+
+  end
+
+end