iiif_print 1.0.0 → 2.0.0

data/spec/helpers/hyrax/iiif_helper_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-# @note This spec was brought over from Hyrax 3.4.2
-# @see https://github.com/samvera/hyrax/blob/afdda8240494ed382301f7d0ab0fd7bafe79185e/spec/helpers/hyrax/iiif_helper_spec.rb
-RSpec.describe Hyrax::IiifHelper, type: :helper do
-  let(:solr_document) { SolrDocument.new }
-  let(:request) { double }
-  let(:ability) { nil }
-  let(:presenter) { Hyrax::WorkShowPresenter.new(solr_document, ability, request) }
-  let(:uv_partial_path) { 'hyrax/base/iiif_viewers/universal_viewer' }
-
-  describe '#iiif_viewer_display' do
-    before do
-      allow(helper).to receive(:iiif_viewer_display_partial).with(presenter)
-                                                            .and_return(uv_partial_path)
-    end
-
-    it "renders a partial" do
-      expect(helper).to receive(:render)
-        .with(uv_partial_path, presenter: presenter)
-      helper.iiif_viewer_display(presenter)
-    end
-
-    it "takes options" do
-      expect(helper).to receive(:render)
-        .with(uv_partial_path, presenter: presenter, transcript_id: '123')
-      helper.iiif_viewer_display(presenter, transcript_id: '123')
-    end
-  end
-
-  describe '#iiif_viewer_display_partial' do
-    subject { helper.iiif_viewer_display_partial(presenter) }
-
-    it 'defaults to universal viewer' do
-      expect(subject).to eq uv_partial_path
-    end
-
-    context "with #iiif_viewer override" do
-      let(:iiif_viewer) { :mirador }
-
-      before do
-        allow(presenter).to receive(:iiif_viewer).and_return(iiif_viewer)
-      end
-
-      it { is_expected.to eq 'hyrax/base/iiif_viewers/mirador' }
-    end
-  end
-
-  describe '#universal_viewer_base_url' do
-    subject { helper.universal_viewer_base_url }
-
-    it 'defaults to universal viewer base path' do
-      expect(subject).to eq "http://test.host/uv/uv.html"
-    end
-  end
-
-  describe '#universal_viewer_config_url' do
-    subject { helper.universal_viewer_config_url }
-
-    it 'defaults to universal viewer base path' do
-      expect(subject).to eq "http://test.host/uv/uv-config.json"
-    end
-  end
-end

data/spec/helpers/iiif_print_helper_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrintHelper do
-  let(:query_term) { 'suffrage' }
-  let(:query_params_hash) { { q: query_term } }
-  let(:document) { build(:newspaper_page_solr_document) }
-
-  describe '#iiif_search_anchor' do
-    it 'returns the correct string' do
-      expect(helper.iiif_search_anchor({})).to eq nil
-      expect(helper.iiif_search_anchor(query_params_hash)).to eq("?h=#{query_term}")
-    end
-  end
-
-  describe '#search_query' do
-    it 'returns the correct string' do
-      expect(helper.search_query({})).to eq nil
-      expect(helper.search_query(query_params_hash)).to eq(query_term)
-    end
-  end
-
-  describe '#highlight_matches' do
-    let(:hl_fl) { 'all_text_tsimv' }
-
-    describe 'when highlighting is present in Solr response' do
-      before do
-        allow(document).to receive(:highlight_field).with(hl_fl).and_return(['foo <em>bar</em> baz'.html_safe])
-      end
-      it 'returns the matching terms when highlighting present' do
-        expect(helper.highlight_matches(document, hl_fl, 'em')).to eq 'bar'
-      end
-    end
-
-    describe 'when highlighting is not present' do
-      before do
-        allow(document).to receive(:highlight_field).with(hl_fl).and_return([])
-      end
-      it 'returns the matching terms when highlighting present' do
-        expect(helper.highlight_matches(document, hl_fl, 'em')).to eq nil
-      end
-    end
-  end
-end

data/spec/iiif_print/base_derivative_service_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::BaseDerivativeService do
-  describe '#valid?' do
-    let(:file_set) { double(FileSet) }
-    let(:service) { described_class.new(file_set) }
-    subject { service.valid? }
-
-    it { is_expected.to be_truthy }
-  end
-end

data/spec/iiif_print/blacklight_iiif_search/annotation_decorator_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::BlacklightIiifSearch::AnnotationDecorator do
-  let(:page_document) { build(:newspaper_page_solr_document) }
-  let(:controller) { CatalogController.new }
-  let(:coordinates) do
-    JSON.parse("{\"coords\":{\"software\":[[2641,4102,512,44]]}}")
-  end
-  let(:parent_document) do
-    SolrDocument.new('id' => page_document[:issue_id_ssi],
-                     'has_model_ssim' => ['NewspaperIssue'])
-  end
-  let(:iiif_search_annotation) do
-    BlacklightIiifSearch::IiifSearchAnnotation.new(page_document, 'software',
-                                                   0, nil, controller,
-                                                   parent_document)
-  end
-  let(:test_request) { ActionDispatch::TestRequest.new({}) }
-
-  before do
-    allow(controller).to receive(:request).and_return(test_request)
-    allow(controller).to receive(:polymorphic_url)
-      .with(parent_document, host: test_request.base_url, locale: nil)
-      .and_return("/#{page_document[:issue_id_ssi]}")
-  end
-
-  describe '#annotation_id' do
-    subject { iiif_search_annotation.annotation_id }
-    it 'returns a properly formatted URL' do
-      expect(subject).to include("#{page_document[:issue_id_ssi]}/manifest/canvas/#{page_document[:file_set_ids_ssim].first}/annotation/0")
-    end
-  end
-
-  describe '#canvas_uri_for_annotation' do
-    before { allow(iiif_search_annotation).to receive(:fetch_and_parse_coords).and_return(coordinates) }
-
-    subject { iiif_search_annotation.canvas_uri_for_annotation }
-    it 'returns a properly formatted URL' do
-      expect(subject).to include("#{page_document[:issue_id_ssi]}/manifest/canvas/#{page_document[:file_set_ids_ssim].first}")
-    end
-
-    describe 'private methods' do
-      # test #coordinates based on output of #canvas_uri_for_annotation, which calls it
-      describe '#coordinates' do
-        it 'gets the expected value from #coordinates' do
-          expect(subject).to include("#xywh=2641,4102,512,44")
-        end
-      end
-    end
-  end
-end

data/spec/iiif_print/catalog_search_builder_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::CatalogSearchBuilder do
-  # specs for IiifPrint::HighlightSearchParams
-  describe 'highlight_search_params' do
-    let(:solr_parameters) { { q: 'abolition' } }
-    subject { described_class.new(solr_parameters) }
-
-    it 'is included in the default_processor_chain' do
-      expect(described_class.default_processor_chain).to include(:highlight_search_params)
-    end
-
-    before { subject.highlight_search_params(solr_parameters) }
-    it 'adds the highlight fields to solr_parameters' do
-      expect(solr_parameters[:hl]).to be_truthy
-      expect(solr_parameters[:'hl.fl']).to eq('all_text_tsimv')
-    end
-  end
-
-  # specs for IiifPrint::ExcludeModels
-  describe 'exclude_models' do
-    let(:solr_parameters) { { all_fields: 'prohibition' } }
-    subject { described_class.new(solr_parameters) }
-
-    it 'is included in the default_processor_chain' do
-      expect(described_class.default_processor_chain).to include(:exclude_models)
-    end
-
-    context 'with configured model name solr field values' do
-      before do
-        config = IiifPrint::Configuration.new.tap { |c| c.excluded_model_name_solr_field_values = ['Excluded Model', 'Another Excluded Model'] }
-        subject.exclude_models(solr_parameters, config: config)
-      end
-
-      it 'adds the facet fields to solr_parameters with default key' do
-        expect(solr_parameters[:fq]).to be_truthy
-        expect(solr_parameters[:fq]).to(
-          include("-human_readable_type_sim:\"Excluded Model\"", "-human_readable_type_sim:\"Another Excluded Model\"")
-        )
-      end
-
-      context 'with configured model name solr field key' do
-        before do
-          config = IiifPrint::Configuration.new.tap do |c|
-            c.excluded_model_name_solr_field_values = ['ExcludedModel', 'AnotherExcludedModel']
-            c.excluded_model_name_solr_field_key = 'has_model_ssim'
-          end
-          subject.exclude_models(solr_parameters, config: config)
-        end
-
-        it 'adds the facet fields to solr_parameters with configured key' do
-          expect(solr_parameters[:fq]).to be_truthy
-          expect(solr_parameters[:fq]).to(
-            include("-has_model_ssim:\"ExcludedModel\"", "-has_model_ssim:\"AnotherExcludedModel\"")
-          )
-        end
-      end
-    end
-  end
-end

data/spec/iiif_print/configuration_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::Configuration do
-  let(:config) { described_class.new }
-
-  describe "#metadata_fields" do
-    subject { config.metadata_fields }
-
-    it { is_expected.to be_a Hash }
-    it "allows for an override" do
-      original = config.metadata_fields
-      config.metadata_fields = { title: {} }
-      expect(config.metadata_fields).not_to eq original
-    end
-  end
-
-  describe "#sort_iiif_manifest_canvases_by" do
-    subject { config.sort_iiif_manifest_canvases_by }
-
-    it { is_expected.to be_a Symbol }
-    it "allows for an override" do
-      original = config.sort_iiif_manifest_canvases_by
-      config.sort_iiif_manifest_canvases_by = :title
-      expect(config.metadata_fields).not_to eq original
-    end
-  end
-
-  describe "#handle_after_create_fileset" do
-    let(:file_set) { double(FileSet) }
-    let(:user) { double(User) }
-    subject(:called_function) { config.handle_after_create_fileset(file_set, user) }
-
-    context "without configuration" do
-      it "calls IiifPrint::Data.handle_after_create_fileset" do
-        expect(IiifPrint::Data).to receive(:handle_after_create_fileset).with(file_set, user)
-
-        called_function
-      end
-    end
-
-    context "with configuration" do
-      let(:config_func) { ->(_file_set, _user) { :yup } }
-
-      it "calls the given configured lambda" do
-        config.after_create_fileset_handler = config_func
-        expect(IiifPrint::Data).not_to receive(:handle_after_create_fileset)
-        expect(config_func).to receive(:call).with(file_set, user)
-        called_function
-      end
-    end
-  end
-
-  describe '#additional_tessearct_options' do
-    context "by default" do
-      subject { config.additional_tessearct_options }
-      it { is_expected.not_to be_present }
-    end
-
-    it "can be configured" do
-      expect do
-        config.additional_tessearct_options = "-l esperanto"
-      end.to change(config, :additional_tessearct_options)
-        .from("")
-        .to("-l esperanto")
-    end
-  end
-end

data/spec/iiif_print/data/work_derivatives_spec.rb

@@ -1,245 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Data::WorkDerivatives do
-  include_context "shared setup"
-
-  let(:bare_work) do
-    work = NewspaperPage.new
-    work.title = ['Another one']
-    work.save!
-    work
-  end
-
-  let(:work) do
-    # sample work comes from shared setup, but we need derivative, save...
-    mk_txt_derivative(sample_work)
-    sample_work.save!(validate: false)
-    sample_work
-  end
-
-  let(:adapter) { described_class.new(work) }
-
-  let(:txt1) do
-    registered_dirs = IiifPrint.config.registered_ingest_dirs
-    registered_dirs.push('/tmp') unless registered_dirs.include?('/tmp')
-    file = Tempfile.new(['txt1', '.txt'])
-    file.write('hello')
-    file.flush
-    file
-  end
-
-  let(:txt2) do
-    file = Tempfile.new('txt2.txt')
-    file.write('bye')
-    file.flush
-    file
-  end
-
-  let(:encoded_text) do
-    file = Tempfile.new('txt_encoded.txt', encoding: 'UTF-8')
-    file.write('Gorgonzola Dolce® — on sale for £12.50/kg')
-    file.flush
-    file
-  end
-
-  describe "enumerates available derivatives like hash" do
-    xit "includes expected derivative path for work" do
-      expect(adapter.keys).to include 'txt'
-    end
-
-    xit "can be introspected for quantity of derivatives" do
-      # `size` method without argument is count of derivatives,
-      #   functions equivalently to adapter.keys.size
-      expect(adapter.size).to eq adapter.keys.size
-    end
-
-    xit "enumerates expected derivative extension for work" do
-      ext_found = adapter.keys
-      expect(ext_found).to include 'txt'
-    end
-
-    xit "enumerates expected derivative extension for file set" do
-      file_set = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.new(file_set)
-      ext_found = adapter.keys
-      expect(ext_found).to include 'txt'
-    end
-
-    xit "enumerates expected derivative extension for file set id" do
-      file_set = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.new(file_set.id)
-      ext_found = adapter.keys
-      expect(ext_found).to include 'txt'
-    end
-  end
-
-  describe "loads derivatives for a work" do
-    xit "Loads text derivative path" do
-      expect(File.exist?(adapter.path('txt'))).to be true
-      expect(adapter.exist?('txt')).to be true
-    end
-
-    xit "Loads text derivative data" do
-      expect(adapter.data('txt')).to include 'mythical'
-    end
-
-    xit "Handles character encoding on read" do
-      # replace fixture text derivative for work with encoded text
-      adapter.attach(encoded_text.path, 'txt')
-      data = adapter.data('txt')
-      expect(data).to include '—' # em-dash
-      expect(data).to include '£' # gb-pound sign
-      expect(data.encoding.to_s).to eq 'UTF-8'
-    end
-
-    xit "Loads thumbnail derivative data" do
-      mk_thumbnail_derivative(work)
-      # get size by loading data
-      expect(adapter.data('thumbnail').bytes.size).to eq 16_743
-      # get size by File.size via .size method
-      expect(adapter.size('thumbnail')).to eq 16_743
-    end
-
-    xit "Can access jp2 derivative" do
-      mk_jp2_derivative(work)
-      expect(File.exist?(adapter.path('jp2'))).to be true
-      expect(adapter.exist?('jp2')).to be true
-    end
-  end
-
-  describe "create, update, delete derivatives" do
-    xit "will queue derivative file assignment" do
-      adapter = described_class.new(bare_work)
-      adapter.assign(example_gray_jp2)
-      expect(adapter.assigned).to include example_gray_jp2
-    end
-
-    xit "will fail to assign file in non-registered dirs" do
-      adapter = described_class.new(bare_work)
-      # need a non-whitlisted file that exists:
-      bad_path = File.expand_path("../../spec_helper.rb", fixture_path)
-      expect { adapter.assign(bad_path) }.to raise_error(SecurityError)
-    end
-
-    xit "will remove file assignment from queue" do
-      adapter = described_class.new(bare_work)
-      expect(adapter.state).to eq 'empty'
-      adapter.assign(example_gray_jp2)
-      expect(adapter.assigned).to include example_gray_jp2
-      expect(adapter.state).to eq 'dirty'
-      adapter.unassign(example_gray_jp2)
-      expect(adapter.assigned).not_to include example_gray_jp2
-      expect(adapter.state).to eq 'empty'
-    end
-
-    xit "will queue a deletion" do
-      # Given a work with a derivative (txt) already assigned
-      expect(adapter.state).to eq 'saved'
-      # unassigning path...
-      adapter.unassign('txt')
-      # will lead to queued unassignment (intent to delete)...
-      expect(adapter.unassigned).to include 'txt'
-      # and a 'dirty' adapter state (unflushed changes):
-      expect(adapter.state).to eq 'dirty'
-    end
-
-    xit "will flush a removal and addition on commit!" do
-      # Given a work with a derivative (txt) already assigned
-      expect(adapter.keys).to include 'txt'
-      expect(adapter.keys).not_to include 'jp2'
-      # unassigning path...
-      adapter.unassign('txt')
-      # and assigning another attachment:
-      adapter.assign(example_gray_jp2)
-      # ...committing these will flush the changes (synchronously):
-      adapter.commit!
-      expect(adapter.keys).not_to include 'txt'
-      expect(adapter.keys).to include 'jp2'
-      expect(adapter.size('jp2')).to eq 27_703
-    end
-
-    xit "can attach derivative from file" do
-      expect(adapter.keys).not_to include 'jp2'
-      adapter.attach(example_gray_jp2, 'jp2')
-      expect(adapter.exist?('jp2')).to be true
-      expect(adapter.path('jp2')).not_to be nil
-      expect(File.size(adapter.path('jp2'))).to eq File.size(example_gray_jp2)
-      expect(adapter.keys).to include 'jp2'
-      d_path = path_factory.derivative_path_for_reference(adapter.fileset_id, 'jp2')
-      expect(adapter.values).to include d_path
-    end
-
-    xit "can replace aderivative with new attachment" do
-      adapter.attach(txt1.path, 'txt')
-      expect(adapter.data('txt')).to eq 'hello'
-      adapter.attach(txt2.path, 'txt')
-      expect(adapter.data('txt')).to eq 'bye'
-    end
-
-    xit "can delete an attached derivative" do
-      adapter.attach(txt1.path, 'txt')
-      expect(adapter.keys).to include 'txt'
-      expect(adapter.data('txt')).to eq 'hello'
-      adapter.delete('txt')
-      expect(adapter.path('txt')).to be nil
-      expect(adapter.keys).not_to include 'txt'
-    end
-
-    xit "persists log of attachment to RDBMS" do
-      adapter.assign(txt1.path)
-      result = IiifPrint::DerivativeAttachment.find_by(
-        fileset_id: adapter.fileset.id,
-        path: txt1.path,
-        destination_name: 'txt'
-      )
-      expect(result).not_to be_nil
-    end
-
-    xit "persists a log of path relation to primary file" do
-      # this is an integration test by practical necessity, with
-      #   WorkFiles adapting a bare work with no fileset.
-      work_files = IiifPrint::Data::WorkFiles.of(bare_work)
-      work_files.assign(example_gray_jp2)
-      adapter = work_files.derivatives
-      adapter.assign(txt1.path)
-      result = IiifPrint::IngestFileRelation.find_by(
-        derivative_path: txt1.path,
-        file_path: example_gray_jp2
-      )
-      expect(result).not_to be_nil
-    end
-
-    xit "commits queued derivatives" do
-      IiifPrint::IngestFileRelation.where(file_path: example_gray_jp2).delete_all
-      work_files = IiifPrint::Data::WorkFiles.of(bare_work)
-      work_files.assign(example_gray_jp2)
-      adapter = work_files.derivatives
-      adapter.assign(txt1.path)
-      expect(File.exist?(txt1.path)).to be true
-      expect(adapter.keys.size).to eq 0
-      # we need a fileset, saved with import_url, attached to work:
-      fileset = valid_file_set
-      fileset.import_url = 'file://' + example_gray_jp2
-      fileset.save!
-      bare_work.members.push(fileset)
-      bare_work.save!
-      fileset.reload
-      expect(fileset.member_of[0].id).to eq bare_work.id
-      # with a new adapter instance...
-      adapter2 = described_class.of(bare_work)
-      # call .commit_queued! with our fileset...
-      expect(File.exist?(txt1.path)).to be true
-      adapter2.commit_queued!(fileset)
-      # ...which should result in saved, reloaded derivative...
-      expect(adapter2.keys.size).to eq 1
-      expect(File.size(adapter2.values[0])).to eq File.size(txt1.path)
-      # ...also found via Hyrax::DerviativePath:
-      found = Hyrax::DerivativePath.derivatives_for_reference(fileset.id)
-      expect(found.size).to eq 1
-      expect(File.size(found[0])).to eq File.size(txt1.path)
-    end
-  end
-end

data/spec/iiif_print/data/work_file_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Data::WorkFile do
-  include_context "shared setup"
-
-  # sample objects:
-  let(:work) { work_with_file }
-
-  describe "adapter composition" do
-    it "adapts work with nil fileset" do
-      adapter = described_class.new(work)
-      expect(adapter.work).to be work
-      expect(adapter.fileset).to be_nil
-    end
-
-    it "adapts work with 'of' alt constructor" do
-      adapter = described_class.of(work)
-      expect(adapter.work).to be work
-    end
-
-    it "adapts work and explicitly provided fileset" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      expect(adapter.work).to be work
-      expect(adapter.fileset).to be fileset
-    end
-
-    it "constructs with a parent object, if provided" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      parent = double('parent')
-      adapter = described_class.of(work, fileset, parent)
-      expect(adapter.parent).to be parent
-    end
-  end
-
-  describe "read file metadata" do
-    it "gets original filename" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      expect(adapter.name).to eq fileset.original_file.original_name
-      expect(adapter.name).to eq 'credits.md'
-    end
-
-    it "gets miscellaneous metadata field values" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      # expectations for accessors of size, date_*, mime_type
-      expect(adapter.size).to eq File.size(txt_path)
-      expect(adapter.name).to eq 'credits.md'
-      expect(adapter.mime_type).to eq 'text/plain'
-      # getting actual value for date fields requires digging through
-      #   multiple layers of ActiveTuples indirection...
-      expect(adapter.date_created.to_a[0].to_s).to eq static_date.to_s
-      expect(adapter.date_modified.to_a[0].to_s).to eq static_date.to_s
-    end
-  end
-
-  describe "read binary via transparent repository checkout" do
-    it "gets path (from checkout)" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      # Get a path to a working copy
-      path = adapter.path
-      expect(path).to be_a String
-      expect(File.exist?(path)).to be true
-      # size of working copy binary checkout matches size in computed metadata
-      expect(File.size(path)).to eq fileset.original_file.size
-    end
-
-    it "gets data as bytes" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      # Get a data from the working copy
-      data = adapter.data
-      expect(data).to be_a String
-      # size of working copy binary checkout matches size in computed metadata
-      expect(data.size).to eq fileset.original_file.size
-    end
-
-    it "runs block on data as IO" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      adapter.with_io { |io| expect(io.read.size).to eq File.size(txt_path) }
-    end
-  end
-
-  describe "derivative access" do
-    it "gets derivatives for file" do
-      fileset = work.members.detect { |m| m.is_a? FileSet }
-      adapter = described_class.of(work, fileset)
-      expect(adapter.derivatives.class).to eq \
-        IiifPrint::Data::WorkDerivatives
-      expect(adapter.derivatives.fileset).to be fileset
-      expect(adapter.derivatives.work).to be work
-      expect(adapter.derivatives.parent).to be adapter
-    end
-  end
-end