iiif_print 1.1.0 → 2.0.1

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,28 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::BaseDerivativeService do
-  let(:file_set) { double(FileSet) }
-  let(:service) { described_class.new(file_set) }
-
-  describe '#valid?' do
-    subject { service.valid? }
-
-    context 'when given an image file' do
-      let(:file_set) { double(FileSet, mime_type: 'image/tiff', class: FileSet) }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context 'when given a non-image file' do
-      let(:file_set) { double(FileSet, mime_type: 'audio/mpeg', class: FileSet) }
-
-      it { is_expected.to be_falsey }
-    end
-  end
-
-  describe "instance" do
-    subject { service }
-
-    it { is_expected.to respond_to :target_extension }
-  end
-end

data/spec/iiif_print/blacklight_iiif_search/annotation_decorator_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::BlacklightIiifSearch::AnnotationDecorator do
-  let(:parent_id) { 'abc123' }
-  let(:page_document) do
-    doc = build(:newspaper_page_solr_document)
-    doc['is_page_of_ssim'] = [parent_id]
-    doc
-  end
-  let(:controller) { CatalogController.new }
-  let(:coordinates) do
-    JSON.parse("{\"coords\":{\"software\":[[2641,4102,512,44]]}}")
-  end
-  let(:parent_document) do
-    SolrDocument.new('id' => parent_id,
-                     'has_model_ssim' => ['NewspaperIssue'])
-  end
-  let(:query) { "software AND (is_page_of_ssim:#{parent_id} OR id:#{parent_id})" }
-  let(:iiif_search_annotation) do
-    BlacklightIiifSearch::IiifSearchAnnotation.new(page_document, query,
-                                                   0, nil, controller,
-                                                   parent_document)
-  end
-  let(:file_set) { build(:file_set_solr_document) }
-  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]}")
-    allow(SolrDocument).to receive(:find).with(file_set.id).and_return(file_set)
-  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('*')
-    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,193 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::Configuration do
-  let(:config) { described_class.new }
-
-  describe '#ancestory_identifier_function' do
-    subject(:function) { config.ancestory_identifier_function }
-    it "is expected to be a lambda with an arity of one" do
-      expect(function.arity).to eq(1)
-    end
-
-    it "is configurable" do
-      expect do
-        config.ancestory_identifier_function = ->(w) { w.object_id }
-      end.to change { config.ancestory_identifier_function.object_id }
-    end
-  end
-
-  describe '#unique_child_title_generator_function' do
-    subject(:function) { config.unique_child_title_generator_function }
-
-    it "is expected to be a lambda with keyword args" do
-      expect(function.parameters).to eq([[:keyreq, :original_pdf_path],
-                                         [:keyreq, :image_path],
-                                         [:keyreq, :parent_work],
-                                         [:keyreq, :page_number],
-                                         [:keyreq, :page_padding]])
-    end
-
-    it 'works as originally designed' do
-      work = double(title: ["My Title"], id: '1234')
-      expect(function.call(
-               original_pdf_path: "/hello/world/nice.pdf",
-               image_path: __FILE__,
-               parent_work: work,
-               page_number: 23,
-               page_padding: 5
-             )).to eq("1234 - nice.pdf Page 00024")
-    end
-
-    it "is configurable" do
-      expect do
-        config.unique_child_title_generator_function = ->(**kwargs) { kwargs }
-      end.to change { config.unique_child_title_generator_function.object_id }
-    end
-  end
-
-  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 "#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_tesseract_options' do
-    context "by default" do
-      subject { config.additional_tesseract_options }
-      it { is_expected.not_to be_present }
-    end
-
-    it "can be configured" do
-      expect do
-        config.additional_tesseract_options = "-l esperanto"
-      end.to change(config, :additional_tesseract_options)
-        .from("")
-        .to("-l esperanto")
-    end
-  end
-
-  describe '#default_iiif_manifest_version' do
-    subject { config.default_iiif_manifest_version }
-
-    context 'default' do
-      it { is_expected.to eq 2 }
-    end
-
-    context 'when set to empty' do
-      before { config.default_iiif_manifest_version = '' }
-      it { is_expected.to eq 2 }
-    end
-
-    it 'can be set' do
-      expect { config.default_iiif_manifest_version = 3 }
-        .to change(config, :default_iiif_manifest_version)
-        .from(2)
-        .to(3)
-    end
-  end
-
-  describe '#child_work_attributes_function' do
-    subject(:function) { config.child_work_attributes_function }
-
-    it "is expected to be a lambda with keyword args" do
-      expect(function.parameters).to eq([[:keyreq, :parent_work],
-                                         [:keyreq, :admin_set_id]])
-    end
-  end
-
-  describe "#sort_iiif_manifest_canvases_by" do
-    subject { config.sort_iiif_manifest_canvases_by }
-
-    it { is_expected.to be_a NilClass }
-    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 "#ocr_coords_from_json_function" do
-    subject(:function) { config.ocr_coords_from_json_function }
-
-    it "is expected to be a lambda with one keyword arg and optional args" do
-      expect(function.parameters).to eq([[:keyreq, :file_set_id], [:keyrest]])
-    end
-  end
-
-  describe "#all_text_generator_function" do
-    subject(:function) { config.all_text_generator_function }
-
-    it "is expected to be a lambda with one keyword arg" do
-      expect(function.parameters).to eq([[:keyreq, :object]])
-    end
-  end
-
-  describe "#iiif_metadata_field_presentation_order" do
-    subject { config.iiif_metadata_field_presentation_order }
-
-    it { is_expected.to be_a NilClass }
-    it "allows for an override" do
-      original = config.iiif_metadata_field_presentation_order
-      config.iiif_metadata_field_presentation_order = :title
-      expect(config.iiif_metadata_field_presentation_order).not_to eq original
-    end
-  end
-
-  describe "#questioning_authority_fields" do
-    subject { config.questioning_authority_fields }
-
-    it { is_expected.to be_a Array }
-    context "by default" do
-      it { is_expected.to eq ['rights_statement', 'license'] }
-    end
-
-    it "allows for an override" do
-      expect do
-        config.questioning_authority_fields = ['rights_statement', 'license', 'subject']
-      end.to change(config, :questioning_authority_fields).from(['rights_statement', 'license']).to(['rights_statement', 'license', 'subject'])
-    end
-  end
-
-  describe '#skip_splitting_pdf_files_that_end_with_these_texts' do
-    subject { config.skip_splitting_pdf_files_that_end_with_these_texts }
-    context 'by default' do
-      it { is_expected.to be_empty }
-    end
-
-    context 'is configurable' do
-      before { config.skip_splitting_pdf_files_that_end_with_these_texts = ['.READER.pdf'] }
-
-      it { is_expected.not_to be_empty }
-    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