berkeley_library-tind 0.4.0

data/spec/berkeley_library/tind/config_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    describe Config do
+      let(:env_base_url) { 'tind.example.edu' }
+      let(:env_api_key) { 'not-a-real-api-key' }
+
+      before(:each) do
+        @base_uri_orig = Config.instance_variable_get(:@base_uri)
+        Config.instance_variable_set(:@base_uri, nil)
+
+        @base_url_orig = ENV['LIT_TIND_BASE_URL']
+        ENV['LIT_TIND_BASE_URL'] = env_base_url
+
+        @api_key_orig = Config.instance_variable_get(:@api_key)
+        Config.instance_variable_set(:@api_key, nil)
+
+        @api_key_env_orig = ENV['LIT_TIND_API_KEY']
+        ENV['LIT_TIND_API_KEY'] = env_api_key
+      end
+
+      after(:each) do
+        Config.instance_variable_set(:@base_uri, @base_uri_orig)
+        ENV['LIT_TIND_BASE_URL'] = @base_url_orig
+
+        Config.api_key = @api_key_orig
+        ENV['LIT_TIND_API_KEY'] = @api_key_env_orig
+      end
+
+      describe :base_uri do
+        it 'returns the base URL from the environment as a URI' do
+          expect(Config.base_uri).to eq(URI(env_base_url))
+        end
+
+        it 'returns nil if no base URL is set in the environment' do
+          ENV['LIT_TIND_BASE_URL'] = nil
+          expect(Config.base_uri).to be_nil
+        end
+
+        it 'returns a URI from Rails config if present' do
+          expect(defined?(Rails)).to be_nil
+
+          Object.send(:const_set, 'Rails', OpenStruct.new)
+          Rails.application = OpenStruct.new
+
+          url = 'tind-test.example.edu'
+          config = OpenStruct.new(tind_base_uri: url)
+          Rails.application.config = config
+
+          ENV['LIT_TIND_BASE_URL'] = nil
+          expect(Config.base_uri).to eq(URI(url))
+        ensure
+          Object.send(:remove_const, 'Rails')
+        end
+      end
+
+      describe :api_key do
+        it 'returns the API key from the environment' do
+          expect(Config.api_key).to eq(env_api_key)
+        end
+
+        it 'returns nil if no API key is set in the environment' do
+          ENV['LIT_TIND_API_KEY'] = nil
+          expect(Config.api_key).to be_nil
+        end
+
+        it 'returns an API key from the Rails config if present' do
+          expect(defined?(Rails)).to be_nil
+
+          Object.send(:const_set, 'Rails', OpenStruct.new)
+          Rails.application = OpenStruct.new
+
+          api_key = 'test-api-key'
+          config = OpenStruct.new(tind_api_key: api_key)
+          Rails.application.config = config
+
+          ENV['LIT_TIND_API_KEY'] = nil
+          expect(Config.api_key).to eq(api_key)
+        ensure
+          Object.send(:remove_const, 'Rails')
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/export/column_group_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe ColumnGroup do
+        describe :new do
+          it 'rejects invalid indicators' do
+            expect { ColumnGroup.new('856', 0, '_', '2', 'uyz'.chars) }.to raise_error(ArgumentError)
+            expect { ColumnGroup.new('856', 0, '2', '_', 'uyz'.chars) }.to raise_error(ArgumentError)
+          end
+
+          it "allows capital indicators, even if it shouldn't" do
+            cg = ColumnGroup.new('856', 0, 'Q', '1', 'uyz'.chars)
+            expect(cg.ind1).to eq('Q')
+          end
+        end
+        describe :to_s do
+          it 'returns the prefix + subfield codes' do
+            cg = ColumnGroup.new('856', 0, '4', '2', 'uyz'.chars)
+            cg_str = cg.to_s
+            expect(cg_str).to include('85642uyz')
+            expect(cg_str).to include('0')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/export/column_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe Column do
+        describe :each_value do
+          let(:values) { %w[a b c d] }
+          attr_reader :col
+
+          before(:each) do
+            cg = instance_double(ColumnGroup)
+            allow(cg).to receive(:row_count).and_return(values.size)
+            allow(cg).to receive(:value_at) { |r, _| values[r] }
+            allow(cg).to receive(:prefix).and_return('99999')
+            allow(cg).to receive(:index_in_tag).and_return(9)
+            allow(cg).to receive(:subfield_codes).and_return(['9'])
+            @col = Column.new(cg, 0)
+          end
+
+          it 'yields each value' do
+            actual = [].tap do |vv|
+              col.each_value { |v| vv << v }
+            end
+            expect(actual).to eq(values)
+          end
+
+          it 'returns an enumerator' do
+            enum = col.each_value
+            expect(enum.to_a).to eq(values)
+          end
+
+          it 'optionally returns the header' do
+            enum = col.each_value(include_header: true)
+            enum_values = enum.to_a
+            expect(enum_values[0]).to eq(col.header)
+            expect(enum_values[1..]).to eq(values)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/export/config_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe Config do
+        let(:env_vars) do
+          %w[
+            ODS_FONT_SIZE_DEFAULT
+            ODS_FORMAT_DIGITS_DEFAULT
+            ODS_HEIGHT_INCREMENT_DEFAULT_POINTS
+            ODS_LINE_HEIGHT_DEFAULT_EM
+            ODS_MAX_COLUMN_WIDTH_INCHES
+            ODS_WIDTH_INCREMENT_DEFAULT_INCHES
+          ]
+        end
+
+        let(:attrs) do
+          %i[
+            font_size_pt
+            format_digits
+            h_incr_pt
+            line_height_em
+            max_col_width_in
+            w_incr_in
+          ]
+        end
+
+        let(:inst_vars) { attrs.map { |a| "@#{a}".to_sym } }
+
+        before(:each) do
+          @env_orig = {}
+          env_vars.each do |v|
+            @env_orig[v] = ENV[v]
+            ENV[v] = nil
+          end
+          @inst_orig = {}
+          inst_vars.each do |v|
+            if Config.instance_variable_defined?(v)
+              @inst_orig[v] = Config.instance_variable_get(v)
+              Config.remove_instance_variable(v)
+            end
+          end
+        end
+
+        after(:each) do
+          @env_orig.each do |k, v|
+            ENV[k] = v
+          end
+          @inst_orig.each do |k, v|
+            Config.instance_variable_set(k, v)
+          end
+        end
+
+        describe 'defaults' do
+          it 'returns sensible default values' do
+            expected = {
+              font_size_pt: Config::FONT_SIZE_DEFAULT,
+              max_col_width_in: Config::MAX_COLUMN_WIDTH_INCHES,
+              w_incr_in: Config::WIDTH_INCREMENT_DEFAULT_INCHES,
+              h_incr_pt: Config::HEIGHT_INCREMENT_DEFAULT_POINTS,
+              line_height_em: Config::LINE_HEIGHT_DEFAULT_EM,
+              format_digits: Config::FORMAT_DIGITS_DEFAULT
+            }
+            expected.each do |attr, value|
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+        end
+
+        describe 'ENV' do
+          it 'can be configured from the environment' do
+            env_vars_by_attr = {
+              font_size_pt: 'ODS_FONT_SIZE_DEFAULT',
+              max_col_width_in: 'ODS_MAX_COLUMN_WIDTH_INCHES',
+              w_incr_in: 'ODS_WIDTH_INCREMENT_DEFAULT_INCHES',
+              h_incr_pt: 'ODS_HEIGHT_INCREMENT_DEFAULT_POINTS',
+              line_height_em: 'ODS_LINE_HEIGHT_DEFAULT_EM',
+              format_digits: 'ODS_FORMAT_DIGITS_DEFAULT'
+            }
+
+            expected = env_vars_by_attr.map do |attr, var|
+              value = 2 * Config.send(attr)
+              ENV[var] = value.to_s
+              [attr, value]
+            end.to_h
+
+            inst_vars.each do |v|
+              Config.remove_instance_variable(v) if Config.instance_variable_defined?(v)
+            end
+
+            expected.each do |attr, value|
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+        end
+
+        describe 'setters' do
+          let(:attr_nonint) { attrs - [:format_digits] }
+
+          it 'set the attributes' do
+            attrs.each do |attr|
+              value = 2 * Config.send(attr)
+              Config.send("#{attr}=", value)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          it 'accepts integers' do
+            attrs.each do |attr|
+              value = (2 * Config.send(attr)).ceil
+              Config.send("#{attr}=", value)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          it 'accepts integers as strings' do
+            attrs.each do |attr|
+              value = (2 * Config.send(attr)).ceil
+              Config.send("#{attr}=", value.to_s)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          it 'rejects non-numeric values' do
+            attrs.each do |attr|
+              value = Config.send(attr)
+              expect { Config.send("#{attr}=", 'not a number') }.to raise_error(ArgumentError)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          it 'rejects negative values' do
+            attrs.each do |attr|
+              value = Config.send(attr)
+              expect { Config.send("#{attr}=", -value) }.to raise_error(ArgumentError)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          it 'rejects zero' do
+            attrs.each do |attr|
+              value = Config.send(attr)
+              expect { Config.send("#{attr}=", 0) }.to raise_error(ArgumentError)
+              expect(Config.send(attr)).to eq(value)
+            end
+          end
+
+          describe :format_digits do
+            it 'rejects non-integer numeric values' do
+              value = Config.format_digits
+              [2.3, '3/5'.to_r].each do |bad_value|
+                expect { Config.format_digits = bad_value }.to raise_error(ArgumentError)
+              end
+              expect(Config.format_digits).to eq(value)
+            end
+
+            it 'accepts hex strings' do
+              Config.format_digits = '0xba0bab'
+              expect(Config.format_digits).to eq(12_192_683)
+            end
+
+            it 'accepts octal strings' do
+              Config.format_digits = '0123'
+              expect(Config.format_digits).to eq(83)
+            end
+          end
+
+          describe 'non-integer attributes' do
+            it 'accepts rationals' do
+              attr_nonint.each do |attr|
+                value = (2 * Config.send(attr)).to_r
+                Config.send("#{attr}=", value)
+                expect(Config.send(attr)).to eq(value)
+              end
+            end
+
+            it 'accepts floats' do
+              attr_nonint.each do |attr|
+                value = (2 * Config.send(attr)).to_f
+                Config.send("#{attr}=", value)
+                expect(Config.send(attr)).to eq(value)
+              end
+            end
+
+            it 'accepts rationals as strings' do
+              attr_nonint.each do |attr|
+                value = (2 * Config.send(attr)).to_r
+                Config.send("#{attr}=", value.to_s)
+                expect(Config.send(attr)).to eq(value)
+              end
+            end
+
+            it 'accepts floats as strings' do
+              attr_nonint.each do |attr|
+                value = (2 * Config.send(attr)).to_f
+                Config.send("#{attr}=", value.to_s)
+                expect(Config.send(attr)).to eq(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/tind/export/export_command_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'fileutils'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe ExportCommand do
+        before(:each) do
+          @base_uri_orig = BerkeleyLibrary::TIND::Config.base_uri
+          @api_key_orig = BerkeleyLibrary::TIND::Config.api_key
+          @logger_orig = BerkeleyLibrary::Logging.logger
+        end
+
+        after(:each) do
+          BerkeleyLibrary::Logging.logger = @logger_orig
+          BerkeleyLibrary::TIND::Config.api_key = @api_key_orig
+          BerkeleyLibrary::TIND::Config.base_uri = @base_uri_orig
+        end
+
+        describe :usage do
+          it 'returns the usage' do
+            expect(ExportCommand.send(:usage)).to be_a(String)
+          end
+        end
+
+        describe :list_collections do
+          it 'lists the collection names' do
+            collections = BerkeleyLibrary::TIND::API::Collection.all_from_json(File.read('spec/data/collections.json'))
+            allow(BerkeleyLibrary::TIND::API::Collection).to receive(:all).and_return(collections)
+
+            out = StringIO.new
+            ExportCommand.new('-l', out: out).execute!
+            # TODO: test counts
+            names_only = out.string.gsub!(/^[0-9]+\t/, '')
+            expect(names_only).to eq(File.read('spec/data/collection-names.txt'))
+          end
+        end
+
+        describe :export_collection do
+          it 'exports a collection' do
+            format = 'csv'
+            collection = 'Bancroft Library'
+            out = instance_double(IO)
+
+            expect(BerkeleyLibrary::TIND::Export).to receive(:export).with(collection, ExportFormat.ensure_format(format), out)
+            ExportCommand.new('-f', format, collection, out: out).execute!
+          end
+        end
+
+        describe 'flags' do
+          let(:api_key) { 'ZghOT0eRm4U9s' }
+          let(:output_path) { '/tmp/export.ods' }
+          let(:collection) { 'Houcun ju shi ji' }
+
+          attr_reader :command
+
+          before(:each) do
+            @command = ExportCommand.new('-v', '-k', api_key, '-o', output_path, collection)
+          end
+
+          describe '-e' do
+            let(:basename) { File.basename(__FILE__, '.rb') }
+
+            before(:each) do
+              @wd = Dir.pwd
+
+              if defined?(Dotenv)
+                @dotenv_old = Dotenv
+                Object.send(:remove_const, :Dotenv)
+              end
+
+              allow_any_instance_of(Kernel).to receive(:require).with('dotenv').and_return(true)
+              Object.const_set(:Dotenv, double(Module))
+            end
+
+            after(:each) do
+              Dir.chdir(@wd)
+              next unless @dotenv_old
+
+              Object.send(:remove_const, :Dotenv)
+              Object.const_set(:Dotenv, @dotenv_old)
+            end
+
+            it 'reads the default .env file' do
+              Dir.mktmpdir(basename) do |tmpdir|
+                env_path = File.join(tmpdir, '.env')
+                FileUtils.touch(env_path)
+
+                env_path_abs = File.realpath(env_path)
+                expect(Dotenv).to receive(:load).with(env_path_abs)
+                Dir.chdir(tmpdir)
+                ExportCommand.new('-l', '-e')
+              end
+            end
+
+            it 'reads a specified .env file' do
+              Dir.mktmpdir(basename) do |tmpdir|
+                env_path = File.join(tmpdir, 'myenv')
+                FileUtils.touch(env_path)
+
+                env_path_abs = File.realpath(env_path)
+                expect(Dotenv).to receive(:load).with(env_path_abs)
+                Dir.chdir(tmpdir)
+                ExportCommand.new('-l', '-e', 'myenv')
+              end
+            end
+          end
+
+          describe '-v' do
+            it 'configures a debug-level logger' do
+              expect(BerkeleyLibrary::Logging.logger.level).to eq(0)
+            end
+          end
+
+          describe '-k' do
+            it 'sets the API key' do
+              expect(BerkeleyLibrary::TIND::API.api_key).to eq(api_key)
+            end
+          end
+
+          describe '-o' do
+            it 'sets the output file and format' do
+              expect(command.options[:outfile]).to eq(output_path)
+              expect(command.options[:format]).to eq(ExportFormat::ODS)
+            end
+          end
+
+          it 'sets the collection' do
+            expect(command.options[:collection]).to eq(collection)
+          end
+        end
+
+        describe 'error handling' do
+          it 'prints usage and exits if given bad options' do
+            stderr_orig = $stderr
+            begin
+              out = StringIO.new
+              $stderr = out
+              expect { ExportCommand.new('-not', '-a', '-valid', '-option') }.to raise_error(SystemExit) do |e|
+                expect(e.status).not_to eq(0)
+              end
+              expected_usage = ExportCommand.send(:usage)
+              expect(out.string).to include(expected_usage)
+            ensure
+              $stderr = stderr_orig
+            end
+          end
+
+          it 'prints usage and exits in the event of an error' do
+            err_class = BerkeleyLibrary::TIND::API::APIException
+            err_msg = '403 Forbidden'
+            expect(BerkeleyLibrary::TIND::Export).to receive(:export).and_raise(err_class, err_msg)
+            stderr_orig = $stderr
+            begin
+              out = StringIO.new
+              $stderr = out
+              expect { ExportCommand.new('Bancroft Library').execute! }.to raise_error(SystemExit) do |e|
+                expect(e.status).not_to eq(0)
+              end
+              expect(out.string).to include(err_msg)
+            ensure
+              $stderr = stderr_orig
+            end
+          end
+        end
+      end
+    end
+  end
+end