iiif_print 1.1.0 → 2.0.1

data/spec/presenters/iiif_print/iiif_manifest_presenter_factory_behavior_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-RSpec.describe IiifPrint::IiifManifestPresenterBehavior do
-  let(:parent_fs_attributes) do
-    { "id" => "parent_fs123",
-      "title_tesim" => ["My Parent FileSet"],
-      "has_model_ssim" => ["FileSet"] }
-  end
-  let(:child_work_attributes) do
-    { "id" => "child_work123",
-      "title_tesim" => ["My Child Image"],
-      "has_model_ssim" => ["Image"],
-      "file_set_ids_ssim" => ["child_image_fs123"] }
-  end
-  let(:child_fs_attributes) do
-    { "id" => "child_fs123",
-    "title_tesim" => ["My Child FileSet"],
-    "has_model_ssim" => ["FileSet"] }
-  end
-  let(:parent_fs_solr_doc) { SolrDocument.new(parent_fs_attributes) }
-  let(:child_work_solr_doc) { SolrDocument.new(child_work_attributes) }
-  let(:child_fs_solr_doc) { SolrDocument.new(child_fs_attributes) }
-  let(:ids) { [parent_fs_solr_doc.id, child_work_solr_doc.id] }
-  let(:presenter_class) { Hyrax::IiifManifestPresenter }
-
-  subject(:presenter_factory) do
-    Hyrax::IiifManifestPresenter::Factory.new(
-      ids: ids,
-      presenter_class: presenter_class,
-      presenter_args: []
-    )
-  end
-
-  describe "#build" do
-    it "returns an Array of DisplayImagePresenters" do
-      allow_any_instance_of(Hyrax::IiifManifestPresenter::Factory)
-        .to receive(:load_docs).and_return([parent_fs_solr_doc, child_work_solr_doc])
-      allow_any_instance_of(IiifPrint::IiifManifestPresenterFactoryBehavior)
-        .to receive(:load_file_set_docs).and_return([child_fs_solr_doc])
-      allow(child_work_solr_doc).to receive(:hydra_model).and_return(MyWork)
-      allow(Hyrax.config).to receive(:curation_concerns).and_return([MyWork])
-
-      expect(subject.build).to be_an Array
-      expect(subject.build.size).to eq ids.size
-      expect(subject.build.map(&:class).uniq.size).to eq 1
-      expect(subject.build.first.class).to eq Hyrax::IiifManifestPresenter::DisplayImagePresenter
-    end
-  end
-end

data/spec/samvera/derivatives/configuration_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'samvera/derivatives/configuration'
-
-RSpec.describe Samvera::Derivatives::Configuration do
-  let(:file_set) { double(:file_set) }
-  let(:config) { described_class.new }
-
-  describe '#registry_for' do
-    it 'has a applicable_for that is falsey' do
-      register = config.registry_for(type: :thumbnail)
-      expect(register.applicable_for?(file_set: file_set)).to be_falsey
-    end
-  end
-
-  describe '#register' do
-    it 'amends the existing registry' do
-      locator = double
-      type = :thumbnail
-      expect do
-        config.register(type: type, locators: [locator], applicators: [])
-      end.to change { config.registry_for(type: type).locators }.from([]).to([locator])
-    end
-
-    context 'validation' do
-      it 'defaults to a truthy validator' do
-        registry = config.register(type: :thumbnail, locators: [], applicators: [])
-        expect(registry.applicable_for?(file_set: file_set)).to be_truthy
-      end
-
-      it 'allows for block configuration' do
-        registry = config.register(type: :thumbnail, locators: [], applicators: []) do |_file_set|
-          false
-        end
-
-        expect(registry.applicable_for?(file_set: file_set)).to be_falsey
-      end
-    end
-  end
-end

data/spec/samvera/derivatives/hyrax_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'samvera/derivatives'
-require 'samvera/derivatives/hyrax'
-
-RSpec.describe Samvera::Derivatives::Hyrax::ServiceShim do
-  let(:config) { Samvera::Derivatives::Configuration.new }
-  let(:file_set) { FileSet.new }
-  let(:other_locator) { double('Locator', locate: nil) }
-  let(:other_applicator) { double('Applicator', apply!: nil) }
-  before do
-    config.register(
-      type: :thumbnail,
-      locators: [other_locator, Samvera::Derivatives::Hyrax::FileLocatorStrategy],
-      applicators: [other_applicator, Samvera::Derivatives::Hyrax::FileApplicatorStrategy]
-    ) { |_file_set| true }
-    config.register(
-      type: :jpg,
-      locators: [other_locator, Samvera::Derivatives::Hyrax::FileLocatorStrategy],
-      applicators: [other_applicator, Samvera::Derivatives::Hyrax::FileApplicatorStrategy]
-    ) { |_file_set| true }
-  end
-
-  let(:shim) { described_class.new(file_set, candidate_derivative_types: [:thumnail, :jpg], config: config) }
-
-  subject { shim }
-
-  it { is_expected.to be_valid }
-
-  describe '#create_derivatives' do
-    let(:file_path) { __FILE__ }
-    subject { shim.create_derivatives(file_path) }
-
-    context 'when other locator and applicator are not applicable' do
-      it 'locates and applies the derivatives using the underlying service' do
-        expect_any_instance_of(Samvera::Derivatives::Hyrax::FileApplicatorStrategy).to receive(:apply!).and_call_original
-        expect_any_instance_of(Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper).to receive(:apply!).and_call_original
-        expect_any_instance_of(::Hyrax::FileSetDerivativesService).to receive(:valid?).and_return(true)
-        expect_any_instance_of(::Hyrax::FileSetDerivativesService).to receive(:create_derivatives).with(file_path)
-        expect(other_applicator).to receive(:apply!)
-
-        subject
-      end
-    end
-
-    context 'when the other locator finds the derivative' do
-      let(:other_locator) { double(locate: file_path) }
-
-      it 'uses that located derivative and applies it' do
-        # Yes, we will attempt to apply the derivative...
-        expect_any_instance_of(Samvera::Derivatives::Hyrax::FileApplicatorStrategy).to receive(:apply!).and_call_original
-        # ...however, we won't be leveraging the wrapper's derivative work; meaning no default behavior.
-        expect_any_instance_of(Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper).not_to receive(:apply!)
-        expect_any_instance_of(::Hyrax::FileSetDerivativesService).not_to receive(:valid?)
-        expect_any_instance_of(::Hyrax::FileSetDerivativesService).not_to receive(:create_derivatives)
-        expect(other_applicator).to receive(:apply!)
-
-        subject
-      end
-    end
-  end
-end

data/spec/samvera/derivatives_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'samvera/derivatives'
-
-RSpec.describe Samvera::Derivatives do
-  describe '.config' do
-    subject { described_class.config }
-
-    it { is_expected.to be_a(described_class::Configuration) }
-  end
-
-  describe '.locate_and_apply_derivative_for' do
-    let(:file_set) { double(FileSet) }
-    let(:file_path) { __FILE__ }
-    let(:applicability) { true }
-    let(:type) { :thumbnail }
-    let(:locator) { described_class::FileLocator::Strategy }
-    let(:applicator) { described_class::FileApplicator::Strategy }
-
-    let(:derivative) do
-      described_class::Configuration::RegisteredType.new(
-        type: type,
-        applicators: [applicator],
-        locators: [locator],
-        applicability: ->(_) { applicability }
-      )
-    end
-
-    subject do
-      described_class.locate_and_apply_derivative_for(
-        file_set: file_set,
-        derivative: derivative,
-        file_path: file_path
-      )
-    end
-
-    context 'when not applicable' do
-      let(:applicability) { false }
-
-      it { is_expected.to be_falsey }
-    end
-
-    context 'when applicable' do
-      let(:from_location) { :from_location }
-
-      it 'locates then applies the derivative' do
-        expect(locator).to receive(:locate).and_return(from_location)
-        expect(applicator).to receive(:apply!).with(file_set: file_set, derivative_type: type, from_location: from_location)
-
-        subject
-      end
-    end
-  end
-end

data/spec/services/iiif_print/derivative_rodeo_service_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe IiifPrint::DerivativeRodeoService do
-  let(:work) { double("Work", { :id => 'work-5678', described_class.parent_work_identifier_property_name => 'hello-1234-id' }) }
-  let(:file_set) { FileSet.new.tap { |fs| fs.save!(validate: false) } }
-  let(:generator) { DerivativeRodeo::Generators::CopyGenerator }
-  let(:output_extension) { "rb" }
-
-  before do
-    allow(file_set).to receive(:parent).and_return(work)
-
-    # TODO: This is a hack that leverages the internals oof Hydra::Works; not excited about it but
-    # this part is only one piece of the over all integration.
-    allow(file_set).to receive(:original_file).and_return(double(original_filename: __FILE__))
-  end
-
-  let(:instance) { described_class.new(file_set) }
-
-  subject(:klass) { described_class }
-
-  describe '.preprocessed_location_adapter_name' do
-    subject { described_class.preprocessed_location_adapter_name }
-    it { is_expected.to eq 's3' }
-  end
-
-  describe '.parent_work_identifier_property_name' do
-    subject { described_class.parent_work_identifier_property_name }
-    it { is_expected.to be_a String }
-  end
-
-  describe '.named_derivatives_and_generators_by_type' do
-    subject { described_class.named_derivatives_and_generators_by_type }
-    it { is_expected.to be_a Hash }
-  end
-
-  describe '.derivative_rodeo_uri' do
-    subject { described_class.derivative_rodeo_uri(file_set: file_set, filename: __FILE__) }
-
-    context 'when the file_set does not have a parent' do
-      xit 'is expected to raise an error' do
-        expect { subject }.to raise_error(IiifPrint::DataError)
-      end
-    end
-
-    context 'when the file_set has a parent' do
-      it { is_expected.to start_with("#{described_class.preprocessed_location_adapter_name}://") }
-      it { is_expected.to end_with(File.basename(__FILE__)) }
-    end
-
-    context 'for a thumbnail based on a PDF' do
-      let(:extension) { DerivativeRodeo::Generators::ThumbnailGenerator.output_extension }
-      let(:filename) { "/tmp/d20230714-1897-1wgmauo/#{work.aark_id}.ARCHIVAL.pdf" }
-      it 'has the correct filename' do
-        expect(described_class.derivative_rodeo_uri(file_set: file_set, filename: filename, extension: extension,
-adapter_name: 'file')).to eq("file://#{work.aark_id}/#{work.aark_id}.ARCHIVAL.#{extension}")
-      end
-    end
-
-    context 'for the original file' do
-      let(:extension) { nil }
-      let(:filename) { "/tmp/d20230714-1897-1wgmauo/#{work.aark_id}.ARCHIVAL.pdf" }
-      it 'has the correct filename' do
-        expect(described_class.derivative_rodeo_uri(file_set: file_set, filename: filename, extension: extension, adapter_name: 'file')).to eq("file://#{work.aark_id}/#{work.aark_id}.ARCHIVAL.pdf")
-      end
-    end
-  end
-
-  # TODO: Need Faux Bucket for Derivative Rodeo
-  xdescribe '#valid?' do
-    subject { instance.valid? }
-
-    before do
-      allow(file_set).to receive(:mime_type).and_return(mime_type)
-      allow(file_set).to receive(:parent).and_return(work)
-    end
-
-    context 'when the mime_type of the file is not supported' do
-      let(:mime_type) { "text/plain" }
-      it { is_expected.to be_falsey }
-    end
-
-    context 'when derivative rodeo has not pre-processed the file set' do
-      before { instance.preprocessed_location_adapter_name = "file" }
-
-      let(:mime_type) { "application/pdf" }
-      it { is_expected.to be_falsey }
-    end
-
-    context 'when the mime type is supported and the derivative rodeo has pre-processed the file set' do
-      before do
-        # TODO: write to the rodeo; consider using AWS's spec support; I want to be able to "fake" S3
-        # with a "fake" bucket.
-        #
-        # Dependent on https://github.com/scientist-softserv/derivative_rodeo/pull/37
-      end
-
-      let(:mime_type) { "application/pdf" }
-      it { is_expected.to be_truthy }
-    end
-  end
-end

data/spec/services/iiif_print/jp2_derivative_service_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-RSpec.describe IiifPrint::JP2DerivativeService do
-  let(:valid_file_set) do
-    file_set = FileSet.new
-    file_set.save!(validate: false)
-    file_set
-  end
-
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  describe "Creates JP2 derivatives" do
-    def source_image(name)
-      File.join(fixture_path, name)
-    end
-
-    def expected_path(file_set)
-      Hyrax::DerivativePath.derivative_path_for_reference(file_set, 'jp2')
-    end
-
-    def metadata_match_checker(source, target)
-      target_meta = IiifPrint::ImageTool.new(target).metadata
-      source_meta = IiifPrint::ImageTool.new(source).metadata
-      expect(target_meta[:content_type]).to eq 'image/jp2'
-      expect(target_meta[:width]).to eq source_meta[:width]
-      expect(target_meta[:height]).to eq source_meta[:height]
-    end
-
-    def makes_jp2(filename)
-      expected = expected_path(valid_file_set)
-      expect(File.exist?(expected)).to be false
-      svc = described_class.new(valid_file_set)
-      source_path = source_image(filename)
-      svc.create_derivatives(source_path)
-      expect(File.exist?(expected)).to be true
-      metadata_match_checker(source_path, expected)
-      svc.cleanup_derivatives
-    end
-
-    it "creates gray JP2 derivative from one-bit source" do
-      makes_jp2('ocr_mono.tiff')
-    end
-
-    it "creates gray JP2 from grayscale source" do
-      makes_jp2('lowres-gray-via-ndnp-sample.tiff')
-    end
-
-    it "creates color JP2 from color source" do
-      makes_jp2('4.1.07.tiff')
-    end
-
-    it "creates JP2 from PDF source, robust to multi-page" do
-      makes_jp2('sample-color-newsletter.pdf')
-    end
-  end
-end

data/spec/services/iiif_print/manifest_builder_service_behavior_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-RSpec.describe IiifPrint::ManifestBuilderServiceBehavior do
-  context '#initialize' do
-    it 'uses defaults to set the version' do
-      builder_service = Hyrax::ManifestBuilderService.new
-      expect(builder_service.manifest_factory).to eq(::IIIFManifest::ManifestFactory)
-      expect(builder_service.version).to eq(IiifPrint.config.default_iiif_manifest_version)
-    end
-
-    it 'allows version overrides' do
-      # This in part verifies the expected interaction of the version as a parameter being picked up
-      # by another parameter.
-      builder_service = Hyrax::ManifestBuilderService.new(version: 3)
-      expect(builder_service.manifest_factory).to eq(::IIIFManifest::V3::ManifestFactory)
-      expect(builder_service.version).to eq(3)
-    end
-  end
-end

data/spec/services/iiif_print/pdf_derivative_service_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-RSpec.describe IiifPrint::PDFDerivativeService do
-  let(:valid_file_set) do
-    file_set = FileSet.new
-    file_set.save!(validate: false)
-    file_set
-  end
-
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  describe "Creates PDF derivatives" do
-    def source_image(name)
-      File.join(fixture_path, name)
-    end
-
-    def expected_path(file_set)
-      Hyrax::DerivativePath.derivative_path_for_reference(file_set, 'pdf')
-    end
-
-    # given output file name, check DPI is 150
-    def check_dpi(expected)
-      metadata = IiifPrint::ImageTool.new(expected).metadata
-      # get width of pdf in points (via imagemagick), should be 864x == 12in
-      page_width = metadata[:width]
-      expect(page_width).to eq 864
-      # get total width of image in pixels from pdfimages -list, ==> 1800
-      image_width = 1800
-      im_list = `pdfimages -list #{expected}`
-      expect(im_list.lines[-1].split(' ')[3]).to eq image_width.to_s
-      # this combination of page pt width, image px width ==> 150ppi
-      expect(image_width / (page_width / 72.0)).to eq 150.0
-    end
-
-    def makes_pdf(filename)
-      expected = expected_path(valid_file_set)
-      expect(File.exist?(expected)).to be false
-      svc = described_class.new(valid_file_set)
-      svc.create_derivatives(source_image(filename))
-      expect(File.exist?(expected)).to be true
-      metadata = IiifPrint::ImageTool.new(expected).metadata
-      expect(metadata[:content_type]).to eq 'application/pdf'
-      check_dpi(expected)
-      svc.cleanup_derivatives
-    end
-
-    it "creates gray PDF derivative from one-bit source" do
-      makes_pdf('ocr_mono.tiff')
-    end
-
-    it "creates gray PDF from grayscale source" do
-      makes_pdf('lowres-gray-via-ndnp-sample.tiff')
-    end
-
-    it "creates color PDF from color source" do
-      makes_pdf('4.1.07.tiff')
-    end
-
-    it "creates color PDF from color JP2 source" do
-      makes_pdf('4.1.07.jp2')
-    end
-  end
-end

data/spec/services/iiif_print/pluggable_derivative_service_spec.rb

@@ -1,175 +0,0 @@
-require 'fileutils'
-require 'spec_helper'
-
-RSpec.describe IiifPrint::PluggableDerivativeService do
-  let(:persisted_file_set) do
-    fs = FileSet.new
-    work.title = ['This is a page!']
-    work.members.push(fs)
-    fs.instance_variable_set(:@mime_type, 'image/tiff')
-    fs.save!(validate: false)
-    work.save!(validate: false)
-    fs
-  end
-
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  describe "service registration" do
-    # integration test with Hyrax, verify services is registered
-
-    it "is registered with Hyrax" do
-      expect(Hyrax::DerivativeService.services).to include described_class
-    end
-
-    it "is the first valid service found" do
-      file_set = double(FileSet,
-                        class: FileSet,
-                        mime_type: 'application/pdf',
-                        parent: MyIiifConfiguredWorkWithAllDerivativeServices.new)
-      found = Hyrax::DerivativeService.for(file_set)
-      expect(found).to be_a described_class
-    end
-  end
-
-  context "when the FileSet's parent is not IiifPrint configured" do
-    before do
-      allow(persisted_file_set).to receive(:in_works).and_return([work])
-    end
-
-    let(:work) { MyWork.new }
-
-    describe "#plugins" do
-      it "uses the default derivatives service" do
-        file_set = double(FileSet,
-                          class: FileSet,
-                          mime_type: 'application/pdf',
-                          parent: MyWork.new)
-        service = described_class.new(file_set)
-        expect(service.plugins).to eq [Hyrax::FileSetDerivativesService]
-      end
-    end
-  end
-
-  context "when the FileSet's parent is IiifPrint configured" do
-    describe "calls the configured derivative plugins" do
-      before do
-        allow(persisted_file_set).to receive(:in_works).and_return([work])
-        allow_any_instance_of(Hyrax::FileSetDerivativesService).to receive(:send)
-      end
-
-      let(:work) { MyIiifConfiguredWork.new }
-      let(:plugin) { FakeDerivativeService.new }
-
-      it "calls each plugin on create" do
-        service = described_class.new(persisted_file_set, plugins: [plugin])
-        expect do
-          service.create_derivatives('not_a_real_filename')
-        end.to change(plugin, :create_called).by(1)
-      end
-
-      def touch_fake_derivative_file(file_set, ext)
-        path = Hyrax::DerivativePath.derivative_path_for_reference(file_set, ext)
-        FileUtils.mkdir_p(File.join(path.split('/')[0..-2]))
-        FileUtils.touch(path)
-      end
-
-      it "does not re-create existing derivative" do
-        service = described_class.new(persisted_file_set, plugins: [plugin])
-        expect(persisted_file_set.id).not_to be_nil
-        expect do
-          touch_fake_derivative_file(persisted_file_set, plugin.target_extension)
-          service.create_derivatives('/nonsense/source/path/ignored ')
-        end.not_to change(plugin, :create_called)
-      end
-
-      it "calls each plugin on cleanup" do
-        service = described_class.new(persisted_file_set, plugins: [plugin])
-        expect { service.cleanup_derivatives }.to change(plugin, :cleanup_called).by(1)
-      end
-    end
-
-    context "integration tests for plugins" do
-      before do
-        allow(persisted_file_set).to receive(:in_works).and_return([work])
-      end
-
-      let(:work) { MyIiifConfiguredWorkWithAllDerivativeServices.new }
-
-      describe "calls all derivative plugins" do
-        def source_image(name)
-          File.join(fixture_path, name)
-        end
-
-        def derivatives_for(file_set)
-          Hyrax::DerivativePath.derivatives_for_reference(file_set)
-        end
-
-        def expected_plugins
-          [
-            Hyrax::FileSetDerivativesService,
-            IiifPrint::TextExtractionDerivativeService
-          ]
-        end
-
-        # The expected set of Plugins that will run for file set
-        it "has expected valid plugins configured" do
-          plugins = described_class.new(persisted_file_set).plugins
-          fs = persisted_file_set
-          services = plugins.map { |plugin| plugin.new(fs) }.select(&:valid?)
-          expect(services.length).to eq 2
-          used_plugins = services.map(&:class)
-          expected_plugins.each do |plugin|
-            expect(used_plugins).to include plugin
-          end
-        end
-
-        it "creates expected derivatives from TIFF source" do
-          svc = described_class.new(persisted_file_set)
-          svc.create_derivatives(source_image('4.1.07.tiff'))
-          made = derivatives_for(persisted_file_set)
-          made.each { |path| expect(File.exist?(path)) }
-          extensions = made.map { |path| path.split('.')[-1] }
-          expect(extensions).not_to include 'tiff'
-          # Thumbnail, created by Hyrax:
-          expect(extensions).to include 'jpeg'
-        end
-      end
-
-      describe "ingest integration" do
-        def log_attachment(file_set)
-          # create a log entry for the fileset given destination name 'jp2'
-          IiifPrint::DerivativeAttachment.create(
-            fileset_id: file_set.id,
-            path: '/some/arbitrary/path/to.jp2',
-            destination_name: 'jp2'
-          )
-        end
-
-        def text_plugin?(plugins)
-          r = plugins.select { |p| p.is_a? IiifPrint::TextExtractionDerivativeServiceService }
-          !r.empty?
-        end
-
-        # TODO: This is not working with the default configuration and is part of a larger refactor
-        # regarding specs.
-        xit "will not attempt creating over pre-made derivative" do
-          service = described_class.new(persisted_file_set)
-          # this should be respected, evaluate by obtaining filtered
-          #   services list, which must omit JP2DerivativeService
-          plugins = service.services(:create_derivatives)
-          # initially has jp2 plugin
-          expect(jp2_plugin?(plugins)).to be true
-          # deny jp2 by effect of log entry of pre-made attachment
-          log_attachment(service.file_set)
-          # omits, after logging intent of previous attachment:
-          plugins = service.services(:create_derivatives)
-          expect(jp2_plugin?(plugins)).to be false
-        end
-      end
-    end
-  end
-end