berkeley_library-tind 0.4.0

data/lib/berkeley_library/util/uris/validator.rb

@@ -0,0 +1,32 @@
+require 'uri'
+
+module BerkeleyLibrary
+  module Util
+    module URIs
+      module Validator
+        class << self
+
+          # Returns the specified URL as a URI.
+          # @param url [String, URI] the URL.
+          # @return [URI] the URI.
+          # @raise [URI::InvalidURIError] if `url` cannot be parsed as a URI.
+          def uri_or_nil(url)
+            return unless url
+
+            # noinspection RubyYardReturnMatch
+            url.is_a?(URI) ? url : URI.parse(url.to_s)
+          end
+
+          # Returns the specified URL as a string.
+          # @param url [String, URI] the URL.
+          # @return [String] the URL.
+          # @raise [URI::InvalidURIError] if `url` cannot be parsed as a URI.
+          def url_str_or_nil(url)
+            uri = Validator.uri_or_nil(url)
+            uri.to_s if uri
+          end
+        end
+      end
+    end
+  end
+end

data/rakelib/bundle.rake

@@ -0,0 +1,8 @@
+namespace :bundle do
+  desc 'Updates the ruby-advisory-db then runs bundle-audit'
+  task :audit do
+    require 'bundler/audit/cli'
+    Bundler::Audit::CLI.start ['update']
+    Bundler::Audit::CLI.start %w[check --ignore CVE-2015-9284]
+  end
+end

data/rakelib/coverage.rake

@@ -0,0 +1,11 @@
+require 'ci/reporter/rake/rspec'
+
+# Configure CI::Reporter report generation
+ENV['GENERATE_REPORTS'] ||= 'true'
+ENV['CI_REPORTS'] = 'artifacts/rspec'
+
+desc 'Run all specs in spec directory, with coverage'
+task coverage: ['ci:setup:rspec'] do
+  ENV['COVERAGE'] ||= 'true'
+  Rake::Task[:spec].invoke
+end

data/rakelib/gem.rake

@@ -0,0 +1,54 @@
+require 'rubygems/gem_runner'
+require 'berkeley_library/tind/module_info'
+
+gem_root_module = BerkeleyLibrary::TIND
+
+class << gem_root_module
+  def project_root
+    @project_root ||= File.expand_path('..', __dir__)
+  end
+
+  def artifacts_dir
+    return project_root unless ENV['CI']
+
+    @artifacts_dir ||= File.join(project_root, 'artifacts')
+  end
+
+  def gemspec_file
+    @gemspec_file ||= begin
+      gemspec_files = Dir.glob(File.expand_path('*.gemspec', project_root))
+      raise ArgumentError, "Too many .gemspecs: #{gemspec_files.join(', ')}" if gemspec_files.size > 1
+      raise ArgumentError, 'No .gemspec file found' if gemspec_files.empty?
+
+      gemspec_files[0]
+    end
+  end
+
+  def gemspec_basename
+    File.basename(gemspec_file)
+  end
+
+  def output_file
+    @output_file ||= begin
+      gem_name = File.basename(gemspec_file, '.*')
+      version = self::ModuleInfo::VERSION
+      basename = "#{gem_name}-#{version}.gem"
+      File.join(artifacts_dir, basename)
+    end
+  end
+
+  def output_file_relative
+    return File.basename(output_file) unless ENV['CI']
+
+    @output_file_relative ||= begin
+      artifacts_dir_relative = File.basename(artifacts_dir)
+      File.join(artifacts_dir_relative, File.basename(output_file))
+    end
+  end
+end
+
+desc "Build #{gem_root_module.gemspec_basename} as #{gem_root_module.output_file_relative}"
+task :gem do
+  args = ['build', gem_root_module.gemspec_file, "--output=#{gem_root_module.output_file}"]
+  Gem::GemRunner.new.run(args)
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+require 'rubocop'
+require 'rubocop/rake_task'
+
+desc 'Run rubocop with HTML output'
+RuboCop::RakeTask.new(:rubocop) do |cop|
+  output = ENV['RUBOCOP_OUTPUT'] || 'artifacts/rubocop/index.html'
+  puts "Writing RuboCop inspection report to #{output}"
+
+  cop.verbose = false
+  cop.formatters = ['html']
+  cop.options = ['--out', output]
+end
+
+desc 'Run RuboCop with auto-correct, and output results to console'
+task :ra do
+  # b/c we want console output, we can't just use `rubocop:auto_correct`
+  RuboCop::CLI.new.run(['--safe-auto-correct'])
+end

data/rakelib/spec.rake

@@ -0,0 +1,2 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/spec/.rubocop.yml

@@ -0,0 +1,40 @@
+inherit_from: ../.rubocop.yml
+
+AllCops:
+  # Exclude generated files
+  Exclude:
+    - 'suite/**/*'
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+############################################################
+# Added in Rubocop 0.89
+
+# Sometimes we're testing the operator
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: false

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

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'rest-client'
+
+module BerkeleyLibrary
+  module TIND
+    module API
+      describe APIException do
+        describe :wrap do
+          it 'rejects nil' do
+            expect { APIException.wrap(nil) }.to raise_error(ArgumentError)
+          end
+
+          describe 'RestClient::RequestFailed' do
+            it 'extracts the status info and response' do
+              url = 'https://example.org'
+              params = { 'foo' => 'bar' }
+              expected_body = 'oops'
+              stub_request(:get, url).with(query: params).to_return(status: 500, body: expected_body)
+
+              expected_msg = 'the wrapper message'
+              expect do
+                RestClient.get(url, params: params)
+              rescue StandardError => e
+                raise APIException.wrap(e, url: url, params: params, detail: expected_msg)
+              end.to raise_error do |e|
+                expect(e).to be_a(APIException)
+                expect(e.cause).to be_a(RestClient::RequestFailed)
+                expect(e.status_code).to eq(500)
+                expect(e.status_message).to eq('500 Internal Server Error')
+                expect(e.body).to eq(expected_body)
+                expect(e.response).to be(e.cause.response)
+                expect(e.url).to eq(url)
+                expect(e.params).to eq(params)
+              end
+            end
+
+            it 'works with or without parameters' do
+              url = 'https://example.org'
+              expected_body = 'oops'
+              stub_request(:get, url).to_return(status: 500, body: expected_body)
+
+              expected_msg = 'the wrapper message'
+              expect do
+                RestClient.get(url)
+              rescue StandardError => e
+                raise APIException.wrap(e, url: url, detail: expected_msg)
+              end.to raise_error do |e|
+                expect(e).to be_a(APIException)
+                expect(e.cause).to be_a(RestClient::RequestFailed)
+                expect(e.status_code).to eq(500)
+                expect(e.status_message).to eq('500 Internal Server Error')
+                expect(e.body).to eq(expected_body)
+                expect(e.response).to be(e.cause.response)
+                expect(e.url).to eq(url)
+                expect(e.params).to be_nil
+              end
+            end
+          end
+
+          describe 'any exception' do
+            it 'wraps an exception' do
+              expected_msg = 'the message'
+              expect do
+
+                raise expected_msg
+              rescue StandardError => e
+                raise APIException.wrap(e)
+              end.to raise_error do |e|
+                expect(e).to be_a(APIException)
+                expect(e.message).to eq(expected_msg)
+              end
+            end
+
+            it 'overrides the message' do
+              expected_msg = 'the message'
+              expect do
+
+                raise "not #{expected_msg}"
+              rescue StandardError => e
+                raise APIException.wrap(e, msg: expected_msg)
+              end.to raise_error do |e|
+                expect(e).to be_a(APIException)
+                expect(e.message).to eq(expected_msg)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'webmock'
+
+module BerkeleyLibrary
+  module TIND
+    RSpec.shared_examples 'a missing key' do |bad_key|
+      before(:each) do
+        expect(BerkeleyLibrary::TIND::Config).to receive(:api_key).and_return(bad_key)
+      end
+
+      it "raises #{API::APIKeyNotSet}" do
+        failure_message = -> { "#{API::APIKeyNotSet} not raised for API key #{bad_key.inspect}" }
+        expect { API.get('some-endpoint') }.to raise_error(API::APIKeyNotSet), failure_message
+      end
+    end
+
+    RSpec.shared_examples 'a missing base URL' do |bad_url|
+      before(:each) do
+        allow(BerkeleyLibrary::TIND::Config).to receive(:base_uri).and_return(bad_url)
+      end
+
+      it "raises #{API::APIKeyNotSet}" do
+        failure_message = -> { "#{API::BaseURINotSet} not raised for API key #{bad_url.inspect}" }
+        expect { API.get('some-endpoint') }.to raise_error(API::BaseURINotSet), failure_message
+      end
+    end
+
+    describe API do
+      let(:base_uri) { 'https://tind.example.org/' }
+      let(:api_key) { 'lorem-ipsum-dolor-sit-amet' }
+
+      describe :get do
+        describe 'with invalid API key' do
+          before(:each) do
+            allow(BerkeleyLibrary::TIND::Config).to receive(:base_uri).and_return(base_uri)
+          end
+
+          [nil, '', ' '].each do |bad_key|
+            describe "api_key = #{bad_key.inspect}" do
+              it_behaves_like 'a missing key', bad_key
+            end
+          end
+        end
+      end
+
+      describe 'bad TIND base URI' do
+        before(:each) do
+          allow(BerkeleyLibrary::TIND::Config).to receive(:api_key).and_return(api_key)
+        end
+
+        [nil, '', ' '].each do |bad_url|
+          describe "base_uri = #{bad_url.inspect}" do
+            it_behaves_like 'a missing base URL', bad_url
+          end
+        end
+      end
+
+      describe 'with valid config' do
+        before(:each) do
+          allow(BerkeleyLibrary::TIND::Config).to receive(:base_uri).and_return(base_uri)
+          allow(BerkeleyLibrary::TIND::Config).to receive(:api_key).and_return(api_key)
+        end
+
+        describe :get do
+          it "raises #{API::APIException} in the event of an invalid response" do
+            aggregate_failures 'responses' do
+              [207, 400, 401, 403, 404, 405, 418, 451, 500, 503].each do |code|
+                endpoint = "endpoint-#{code}"
+                url_str = API.uri_for(endpoint).to_s
+                stub_request(:get, url_str).to_return(status: code)
+
+                expect { API.get(endpoint) }.to raise_error(API::APIException) do |e|
+                  expect(e.message).to include(code.to_s)
+                end
+              end
+            end
+          end
+
+          it 'logs the response body if an error occurs in handling' do
+            endpoint = 'test-endpoint'
+            url_str = API.uri_for(endpoint).to_s
+            body_text = 'the body'
+            stub_request(:get, url_str).to_return(status: 200, body: body_text)
+
+            logdev = StringIO.new
+            logger = BerkeleyLibrary::Logging::Loggers.new_readable_logger(logdev)
+            allow(BerkeleyLibrary::Logging).to receive(:logger).and_return(logger)
+
+            msg = 'the error message'
+            expect { API.get(endpoint) { |_| raise(StandardError, msg) } }.to raise_error(StandardError, msg)
+            expect(logdev.string).to include(body_text)
+          end
+
+          it 'sends a default user agent' do
+            expected_ua = Config::DEFAULT_USER_AGENT
+
+            endpoint = 'test-endpoint'
+            url_str = API.uri_for(endpoint).to_s
+            body_text = 'the body'
+            stub_request(:get, url_str).with(headers: { 'User-Agent' => expected_ua })
+              .to_return(status: 200, body: body_text)
+
+            result = API.get(endpoint)
+            expect(result).to eq(body_text)
+          end
+
+          it 'sends a configured user ageint' do
+            expected_ua = 'Help I am trapped in an HTTP request'
+            Config.user_agent = expected_ua
+
+            endpoint = 'test-endpoint'
+            url_str = API.uri_for(endpoint).to_s
+            body_text = 'the body'
+            stub_request(:get, url_str).with(headers: { 'User-Agent' => expected_ua })
+              .to_return(status: 200, body: body_text)
+
+            result = API.get(endpoint)
+            expect(result).to eq(body_text)
+          end
+        end
+      end
+
+      describe :format_request do
+        it 'formats a request' do
+          url = 'https://example.org/frob'
+          params = { foo: 'bar', 'qux' => 'baz' }
+          expected_url = 'https://example.org/frob?foo=bar&qux=baz'
+          expect(API.format_request(url, params)).to eq("GET #{expected_url}")
+        end
+
+        it 'works without parameters' do
+          url = 'https://example.org/frob'
+          expect(API.format_request(url)).to eq("GET #{url}")
+        end
+
+        it 'rejects garbage parameters' do
+          # noinspection RubyYardParamTypeMatch
+          expect { API.format_request('https://example.org', Object.new) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'webmock'
+
+module BerkeleyLibrary
+  module TIND
+    module API
+      describe Collection do
+        let(:base_uri) { 'https://tind.example.org/' }
+        let(:api_key) { 'not-a-real-api-key' }
+
+        before(:each) do
+          @base_uri_orig = BerkeleyLibrary::TIND::Config.instance_variable_get(:@base_uri)
+          BerkeleyLibrary::TIND::Config.base_uri = base_uri
+
+          @api_key_orig = BerkeleyLibrary::TIND::Config.instance_variable_get(:@api_key)
+          BerkeleyLibrary::TIND::Config.api_key = api_key
+        end
+
+        after(:each) do
+          BerkeleyLibrary::TIND::Config.instance_variable_set(:@base_uri, @base_uri_orig)
+          BerkeleyLibrary::TIND::Config.instance_variable_set(:@api_key, @api_key_orig)
+        end
+
+        describe :all do
+          it 'reads the collections from the API' do
+            query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/collections?depth=100')
+            stub_request(:get, query_uri)
+              .with(headers: { 'Authorization' => 'Token not-a-real-api-key' })
+              .to_return(status: 200, body: File.read('spec/data/collections.json'))
+
+            all_collections = Collection.all
+            expect(all_collections.size).to eq(1)
+            expect(root_collection = all_collections.first).not_to be_nil
+            expect(root_collection.name).to eq('Digital Collections')
+
+            top_level_collections = root_collection.children
+            expect(top_level_collections.map(&:name)).to eq(['Bampfa', 'Bancroft Library', 'Berkeley Library', 'East Asian Library', 'Humanities & Social Sciences', 'Sciences'])
+
+            bancroft = top_level_collections.find { |c| c.name == 'Bancroft Library' }
+            examiner = bancroft.children.find { |c| c.name == 'SFExaminer' }
+            expect(examiner.name_en).to eq('San Francisco Examiner')
+            expect(examiner.size).to eq(15_564)
+          end
+
+          it 'returns an empty array in the event of an error' do
+            query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/collections?depth=100')
+            stub_request(:get, query_uri).to_return(status: 404)
+
+            expect(Collection.all).to eq([])
+          end
+
+          it 'raises an error if the API key is not set' do
+            BerkeleyLibrary::TIND::API.instance_variable_set(:@api_key, nil)
+          end
+        end
+
+        describe :each_collection do
+          it 'yields each collection' do
+            collections_json = File.read('spec/data/collections.json')
+            expected_names = File.readlines('spec/data/collection-names.txt', chomp: true)
+
+            query_uri = BerkeleyLibrary::Util::URIs.append(base_uri, '/api/v1/collections?depth=100')
+            stub_request(:get, query_uri)
+              .with(headers: { 'Authorization' => 'Token not-a-real-api-key' })
+              .to_return(status: 200, body: collections_json)
+
+            actual_names = Collection.each_collection.each_with_object([]) { |c, arr| arr << c.name }
+            expect(actual_names).to contain_exactly(*expected_names)
+          end
+        end
+      end
+    end
+  end
+end