dpla-analysand 3.0.2

data/spec/analysand/a_response.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+shared_examples_for 'a response' do
+  %w(success? conflict? unauthorized?
+     etag code cookies session_cookie).each do |m|
+    it "responds to ##{m}" do
+      response.should respond_to(m)
+    end
+  end
+
+  describe '#conflict?' do
+    it 'returns true if response code is 409' do
+      response.stub(:code => '409')
+
+      expect(response.conflict?).to eq(true)
+    end
+
+    it 'returns false if response code is 200' do
+      response.stub(:code => '200')
+
+      expect(response.conflict?).to eq(false)
+    end
+  end
+
+  describe '#unauthorized?' do
+    it 'returns true if response code is 401' do
+      response.stub(:code => '401')
+
+      response.should be_unauthorized
+    end
+
+    it 'returns false if response code is 200' do
+      response.stub(:code => '200')
+
+      response.should_not be_unauthorized
+    end
+  end
+
+  describe '#etag' do
+    it 'returns a string' do
+      response.etag.should be_instance_of(String)
+    end
+
+    it 'returns ETags without quotes' do
+      response.etag.should_not include('"')
+    end
+  end
+
+  describe '#session_cookie' do
+    describe 'with an AuthSession cookie' do
+      let(:cookie) do
+        'AuthSession=foobar; Version=1; Expires=Wed, 14 Nov 2012 16:32:04 GMT; Max-Age=600; Path=/; HttpOnly'
+      end
+
+      before do
+        response.stub(:cookies => [cookie])
+      end
+
+      it 'returns the AuthSession cookie' do
+        response.session_cookie.should == 'AuthSession=foobar'
+      end
+    end
+
+    describe 'without an AuthSession cookie' do
+      it 'returns nil' do
+        response.session_cookie.should be_nil
+      end
+    end
+  end
+end

data/spec/analysand/change_watcher_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+require 'analysand/change_watcher'
+require 'analysand/database'
+require 'celluloid'
+
+module Analysand
+  describe ChangeWatcher do
+    class TestWatcher < Analysand::ChangeWatcher
+      attr_accessor :changes
+
+      def initialize(database, credentials)
+        super(database)
+
+        self.changes = []
+
+        @credentials = credentials
+      end
+
+      def customize_request(req)
+        req.basic_auth(@credentials[:username], @credentials[:password])
+      end
+
+      def process(change)
+        changes << change
+        change_processed(change)
+      end
+    end
+
+    let(:db) { Database.new(database_uri) }
+
+    before do
+      create_databases!
+    end
+
+    after do
+      Celluloid.shutdown
+
+      drop_databases!
+    end
+
+    describe '#connection_ok' do
+      describe 'with a non-public change feed' do
+        before do
+          set_security({ 'names' => [admin_username] })
+        end
+
+        after do
+          clear_security
+        end
+
+        it 'passes credentials' do
+          watcher = TestWatcher.new(db, admin_credentials)
+
+          expect(watcher.connection_ok).to eq(true)
+        end
+      end
+    end
+
+    describe '#changes_feed_uri' do
+      let!(:watcher) { TestWatcher.new(db, admin_credentials) }
+
+      describe 'when invoked multiple times' do
+        it 'returns what it returned the first time' do
+          uri1 = watcher.changes_feed_uri
+          uri2 = watcher.changes_feed_uri
+
+          uri1.should == uri2
+        end
+      end
+    end
+
+    describe '#waiter_for' do
+      let!(:watcher) { TestWatcher.new(db, admin_credentials) }
+
+      describe 'if the given document has not been processed' do
+        it 'blocks until the document has been processed' do
+          waiter = watcher.waiter_for('bar')
+
+          Thread.new do
+            db.put('foo', { 'foo' => 'bar' }, admin_credentials)
+            db.put('bar', { 'foo' => 'bar' }, admin_credentials)
+          end
+
+          waiter.wait
+
+          watcher.changes.detect { |r| r['id'] == 'foo' }.should_not be_nil
+        end
+      end
+    end
+
+    it 'receives changes' do
+      watcher = TestWatcher.new(db, admin_credentials)
+
+      waiter = watcher.waiter_for('foo')
+      db.put('foo', { 'foo' => 'bar' }, admin_credentials)
+      waiter.wait
+
+      expect(watcher.changes.select { |r| r['id'] == 'foo' }.length).to eq(1)
+    end
+  end
+end

data/spec/analysand/database_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+require 'analysand/database'
+require 'analysand/errors'
+require 'thread'
+require 'uri'
+
+module Analysand
+  describe Database do
+    let(:db) { Database.new(database_uri) }
+
+    describe '#initialize' do
+      it 'requires an absolute URI' do
+        lambda { Database.new(URI("/abc")) }.should raise_error(InvalidURIError)
+      end
+
+      it 'accepts URIs as strings' do
+        uri = 'http://localhost:5984/foo/'
+
+        db = Database.new(uri)
+
+        db.uri.should == URI(uri)
+      end
+    end
+
+    describe '.create!' do
+      before do
+        drop_databases!
+      end
+
+      it 'creates the database at the given URI' do
+        db = Database.create!(database_uri, admin_credentials)
+
+        resp = db.ping
+        resp.body['db_name'].should == database_name
+      end
+
+      it 'raises an exception if the database cannot be created' do
+        Database.create!(database_uri, admin_credentials)
+
+        lambda { Database.create!(database_uri, admin_credentials) }.should raise_error(DatabaseError)
+      end
+    end
+
+    describe '.drop' do
+      before do
+        create_databases!
+      end
+
+      it 'drops the database at the given URI' do
+        resp = Database.drop(database_uri, admin_credentials)
+
+        resp.should be_success
+        Database.new(database_uri).ping.code.should == '404'
+      end
+    end
+
+    describe '#head' do
+      before do
+        clean_databases!
+
+        db.put!('foo', { 'foo' => 'bar' })
+      end
+
+      it 'retrieves the rev of a document' do
+        resp = db.head('foo')
+
+        resp.etag.should_not be_empty
+      end
+    end
+
+    describe '#get!' do
+      before do
+        clean_databases!
+
+        db.put!('foo', { 'foo' => 'bar' })
+      end
+
+      describe 'if the response code is 200' do
+        it 'returns the document' do
+          db.get!('foo').body['foo'].should == 'bar'
+        end
+      end
+
+      describe 'if the response code is 404' do
+        it 'raises Analysand::CannotAccessDocument' do
+          lambda { db.get!('bar') }.should raise_error(Analysand::CannotAccessDocument)
+        end
+
+        it 'includes the response in the exception' do
+          code = nil
+
+          begin
+            db.get!('bar')
+          rescue Analysand::CannotAccessDocument => e
+            code = e.response.code
+          end
+
+          code.should == '404'
+        end
+      end
+    end
+
+    describe '#get_attachment' do
+      let(:io) { StringIO.new('an attachment') }
+
+      before do
+        clean_databases!
+
+        db.put_attachment('doc_id/a', io, {}, admin_credentials)
+      end
+
+      xit 'permits streaming' do
+        resp = db.get_attachment('doc_id/a')
+
+        lambda { resp.read_body { } }.should_not raise_error
+      end
+    end
+
+    describe '#view' do
+      before do
+        clean_databases!
+
+        doc = {
+          'views' => {
+            'a_view' => {
+              'map' => %q{function (doc) { emit(doc['_id'], 1); }}
+            },
+            'composite_key' => {
+              'map' => %q{function (doc) { emit([1, doc['_id']], 1); }}
+            }
+          }
+        }
+
+        db.put('_design/doc', doc, admin_credentials)
+        db.put('abc123', {}, admin_credentials)
+        db.put('abc456', {}, admin_credentials)
+      end
+
+      it 'retrieves _all_docs' do
+        resp = db.view('_all_docs')
+
+        resp.code.should == '200'
+      end
+
+      it 'retrieves a view' do
+        resp = db.view('doc/a_view')
+
+        resp.code.should == '200'
+        resp.total_rows.should == resp.body['total_rows']
+        resp.offset.should == resp.body['offset']
+        resp.rows.should == resp.body['rows']
+      end
+
+      it 'works with the full document name' do
+        resp = db.view('_design/doc/_view/a_view')
+
+        resp.code.should == '200'
+      end
+
+      it 'passes through view parameters' do
+        resp = db.view('doc/a_view', :skip => 1)
+
+        resp.offset.should == 1
+        resp.rows.length.should == 1
+      end
+
+      it 'JSON-encodes the key parameter' do
+        resp = db.view('doc/composite_key', :key => [1, 'abc123'])
+
+        resp.code.should == '200'
+        resp.rows.length.should == 1
+      end
+
+      it 'JSON-encodes the keys parameter' do
+        resp = db.view('doc/composite_key', :keys => [[1, 'abc123'], [1, 'abc456']])
+
+        resp.code.should == '200'
+        resp.rows.length.should == 2
+      end
+
+      it 'JSON-encodes the startkey parameter' do
+        resp = db.view('doc/composite_key', :startkey => [1, 'abc123'])
+
+        resp.code.should == '200'
+        resp.rows.length.should == 2
+      end
+
+      it 'JSON-encodes the endkey parameter' do
+        resp = db.view('doc/composite_key', :endkey => [1, 'abc456'], :skip => 1)
+
+        resp.code.should == '200'
+        resp.rows.length.should == 1
+      end
+
+      it 'can issue POSTs' do
+        resp = db.view('doc/a_view', :keys => ['abc123', 'abc456'], :post => true)
+
+        resp.code.should == '200'
+        resp.rows.length.should == 2
+      end
+
+      it 'passes credentials' do
+        security = {
+          'members' => {
+            'names' => [member1_username],
+            'roles' => []
+          }
+        }
+
+        db.put!('_security', security, admin_credentials)
+
+        resp = db.view('doc/a_view', { :skip => 1 }, member1_credentials)
+
+        resp.code.should == '200'
+      end
+    end
+
+    describe '#view!' do
+      before do
+        clean_databases!
+      end
+
+      describe 'if the response code is 404' do
+        it 'raises Analysand::CannotAccessView' do
+          lambda { db.view!('unknown/view') }.should raise_error(Analysand::CannotAccessView)
+        end
+
+        it 'includes the response in the exception' do
+          code = nil
+
+          begin
+            db.view!('unknown/view')
+          rescue Analysand::CannotAccessView => e
+            code = e.response.code
+          end
+
+          code.should == '404'
+        end
+      end
+    end
+  end
+end

data/spec/analysand/database_writing_spec.rb

@@ -0,0 +1,488 @@
+require 'spec_helper'
+
+require 'analysand/database'
+require 'analysand/errors'
+
+module Analysand
+  describe Database do
+    let(:db) { Database.new(database_uri) }
+
+    let(:doc_id) { 'abc123' }
+    let(:doc) do
+      { 'foo' => 'bar' }
+    end
+
+    before do
+      clean_databases!
+      clear_security
+    end
+
+    shared_examples_for '#put success examples' do
+      def put(*args)
+        db.send(method, *args)
+      end
+
+      it 'creates documents' do
+        put(doc_id, doc)
+
+        db.get(doc_id).body['foo'].should == 'bar'
+      end
+
+      it 'returns success on document creation' do
+        resp = put(doc_id, doc)
+
+        resp.should be_success
+      end
+
+      it 'ignores the _id attribute in documents' do
+        doc.update('_id' => 'wrong')
+        put(doc_id, doc)
+
+        db.get(doc_id).body['foo'].should == 'bar'
+        db.get('wrong').should_not be_success
+      end
+
+      it 'passes credentials' do
+        set_security({ 'users' => [member1_username] })
+
+        put(doc_id, doc, member1_credentials)
+        db.get(doc_id).should be_success
+      end
+
+      it 'passes the batch option' do
+        resp = put(doc_id, doc, nil, :batch => 'ok')
+
+        resp.code.should == '202'
+      end
+
+      it 'updates documents' do
+        resp = put(doc_id, doc)
+
+        doc['bar'] = 'baz'
+        doc['_rev'] = resp['rev']
+
+        put(doc_id, doc)
+        db.get(doc_id)['bar'].should == 'baz'
+      end
+
+      it 'returns success on document update' do
+        resp = put(doc_id, doc)
+
+        doc['bar'] = 'baz'
+        doc['_rev'] = resp['rev']
+
+        resp = put(doc_id, doc)
+        resp.should be_success
+      end
+
+      it 'escapes document IDs' do
+        db.put('an ID', doc)
+
+        db.get('an ID').should be_success
+      end
+
+      it 'handles URN-like IDs' do
+        db.put('org.couchdb.doc:one', doc)
+
+        db.get('org.couchdb.doc:one').should be_success
+      end
+    end
+
+    describe '#create' do
+      before do
+        drop_databases!
+      end
+
+      it 'creates a database' do
+        db.create(admin_credentials)
+
+        db.ping.should be_success
+      end
+
+      it 'returns success' do
+        db.create(admin_credentials).should be_success
+      end
+    end
+
+    describe '#drop' do
+      it 'drops the database' do
+        db.drop(admin_credentials)
+
+        db.ping.should_not be_success
+      end
+
+      it 'returns success' do
+        db.drop(admin_credentials).should be_success
+      end
+    end
+
+    describe '#drop!' do
+      it 'drops the database' do
+        db.drop(admin_credentials)
+
+        db.ping.should_not be_success
+      end
+
+      it 'raises Analysand::CannotDropDatabase on failure' do
+        lambda { db.drop!(member1_credentials) }.should raise_error(Analysand::CannotDropDatabase)
+      end
+    end
+
+    describe '#put' do
+      it_should_behave_like '#put success examples' do
+        let(:method) { :put }
+      end
+
+      describe 'on update conflict' do
+        before do
+          db.put(doc_id, doc)
+        end
+
+        it 'returns the error code' do
+          resp = db.put(doc_id, doc)
+
+          resp.code.should == '409'
+        end
+
+        it 'returns the error body' do
+          resp = db.put(doc_id, doc)
+
+          resp.body.should have_key('error')
+        end
+      end
+    end
+
+    describe '#put!' do
+      it_should_behave_like '#put success examples' do
+        let(:method) { :put! }
+      end
+
+      describe 'on update conflict' do
+        before do
+          db.put(doc_id, doc)
+        end
+
+        it 'raises Analysand::DocumentNotSaved' do
+          lambda { db.put!(doc_id, doc) }.should raise_error(Analysand::DocumentNotSaved) { |e|
+            e.response.code.should == '409'
+          }
+        end
+      end
+    end
+
+    describe '#ensure_full_commit' do
+      before do
+        db.put('abc', {}, :batch => :ok)
+      end
+
+      it 'returns success' do
+        db.ensure_full_commit.should be_success
+      end
+
+      it 'flushes batched PUTs' do
+        db.ensure_full_commit
+
+        db.get('abc').should be_success
+      end
+
+      it 'accepts credentials' do
+        lambda { db.ensure_full_commit(member1_credentials) }.should_not raise_error
+      end
+
+      it 'accepts a seq parameter' do
+        lambda { db.ensure_full_commit(member1_credentials, :seq => 10) }.should_not raise_error
+      end
+    end
+
+    describe '#put_attachment' do
+      let(:string) { 'an attachment' }
+      let(:io) { StringIO.new(string) }
+
+      it 'creates attachments' do
+        db.put_attachment("#{doc_id}/attachment", io)
+
+        db.get_attachment("#{doc_id}/attachment").body.should == string
+      end
+
+      it 'returns success when the attachment is uploaded' do
+        resp = db.put_attachment("#{doc_id}/attachment", io)
+
+        resp.should be_success
+      end
+
+      it 'passes credentials' do
+        set_security({ 'users' => [member1_username] })
+
+        resp = db.put_attachment("#{doc_id}/a", io, member1_credentials)
+        resp.should be_success
+      end
+
+      it 'sends the rev of the target document' do
+        resp = db.put!(doc_id, doc)
+        rev = resp['rev']
+
+        resp = db.put_attachment("#{doc_id}/a", io, nil, :rev => rev)
+        resp.should be_success
+      end
+
+      it 'sends the content type of the attachment' do
+        db.put_attachment("#{doc_id}/a", io, nil, :content_type => 'text/plain')
+
+        type = db.get_attachment("#{doc_id}/a").get_fields('Content-Type')
+        type.should == ['text/plain']
+      end
+    end
+
+    describe '#bulk_docs' do
+      let(:doc1) { { '_id' => 'doc1', 'foo' => 'bar' } }
+      let(:doc2) { { '_id' => 'doc2', 'bar' => 'baz' } }
+
+      it 'creates many documents' do
+        db.bulk_docs([doc1, doc2])
+
+        db.get('doc1')['foo'].should == 'bar'
+        db.get('doc2')['bar'].should == 'baz'
+      end
+
+      it 'updates many documents' do
+        r1 = db.put!('doc1', doc1)
+        r2 = db.put!('doc2', doc2)
+
+        doc1['foo'] = 'qux'
+        doc2['bar'] = 'quux'
+        doc1['_rev'] = r1['rev']
+        doc2['_rev'] = r2['rev']
+
+        db.bulk_docs([doc1, doc2])
+
+        db.get('doc1')['foo'].should == 'qux'
+        db.get('doc2')['bar'].should == 'quux'
+      end
+
+      it 'deletes many documents' do
+        r1 = db.put!('doc1', doc1)
+        r2 = db.put!('doc2', doc2)
+
+        d1 = { '_id' => 'doc1', '_rev' => r1['rev'], '_deleted' => true }
+        d2 = { '_id' => 'doc2', '_rev' => r2['rev'], '_deleted' => true }
+
+        db.bulk_docs([d1, d2])
+
+        db.get('doc1').code.should == '404'
+        db.get('doc2').code.should == '404'
+      end
+
+      it 'updates and deletes documents' do
+        r1 = db.put!('doc1', doc1)
+        r2 = db.put!('doc2', doc2)
+
+        d1 = { '_id' => 'doc1', '_rev' => r1['rev'], '_deleted' => true }
+        d2 = { '_id' => 'doc2', '_rev' => r2['rev'], 'bar' => 'quux' }
+
+        db.bulk_docs([d1, d2])
+
+        db.get('doc1').code.should == '404'
+        db.get('doc2')['bar'].should == 'quux'
+      end
+
+      it 'returns success if all operations succeeded' do
+        resp = db.bulk_docs([doc1, doc2])
+
+        resp.should be_success
+      end
+
+      it 'returns non-success if one operation had an error' do
+        db.put!('doc1', doc1)
+
+        resp = db.bulk_docs([doc1, doc2])
+
+        resp.should_not be_success
+      end
+
+      it 'passes credentials' do
+        set_security({ 'users' => [member1_username] })
+
+        resp = db.bulk_docs([doc1, doc2], member1_credentials)
+
+        resp.should be_success
+      end
+
+      it 'operates in non-atomic mode by default' do
+        db.put!('doc1', doc1)
+        db.bulk_docs([doc1, doc2])
+
+        db.get('doc2').should be_success
+      end
+
+      it 'supports all-or-nothing mode' do
+        # Force a validation failure to check that all-or-nothing mode is
+        # properly enabled.
+        db.put!('doc1', doc1)
+        db.put!('_design/validation', {
+          'validate_doc_update' => 'function(){throw({forbidden: ""});}'
+        }, admin_credentials)
+
+        db.bulk_docs([doc1, doc2], nil, :all_or_nothing => true)
+
+        db.get('doc2').code.should == '404'
+      end
+    end
+
+    describe '#bulk_docs!' do
+      let(:doc1) { { '_id' => 'doc1', 'foo' => 'bar' } }
+      let(:doc2) { { '_id' => 'doc2', 'bar' => 'baz' } }
+
+      it 'returns success if all operations succeeded' do
+        resp = db.bulk_docs!([doc1, doc2])
+
+        resp.should be_success
+      end
+
+      describe 'if authorization fails' do
+        let(:wrong) do
+          { :username => 'wrong', :password => 'wrong' }
+        end
+
+        it 'raises Analysand::BulkOperationFailed' do
+          lambda { db.bulk_docs!([doc1, doc2], wrong) }.should raise_error(Analysand::BulkOperationFailed)
+        end
+      end
+
+      describe 'if an operation fails' do
+        before do
+          doc2['_id'] = 'doc1'
+        end
+
+        it 'raises Analysand::BulkOperationFailed' do
+          lambda { db.bulk_docs!([doc1, doc2]) }.should raise_error(Analysand::BulkOperationFailed, /bulk operation failed/i)
+        end
+      end
+    end
+
+    describe '#copy' do
+      before do
+        db.put!(doc_id, doc)
+      end
+
+      it 'copies one doc to another ID' do
+        db.copy(doc_id, 'bar')
+
+        db.get('bar')['foo'].should == 'bar'
+      end
+
+      it 'returns success if copy succeeds' do
+        resp = db.copy(doc_id, 'bar')
+
+        resp.should be_success
+      end
+
+      it 'returns failure if copy fails' do
+        db.put!('bar', {})
+        resp = db.copy(doc_id, 'bar')
+
+        resp.code.should == '409'
+      end
+
+      it 'overwrites documents' do
+        resp = db.put!('bar', {})
+        db.copy(doc_id, "bar?rev=#{resp['rev']}")
+
+        db.get('bar')['foo'].should == 'bar'
+      end
+
+      it 'passes credentials' do
+        set_security({ 'users' => [member1_username] })
+
+        db.copy(doc_id, 'bar', member1_credentials)
+        db.get('bar')['foo'].should == 'bar'
+      end
+
+      it 'escapes document IDs in URIs' do
+        db.copy(doc_id, 'an ID')
+
+        db.get('an ID')['foo'].should == 'bar'
+      end
+    end
+
+    shared_examples_for '#delete success examples' do
+      let(:rev) { @put_resp['rev'] }
+
+      before do
+        @put_resp = db.put!(doc_id, doc)
+      end
+
+      def delete(*args)
+        db.send(method, *args)
+      end
+
+      it 'deletes documents' do
+        db.delete(doc_id, rev)
+
+        db.get(doc_id).code.should == '404'
+      end
+
+      it 'returns success on deletion' do
+        resp = db.delete(doc_id, rev)
+
+        resp.should be_success
+      end
+
+      it 'passes credentials' do
+        set_security({ 'users' => [member1_username] })
+
+        resp = db.delete(doc_id, rev, member1_credentials)
+
+        resp.should be_success
+      end
+
+      it 'escapes document IDs in URIs' do
+        @put_resp = db.put!('an ID', doc)
+
+        resp = db.delete('an ID', rev)
+        resp.should be_success
+      end
+    end
+
+    describe '#delete' do
+      it_should_behave_like '#delete success examples' do
+        let(:method) { :delete }
+      end
+
+      describe 'on update conflict' do
+        before do
+          db.put!(doc_id, doc)
+        end
+
+        it 'returns the error code' do
+          resp = db.delete(doc_id, nil)
+
+          resp.code.should == '400'
+        end
+
+        it 'returns the error body' do
+          resp = db.delete(doc_id, nil)
+
+          resp.body.should have_key('error')
+        end
+      end
+    end
+
+    describe '#delete!' do
+      it_should_behave_like '#delete success examples' do
+        let(:method) { :delete! }
+      end
+
+      describe 'on update conflict' do
+        before do
+          db.put!(doc_id, doc)
+        end
+
+        it 'raises Analysand::DocumentNotDeleted' do
+          lambda { db.delete!(doc_id, nil) }.should raise_error(Analysand::DocumentNotDeleted) { |e|
+            e.response.code.should == '400'
+          }
+        end
+      end
+    end
+  end
+end