berkeley_library-tind 0.4.0

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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe ExportFormat do
+        describe :to_str do
+          it 'returns the value' do
+            ExportFormat.each do |fmt|
+              # rubocop:disable Style/StringConcatenation
+              expect('' + fmt).to eq(fmt.value)
+              # rubocop:enable Style/StringConcatenation
+            end
+          end
+        end
+
+        describe :mime_type do
+          it 'returns the correct MIME type' do
+            {
+              ExportFormat::CSV => 'text/csv',
+              ExportFormat::ODS => 'application/vnd.oasis.opendocument.spreadsheet'
+            }.each do |fmt, mime_type|
+              expect(fmt.mime_type).to eq(mime_type)
+            end
+          end
+        end
+
+        describe :ensure_format do
+          it 'rejects unsupported formats' do
+            expect { ExportFormat.ensure_format(:wks) }.to raise_error(ArgumentError)
+          end
+        end
+
+        describe :description do
+          it 'returns a description' do
+            ExportFormat.each do |fmt|
+              expect(fmt.description).to be_a(String)
+              expect(fmt.description).not_to be_empty
+            end
+          end
+        end
+
+        describe :DEFAULT do
+          it 'defaults to ODS' do
+            expect(ExportFormat::DEFAULT).to be(ExportFormat::ODS)
+          end
+        end
+
+        describe :default? do
+          it 'returns true for default, false otherwise' do
+            ExportFormat.each do |fmt|
+              expect(fmt.default?).to eq(fmt == ExportFormat::DEFAULT)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require 'rspec'
+require 'berkeley_library/util/strings'
+
+RSpec::Matchers.define :match_table do |expected_table|
+  match { |actual| diff(expected_table, actual).empty? }
+
+  failure_message do |actual|
+    diff = diff(expected_table, actual)
+
+    msg_elements = ['output differs from table:']
+    diff.each do |(row, col), (v_expected, v_actual)|
+      msg = format_diff_msg(row, col, v_expected, v_actual)
+      msg_elements << msg
+    end
+    msg_elements.join("\n\t")
+  end
+
+  def diff(expected_table, ss_or_csv_str)
+    return diff_spreadsheet(expected_table, ss_or_csv_str) if ss_or_csv_str.respond_to?(:cell)
+
+    diff_csv(expected_table, ss_or_csv_str)
+  end
+
+  def diff_spreadsheet(expected_table, spreadsheet)
+    {}.tap do |diffs|
+      # NOTE: spreadsheet rows are 1-indexed, but row 1 is header
+      expected_table.headers.each_with_index do |expected_header, col|
+        cell_index = [1, 1 + col]
+        next if expected_header == (actual_header = spreadsheet.cell(*cell_index))
+
+        diffs[cell_index] = [expected_header, actual_header]
+      end
+
+      (0..expected_table.row_count).each do |row|
+        ss_row = 2 + row # row 1 is header
+        (0..expected_table.column_count).each do |col|
+          cell_index = [ss_row, 1 + col]
+          expected_value = expected_table.value_at(row, col)
+          actual_value = spreadsheet.cell(*cell_index)
+          next if expected_value == actual_value
+
+          diffs[cell_index] = [expected_value, actual_value]
+        end
+      end
+    end
+  end
+
+  def diff_csv(expected_table, csv_string)
+    # NOTE: CSV.parse() returns zero-indexed row array
+    csv = CSV.parse(csv_string, headers: false)
+    {}.tap do |diffs|
+      header_row = csv[0]
+      expected_table.headers.each_with_index do |expected_header, col|
+        next if expected_header == (actual_header = header_row[col])
+
+        diffs[[0, col]] = [expected_header, actual_header]
+      end
+
+      (0...expected_table.row_count).each do |row|
+        csv_row = 1 + row # row 1 is header
+        row_values = csv[csv_row] || []
+        (0...expected_table.column_count).each do |col|
+          expected_value = expected_table.value_at(row, col)
+          actual_value = row_values[col]
+          next if expected_value == actual_value
+
+          diffs[[csv_row, col]] = [expected_value, actual_value]
+        end
+      end
+    end
+  end
+
+  def matching_spreadsheet?(expected_table, spreadsheet)
+    aggregate_failures 'headers' do
+      expected_table.headers.each_with_index do |h, col|
+        ss_col = 1 + col
+        actual_header = spreadsheet.cell(1, ss_col)
+        expect(actual_header).to eq(h), "Expected header #{h.inspect} for column #{ss_col}, got #{actual_header.inspect}"
+      end
+    end
+
+    aggregate_failures 'values' do
+      (0..expected_table.row_count).each do |row|
+        ss_row = 2 + row # row 1 is header
+        (0..expected_table.column_count).each do |col|
+          ss_col = 1 + col
+          expected_value = expected_table.value_at(row, col)
+          actual_value = spreadsheet.cell(ss_row, ss_col)
+          expect(actual_value).to eq(expected_value), "(#{ss_row}, #{ss_col}): expected #{expected_value.inspect}, got #{actual_value.inspect}"
+        end
+      end
+    end
+  end
+
+  # TODO: make this work better
+  def format_diff_msg(row, col, v_expected, v_actual)
+    if (diff_index = BerkeleyLibrary::Util::Strings.diff_index(v_expected, v_actual))
+      <<~MSG
+        (#{row}, #{col}):
+                expected: #{v_expected.inspect}#{' '}
+                     got: #{v_actual.inspect}
+                          #{' ' * diff_index}^
+      MSG
+    else
+      <<~MSG
+        (#{row}, #{col}):#{' '}
+                expected: #{v_expected.inspect}#{' '}
+                     got: #{v_actual.inspect}
+      MSG
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'roo'
+
+require_relative 'export_matcher'
+
+module BerkeleyLibrary
+  # noinspection RubyYardParamTypeMatch
+  module TIND
+    describe Export do
+      let(:basename) { File.basename(__FILE__, '.rb') }
+
+      describe 'export' do
+        let(:collection) { 'Bancroft Library' }
+
+        describe 'with results' do
+
+          let(:records) do
+            (1..7)
+              .map { |page| File.read("spec/data/records-api-search-p#{page}.xml") }
+              .map { |p| BerkeleyLibrary::TIND::MARC::XMLReader.new(p, freeze: true).to_a }
+              .flatten
+          end
+          let(:expected_table) { Export::Table.from_records(records, freeze: true, exportable_only: true) }
+
+          before(:each) do
+            search = instance_double(BerkeleyLibrary::TIND::API::Search)
+            allow(search).to receive(:each_result).with(freeze: true).and_return(records.each)
+            allow(BerkeleyLibrary::TIND::API::Search).to receive(:new).with(collection: collection).and_return(search)
+          end
+
+          describe :export do
+            describe 'CSV formats' do
+              it 'defaults to CSV' do
+                actual_csv = Export.export(collection)
+                expect(actual_csv).to match_table(expected_table)
+              end
+
+              [Export::ExportFormat::CSV, :csv, 'CSV'].each do |fmt|
+                it "accepts #{fmt.inspect} as a format parameter" do
+                  actual_csv = Export.export(collection, fmt)
+                  expect(actual_csv).to match_table(expected_table)
+                end
+              end
+            end
+
+            describe 'ODS formats' do
+              [Export::ExportFormat::ODS, :ods, 'ODS'].each_with_index do |fmt, i|
+                it "accepts #{fmt.inspect} as a format parameter" do
+                  Dir.mktmpdir(basename) do |dir|
+                    output_path = File.join(dir, "#{basename}-#{i}.ods")
+                    Export.export(collection, fmt, output_path)
+
+                    ss = Roo::Spreadsheet.open(output_path)
+                    begin
+                      expect(ss).to match_table(expected_table)
+                    ensure
+                      ss.close
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe 'without results' do
+          before(:each) do
+            search = instance_double(BerkeleyLibrary::TIND::API::Search)
+            allow(search).to receive(:each_result).with(freeze: true).and_return([].each)
+            allow(BerkeleyLibrary::TIND::API::Search).to receive(:new).with(collection: collection).and_return(search)
+          end
+
+          it 'raises NoResultsError' do
+            expect { Export.export(collection) }.to raise_error(Export::NoResultsError)
+          end
+        end
+
+        describe 'CJK support' do
+          let(:collection) { 'Houcun ju shi ji' }
+          let(:records) { BerkeleyLibrary::TIND::MARC::XMLReader.new('spec/data/records-api-search-cjk-p1.xml', freeze: true).to_a }
+          let(:expected_table) { Export::Table.from_records(records, freeze: true, exportable_only: true) }
+
+          before(:each) do
+            search = instance_double(BerkeleyLibrary::TIND::API::Search)
+            allow(search).to receive(:each_result).with(freeze: true).and_return(records.each)
+            allow(BerkeleyLibrary::TIND::API::Search).to receive(:new).with(collection: collection).and_return(search)
+          end
+
+          describe 'LibreOffice' do
+            it 'works for LibreOffice' do
+              Dir.mktmpdir(basename) do |dir|
+                output_path = File.join(dir, "#{basename}.ods")
+                Export.export(collection, 'ods', output_path)
+
+                ss = Roo::Spreadsheet.open(output_path)
+                begin
+                  expect(ss).to match_table(expected_table)
+                ensure
+                  ss.close
+                end
+              end
+            end
+
+            it 'writes to an exploded directory' do
+              Dir.mktmpdir(basename) do |dir|
+                Export.export(collection, 'ods', dir)
+
+                expected_paths_relative = %w[META-INF/manifest.xml styles.xml content.xml]
+                expected_paths_absolute = expected_paths_relative.map do |path_relative|
+                  joined_path = File.join(dir, path_relative)
+                  File.absolute_path(joined_path)
+                end
+
+                expected_paths_absolute.each do |path_absolute|
+                  expect(File.file?(path_absolute)).to eq(true)
+                end
+              end
+            end
+          end
+
+          it 'works for CSV' do
+            actual_csv = Export.export(collection, 'csv')
+            expect(actual_csv).to match_table(expected_table)
+          end
+        end
+      end
+
+      describe 'with no results' do
+        let(:collection) { 'Not a collection' }
+
+        before(:each) do
+          search = instance_double(BerkeleyLibrary::TIND::API::Search)
+          empty_enumerator = Enumerator.new({})
+          allow(search).to receive(:each_result).and_return(empty_enumerator)
+          allow(BerkeleyLibrary::TIND::API::Search).to receive(:new).with(collection: collection).and_return(search)
+        end
+
+        describe :export do
+          it 'raises an error' do
+            Export::ExportFormat.each do |fmt|
+              out = instance_double(IO)
+              %i[reopen rewind << write].each { |m| expect(out).not_to receive(m) }
+              expect { Export.export(collection, fmt, out) }.to raise_error(Export::NoResultsError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'roo'
+
+require_relative 'export_matcher'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      describe Exporter do
+        let(:collection) { 'Bancroft Library' }
+
+        describe 'base class' do
+          let(:exporter) { Exporter.new(collection) }
+
+          it "doesn't implement :export" do
+            expect { exporter.export }.to raise_error(NoMethodError)
+          end
+
+          it "doesn't respond to :export" do
+            expect(exporter.respond_to?('export')).to eq(false)
+            expect(exporter.respond_to?(:export)).to eq(false)
+          end
+        end
+
+        Export::ExportFormat.each do |export_format|
+
+          attr_reader :search
+
+          before(:each) do
+            @search = instance_double(BerkeleyLibrary::TIND::API::Search)
+            allow(BerkeleyLibrary::TIND::API::Search).to receive(:new).with(collection: collection).and_return(search)
+          end
+
+          describe export_format.to_s do
+            let(:ext) { export_format.to_s.downcase }
+            let(:exporter) { export_format.exporter_for(collection) }
+
+            it 'responds to :export' do
+              expect(exporter.respond_to?('export')).to eq(true)
+              expect(exporter.respond_to?(:export)).to eq(true)
+            end
+
+            describe 'with results' do
+              let(:records) do
+                (1..7)
+                  .map { |page| File.read("spec/data/records-api-search-p#{page}.xml") }
+                  .map { |p| BerkeleyLibrary::TIND::MARC::XMLReader.new(p, freeze: true).to_a }
+                  .flatten
+              end
+
+              before(:each) do
+                allow(search).to receive(:each_result).with(freeze: true).and_return(records.each)
+              end
+
+              describe :any_results? do
+                it 'returns true' do
+                  expect(exporter.any_results?).to eq(true)
+                end
+
+                it 'caches the search result' do
+                  2.times { exporter.any_results? }
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+              end
+
+              describe :export do
+                it 'exports' do
+                  exported_data = exporter.export
+                  expect(exported_data).not_to be_nil
+                end
+
+                it 'caches search results' do
+                  2.times { expect(exporter.export).not_to be_nil }
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+
+                it 'caches search results from a previous `has_results?` invocation' do
+                  exporter.any_results?
+                  exporter.export
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+              end
+            end
+
+            describe 'without results' do
+              before(:each) do
+                allow(search).to receive(:each_result).with(freeze: true).and_return([].each)
+              end
+
+              describe :any_results? do
+                it 'returns false' do
+                  expect(exporter.any_results?).to eq(false)
+                end
+
+                it 'caches the search result' do
+                  2.times { exporter.any_results? }
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+              end
+
+              describe :export do
+                it 'raises NoResultsError' do
+                  expect { exporter.export }.to raise_error(NoResultsError)
+                end
+
+                it 'caches the failed search result' do
+                  2.times do
+                    expect { exporter.export }.to raise_error(NoResultsError)
+                  end
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+
+                it 'caches the failed search result from a previous `has_results?` invocation' do
+                  exporter.any_results?
+                  expect { exporter.export }.to raise_error(NoResultsError)
+                  expect(search).to have_received(:each_result).with(freeze: true).exactly(1).time
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end