couchrest 1.2.1 → 2.0.0.beta1

data/spec/couchrest/exceptions_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CouchRest::Exception do
+  it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
+    e = CouchRest::Exception.new
+    expect(e.message).to eq "CouchRest::Exception"
+  end
+
+  it "returns the 'message' that was set" do
+    e = CouchRest::Exception.new
+    message = "An explicitly set message"
+    e.message = message
+    expect(e.message).to eq message
+  end
+
+  it "sets the exception message to ErrorMessage" do
+    expect(CouchRest::NotFound.new.message).to eq 'Not Found'
+  end
+
+  it "contains exceptions in CouchRest" do
+    expect(CouchRest::Unauthorized.new).to be_a_kind_of(CouchRest::Exception)
+  end
+end
+
+describe CouchRest::RequestFailed do
+  before do
+    @response = double('HTTP Response', :status => 500)
+  end
+
+  it "stores the http response on the exception" do
+    response = "response"
+    begin
+      raise CouchRest::RequestFailed, response
+    rescue CouchRest::RequestFailed => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    expect(CouchRest::RequestFailed.new(@response).http_code).to eq 500
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    expect(CouchRest::RequestFailed.new(@response).http_code).to eq 500
+    expect(CouchRest::RequestFailed.new(@response).message).to eq 'HTTP status code 500'
+  end
+
+  it "shows the status code in the message" do
+    expect(CouchRest::RequestFailed.new(@response).to_s).to match(/500/)
+  end
+end
+
+describe CouchRest::NotFound do
+  it "also has the http response attached" do
+    response = "response"
+    begin
+      raise CouchRest::NotFound, response
+    rescue CouchRest::NotFound => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it 'stores the body on the response of the exception' do
+    body = "body"
+    stub_request(:get, "http://www.example.com").to_return(:body => body, :status => 404)
+    begin
+      CouchRest.get "http://www.example.com"
+      raise
+    rescue CouchRest::NotFound => e
+      expect(e.response.body).to eq body
+    end
+  end
+end
+

data/spec/couchrest/helpers/pager_spec.rb

@@ -22,7 +22,7 @@ describe CouchRest::Pager do
   end
   
   it "should store the db" do
-    @pager.db.should == @db
+    expect(@pager.db).to eql @db
   end
   
   describe "paging all docs" do
@@ -31,22 +31,22 @@ describe CouchRest::Pager do
       @pager.all_docs(10) do |doc|
         n += 1
       end
-      n.should == 10
+      expect(n).to eql 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
+          expect(docids[row['id']]).to be_nil
           docids[row['id']] = true
         end
       end      
-      docids.keys.length.should == 100
+      expect(docids.keys.length).to eql 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
+        expect(doc['number'].class).to eql Fixnum
       end      
     end
   end
@@ -64,12 +64,12 @@ describe CouchRest::Pager do
     end
     
     it "should have docs" do
-      @docs.length.should == 100
-      @db.documents['rows'].length.should == 101
+      expect(@docs.length).to eql 100
+      expect(@db.documents['rows'].length).to eql 101
     end
     
     it "should have a view" do
-      @db.view('magic/number', :limit => 10)['rows'][0]['key'].should == 0
+      expect(@db.view('magic/number', :limit => 10)['rows'][0]['key']).to eql 0
     end
     
     it "should yield once per key" do
@@ -77,8 +77,8 @@ describe CouchRest::Pager do
       @pager.key_reduce('magic/number', 20) do |k,vs|
         results[k] = vs.length
       end
-      results[0].should == 10
-      results[3].should == 10
+      expect(results[0]).to eql 10
+      expect(results[3]).to eql 10
     end
     
     it "with a small step size should yield once per key" do
@@ -86,30 +86,30 @@ describe CouchRest::Pager do
       @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
+      expect(results[0]).to eql 10
+      expect(results[3]).to eql 10
+      expect(results[9]).to eql 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
+      expect(results[0]).to eql 10
+      expect(results[3]).to eql 10
+      expect(results[9]).to eql 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
+      expect(results[0]).to be_nil
+      expect(results[4]).to eql 10
+      expect(results[6]).to eql 10
+      expect(results[7]).to be_nil
+      expect(results[8]).to be_nil
+      expect(results[9]).to be_nil
     end
   end
 end

data/spec/couchrest/helpers/stream_row_parser_spec.rb

@@ -0,0 +1,154 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe CouchRest::StreamRowParser do
+
+  describe :initialize do
+
+    let :obj do
+      CouchRest::StreamRowParser.new
+    end
+
+    it "should provide object" do
+      expect(obj).to_not be_nil
+    end
+
+  end
+
+  describe "#parse with rows" do
+
+    let :obj do
+      CouchRest::StreamRowParser.new
+    end
+
+    it "should parse a basic complete segment" do
+      data = <<-EOF
+      {
+        "total_rows": 3, "offset": 0, "rows": [
+          {"id": "doc1", "key": "doc1", "value": {"rev": "4324BB"}},
+          {"id": "doc2", "key": "doc2", "value": {"rev":"2441HF"}},
+          {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+        ]
+      }
+      EOF
+      rows = []
+      obj.parse(data) do |row|
+        rows << row
+      end
+
+      expect(rows.length).to eql(3)
+      row = nil
+      expect do
+        row = MultiJson.load(rows[0])
+      end.to_not raise_error
+      expect(row['id']).to eql('doc1')
+
+      head = nil
+      expect do
+        head = MultiJson.load(obj.header)
+      end.to_not raise_error
+      expect(head).to include('total_rows')
+      expect(head['total_rows']).to eql(3)
+    end
+
+    it "should deal with basic data in segments" do
+      data = []
+      data << '{ "total_rows": 3, "offset": 0, "ro'
+      data << 'ws": [  {"id": "doc1", "key": "doc1", "value": {"rev": '
+      data << '"4324BB"}}, {"id": "doc2", "key": "doc2", "value": '
+      data << '{"rev":"2441HF"}}, {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}'
+      data << ']  }'
+
+      rows = []
+      data.each do |d|
+        obj.parse(d) do |row|
+          rows << row
+        end
+      end
+
+      expect(rows.length).to eql(3)
+      row = nil
+      expect do
+        row = MultiJson.load(rows[1])
+      end.to_not raise_error
+      expect(row['id']).to eql('doc2')
+
+      head = nil
+      expect do
+        head = MultiJson.load(obj.header)
+      end.to_not raise_error
+      expect(head).to include('total_rows')
+      expect(head['total_rows']).to eql(3)
+    end
+
+
+    it "should handle strings with '}'" do
+      data = <<-EOF
+      {
+        "total_rows": 3, "offset": 0, "rows": [
+          {"id": "doc1", "key": "doc1", "value": {"rev":"43}24BB"}},
+          {"id": "doc2", "key": "doc2", "value": {"rev":"2{441HF"}},
+          {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+        ]
+      }
+      EOF
+      rows = []
+      obj.parse(data) do |row|
+        rows << row
+      end
+      expect(rows.length).to eql(3)
+      expect(rows.first).to match(/43}24BB/)
+    end
+
+    it "should handle escaped chars" do
+      data = <<-EOF
+      {
+        "total_rows": 3, "offset": 0, "rows": [
+          {"id": "doc1", "key": "doc1", "value": {"rev":"43\\"4BB"}},
+          {"id": "doc2", "key": "doc2", "value": {"rev":"2441HF"}},
+          {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+        ]
+      }
+      EOF
+      rows = []
+      obj.parse(data) do |row|
+        rows << row
+      end
+      expect(rows.length).to eql(3)
+      row = MultiJson.load(rows.first)
+      expect(row['value']['rev']).to match(/43"4BB/)
+    end
+
+  end
+
+
+  describe "#parse with feed" do
+
+    let :obj do
+      CouchRest::StreamRowParser.new(:feed)
+    end
+
+    it "should parse a basic complete segment" do
+      data = <<-EOF
+        {"id": "doc1", "key": "doc1", "value": {"rev": "4324BB"}}
+        {"id": "doc2", "key": "doc2", "value": {"rev":"2441HF"}}
+        {"id": "doc3", "key": "doc3", "value": {"rev":"74EC24"}}
+      EOF
+      rows = []
+      obj.parse(data) do |row|
+        rows << row
+      end
+
+      expect(rows.length).to eql(3)
+      row = nil
+      expect do
+        row = MultiJson.load(rows[0])
+      end.to_not raise_error
+      expect(row['id']).to eql('doc1')
+
+      obj.header.should be_empty
+    end
+
+
+  end
+
+end

data/spec/couchrest/rest_api_spec.rb

@@ -6,236 +6,72 @@ describe CouchRest::RestAPI 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)
+    let :mock_conn do
+      CouchRest::Connection.new(URI "http://mock")
     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
+    it "should exist" do
+      expect(subject).to respond_to :get
+      expect(subject).to respond_to :put
+      expect(subject).to respond_to :post
+      expect(subject).to respond_to :copy
+      expect(subject).to respond_to :delete
+      expect(subject).to respond_to :head
     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
+    describe "basic forwarding" do
 
-      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)
+      let :uri do
+        URI("http://mock/db/doc")
       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 start and use connection" do
+        expect(CouchRest::Connection).to receive(:new)
+          .with(uri, {})
+          .and_return(mock_conn)
+  
+        stub_request(:get, uri.to_s)
+          .to_return(:body => {'_id' => 'test', 'name' => 'none'}.to_json)
 
-      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
+        res = CouchRest.get(uri.to_s)
+        expect(res['name']).to eql('none')
       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 start connection with options" do
+        expect(CouchRest::Connection).to receive(:new)
+          .with(uri, hash_including(:test => 'foo'))
+          .and_return(mock_conn)
+  
+        stub_request(:get, uri.to_s)
+          .to_return(:body => {'_id' => 'test', 'name' => 'none'}.to_json)
 
-      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)
+        res = CouchRest.get(uri.to_s, :test => 'foo')
+        expect(res['name']).to eql('none')
       end
-    end
 
+      it "should handle query parameters and send them to connection" do
 
-    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')
+        uri = URI("http://mock/db/doc?q=a")
+        expect(CouchRest::Connection).to receive(:new)
+          .with(uri, {})
+          .and_return(mock_conn)
+        stub_request(:get, uri.to_s)
+          .to_return(:body => {'_id' => 'test', 'name' => 'none'}.to_json)
+        res = CouchRest.get(uri.to_s)
+        expect(res['name']).to eql('none')
       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')
+    
+      it "should delete a document" do
+        res = CouchRest.post(DB.uri.to_s, {'name' => "TestDoc"})
+        res = CouchRest.delete("#{DB.uri.to_s}/#{res['id']}?rev=#{res['rev']}")
+        expect(res['ok']).to be_true
       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