newspaper_works 0.1.0

data/spec/lib/newspaper_works/data/work_files_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe NewspaperWorks::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-whitelisted dir" do
+      adapter = described_class.new(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
+
+    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 NewspaperWorks::Data::WorkFile
+      expect(values[0].parent).to be adapter
+      first_fileset = work.members.select { |m| m.class == FileSet }[0]
+      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.select { |m| m.class == FileSet }[0]
+      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.select { |m| m.class == FileSet }[0]
+      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.select { |m| m.class == FileSet }[0]
+      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 = NewspaperPage.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
+    # These jobs we need whitelisted 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 = NewspaperPage.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.select { |m| m.class == FileSet }.size).to eq 0
+    end
+
+    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(:create).and_return(true)
+      expect(Hyrax::CurationConcern.actor).to receive(:create)
+      expect(adapter.commit!).to be true
+    end
+
+    it "commits successful file attachment", perform_enqueued: do_now_jobs do
+      work = bare_work
+      adapter = described_class.of(work)
+      adapter.assign(tiff_path)
+      adapter.commit!
+      # whitelisted 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.select { |m| m.class == FileSet }.size).to eq 1
+      expect(adapter.names).to include 'ocr_gray.tiff'
+    end
+
+    it "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.select { |w| w.class == FileSet }[0]
+      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.select { |m| m.class == FileSet }[0]
+      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 \
+        NewspaperWorks::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/lib/newspaper_works/ingest/batch_issue_ingester_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'newspaper_works_fixtures'
+
+RSpec.describe NewspaperWorks::Ingest::BatchIssueIngester do
+  include_context "ingest test fixtures"
+
+  # lccn, paths for respective media:
+  let(:pdf_lccn) { 'sn93059126' }
+  let(:tiff_lccn) { 'sn93059126' }
+  let(:jp2_lccn) { 'sn85058233' }
+  let(:pdf_path) { File.join(pdf_fixtures, pdf_lccn) }
+  let(:tiff_path) { File.join(tiff_fixtures, tiff_lccn) }
+  let(:jp2_path) { File.join(jp2_fixtures, jp2_lccn) }
+
+  describe "ingester construction and composition" do
+    it "constructs ingester from PDF with expected metadata" do
+      # given path to single batch
+      ingester = described_class.new(pdf_path)
+      # correctly parses LCCN from path:
+      expect(ingester.lccn).to eq pdf_lccn
+      expect(ingester.path).to eq pdf_path
+    end
+
+    it "constructs ingester from TIFF with expected metadata" do
+      ingester = described_class.new(tiff_path)
+      expect(ingester.lccn).to eq tiff_lccn
+      expect(ingester.path).to eq tiff_path
+    end
+
+    it "constructs ingester from JP2 with expected metadata" do
+      ingester = described_class.new(jp2_path)
+      expect(ingester.lccn).to eq jp2_lccn
+      expect(ingester.path).to eq jp2_path
+    end
+
+    it "constructs ingester with publication metadata" do
+      ingester = described_class.new(pdf_path)
+      expect(ingester.publication).to be_a NewspaperWorks::Ingest::PublicationInfo
+      expect(ingester.publication.lccn).to eq ingester.lccn
+      expect(ingester.publication.title).to eq 'The weekly journal'
+    end
+
+    it "constructs ingester with explicit LCCN" do
+      # path is for The weekly journal (Chicopee Mass), pass LCCN for other pub
+      sltrib = 'sn83045396'
+      ingester = described_class.new(pdf_path, lccn: sltrib)
+      expect(ingester.lccn).to eq sltrib
+      expect(ingester.publication.lccn).to eq ingester.lccn
+      expect(ingester.publication.title).to eq 'Salt Lake tribune'
+    end
+
+    it "constructs ingester enumerating PDF files" do
+      ingester = described_class.new(pdf_path)
+      pdfs = Dir.entries(pdf_path).select { |name| name.end_with?('.pdf') }
+      paths = pdfs.map { |name| File.join(pdf_path, name) }
+      issues = ingester.issues
+      expect(issues).to be_a NewspaperWorks::Ingest::PDFIssues
+      expect(issues.size).to eq pdfs.size
+      expect(issues.keys).to match_array paths
+    end
+
+    it "constructs ingester enumerating issues of page images" do
+      ingester = described_class.new(tiff_path)
+      entries = Dir.entries(tiff_path)
+                   .map { |name| File.join(tiff_path, name) }
+                   .select { |v| !v.end_with?('.') && File.directory?(v) }
+      issues = ingester.issues
+      expect(issues).to be_a NewspaperWorks::Ingest::ImageIngestIssues
+      expect(issues.size).to eq 2
+      expect(issues.keys).to match_array entries
+    end
+  end
+
+  describe "ingester behavior" do
+    # Ensure LCCN has no initial publication NewspaperTitle asset:
+    let(:pdf_lccn) do
+      v = 'sn93059126'
+      NewspaperTitle.where(lccn: v).delete_all
+      v
+    end
+
+    let(:tiff_lccn) do
+      v = 'sn93059126'
+      NewspaperTitle.where(lccn: v).delete_all
+      v
+    end
+
+    let(:jp2_lccn) do
+      v = 'sn85058233'
+      NewspaperTitle.where(lccn: v).delete_all
+      v
+    end
+
+    let(:pdf_issue_path) { File.join(pdf_path, '1853060401.pdf') }
+    let(:tiff_issue_path) { File.join(tiff_path, '1853060401') }
+    let(:jp2_issue_path) { File.join(jp2_path, '1935080201') }
+
+    def single_issue_dir(lccn, target_issue_path)
+      Hyrax.config.whitelisted_ingest_dirs |= ['/tmp']
+      parent_dir = Dir.mktmpdir
+      dir = File.join(parent_dir, lccn)
+      FileUtils.mkdir(dir)
+      FileUtils.cp_r(target_issue_path, dir)
+      dir
+    end
+
+    def job_enqueued?(job)
+      jobs = ActiveJob::Base.queue_adapter.enqueued_jobs.map { |j| j[:job] }
+      jobs.include?(job)
+    end
+
+    def expect_administrative_metadata(work)
+      expect(work.depositor).to eq User.batch_user.user_key
+      expect(work.admin_set).to eq AdminSet.find(AdminSet::DEFAULT_ID)
+      expect(work.visibility).to eq 'open'
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def issue_ingest(lccn, path, page_count, metadata)
+      dir = single_issue_dir(lccn, path)
+      ingester = described_class.new(dir)
+      ingester.ingest
+      # Outcomes tested:
+      # 1. NewspaperTitle for Publication created, and contains issue
+      issue = NewspaperTitle.where(lccn: lccn).first.members.to_a[0]
+      # 2. Metadata:
+      expect(issue.publication_date).to eq metadata[:publication_date]
+      expect(issue.title).to contain_exactly metadata[:title]
+      expect_administrative_metadata(issue)
+      if page_count > 0
+        # 3. Child pages created
+        expect(issue.pages.size).to eq page_count
+        expect_administrative_metadata(issue.pages[0])
+        # 4. Creation of issue PDF enqueued:
+        expect(job_enqueued?(NewspaperWorks::ComposeIssuePDFJob)).to be true
+      end
+      # clean up after temp dir:
+      FileUtils.rmtree(File.dirname(dir))
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    it "ingests PDFs" do
+      expected_metadata = {
+        title: "The weekly journal: June 4, 1853",
+        publication_date: "1853-06-04"
+      }
+      issue_ingest(pdf_lccn, pdf_issue_path, 0, expected_metadata)
+    end
+
+    it "ingests JP2 page images (as TIFF) into an issue with child pages" do
+      expected_metadata = {
+        title: "The Park record: August 2, 1935",
+        publication_date: "1935-08-02"
+      }
+      issue_ingest(jp2_lccn, jp2_issue_path, 2, expected_metadata)
+    end
+  end
+end

data/spec/lib/newspaper_works/ingest/chronam_publication_info_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe NewspaperWorks::Ingest::ChronAmPublicationInfo do
+  let(:lccn1) { 'sn94051019' }
+  let(:lccn2) { 'sn84038814' }
+  let(:bad_lccn) { 'sn99999999' }
+
+  describe "gets metadata" do
+    it "gets simple metadata" do
+      meta = described_class.new(lccn1)
+      expect(meta.title).to eq 'Marysville daily news'
+      expect(meta.issn).to be_nil
+      expect(meta.oclcnum).to eq 'ocm30043558'
+      expect(meta.place_name).to eq 'Marysville, Calif.'
+      expect(meta.place_of_publication).to eq 'http://sws.geonames.org/5370984/'
+    end
+
+    it "gets related item metadata" do
+      meta1 = described_class.new(lccn1)
+      meta2 = described_class.new(lccn2)
+      # lccn2 succeeds lccn1, favors lccn.loc.gov URL as authoritative:
+      expect(meta1.succeeded_by).to eq "https://lccn.loc.gov/#{lccn2}"
+      # lccn1 precedes lccn2, favors chronam URL as authoritative, since
+      #   catalog.loc.gov and lccn.loc.gov do not have records for this LCCN:
+      expect(meta2.preceded_by).to eq "https://chroniclingamerica.loc.gov/lccn/sn94051019"
+    end
+  end
+
+  describe "error handling" do
+    it "handles unknown LCCN (404)" do
+      meta = described_class.new(bad_lccn)
+      expect(meta.empty?).to be true
+    end
+  end
+end

data/spec/lib/newspaper_works/ingest/from_command_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'newspaper_works_fixtures'
+
+RSpec.describe NewspaperWorks::Ingest::FromCommand do
+  include_context "ingest test fixtures"
+
+  describe "alternate construction" do
+    let(:klass) do
+      Class.new do
+        extend NewspaperWorks::Ingest::FromCommand
+
+        attr_accessor :path, :opts
+
+        def initialize(path, opts = {})
+          @path = path
+          @opts = opts
+        end
+      end
+    end
+
+    def construct(args)
+      klass.from_command(
+        args,
+        'rake newspaper_works:ingest_pdf_issues --'
+      )
+    end
+
+    let(:lccn) { 'sn93059126' }
+
+    let(:pdf_path) { File.join(pdf_fixtures, lccn) }
+
+    let(:fake_argv) do
+      [
+        'newspaper_works:ingest_pdf_issues',
+        '--',
+        "--path=#{pdf_path}"
+      ]
+    end
+
+    let(:more_argv) do
+      fake_argv + [
+        "--lccn=#{lccn}"
+      ]
+    end
+
+    let(:most_argv) do
+      more_argv + [
+        "--admin_set=admin_set/default",
+        "--depositor=#{User.batch_user.user_key}",
+        "--visibility=open"
+      ]
+    end
+
+    it "calls constructor with minimal options parsed" do
+      ingester = construct(fake_argv)
+      expect(ingester.path).to eq pdf_path
+      expect(ingester.opts[:path]).to eq pdf_path
+    end
+
+    it "calls constructor with explict lccn option" do
+      ingester = construct(more_argv)
+      expect(ingester.path).to eq pdf_path
+      expect(ingester.opts[:lccn]).to eq lccn
+    end
+
+    it "calls constructor with all options" do
+      ingester = construct(most_argv)
+      expect(ingester.path).to eq pdf_path
+      expect(ingester.opts[:lccn]).to eq lccn
+      expect(ingester.opts[:admin_set]).to eq 'admin_set/default'
+      expect(ingester.opts[:depositor]).to eq User.batch_user.user_key
+      expect(ingester.opts[:visibility]).to eq 'open'
+    end
+  end
+end

data/spec/lib/newspaper_works/ingest/image_ingest_issues_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe NewspaperWorks::Ingest::ImageIngestIssues do
+  include_context 'ingest test fixtures'
+
+  let(:lccn) { 'sn93059126' }
+
+  let(:publication) { NewspaperWorks::Ingest::PublicationInfo.new(lccn) }
+
+  let(:pub_path) { File.join(tiff_fixtures, lccn) }
+
+  let(:expected_paths) do
+    entries = Dir.entries(pub_path).map { |p| File.join(pub_path, p) }
+    entries.select { |p| File.directory?(p) && !File.basename(p).start_with?('.') }
+  end
+
+  let(:issues) { described_class.new(pub_path, publication) }
+
+  describe " construction and metadata" do
+    it "constructs with path and publication" do
+      expect(issues.path).to eq pub_path
+      expect(issues.publication).to be publication
+      expect(issues.lccn).to eq lccn
+      expect(issues.publication.lccn).to eq lccn
+    end
+
+    it "enumerates valid directories as IssueImages objects" do
+      expect(issues.size).to eq 2
+      enumerated = issues.values
+      expect(enumerated.size).to eq issues.size
+      sample = enumerated[0]
+      expect(sample).to be_a NewspaperWorks::Ingest::IssueImages
+      expect(File.dirname(sample.path)).to eq pub_path
+    end
+
+    it "presents hash-like mapping behavior" do
+      # Keys are paths to directory containing issue images:
+      expect(issues.keys).to match_array expected_paths
+      # info and [] methods get IssueImages object for given path key:
+      issue1 = issues[issues.keys[0]]
+      issue2 = issues.info(issues.keys[1])
+      expect(issue1).to be_a NewspaperWorks::Ingest::IssueImages
+      expect(issue2).to be_a NewspaperWorks::Ingest::IssueImages
+      expect(issue1.path).to eq issues.keys[0]
+    end
+
+    it "enumerates pairs like a hash" do
+      issues.each_value do |v|
+        expect(v).to be_a NewspaperWorks::Ingest::IssueImages
+      end
+      issues.each_key do |k|
+        expect(expected_paths).to include k
+      end
+      issues.each do |path, info|
+        expect(expected_paths).to include path
+        expect(info).to be_a NewspaperWorks::Ingest::IssueImages
+        expect(info.path).to eq path
+      end
+      expect(issues.to_a.size).to eq 2
+    end
+  end
+end

data/spec/lib/newspaper_works/ingest/ingest_shared.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'newspaper_works_fixtures'
+
+RSpec.shared_context "ingest test fixtures", shared_context: :metadata do
+  # Path to fixtures gem for sample fixtures, whitelisted:
+  let(:fixtures_path) do
+    path = NewspaperWorksFixtures.file_fixtures
+    whitelist = Hyrax.config.whitelisted_ingest_dirs
+    whitelist.push(path) unless whitelist.include?(path)
+    path
+  end
+
+  # directory containing PDF fixture batch(es)
+  let(:pdf_fixtures) { File.join(fixtures_path, 'pdf_batch') }
+
+  # directory containing TIFF image fixtures batch(es)
+  let(:tiff_fixtures) { File.join(fixtures_path, 'tiff_batch') }
+
+  # directory containing JP2 image fixture batch(es)
+  let(:jp2_fixtures) { File.join(fixtures_path, 'jp2_batch') }
+end
+
+RSpec.shared_examples 'ingest adapter IO' do
+  # define the path to the file we will use for multiple examples
+  let(:path) do
+    fixtures = File.join(NewspaperWorks::GEM_PATH, 'spec/fixtures/files')
+    File.join(fixtures, 'page1.tiff')
+  end
+
+  # DRY for this matcher's use in multiple examples:
+  let(:have_io_and_correct_filename) do
+    have_attributes(
+      filename: 'page1.tiff',
+      io: an_object_responding_to(:read)
+    )
+  end
+
+  describe "file loading" do
+    # the first half of work done by ingest is done by load(); these
+    # assertions test load() independent of work done.
+
+    it "loads stream from path" do
+      adapter = build(:newspaper_page_ingest)
+      adapter.load(path)
+      expect(adapter).to have_io_and_correct_filename
+    end
+
+    it "loads stream from a Pathname object" do
+      adapter = build(:newspaper_page_ingest)
+      adapter.load(Pathname.new(path))
+      expect(adapter).to have_io_and_correct_filename
+    end
+
+    it "loads an File object" do
+      adapter = build(:newspaper_page_ingest)
+      File.open(path) do |file|
+        adapter.load(file)
+        expect(adapter).to have_io_and_correct_filename
+      end
+    end
+
+    it "loads a StringIO with filename" do
+      adapter = build(:newspaper_page_ingest)
+      io = StringIO.new('File Content Here, Maybe')
+      adapter.load(io, filename: 'page1.tiff')
+      expect(adapter).to have_io_and_correct_filename
+    end
+
+    it "raises on missing explicit filename for StringIO" do
+      adapter = build(:newspaper_page_ingest)
+      io = StringIO.new('File Content Here, Maybe')
+      expect { adapter.load(io) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/lib/newspaper_works/ingest/issue_images_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe NewspaperWorks::Ingest::IssueImages do
+  include_context 'ingest test fixtures'
+
+  # LCCN for TIFF fixture examples:
+  let(:lccn_tiff) { 'sn93059126' }
+
+  # LCCN for JP2 fixture examples:
+  let(:lccn_jp2) { 'sn85058233' }
+
+  let(:tiff_issue_path) { File.join(tiff_fixtures, lccn_tiff, '1853060401') }
+
+  let(:jp2_issue_path) { File.join(jp2_fixtures, lccn_jp2, '1935080201') }
+
+  # Publication for TIFF fixtures:
+  let(:publication) { NewspaperWorks::Ingest::PublicationInfo.new(lccn_tiff) }
+
+  # Publication for JP2 fixtures:
+  let(:publication_jp2) { NewspaperWorks::Ingest::PublicationInfo.new(lccn_jp2) }
+
+  let(:issue) { described_class.new(tiff_issue_path, publication) }
+
+  describe "issue construction and metadata" do
+    it "constructs with path and publication" do
+      expect(issue.path).to eq tiff_issue_path
+      expect(issue.filename).to eq File.basename(tiff_issue_path)
+      expect(issue.publication).to be publication
+      expect(issue.lccn).to eq lccn_tiff
+      expect(issue.publication.lccn).to eq lccn_tiff
+    end
+
+    it "extracts date, edition, title from filename" do
+      expect(issue.publication_date).to eq '1853-06-04'
+      expect(issue.edition_number).to eq 1
+      expect(issue.title).to contain_exactly 'The weekly journal: June 4, 1853'
+    end
+
+    it "enumerates pages (TIFF)" do
+      expect(issue.to_a.size).to eq 4
+      expect(issue.keys.size).to eq 4
+      # lexical ordering:
+      expect(issue.keys).to eq issue.keys.sort
+      issue.entries.each_with_index do |pair, idx|
+        # PageImage object value:
+        page_image = pair[1]
+        expect(page_image).to be_a NewspaperWorks::Ingest::PageImage
+        expect(page_image.lccn).to eq publication.lccn
+        # path key
+        expect(page_image.path).to eq pair[0]
+        expect(page_image.issue).to be issue
+        # Verify lexical ordering (for page_number in file name vs. seq num):
+        expect(page_image.page_number.to_i).to eq idx + 1
+        # page numbering matches sequence numbering:
+        expected_title = "The weekly journal: June 4, 1853: Page #{page_image.page_number}"
+        expect(page_image.title).to contain_exactly expected_title
+      end
+    end
+
+    it "enumerates pages (JP2)" do
+      issue = described_class.new(jp2_issue_path, publication_jp2)
+      expect(issue.to_a.size).to eq 2
+    end
+  end
+end