iiif_print 1.1.0 → 2.0.0

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

data/spec/iiif_print/data/work_files_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Data::WorkFiles do
-  include_context "shared setup"
-
-  let(:work) { work_with_file }
-  let(:tiff_path) { File.join(fixture_path, 'ocr_gray.tiff') }
-  let(:tiff_uri) { 'file://' + File.expand_path(tiff_path) }
-
-  describe "adapter composition" do
-    it "adapts work" do
-      adapter = described_class.new(work)
-      expect(adapter.work).to be work
-    end
-
-    it "adapts work with 'of' alt constructor" do
-      adapter = described_class.of(work)
-      expect(adapter.work).to be work
-    end
-  end
-
-  describe "path assignment queueing" do
-    it "queues assigned file path" do
-      adapter = described_class.of(work)
-      expect(adapter.assigned).to be_empty
-      # assign a valid source path
-      adapter.assign(tiff_path)
-      expect(adapter.assigned).to include tiff_path
-    end
-
-    it "will fail to assign file in non registered dir" do
-      adapter = described_class.new(work)
-      # need a non-registered file that exists:
-      bad_path = File.expand_path("../../spec_helper.rb", fixture_path)
-      expect { adapter.assign(bad_path) }.to raise_error(SecurityError)
-    end
-
-    it "queues a file:/// URI" do
-      adapter = described_class.of(work)
-      expect(adapter.assigned).to be_empty
-      adapter.assign(tiff_uri)
-      expect(adapter.assigned).to include tiff_uri
-    end
-
-    it "queues a Pathname, normalized to string" do
-      adapter = described_class.of(work)
-      expect(adapter.assigned).to be_empty
-      adapter.assign(Pathname.new(tiff_path))
-      expect(adapter.assigned).to include tiff_path
-    end
-
-    it "unqueues a queued path" do
-      adapter = described_class.of(work)
-      adapter.assign(tiff_path)
-      expect(adapter.assigned).to include tiff_path
-      adapter.unassign(tiff_path)
-      expect(adapter.assigned).to be_empty
-    end
-  end
-
-  describe "hash/mapping-like file enumeration" do
-    it "has expected WorkFile in values for work" do
-      adapter = described_class.of(work)
-      values = adapter.values
-      expect(values).to be_an Array
-      expect(values.size).to eq 1
-      expect(values[0]).to be_an IiifPrint::Data::WorkFile
-      expect(values[0].parent).to be adapter
-      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
-      expect(values[0].fileset).to eq first_fileset
-      expect(values[0].unwrapped).to be_a Hydra::PCDM::File
-    end
-
-    it "has expected fileset keys for work" do
-      adapter = described_class.of(work)
-      keys = adapter.keys
-      expect(keys).to be_an Array
-      expect(keys[0]).to be_a String
-      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
-      expect(keys[0]).to eq first_fileset.id
-    end
-
-    it "has expected entries for work" do
-      adapter = described_class.of(work)
-      entries = adapter.entries
-      expect(entries).to be_an Array
-      expect(entries[0]).to be_an Array
-      expect(entries[0].size).to eq 2
-      expect(entries[0][0]).to eq adapter.keys[0]
-      expect(entries[0][1]).to eq adapter.values[0]
-    end
-
-    it "gets work file by fileset id" do
-      adapter = described_class.of(work)
-      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
-      fsid = adapter.keys[0]
-      expect(fsid).to eq first_fileset.id
-      work_file = adapter.get(fsid)
-      expect(work_file.unwrapped).to eq first_fileset.original_file
-      work_file = adapter[fsid]
-      expect(work_file.unwrapped).to eq first_fileset.original_file
-    end
-
-    it "gets work file by work-local filename" do
-      adapter = described_class.of(work)
-      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
-      name = first_fileset.original_file.original_name
-      work_file = adapter.get(name)
-      expect(work_file).to eq adapter.get(first_fileset.id)
-    end
-
-    it "verifies inclusion of fileset id key" do
-      adapter = described_class.of(work)
-      fsid = adapter.keys[0]
-      expect(adapter.include?(fsid)).to be true
-    end
-  end
-
-  describe "assignment state" do
-    it "has empty state for work with no files" do
-      bare_work = MyWork.new
-      bare_work.title = ['No files to see here']
-      bare_work.save!
-      adapter = described_class.of(bare_work)
-      expect(adapter.keys.empty?).to be true
-      expect(adapter.state).to eq 'empty'
-    end
-
-    it "has 'dirty' state when files assigned" do
-      adapter = described_class.of(work)
-      expect(adapter.state).to eq 'saved'
-      adapter.assign(tiff_path)
-      # changes to dirty
-      expect(adapter.state).to eq 'dirty'
-      # unassign path again to empty assigned queue:
-      adapter.unassign(tiff_path)
-      # no we are back to 'saved' since no changes are queued now:
-      expect(adapter.state).to eq 'saved'
-    end
-  end
-
-  describe "commits changes" do
-    # We need to register these jobs to run now, at minimum:
-    do_now_jobs = [IngestLocalFileJob, IngestJob, InheritPermissionsJob]
-    # These we skip: [CharacterizeJob, CreateDerivativesJob]
-    #   -- skipping these saves 10-15 seconds on attachment example
-
-    permission_methods = [
-      :edit_users,
-      :read_users,
-      :discover_users,
-      :edit_groups,
-      :read_groups,
-      :discover_groups
-    ]
-
-    let(:bare_work) do
-      bare_work = MyWork.new
-      bare_work.title = ['No files to see here']
-      bare_work.save!
-      bare_work
-    end
-
-    it "commits unassign (file deletions)" do
-      adapter = described_class.of(work)
-      expect(adapter.keys.size).to eq 1
-      adapter.unassign(adapter.keys[0])
-      adapter.commit!
-      expect(adapter.keys.size).to eq 0
-      expect(work.members.to_a.count { |m| m.is_a? FileSet }).to eq 0
-    end
-
-    context "when it is a new work" do
-      it "commit for assignment invokes actor stack" do
-        work = MyWork.new(title: ['Just a new work'])
-        adapter = described_class.of(work)
-        adapter.assign(tiff_path)
-        allow(Hyrax::CurationConcern.actor).to receive(:create).and_return(true)
-        expect(Hyrax::CurationConcern.actor).to receive(:create)
-        expect(adapter.commit!).to be true
-      end
-    end
-
-    context "when the work already exists" do
-      it "commit for assignment invokes actor stack" do
-        work = bare_work
-        adapter = described_class.of(work)
-        adapter.assign(tiff_path)
-        allow(Hyrax::CurationConcern.actor).to receive(:update).and_return(true)
-        expect(Hyrax::CurationConcern.actor).to receive(:update)
-        expect(adapter.commit!).to be true
-      end
-    end
-
-    xit "commits successful file attachment", perform_enqueued: do_now_jobs do
-      work = bare_work
-      adapter = described_class.of(work)
-      adapter.assign(tiff_path)
-      adapter.commit!
-      # registered jobs (do_now_jobs) performed as effect of commit!
-      #   are configured to effectively run inline. Reloading work
-      #   should refresh the work.members, and by consequence adapter.keys
-      work.reload
-      expect(adapter.keys.size).to eq 1
-      expect(work.members.to_a.count { |m| m.is_a? FileSet }).to eq 1
-      expect(adapter.names).to include 'ocr_gray.tiff'
-    end
-
-    xit "copies work perimssions to fileset", perform_enqueued: do_now_jobs do
-      adapter = described_class.of(bare_work)
-      adapter.assign(tiff_path)
-      adapter.commit!
-      bare_work.reload
-      fileset = bare_work.members.detect { |m| m.is_a?(FileSet) }
-      permission_methods.each do |m|
-        expect(fileset.send(m)).to match_array bare_work.send(m)
-      end
-      expect(fileset.visibility).to eq bare_work.visibility
-    end
-  end
-
-  describe "derivative access" do
-    it "gets derivatives for first fileset" do
-      fileset = work.members.detect { |m| m.is_a?(FileSet) }
-      adapter = described_class.of(work)
-      # adapts same context(s):
-      expect(adapter.derivatives.fileset.id).to eq fileset.id
-      expect(adapter.derivatives.work).to be work
-      expect(adapter.derivatives.class).to eq \
-        IiifPrint::Data::WorkDerivatives
-      # transitive parent/child relationship, can traverse to adapter from
-      # derivatives:
-      expect(adapter.derivatives.parent.parent).to be adapter
-    end
-  end
-end

data/spec/iiif_print/image_tool_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'tmpdir'
-
-describe IiifPrint::ImageTool do
-  let(:fixtures) { File.join(IiifPrint::GEM_PATH, 'spec/fixtures/files') }
-
-  # Image fixtures to test identification, metadata extraction for:
-  let(:gray_jp2) { File.join(fixtures, 'ocr_gray.jp2') }
-  let(:color_jp2) { File.join(fixtures, '4.1.07.jp2') }
-  let(:gray_tiff) { File.join(fixtures, 'ocr_gray.tiff') }
-  let(:mono_tiff) { File.join(fixtures, 'ocr_mono.tiff') }
-  let(:color_tiff) { File.join(fixtures, '4.1.07.tiff') }
-  let(:pdf) { File.join(fixtures, 'minimal-1-page.pdf') }
-
-  describe "Extracts metadata with JP2 backend" do
-    it "constructs with a path" do
-      identify = described_class.new(gray_jp2)
-      expect(identify.path).to eq gray_jp2
-    end
-
-    it "gets metadata for grayscale JP2 image" do
-      result = described_class.new(gray_jp2).metadata
-      expect(result[:color]).to eq 'gray'
-      expect(result[:width]).to eq 418
-      expect(result[:height]).to eq 1046
-      expect(result[:bits_per_component]).to eq 8
-      expect(result[:num_components]).to eq 1
-    end
-
-    it "gets metadata for color JP2 image" do
-      result = described_class.new(color_jp2).metadata
-      expect(result[:color]).to eq 'color'
-      expect(result[:width]).to eq 256
-      expect(result[:height]).to eq 256
-      expect(result[:bits_per_component]).to eq 8
-      # e.g. is 3, but would be four if sample image had an alpha channel
-      expect(result[:num_components]).to eq 3
-    end
-  end
-
-  describe "Extracts metadata for non-JP2 images with imagemagick" do
-    it "gets metadata for gray TIFF image" do
-      result = described_class.new(gray_tiff).metadata
-      expect(result[:color]).to eq 'gray'
-      expect(result[:width]).to eq 418
-      expect(result[:height]).to eq 1046
-      expect(result[:bits_per_component]).to eq 8
-      expect(result[:num_components]).to eq 1
-    end
-
-    it "gets metadata for monochrome TIFF image" do
-      result = described_class.new(mono_tiff).metadata
-      expect(result[:color]).to eq 'monochrome'
-      expect(result[:width]).to eq 1261
-      expect(result[:height]).to eq 1744
-      expect(result[:bits_per_component]).to eq 1
-      expect(result[:num_components]).to eq 1
-    end
-
-    it "gets metadata for color TIFF image" do
-      result = described_class.new(color_tiff).metadata
-      expect(result[:color]).to eq 'color'
-      expect(result[:width]).to eq 256
-      expect(result[:height]).to eq 256
-      expect(result[:bits_per_component]).to eq 8
-      # e.g. is 3, but would be four if sample image had an alpha channel
-      expect(result[:num_components]).to eq 3
-    end
-
-    it "detects mime type of pdf" do
-      result = described_class.new(pdf).metadata
-      expect(result[:content_type]).to eq 'application/pdf'
-    end
-  end
-
-  describe "converts images" do
-    it "makes a monochrome TIFF from JP2" do
-      tool = described_class.new(gray_jp2)
-      dest = File.join(Dir.mktmpdir, 'mono.tif')
-      tool.convert(dest, true)
-      expect(File.exist?(dest)).to be true
-      expect(described_class.new(dest).metadata[:color]).to eq 'monochrome'
-    end
-
-    it "makes a gray TIFF from JP2" do
-      tool = described_class.new(gray_jp2)
-      dest = File.join(Dir.mktmpdir, 'gray.tif')
-      tool.convert(dest, false)
-      expect(File.exist?(dest)).to be true
-      expect(described_class.new(dest).metadata[:color]).to eq 'gray'
-    end
-
-    it "makes a monochrome TIFF from grayscale TIFF" do
-      tool = described_class.new(gray_tiff)
-      dest = File.join(Dir.mktmpdir, 'mono.tif')
-      tool.convert(dest, true)
-      expect(File.exist?(dest)).to be true
-      expect(described_class.new(dest).metadata[:color]).to eq 'monochrome'
-    end
-
-    # Not yet supported to use this tool to make JP2, for now the only
-    #   component in IiifPrint doing that is
-    #   IiifPrint::JP2DerivativeService
-    it "raises error on JP2 destination" do
-      expect { described_class.new(gray_tiff).convert('out.jp2') }.to \
-        raise_error(RuntimeError)
-    end
-  end
-end

data/spec/iiif_print/jobs/child_works_from_pdf_job_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
-  # TODO: add specs
-  let(:work) { WorkWithIiifPrintConfig.new(title: ['required title'], id: '123') }
-  let(:my_user) { build(:user) }
-  let(:uploaded_pdf_file) { create(:uploaded_pdf_file) }
-  let(:uploaded_file_ids) { [uploaded_pdf_file.id] }
-  let(:pdf_paths) do
-    uploads = Hyrax::UploadedFile.find(uploaded_file_ids)
-    upload_paths = uploads.map { |upload| upload.file.file.file }
-    upload_paths.select { |path| path.end_with?('.pdf', '.PDF') }
-  end
-  let(:admin_set_id) { "admin_set/default" }
-  let(:prior_pdfs) { 0 }
-
-  let(:subject) { described_class.perform_now(work, pdf_paths, my_user, admin_set_id, prior_pdfs) }
-
-  describe '#perform' do
-    xit 'calls pdf splitter service with path' do
-    end
-
-    xit 'submits one BatchCreateJob per PDF' do
-    end
-
-    xit 'submits IiifPrint::Jobs::CreateRelationshipsJob' do
-    end
-
-    context 'with more than 9 pages' do
-      xit 'pads the page number with a zero' do
-      end
-    end
-  end
-end

data/spec/iiif_print/jobs/create_relationships_job_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'misc_shared'
-
-module IiifPrint::Jobs
-  RSpec.describe CreateRelationshipsJob, type: :job do
-    let(:create_relationships_job) { described_class.new }
-
-    let(:parent_model) { WorkWithIiifPrintConfig.to_s }
-    let(:child_model) { WorkWithIiifPrintConfig.to_s }
-    let(:file) { FileSet.new.tap { |fs| fs.save!(validate: false) } }
-    let(:parent_record) { WorkWithIiifPrintConfig.new(title: ['required title']) }
-    let(:child_record1) { WorkWithIiifPrintConfig.new(title: ["Child of #{parent_record.id} page 01"]) }
-    let(:child_record2) { WorkWithIiifPrintConfig.new(title: ["Child of #{parent_record.id} page 02"]) }
-    let(:pending_rel1) do
-      IiifPrint::PendingRelationship.new(
-      parent_id: parent_record.id,
-      child_title: "Child of #{parent_record.id} page 01",
-      child_order: "Child of #{parent_record.id} page 01",
-      parent_model: parent_model,
-      child_model: child_model,
-      file_id: file.id
-    )
-    end
-    let(:pending_rel2) do
-      IiifPrint::PendingRelationship.new(
-      parent_id: parent_record.id,
-      child_title: "Child of #{parent_record.id} page 02",
-      child_order: "Child of #{parent_record.id} page 02",
-      parent_model: parent_model,
-      child_model: child_model,
-      file_id: file.id
-    )
-    end
-
-    describe '#perform' do
-      before do
-        allow(create_relationships_job).to receive(:acquire_lock_for).and_yield
-        allow(create_relationships_job).to receive(:reschedule_job)
-        allow(parent_record).to receive(:save!)
-
-        parent_record.save
-        pending_rel1.save
-        pending_rel2.save
-      end
-
-      subject(:perform) do
-        create_relationships_job.perform(
-          parent_id: parent_record.id,
-          parent_model: parent_model,
-          child_model: child_model,
-          retries: 0
-        )
-      end
-
-      context 'when adding a child work to a parent work' do
-        before do
-          child_record1.save
-          child_record2.save
-        end
-
-        it 'assigns the child to the parent\'s #ordered_members' do
-          perform
-          expect(parent_record.reload.ordered_member_ids).to eq([child_record1.id, child_record2.id])
-        end
-
-        it 'deletes the pending relationships' do
-          expect { perform }.to change(IiifPrint::PendingRelationship, :count).by(-2)
-        end
-
-        it 'does not reschedule the job' do
-          perform
-          expect(create_relationships_job).not_to have_received(:reschedule_job)
-        end
-      end
-
-      context 'when a relationship fails' do
-        before do
-          child_record1.save
-          child_record2.save
-        end
-
-        before do
-          expect_any_instance_of(CreateRelationshipsJob).to receive(:add_to_work).and_raise('error')
-        end
-
-        it 'does not save the parent' do
-          expect { perform }.to raise_error(RuntimeError)
-          expect(parent_record).not_to have_received(:save!)
-        end
-
-        it 'does not delete the pending relationships' do
-          expect { perform }.to raise_error(RuntimeError)
-          expect(IiifPrint::PendingRelationship.where(parent_id: parent_record.id).count).to eq(2)
-        end
-      end
-
-      context 'when any child record is not found' do
-        let(:child_record2) { nil }
-
-        before do
-          child_record1.save
-        end
-
-        it 'does not save the parent' do
-          perform
-          expect(parent_record).not_to have_received(:save!)
-        end
-
-        it 'reschedules the job' do
-          perform
-          expect(create_relationships_job).to have_received(:reschedule_job)
-        end
-      end
-    end
-  end
-end

data/spec/iiif_print/jp2_image_metadata_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe IiifPrint::JP2ImageMetadata do
-  let(:fixtures) { File.join(IiifPrint::GEM_PATH, 'spec/fixtures/files') }
-
-  let(:gray_jp2) { File.join(fixtures, 'ocr_gray.jp2') }
-
-  let(:color_jp2) { File.join(fixtures, '4.1.07.jp2') }
-
-  describe "Extracts technical metadata from a JP2 file" do
-    it "constructs with a path" do
-      meta = described_class.new(gray_jp2)
-      expect(meta.path).to eq gray_jp2
-    end
-
-    it "gets metadata for grayscale image" do
-      meta = described_class.new(gray_jp2)
-      result = meta.technical_metadata
-      expect(result[:color]).to eq 'gray'
-      expect(result[:width]).to eq 418
-      expect(result[:height]).to eq 1046
-      expect(result[:bits_per_component]).to eq 8
-      expect(result[:num_components]).to eq 1
-    end
-
-    it "gets metadata for color image" do
-      meta = described_class.new(color_jp2)
-      result = meta.technical_metadata
-      expect(result[:color]).to eq 'color'
-      expect(result[:width]).to eq 256
-      expect(result[:height]).to eq 256
-      expect(result[:bits_per_component]).to eq 8
-      # e.g. is 3, but would be four if sample image had an alpha channel
-      expect(result[:num_components]).to eq 3
-    end
-  end
-end

data/spec/iiif_print/lineage_service_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe IiifPrint::LineageService do
-  describe '.ancestor_ids_for' do
-    xit 'works'
-  end
-
-  describe '.descendent_member_ids_for' do
-    xit 'works'
-  end
-end