iiif_print 1.0.0 → 2.0.0

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,30 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
-  # TODO: add specs
-  let(:work) { WorkWithIiifPrintConfig.new(title: ['required title']) }
-  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(work, paths, 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
-  end
-end

data/spec/iiif_print/jobs/create_relationships_job_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::Jobs::CreateRelationshipsJob do
-  # TODO: add specs
-  let(:parent) { WorkWithIiifPrintConfig.new(title: ['required title']) }
-  let(:my_user) { build(:user) }
-  let(:parent_model) { WorkWithIiifPrintConfig }
-  let(:child_model) { WorkWithIiifPrintConfig }
-
-  let(:subject) { described_class.perform(user: my_user, parent_id: parent.id, parent_model: parent_model, child_model: child_model) }
-
-  describe '#perform' do
-    xit 'loads all child work ids into ordered_members' do
-    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_file_set_ids_for' do
-    xit 'works'
-  end
-end

data/spec/iiif_print/metadata_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::Metadata do
-  let(:base_url) { "https://my.dev.test" }
-  let(:solr_document) { SolrDocument.new(attributes) }
-  let(:fields) do
-    metadata_fields.map do |field|
-      SampleField.new(
-        name: field.first,
-        label: Hyrax::Renderers::AttributeRenderer.new(field, nil).label,
-        options: field.last
-      )
-    end
-  end
-  let(:metadata_fields) do
-    {
-      title: {},
-      description: {},
-      date_modified: {}
-    }
-  end
-
-  SampleField = Struct.new(:name, :label, :options, keyword_init: true)
-
-  describe ".build_metadata_for" do
-    subject(:manifest_metadata) do
-      described_class.build_metadata_for(
-        work: solr_document,
-        version: version,
-        fields: fields,
-        current_ability: double(Ability),
-        base_url: base_url
-      )
-    end
-
-    context "for version 2 of the IIIF spec" do
-      let(:version) { 2 }
-
-      context "with a field that has some plain text" do
-        let(:attributes) { { "title_tesim" => ["My Awesome Title"] } }
-
-        it "maps the metadata accordingly" do
-          expect(manifest_metadata).to eq [
-            { "label" => "Title", "value" => ["My Awesome Title"] }
-          ]
-        end
-      end
-
-      context "with a field that contains a url string" do
-        let(:attributes) { { "description_tesim" => ["A url like https://www.example.com/, cool!"] } }
-
-        it "creates a link for the url string" do
-          expect(manifest_metadata).to eq [
-            { "label" => "Description",
-               "value" =>
-                [
-                  "A url like <a href='https://www.example.com/' target='_blank'>https://www.example.com/</a>, cool!"
-                ] }
-          ]
-        end
-      end
-
-      context "with a date" do
-        let(:attributes) { { "date_modified_dtsi" => "2011-11-11T11:11:11Z" } }
-
-        it "displays it just the date" do
-          expect(manifest_metadata).to eq [{ "label" => "Date modified", "value" => ["2011-11-11"] }]
-        end
-      end
-
-      context "with a faceted option" do
-        let(:metadata_fields) { { creator: { render_as: :faceted } } }
-        let(:attributes) { { "creator_tesim" => ["McAuthor, Arthur"] } }
-
-        it "adds a link to the faceted search" do
-          expect(manifest_metadata). to eq [
-            { "label" => "Creator",
-              "value" =>
-                ["<a href='#{base_url}/catalog?f%5Bcreator_sim%5D%5B%5D=McAuthor%2C+Arthur&locale=en'>McAuthor, Arthur</a>"] }
-          ]
-        end
-      end
-
-      context "when the work is apart of a collection" do
-        let(:metadata_fields) { { collection: {} } }
-        let(:collection_attributes) { { "id" => "321cba", "title_tesim" => ["My Cool Collection"] } }
-        let(:collection_solr_doc) { SolrDocument.new(collection_attributes) }
-        let(:attributes) { { "member_of_collection_ids_ssim" => "321cba" } }
-
-        it "renders a link to the collection" do
-          allow(Hyrax::CollectionMemberService).to receive(:run).and_return([collection_solr_doc])
-          expect(manifest_metadata).to eq [
-            { "label" => "Collection",
-              "value" => ["<a href='#{base_url}/collections/321cba'>My Cool Collection</a>"] }
-          ]
-        end
-      end
-    end
-
-    context "for version 3 of the IIIF spec", skip: "version 3 metadata not implemented yet" do
-      let(:version) { 3 }
-
-      it "maps the metadata accordingly" do
-        # NOTE: this assumes the I18n.locale is set as :en
-        expect(manifest_metadata).to eq [
-          { "label" => { "en" => ["Title"] }, "value" => { "none" => ["My Awesome Title"] } },
-          { "label" => { "en" => ["Description"] },
-            "value" => { "none" => ["This is and awesome description"] } },
-          { "label" => { "en" => ["Date modified"] }, "value" => { "none" => ["2011-11-11"] } },
-          { "label" => { "en" => ["Creator"] }, "value" => { "none" => ["McAuthor, Arthur"] } }
-        ]
-      end
-    end
-  end
-end

data/spec/iiif_print/split_pdfs/pages_into_images_service_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'misc_shared'
-
-RSpec.describe IiifPrint::SplitPdfs::PagesIntoImagesService do
-  # TODO: add specs
-end

data/spec/iiif_print/text_extraction/alto_reader_spec.rb

@@ -1,49 +0,0 @@
-require 'json'
-require 'spec_helper'
-
-RSpec.describe IiifPrint::TextExtraction::AltoReader do
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  let(:minimal_path) { File.join(fixture_path, 'minimal-alto.xml') }
-  let(:ndnp_alto_path) { File.join(fixture_path, 'ndnp-alto-sample.xml') }
-  let(:minimal) { File.read(minimal_path) }
-
-  let(:reader_minimal) { described_class.new(minimal) }
-  let(:reader_minimal_path) { described_class.new(minimal_path) }
-  let(:reader_ndnp) { described_class.new(ndnp_alto_path) }
-
-  describe "reads alto" do
-    it "loads ALTO source" do
-      expect(reader_minimal_path.source).to eq reader_minimal.source
-      expect(reader_minimal_path.source.size).to eq 1383
-      expect(reader_ndnp.source.size).to eq 1_050_876
-    end
-
-    it "loads document stream" do
-      expect(reader_minimal_path.doc_stream).to be_kind_of Nokogiri::XML::SAX::Document
-      expect(reader_minimal_path.doc_stream).to respond_to :text
-      expect(reader_minimal_path.doc_stream).to respond_to :words
-    end
-  end
-
-  describe "outputs text derivative formats" do
-    it "outputs plain text" do
-      # try simple flat text input
-      expect(reader_minimal.text).to eq "This is only a test."
-      expect(reader_minimal.text).to eq reader_minimal.doc_stream.text
-      # try more complex input
-      expect(reader_ndnp.text.size).to eq 30_519
-    end
-
-    it "passes args to WordCoordsBuilder and receives output" do
-      parsed = JSON.parse(reader_minimal.json)
-      expect(parsed['coords'].length).to be > 1
-      parsed = JSON.parse(reader_ndnp.json)
-      expect(parsed['coords'].size).to eq 2_125
-    end
-  end
-end

data/spec/iiif_print/text_extraction/hocr_reader_spec.rb

@@ -1,45 +0,0 @@
-require 'json'
-require 'nokogiri'
-require 'spec_helper'
-
-RSpec.describe IiifPrint::TextExtraction::HOCRReader do
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  let(:minimal_path) { File.join(fixture_path, 'ocr_mono_text_hocr.html') }
-  let(:minimal) { File.read(minimal_path) }
-
-  let(:reader_minimal) { described_class.new(minimal) }
-  let(:reader_minimal_path) { described_class.new(minimal_path) }
-
-  describe "reads hOCR" do
-    it "loads hOCR either from path or source text" do
-      expect(reader_minimal_path.source).to eq reader_minimal.source
-      # size here is in Unicode characters, not bytes:
-      expect(reader_minimal_path.source.size).to eq 16_590
-    end
-
-    it "loads document stream" do
-      expect(reader_minimal_path.doc_stream).to be_kind_of Nokogiri::XML::SAX::Document
-      expect(reader_minimal_path.doc_stream).to respond_to :text
-      expect(reader_minimal_path.doc_stream).to respond_to :words
-    end
-  end
-
-  describe "outputs text derivative formats" do
-    it "outputs plain text" do
-      plain_text = reader_minimal.text
-      expect(plain_text.slice(0, 40)).to eq "_A  FEARFUL  ADVENTURE.\n‘The  Missouri. "
-      expect(reader_minimal.text).to eq reader_minimal.doc_stream.text
-      expect(reader_minimal.text.size).to eq 831
-    end
-
-    it "passes args to WordCoordsBuilder and receives output" do
-      parsed = JSON.parse(reader_minimal.json)
-      expect(parsed['coords'].length).to be > 1
-    end
-  end
-end