berkeley_library-tind 0.4.0

data/spec/berkeley_library/tind/api/date_range_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module API
+      describe DateRange do
+
+        let(:t1) { Time.new(2021, 2, 15, 16, 23, 14, '-08:00') }
+        let(:t2) { Time.new(2021, 2, 16, 19, 23, 14, '-07:00') }
+
+        it 'is always in UTC' do
+          expect(t1.utc_offset).to eq(-28_800) # just to be sure
+          expect(t2.utc_offset).to eq(-25_200) # just to be sure
+
+          date_range = DateRange.new(from_time: t1, until_time: t2)
+          expect(date_range.from_time).to eq(t1.getutc)
+          expect(date_range.until_time).to eq(t2.getutc)
+
+          expect(t1.utc_offset).to eq(-28_800), 'DateRange initializer should not modify input from_time'
+          expect(t2.utc_offset).to eq(-25_200), 'DateRange initializer should not modify input until_time'
+        end
+
+        it 'rejects invalid ranges' do
+          expect { DateRange.new(from_time: t2, until_time: t1) }.to raise_error(ArgumentError)
+        end
+
+        describe :mtime do
+          it 'defaults to false' do
+            date_range = DateRange.new(from_time: t1, until_time: t2)
+            expect(date_range.mtime?).to eq(false)
+
+            params = date_range.to_params
+            expect(params.key?(:dt)).to eq(false)
+          end
+
+          it 'can be set to true' do
+            date_range = DateRange.new(from_time: t1, until_time: t2, mtime: true)
+            expect(date_range.mtime?).to eq(true)
+
+            params = date_range.to_params
+            expect(params[:dt]).to eq('m')
+          end
+        end
+
+        describe :to_params do
+          let(:tz_utc) { TZInfo::Timezone.get('UTC') }
+          let(:tz_local) { TZInfo::Timezone.get('Antarctica/South_Pole') }
+
+          before(:each) do
+            @tz_orig = BerkeleyLibrary::TIND::Config.instance_variable_get(:@timezone)
+          end
+
+          after(:each) do
+            BerkeleyLibrary::TIND::Config.instance_variable_set(:@timezone, @tz_orig)
+          end
+
+          it 'formats the dates' do
+            BerkeleyLibrary::TIND::Config.timezone = tz_utc
+
+            date_range = DateRange.new(from_time: t1, until_time: t2)
+            params = date_range.to_params
+            expect(params[:d1]).to eq('2021-02-16 00:23:14')
+            expect(params[:d2]).to eq('2021-02-17 02:23:14')
+          end
+
+          it 'formats the dates in the configured timezone' do
+            BerkeleyLibrary::TIND::Config.timezone = tz_local
+
+            date_range = DateRange.new(from_time: t1, until_time: t2)
+            params = date_range.to_params
+            expect(params[:d1]).to eq('2021-02-16 13:23:14')
+            expect(params[:d2]).to eq('2021-02-17 15:23:14')
+          end
+        end
+
+        describe :ensure_date_range do
+          it 'accepts a DateRange' do
+            date_range = DateRange.new(from_time: t1, until_time: t2)
+            expect(DateRange.ensure_date_range(date_range)).to be(date_range)
+          end
+
+          it 'accepts a range of Dates' do
+            d1 = t1.to_date
+            d2 = t2.to_date
+            date_range = d1..d2
+            expected = DateRange.new(from_time: d1, until_time: d2)
+            expect(DateRange.ensure_date_range(date_range)).to eq(expected)
+          end
+
+          it 'accepts a range of times' do
+            time_range = t1..t2
+            expected = DateRange.new(from_time: t1, until_time: t2)
+            expect(DateRange.ensure_date_range(time_range)).to eq(expected)
+          end
+
+          it 'is always in UTC' do
+            time_range = t1..t2
+            date_range = DateRange.ensure_date_range(time_range)
+            expect(date_range.from_time).to eq(t1.getutc)
+            expect(date_range.until_time).to eq(t2.getutc)
+          end
+
+          it 'rejects things that are not date/time ranges' do
+            expect { DateRange.ensure_date_range('1975-1990') }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/api/format_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module API
+      describe Format do
+        describe :to_s do
+          it 'returns the value' do
+            expected = { Format::ID => 'id', Format::XML => 'xml', Format::FILES => 'files', Format::JSON => 'json' }
+            expected.each do |fmt, val|
+              expect(fmt.value).to eq(val)
+              expect(fmt.to_s).to eq(val)
+            end
+          end
+        end
+
+        describe :to_str do
+          it 'returns the value' do
+            { Format::ID => 'id', Format::XML => 'xml', Format::FILES => 'files' }.each do |fmt, val|
+              expect(fmt.value).to eq(val)
+              expect(fmt.to_str).to eq(val)
+            end
+          end
+        end
+
+        describe :ensure_format do
+          it 'returns nil for nil' do
+            expect(Format.ensure_format(nil)).to be_nil
+          end
+
+          it 'returns a Format' do
+            expect(Format.ensure_format(Format::XML)).to be(Format::XML)
+          end
+
+          it 'accepts a string' do
+            expect(Format.ensure_format('xml')).to be(Format::XML)
+          end
+
+          it 'accepts a symbol' do
+            expect(Format.ensure_format(:xml)).to be(Format::XML)
+          end
+
+          it 'rejects unsupported values' do
+            expect { Format.ensure_format('CORBA') }.to raise_error(ArgumentError)
+          end
+
+          it 'rejects inconvertible values' do
+            expect { Format.ensure_format(Object.new) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/api/search_spec.rb

@@ -0,0 +1,364 @@
+require 'spec_helper'
+require 'webmock'
+
+module BerkeleyLibrary
+  module TIND
+    module API
+      describe Search do
+        let(:base_uri) { 'https://tind.example.org/' }
+        let(:api_key) { 'lorem-ipsum-dolor-sit-amet' }
+        let(:query_uri) { BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/search') }
+        let(:headers) { { 'Authorization' => "Token #{api_key}" } }
+
+        before(:each) do
+          allow(BerkeleyLibrary::TIND::Config).to receive(:api_key).and_return(api_key)
+          allow(BerkeleyLibrary::TIND::Config).to receive(:base_uri).and_return(base_uri)
+        end
+
+        describe 'single page' do
+          let(:collection) { 'Bancroft Library' }
+          let(:search) { Search.new(collection: collection) }
+
+          before(:each) do
+            body = File.read('spec/data/records-api-search.xml')
+            stub_request(:get, query_uri)
+              .with(headers: headers, query: { 'c' => collection, 'format' => 'xml' })
+              .to_return(status: 200, body: body)
+          end
+
+          describe :results do
+            it 'returns the results' do
+              results = search.results
+              expect(results).to be_a(Array)
+              expect(results.size).to eq(5)
+            end
+          end
+
+          describe :each_result do
+            it 'iterates over the results' do
+              results = []
+              search.each_result { |r| results << r }
+              expect(results.size).to eq(5)
+            end
+
+            it 'returns an enumerator' do
+              results = []
+              enum = search.each_result
+              expect(enum).to be_a(Enumerable)
+              enum.each { |r| results << r }
+              expect(results.size).to eq(5)
+            end
+
+            describe :freeze do
+              describe 'with block' do
+                it 'defaults to false' do
+                  search.each_result do |marc_record|
+                    expect(marc_record).not_to be_frozen
+                  end
+                end
+
+                it 'freezes results if true' do
+                  search.each_result(freeze: true) do |marc_record|
+                    expect(marc_record).to be_frozen
+                  end
+                end
+              end
+
+              describe 'as enumerator' do
+                it 'defaults to false' do
+                  enum = search.each_result
+                  enum.each do |marc_record|
+                    expect(marc_record).not_to be_frozen
+                  end
+                end
+
+                it 'freezes results if true' do
+                  enum = search.each_result(freeze: true)
+                  enum.each do |marc_record|
+                    expect(marc_record).to be_frozen
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe 'multiple pages' do
+          let(:collection) { 'Bancroft Library' }
+          let(:search) { Search.new(collection: collection) }
+          let(:search_id) { 'DnF1ZXJ5VGhlbkZldG' }
+          let(:expected_count) { 554 }
+
+          before(:each) do
+            result_xml_pages = (1..7).map { |page| File.read("spec/data/records-api-search-p#{page}.xml") }
+
+            query = { 'c' => collection, 'format' => 'xml' }
+
+            stub_request(:get, query_uri)
+              .with(headers: headers, query: query)
+              .to_return(status: 200, body: result_xml_pages[0])
+
+            stubs = result_xml_pages[1..].map { |b| { status: 200, body: b } }
+            stub_request(:get, query_uri).with(
+              headers: headers, query: query.merge({ 'search_id' => search_id })
+            ).to_return(stubs)
+          end
+
+          describe :results do
+            it 'returns the results' do
+              results = search.results
+              expect(results).to be_a(Array)
+              expect(results.size).to eq(expected_count)
+
+              first = results.first
+              expect(first).to be_a(::MARC::Record)
+              expect(first['024']['a']).to eq('BANC PIC 1958.021 Vol. 2:001--fALB')
+
+              last = results.last
+              expect(last).to be_a(::MARC::Record)
+              expect(last['024']['a']).to eq('BANC PIC 1958.021 Vol. 3:162--fALB')
+            end
+          end
+
+          describe :each_result do
+            it 'iterates over the results' do
+              results = []
+              search.each_result { |r| results << r }
+              expect(results.size).to eq(expected_count)
+            end
+
+            it 'returns an enumerator' do
+              results = []
+              enum = search.each_result
+              expect(enum).to be_a(Enumerable)
+              enum.each { |r| results << r }
+              expect(results.size).to eq(expected_count)
+            end
+
+            describe :freeze do
+              describe 'with block' do
+                it 'defaults to false' do
+                  search.each_result do |marc_record|
+                    expect(marc_record).not_to be_frozen
+                  end
+                end
+
+                it 'freezes results if true' do
+                  search.each_result(freeze: true) do |marc_record|
+                    expect(marc_record).to be_frozen
+                  end
+                end
+              end
+
+              describe 'as enumerator' do
+                it 'defaults to false' do
+                  enum = search.each_result
+                  enum.each do |marc_record|
+                    expect(marc_record).not_to be_frozen
+                  end
+                end
+
+                it 'freezes results if true' do
+                  enum = search.each_result(freeze: true)
+                  enum.each do |marc_record|
+                    expect(marc_record).to be_frozen
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe 'error handling' do
+
+          describe 'Nonexistent collection' do
+            let(:collection) { 'Not a collection' }
+            let(:search) { Search.new(collection: collection) }
+            let(:body) { '{"success": false, "error": "need more than 0 values to unpack"}' }
+
+            before(:each) do
+              stub_request(:get, query_uri)
+                .with(headers: headers, query: { 'c' => collection, 'format' => 'xml' })
+                .to_return(status: 500, body: body, headers: { 'Content-Type' => 'applicaton/json' })
+            end
+
+            describe :results do
+              it 'returns an empty array' do
+                results = search.results
+                expect(results).to be_a(Array)
+                expect(results.size).to eq(0)
+              end
+            end
+
+            describe :each_result do
+              it 'yields nothing' do
+                expect { |b| search.each_result(&b) }.not_to yield_control
+              end
+            end
+          end
+
+          describe 'Empty result set' do
+            let(:collection) { 'Restricted2Bancroft' }
+            let(:search) { Search.new(collection: collection) }
+            let(:body) do
+              <<~XML
+                <response>
+                  <total>0</total>
+                  <search_id>DnF1ZXJ5VGhlbkZldGNoBQAAAAACe5PjFmN0YjJMb0tKUTQtV1VfVzI2Qm8yY1EAAAAAABFKdxZuTnljT0hTU1FrMi1QSkNwVUEtZHJRAAAAAAIsSOcWSC0wU1Y0N2pRWUdodVBEdmdZUjBGUQAAAAACBSBOFjN6NGdTWWgzVFNpMGdQaDJyeGxBUncAAAAABEoXGhZ3SkFfY25BaFIzYVJMOGlDWnhxbHJn</search_id>
+                  <collection xmlns="http://www.loc.gov/MARC21/slim"/>
+                </response>
+              XML
+            end
+
+            before(:each) do
+              stub_request(:get, query_uri)
+                .with(headers: headers, query: { 'c' => collection, 'format' => 'xml' })
+                .to_return(status: 200, body: body, headers: { 'Content-Type' => 'applicaton/xml' })
+            end
+
+            describe :results do
+              it 'returns an empty array' do
+                results = search.results
+                expect(results).to be_a(Array)
+                expect(results.size).to eq(0)
+              end
+            end
+
+            describe :each_result do
+              it 'yields nothing' do
+                expect { |b| search.each_result(&b) }.not_to yield_control
+              end
+            end
+          end
+
+          describe 'Authn/Authz' do
+            let(:collection) { 'Bancroft Library' }
+            let(:search) { Search.new(collection: collection) }
+            let(:params) { { 'c' => collection, 'format' => 'xml' } }
+
+            describe 'insufficient privileges' do
+              # NOTE: TIND seems to return 'guest' regardless of username in the insufficient-privileges case
+              let(:body) { '{"error": "User guest is not authorized to perform runapi with parameters operation=read,endpoint=search"}' }
+
+              before(:each) do
+                @query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/search')
+
+                stub_request(:get, query_uri)
+                  .with(headers: headers, query: params)
+                  .to_return(status: 403, body: body)
+              end
+
+              it 'raises an APIException' do
+                expected_uri = BerkeleyLibrary::Util::URIs.append(query_uri, "?#{URI.encode_www_form(params)}")
+                expect { search.results }.to raise_error do |e|
+                  expect(e).to be_a(APIException)
+                  expect(e.message).to include('403 Forbidden')
+                  expect(e.message).to include(expected_uri.to_s)
+                  expect(e.status_code).to eq(403)
+                  expect(e.status_message).to eq('403 Forbidden')
+                end
+              end
+            end
+
+            describe 'API key not set' do
+              it 'raises an APIException without actually performing the search' do
+                allow(BerkeleyLibrary::TIND::Config).to receive(:api_key).and_return(nil)
+
+                expected_uri = BerkeleyLibrary::Util::URIs.append(query_uri, "?#{URI.encode_www_form(params)}")
+                expect { search.results }.to raise_error do |e|
+                  expect(e).to be_a(APIException)
+                  expect(e.message).to include(expected_uri.to_s)
+                  expect(e.status_code).to eq(401)
+                  expect(e.status_message).to eq('401 Unauthorized')
+                end
+              end
+            end
+
+            describe 'invalid API key' do
+              let(:body) { '{"error": "The entered api key is invalid"}' }
+
+              before(:each) do
+                @query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/search')
+
+                stub_request(:get, query_uri)
+                  .with(headers: headers, query: params)
+                  .to_return(status: 401, body: body)
+              end
+
+              it 'raises an APIException' do
+                expected_uri = BerkeleyLibrary::Util::URIs.append(query_uri, "?#{URI.encode_www_form(params)}")
+                expect { search.results }.to raise_error do |e|
+                  expect(e).to be_a(APIException)
+                  expect(e.message).to include('401 Unauthorized')
+                  expect(e.message).to include(expected_uri.to_s)
+                  expect(e.status_code).to eq(401)
+                  expect(e.status_message).to eq('401 Unauthorized')
+                end
+              end
+            end
+          end
+
+          describe '500 (some other error)' do
+            let(:collection) { 'Bancroft Library' }
+            let(:search) { Search.new(collection: collection) }
+            let(:params) { { 'c' => collection, 'format' => 'xml' } }
+
+            before(:each) do
+              @query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/search')
+
+              stub_request(:get, query_uri)
+                .with(headers: headers, query: params)
+                .to_return(status: 500, body: 'oops')
+            end
+
+            describe :results do
+              it 'raises an APIException' do
+                expected_uri = BerkeleyLibrary::Util::URIs.append(query_uri, "?#{URI.encode_www_form(params)}")
+
+                expect { search.results }.to raise_error do |e|
+                  expect(e).to be_a(APIException)
+                  expect(e.message).to include('500 Internal Server Error')
+                  expect(e.message).to include(expected_uri.to_s)
+                  expect(e.status_code).to eq(500)
+                  expect(e.status_message).to eq('500 Internal Server Error')
+                end
+              end
+            end
+
+            describe :each_result do
+              it 'yields nothing' do
+                results = []
+                expect { search.each_result { |r| results << r } }.to raise_error do |e|
+                  expect(e).to be_a(APIException)
+                  expect(e.message).to include('500 Internal Server Error')
+                  expect(e.message).to include(query_uri.to_s)
+                  expect(e.status_code).to eq(500)
+                  expect(e.status_message).to eq('500 Internal Server Error')
+                end
+                expect(results).to be_empty
+              end
+            end
+          end
+        end
+
+        it 'handles CJK' do
+          collection = 'Houcun ju shi ji'
+          search = Search.new(collection: collection)
+          params = { 'c' => collection, 'format' => 'xml' }
+
+          stub_request(:get, query_uri)
+            .with(headers: headers, query: params)
+            .to_return(status: 200, body: File.read('spec/data/records-api-search-cjk-p1.xml'))
+          stub_request(:get, query_uri)
+            .with(headers: headers, query: params.merge('search_id' => 'DnF1ZXJ5VGhlbkZldGNoBQAAAAAA'))
+            .to_return(status: 200, body: File.read('spec/data/records-api-search-cjk-p2.xml'))
+
+          results = search.results
+          expect(results).to be_a(Array)
+          expect(results.size).to eq(5)
+        end
+
+      end
+    end
+  end
+end