dpla-analysand 3.0.2

data/spec/analysand/instance_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+require 'analysand/errors'
+require 'analysand/instance'
+require 'json'
+require 'uri'
+require 'vcr'
+
+module Analysand
+  describe Instance do
+    describe '#initialize' do
+      it 'requires an absolute URI' do
+        lambda { Instance.new(URI("/abc")) }.should raise_error(InvalidURIError)
+      end
+
+      it 'accepts URIs as strings' do
+        uri = 'http://localhost:5984/'
+
+        db = Instance.new(uri)
+
+        db.uri.should == URI(uri)
+      end
+    end
+
+    let(:instance) { Instance.new(instance_uri) }
+
+    describe '#post_session' do
+      describe 'with valid credentials' do
+        let(:resp) { instance.post_session(member1_username, member1_password) }
+
+        it 'returns success' do
+          resp.should be_success
+        end
+
+        it 'returns a session cookie in the response' do
+          resp.session_cookie.should_not be_empty
+        end
+      end
+
+      it 'supports hash credentials' do
+        resp = instance.post_session(member1_credentials)
+
+        resp.should be_success
+      end
+
+      describe 'with invalid credentials' do
+        let(:resp) { instance.post_session(member1_username, 'wrong') }
+
+        it 'does not return success' do
+          resp.should_not be_success
+        end
+      end
+    end
+
+    describe '#test_session' do
+      describe 'with a valid cookie' do
+        let(:resp) { instance.post_session(member1_username, member1_password) }
+        let(:cookie) { resp.session_cookie }
+
+        it 'returns success' do
+          resp = instance.get_session(cookie)
+
+          resp.should be_success
+        end
+
+        it 'returns valid' do
+          resp = instance.get_session(cookie)
+
+          resp.should be_valid
+        end
+      end
+
+      describe 'with an invalid cookie' do
+        let(:cookie) { 'AuthSession=YWRtaW46NTBBNDkwRUE6npTfHKz68y5q1FX4pWiB-Lzk5mQ' }
+
+        it 'returns success' do
+          resp = instance.get_session(cookie)
+
+          resp.should be_success
+        end
+
+        it 'does not return valid' do
+          resp = instance.get_session(cookie)
+
+          resp.should_not be_valid
+        end
+      end
+
+      describe 'with a malformed cookie' do
+        let(:cookie) { 'AuthSession=wrong' }
+
+        it 'does not return success' do
+          resp = instance.get_session(cookie)
+
+          resp.should_not be_success
+        end
+
+        it 'does not return valid' do
+          resp = instance.get_session(cookie)
+
+          resp.should_not be_valid
+        end
+      end
+    end
+
+    describe '#get_config' do
+      let(:credentials) { admin_credentials }
+
+      it 'retrieves a configuration option' do
+        VCR.use_cassette('get_config') do
+          instance.get_config('stats/rate', admin_credentials).value.should == '"1000"'
+        end
+      end
+
+      it 'retrieves many configuration options' do
+        VCR.use_cassette('get_many_config') do
+          json = instance.get_config('stats', admin_credentials).value
+
+          JSON.parse(json).should == {
+            'rate' => '1000',
+            'samples' => '[0, 60, 300, 900]'
+          }
+        end
+      end
+    end
+
+    describe '#put_config!' do
+      it 'raises ConfigurationNotSaved on non-success' do
+        VCR.use_cassette('unauthorized_put_config') do
+          lambda { instance.put_config!('stats/rate', '"1000"') }.should raise_error(ConfigurationNotSaved)
+        end
+      end
+    end
+
+    describe '#put_config' do
+      let(:credentials) { admin_credentials }
+
+      after do
+        instance.delete_config!('foo/bar', admin_credentials)
+      end
+
+      it 'sets a configuration option' do
+        instance.put_config('foo/bar', '"1200"', admin_credentials)
+        instance.get_config('foo/bar', admin_credentials).value.should == '"1200"'
+      end
+
+      it 'roundtrips values from get_config' do
+        instance.put_config!('foo/bar', '"[0, 60, 300, 900]"', admin_credentials)
+
+        from_db = instance.get_config('foo/bar', admin_credentials).value
+        instance.put_config('foo/bar', from_db, admin_credentials)
+        instance.get_config('foo/bar', admin_credentials).value.should == from_db
+      end
+    end
+
+    describe '#delete_config' do
+      let(:credentials) { admin_credentials }
+
+      before do
+        instance.put_config!('foo/bar', '"1000"', admin_credentials)
+      end
+
+      it 'deletes configuration options' do
+        instance.delete_config('foo/bar', admin_credentials)
+
+        resp = instance.get_config('foo/bar', admin_credentials)
+        expect(resp.not_found?).to eq(true)
+      end
+    end
+
+    describe '#put_admin' do
+      let(:credentials) { admin_credentials }
+      let(:password) { 'password' }
+      let(:username) { 'new_admin' }
+
+      after do
+        instance.delete_admin!(username, credentials)
+      end
+
+      it 'adds an admin to the CouchDB admins list' do
+        instance.put_admin(username, password, admin_credentials)
+
+        resp = instance.post_session(username, password)
+        resp.body['roles'].should include('_admin')
+      end
+    end
+
+    describe '#delete_admin' do
+      let(:credentials) { admin_credentials }
+      let(:password) { 'password' }
+      let(:username) { 'new_admin' }
+
+      before do
+        instance.put_admin!(username, password, admin_credentials)
+      end
+
+      it 'deletes an admin from the CouchDB admins list' do
+        instance.delete_admin(username, admin_credentials)
+
+        resp = instance.post_session(username, password)
+        resp.should be_unauthorized
+      end
+    end
+  end
+end

data/spec/analysand/response_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'analysand/database'
+require 'analysand/response'
+
+require File.expand_path('../a_response', __FILE__)
+
+module Analysand
+  describe Response do
+    let(:db) { Database.new(database_uri) }
+
+    let(:response) do
+      VCR.use_cassette('head_request_with_etag') do
+        db.head('abc123', admin_credentials)
+      end
+    end
+
+    it_should_behave_like 'a response'
+
+    describe '#etag' do
+      it 'removes quotes from ETags' do
+        response.etag.should == '1-967a00dff5e02add41819138abb3284d'
+      end
+    end
+  end
+end

data/spec/analysand/view_response_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require 'analysand/database'
+require 'analysand/view_response'
+
+require File.expand_path('../a_response', __FILE__)
+
+module Analysand
+  describe ViewResponse do
+    let(:resp_with_docs) do
+      '{"rows": [{"id":"foo","key":"foo","value":{},"doc":{"foo":"bar"}}]}'
+    end
+
+    let(:resp_without_docs) do
+      '{"rows": [{"id":"foo","key":"foo","value":{}}]}'
+    end
+
+    let(:db) { Database.new(database_uri) }
+
+    it_should_behave_like 'a response' do
+      let(:response) do
+        VCR.use_cassette('view') { db.view('doc/a_view') }
+      end
+    end
+
+    describe '#docs' do
+      describe 'if the view includes docs' do
+        subject { ViewResponse.new(double(:body => resp_with_docs)) }
+
+        it 'returns the value of the "doc" key in each row' do
+          subject.docs.should == [{'foo' => 'bar'}]
+        end
+      end
+
+      describe 'if the view does not include docs' do
+        subject { ViewResponse.new(double(:body => resp_without_docs)) }
+
+        it 'returns []' do
+          subject.docs.should == []
+        end
+      end
+    end
+  end
+end

data/spec/analysand/view_streaming/builder_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require 'analysand/view_streaming/builder'
+
+module Analysand
+  module ViewStreaming
+    describe Builder do
+      let(:builder) { Builder.new }
+
+      it 'recognizes the "total_rows" key' do
+        builder << '{"total_rows":10000}'
+
+        builder.total_rows.should == 10000
+      end
+
+      it 'recognizes the "offset" key' do
+        builder << '{"offset":20}'
+
+        builder.offset.should == 20
+      end
+
+      describe 'for rows' do
+        before do
+          builder << '{"total_rows":10000,"offset":20,"rows":'
+        end
+
+        it 'builds objects' do
+          builder << '[{"id":"foo","key":"bar","value":1}]'
+
+          builder.staged_rows.should == [
+            { 'id' => 'foo', 'key' => 'bar', 'value' => 1 }
+          ]
+        end
+
+        it 'builds objects containing other objects' do
+          builder << '[{"id":"foo","key":"bar","value":{"total_rows":1}}]'
+
+          builder.staged_rows.should == [
+            { 'id' => 'foo',
+              'key' => 'bar',
+              'value' => {
+                 'total_rows' => 1
+               }
+            }
+          ]
+        end
+
+        it 'builds objects containing arrays' do
+          builder << '[{"id":"foo","key":"bar","value":{"things":[1,2,3]}}]'
+
+          builder.staged_rows.should == [
+            { 'id' => 'foo',
+              'key' => 'bar',
+              'value' => {
+                'things' => [1, 2, 3]
+              }
+            }
+          ]
+        end
+      end
+
+      describe 'given unexpected top-level keys' do
+        before do
+          builder << '{"total_rows":10000,"offset":20,"rows":[],'
+        end
+
+        it 'raises Analysand::UnexpectedViewKey' do
+          lambda { builder << '"abc":"def"}' }.should raise_error(Analysand::UnexpectedViewKey)
+        end
+      end
+    end
+  end
+end

data/spec/analysand/view_streaming_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+require 'analysand/database'
+require 'benchmark'
+
+require File.expand_path('../a_response', __FILE__)
+
+module Analysand
+  describe Database do
+    let(:db) { Database.new(database_uri) }
+    let(:row_count) { 15000 }
+
+    before do
+      WebMock.disable!
+    end
+
+    after do
+      WebMock.enable!
+    end
+
+    before do
+      clean_databases!
+
+      doc = {
+        'views' => {
+          'a_view' => {
+            'map' => %Q{
+              function (doc) {
+                var i;
+
+                for(i = 0; i < #{row_count}; i++) {
+                  emit(doc['_id'], i);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      db.put!('_design/doc', doc, admin_credentials)
+      db.put!('abc123', {}, admin_credentials)
+    end
+
+    shared_examples_for 'a view streamer' do
+      def get_view(options = {})
+        db.send(method, 'doc/a_view', options)
+      end
+
+      describe 'response' do
+        it_should_behave_like 'a response' do
+          let(:response) { get_view(:stream => true) }
+        end
+      end
+
+      it 'returns all rows in order' do
+        resp = get_view(:stream => true)
+
+        resp.rows.map { |r| r['value'] }.should == (0...row_count).to_a
+      end
+
+      it 'yields docs' do
+        resp = get_view(:include_docs => true, :stream => true)
+
+        expect(resp.docs.take(10).all? { |d| d.has_key?('_id') }).to eq(true)
+      end
+
+      it 'returns rows as soon as possible' do
+        # first, make sure the view's built
+        db.head('_design/doc/_view/a_view', admin_credentials)
+
+        streamed = Benchmark.realtime do
+          resp = get_view(:stream => true)
+          resp.rows.take(10)
+        end
+
+        read_everything = Benchmark.realtime do
+          resp = get_view
+          resp.rows.take(10)
+        end
+
+        streamed.should_not be_within(0.5).of(read_everything)
+      end
+
+      it 'returns view metadata' do
+        resp = get_view(:stream => true)
+
+        resp.total_rows.should == row_count
+        resp.offset.should == 0
+      end
+
+      describe '#each' do
+        it 'returns an Enumerator if no block is given' do
+          resp = get_view(:stream => true)
+
+          resp.rows.each.should be_instance_of(Enumerator)
+        end
+      end
+    end
+
+    describe '#view in streaming mode' do
+      it_should_behave_like 'a view streamer' do
+        let(:method) { :view }
+      end
+
+      it 'returns error codes from failures' do
+        resp = db.view('doc/nonexistent', :stream => true)
+
+        resp.code.should == '404'
+      end
+    end
+
+    describe '#view! in streaming mode' do
+      it_should_behave_like 'a view streamer' do
+        let(:method) { :view! }
+      end
+
+      it 'raises CannotAccessView on failure' do
+        lambda { db.view!('doc/nonexistent', :stream => true) }.should raise_error(CannotAccessView)
+      end
+    end
+  end
+end