iiif_print 1.1.0 → 2.0.1

data/spec/iiif_print/text_extraction/page_ocr_spec.rb

@@ -1,84 +0,0 @@
-require 'json'
-require 'nokogiri'
-require 'spec_helper'
-
-RSpec.describe IiifPrint::TextExtraction::PageOCR do
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  let(:altoxsd) do
-    xsdpath = File.join(fixture_path, 'alto-2-0.xsd')
-    Nokogiri::XML::Schema(File.read(xsdpath))
-  end
-
-  # sample "snippet" images for OCR testing:
-  let(:example_gray_tiff) { File.join(fixture_path, 'ocr_gray.tiff') }
-  let(:example_mono_tiff) { File.join(fixture_path, 'ocr_mono.tiff') }
-  let(:example_color_tiff) { File.join(fixture_path, 'ocr_color.tiff') }
-  let(:example_gray_jp2) { File.join(fixture_path, 'ocr_gray.jp2') }
-  let(:ocr_from_gray_tiff) { described_class.new(example_gray_tiff) }
-
-  describe "performs OCR" do
-    def match_ocr_expectations(words)
-      expect(words).to be_an(Array)
-      expect(words).not_to be_empty
-      expect(words[0]).to be_a(Hash)
-      [:word, :coordinates].each do |key|
-        expect(words[0].keys).to include key
-      end
-    end
-
-    it "gets words and coordinates from grayscale source" do
-      match_ocr_expectations(ocr_from_gray_tiff.words)
-    end
-
-    it "gets words and coordinates from one-bit source" do
-      ocr = described_class.new(example_mono_tiff)
-      match_ocr_expectations(ocr.words)
-    end
-
-    it "gets words and coordinates from color source" do
-      ocr = described_class.new(example_color_tiff)
-      match_ocr_expectations(ocr.words)
-    end
-
-    it "gets words and coordinates from jp2 source" do
-      ocr = described_class.new(example_gray_jp2)
-      match_ocr_expectations(ocr.words)
-    end
-  end
-
-  describe "turns image into ALTO" do
-    xit "takes grayscale tiff, outputs valid ALTO, geometry" do
-      alto = ocr_from_gray_tiff.alto
-      document = Nokogiri::XML(alto)
-      errors = altoxsd.validate(document)
-      expect(errors.length).to eq 0
-      expect(document.at_css('PrintSpace')['WIDTH']).to eq "418"
-      expect(document.at_css('PrintSpace')['HEIGHT']).to eq "1046"
-    end
-  end
-
-  describe "plain text" do
-    it "makes plain text available for image" do
-      plain = ocr_from_gray_tiff.plain
-      expect(plain.class).to be String
-      expect(plain.length).to be > 0
-    end
-  end
-
-  describe "JSON word coordinates" do
-    it "passes properly formatted data to WordCoordsBuilder and receives output" do
-      parsed = JSON.parse(ocr_from_gray_tiff.word_json)
-      expect(parsed['coords'].length).to be > 1
-      word = ocr_from_gray_tiff.words[0]
-      word1 = parsed['coords'][word[:word]]
-      word1_coords = word1[0]
-      expect(word1_coords[2]).to eq word[:coordinates][2]
-      expect(word1_coords[3]).to eq word[:coordinates][3]
-    end
-  end
-end

data/spec/iiif_print/text_extraction/render_alto_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::TextExtraction::RenderAlto do
-  let(:fixture_path) do
-    File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-  end
-
-  let(:altoxsd) do
-    xsdpath = File.join(fixture_path, 'alto-2-0.xsd')
-    Nokogiri::XML::Schema(File.read(xsdpath))
-  end
-
-  let(:page_prefix) { '<Page ID="ID1" PHYSICAL_IMG_NR="1"' }
-
-  let(:words) do
-    [
-      { word: "If", coordinates: [52, 13, 11, 14] },
-      { word: "you", coordinates: [69, 17, 31, 14] },
-      { word: "are", coordinates: [108, 17, 28, 10] },
-      { word: "a", coordinates: [143, 17, 8, 10] },
-      { word: "friend,", coordinates: [158, 13, 56, 16] },
-      { word: "you", coordinates: [51, 39, 31, 14] },
-      { word: "speak", coordinates: [90, 35, 50, 18] },
-      { word: "the", coordinates: [146, 35, 28, 14] },
-      { word: "password,", coordinates: [182, 35, 85, 18] },
-      { word: "and", coordinates: [51, 57, 30, 14] },
-      { word: "the", coordinates: [89, 57, 28, 14] },
-      { word: "doors", coordinates: [124, 57, 48, 14] },
-      { word: "will", coordinates: [180, 57, 28, 14] },
-      { word: "open.", coordinates: [216, 61, 47, 14] }
-    ]
-  end
-
-  describe "renders alto" do
-    it "creates alto given width, height, words" do
-      renderer = described_class.new(12_000, 9600)
-      output = renderer.to_alto(words)
-      expect(output.class).to be String
-      expect(output).to include '<alto'
-      expect(output).to include '<String'
-      expect(output).to include page_prefix + ' HEIGHT="9600" WIDTH="12000"'
-      expect(Nokogiri::XML(output).errors.empty?).to be true
-    end
-
-    xit "makes alto 2.0 that validates" do
-      renderer = described_class.new(12_000, 9600)
-      output = renderer.to_alto(words)
-      document = Nokogiri::XML(output)
-      altoxsd.validate(document)
-    end
-  end
-end

data/spec/iiif_print/text_extraction/word_coords_builder_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::TextExtraction::WordCoordsBuilder do
-  let(:words) do
-    [
-      { word: "foo", coordinates: [1, 2, 3, 4] },
-      { word: "bar", coordinates: [5, 6, 7, 8] },
-      { word: "baz", coordinates: [9, 10, 11, 12] },
-      { word: "foo", coordinates: [13, 14, 15, 16] }
-    ]
-  end
-  let(:image_width) { 1_234 }
-  let(:image_height) { 5_678 }
-
-  describe '.json_coordinates_for' do
-    let(:wcb_to_json) { JSON.parse(described_class.json_coordinates_for(words: words, width: image_width, height: image_height)) }
-    it 'has the correct structure' do
-      expect(wcb_to_json['height']).to eq image_height
-      expect(wcb_to_json['width']).to eq image_width
-      expect(wcb_to_json['coords'].length).to eq 3
-      expect(wcb_to_json['coords']['foo']).not_to be_falsey
-    end
-
-    it 'combines coordinates for the same word' do
-      expect(wcb_to_json['coords']['foo']).to eq [[1, 2, 3, 4], [13, 14, 15, 16]]
-    end
-  end
-
-  describe '#to_json' do
-    let(:wcb_to_json) { JSON.parse(wcb.to_json) }
-    let(:wcb) { described_class.new(words, image_width, image_height) }
-
-    it 'has the correct structure' do
-      expect(wcb_to_json['height']).to eq image_height
-      expect(wcb_to_json['width']).to eq image_width
-      expect(wcb_to_json['coords'].length).to eq 3
-      expect(wcb_to_json['coords']['foo']).not_to be_falsey
-    end
-
-    it 'combines coordinates for the same word' do
-      expect(wcb_to_json['coords']['foo']).to eq [[1, 2, 3, 4], [13, 14, 15, 16]]
-    end
-  end
-end

data/spec/iiif_print_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint do
-  describe '.skip_splitting_pdf_files_that_end_with_these_texts' do
-    subject { described_class }
-    it { is_expected.to respond_to :skip_splitting_pdf_files_that_end_with_these_texts }
-  end
-
-  describe ".manifest_metadata_for" do
-    let(:attributes) do
-      { "id" => "abc123",
-        "title_tesim" => ['My Awesome Title'] }
-    end
-    let(:solr_document) { SolrDocument.new(attributes) }
-    let(:base_url) { "https://my.dev.test" }
-
-    subject(:manifest_metadata) do
-      described_class.manifest_metadata_for(work: solr_document, current_ability: double(Ability), base_url: base_url)
-    end
-    it { is_expected.not_to be_falsey }
-    it "does not contain any nil values" do
-      expect(subject).not_to include(nil)
-    end
-  end
-
-  describe ".model_configuration" do
-    context "default configuration" do
-      let(:model) do
-        Class.new do
-          include IiifPrint.model_configuration(pdf_split_child_model: Class.new)
-        end
-      end
-
-      subject(:record) { model.new }
-
-      it { is_expected.to be_iiif_print_config }
-
-      it "has a #pdf_splitter_job" do
-        expect(record.iiif_print_config.pdf_splitter_job).to be(IiifPrint::Jobs::ChildWorksFromPdfJob)
-      end
-
-      it "has a #pdf_splitter_service" do
-        expect(record.iiif_print_config.pdf_splitter_service).to be(IiifPrint::SplitPdfs::PagesToJpgsSplitter)
-      end
-
-      it "has #derivative_service_plugins" do
-        expect(record.iiif_print_config.derivative_service_plugins).to eq(
-          [IiifPrint::TextExtractionDerivativeService]
-        )
-      end
-    end
-  end
-
-  describe ".fields_for_allinson_flex" do
-    subject { described_class.fields_for_allinson_flex(fields: fields, sort_order: sort_order) }
-    let(:sort_order) { [] }
-
-    context "when the fields include an admin only indexing property" do
-      let(:fields) do
-        [
-          IiifPrint::CollectionFieldShim.new(name: :title, value: "My Title"),
-          IiifPrint::CollectionFieldShim.new(name: :creator, value: "Hyrax, Sam", indexing: ["admin_only"])
-        ]
-      end
-
-      it "does not include the admin only field" do
-        # We are mapping from one data structure to another
-        expect(subject.map(&:name)).to eq([fields.first.name])
-      end
-    end
-
-    context "when the fields include duplicate name properties" do
-      let(:fields) do
-        [
-          IiifPrint::CollectionFieldShim.new(name: :title, value: "My Title"),
-          IiifPrint::CollectionFieldShim.new(name: :title, value: "My Other Title")
-        ]
-      end
-
-      it "does not include later duplicates" do
-        expect(subject.map(&:label)).to eq([fields.first.value])
-      end
-    end
-
-    context "when we provide a fields sort order" do
-      let(:fields) do
-        [
-          IiifPrint::CollectionFieldShim.new(name: :title, value: "My Title"),
-          IiifPrint::CollectionFieldShim.new(name: :creator, value: "Hyrax, Sam"),
-          IiifPrint::CollectionFieldShim.new(name: :date_created, value: "2023-05-02")
-        ]
-      end
-      let(:sort_order) { [:creator, :title] }
-
-      it "returns the fields in the order specified and puts unspecified fields last" do
-        expect(subject.map(&:name)).to eq([:creator, :title, :date_created])
-      end
-    end
-  end
-
-  describe ".sort_af_fields!" do
-    let(:fields) { [:title, :creator, :date_created].map { |name| IiifPrint::Field.new(name: name) } }
-    subject(:sort_af_fields) { described_class.sort_af_fields!(fields, sort_order: sort_order) }
-
-    context "when the sort order is an empty array" do
-      let(:sort_order) { [] }
-
-      it "returns the fields in the order they were given" do
-        expect(sort_af_fields).to eq(fields)
-      end
-    end
-
-    context "when the sort order specifies some of the fields" do
-      let(:sort_order) { [:date_created, :title] }
-
-      it "returns the fields in the order specified and puts unspecified fields last" do
-        expect(sort_af_fields).to eq([:date_created, :title, :creator].map { |name| IiifPrint::Field.new(name: name) })
-      end
-    end
-  end
-
-  describe '.conditionally_submit_split_for' do
-    context 'when the file suffix is one that we skip' do
-      subject do
-        described_class.conditionally_submit_split_for(
-          work: double,
-          file_set: double,
-          locations: ['hello.reader.pdf'],
-          skip_these_endings: ['.reader.pdf'],
-          user: double
-        )
-      end
-
-      it { is_expected.to eq(:no_pdfs_for_splitting) }
-    end
-  end
-
-  describe '.split_for_path_suffix?' do
-    context 'with default .skip_splitting_pdf_files_that_end_with_these_texts' do
-      subject { described_class.split_for_path_suffix?(path) }
-      [
-        ["hello.pdf", true],
-        ["hello.PDF", true],
-        ["hello.reader.pdf", true],
-        ["hello.png", false],
-        ["hello.pdf.png", false]
-      ].each do |given_path, expected_value|
-        context "with #{given_path.inspect}" do
-          let(:path) { given_path }
-          it { is_expected.to eq(expected_value) }
-        end
-      end
-    end
-
-    context 'with customized .skip_splitting_pdf_files_that_end_with_these_texts' do
-      subject { described_class.split_for_path_suffix?(path, skip_these_endings: ['.READER.pdf']) }
-      [
-        ["hello.pdf", true],
-        ["hello.PDF", true],
-        ["hello.reader.pdf", false],
-        ["hello.png", false],
-        ["hello.pdf.png", false]
-      ].each do |given_path, expected_value|
-        context "with #{given_path.inspect}" do
-          let(:path) { given_path }
-          it { is_expected.to eq(expected_value) }
-        end
-      end
-    end
-  end
-end

data/spec/misc_shared.rb

@@ -1,111 +0,0 @@
-RSpec.shared_context "shared setup", shared_context: :metadata do
-  let(:fixture_path) do
-    path = File.join(
-      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
-    )
-    # TODO: NOTE: this has potential timing issues in the specs, because we're adjusting the
-    # configured value during the spec run.
-    registered = Hyrax.config.registered_ingest_dirs
-    registered.push(path) unless registered.include?(path)
-    path
-  end
-
-  # shared date to be invariant across all tests in a run:
-  date_static = Hyrax::TimeService.time_in_utc
-  let(:static_date) { date_static }
-
-  # path fixtures:
-  let(:example_gray_jp2) { File.join(fixture_path, 'ocr_gray.jp2') }
-  let(:txt_path) { File.join(fixture_path, 'credits.md') }
-  let(:sample_thumbnail) { File.join(fixture_path, 'thumbnail.jpg') }
-
-  # sample data:
-  let(:sample_text) { 'even in a mythical Age there must be some enigmas' }
-
-  let(:valid_file_set) do
-    file_set = FileSet.new
-    file_set.save!(validate: false)
-    file_set
-  end
-
-  let(:sample_work) do
-    work = MyWork.new
-    work.title = ['Bombadil']
-    work.members.push(valid_file_set)
-    work.save!
-    work
-  end
-
-  # sample objects:
-  let(:work_with_file) do
-    # we need a work with not just a valid (but empty) fileset, but also
-    #   a persisted file, so we use the shared work sample, and expand
-    #   on it with actual file data/metadata.
-    work = sample_work
-    fileset = work.members.first
-    file = Hydra::PCDM::File.create
-    fileset.original_file = file
-    # Set binary content on file via ActiveFedora content= mutator method
-    #   which also makes .size method return valid result for content
-    file.content = File.open(txt_path)
-    # Set some metdata we would expect to otherwise be set upon an upload
-    file.original_name = 'credits.md'
-    file.mime_type = 'text/plain'
-    file.date_modified = static_date
-    file.date_created = static_date
-    # saving fileset also saves file content
-    fileset.save!
-    work
-  end
-
-  def path_factory
-    Hyrax::DerivativePath
-  end
-
-  def work_file_set(work)
-    work.members.detect { |m| m.is_a? FileSet }
-  end
-
-  def text_path(work)
-    path_factory.derivative_path_for_reference(work_file_set(work), 'txt')
-  end
-
-  def jp2_path(work)
-    path_factory.derivative_path_for_reference(work_file_set(work), 'jp2')
-  end
-
-  def thumbnail_path(work)
-    path_factory.derivative_path_for_reference(work_file_set(work), 'thumbnail')
-  end
-
-  def mkdir_derivative(work, name)
-    # make shared path for derivatives to live, Hyrax ususally does this
-    #   for thumbnails, and iiif_print does this in its derivative
-    #   service plugins; here we do same.
-    fsid = work_file_set(work).id
-    path = path_factory.derivative_path_for_reference(fsid, name)
-    dir = File.join(path.split('/')[0..-2])
-    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-  end
-
-  def mk_jp2_derivative(work)
-    mkdir_derivative(work, 'jp2')
-    dst_path = jp2_path(work)
-    FileUtils.copy(example_gray_jp2, dst_path)
-    expect(File.exist?(dst_path)).to be true
-  end
-
-  def mk_txt_derivative(work)
-    mkdir_derivative(work, 'txt')
-    dst_path = text_path(work)
-    File.open(dst_path, 'w') { |f| f.write(sample_text) }
-    expect(File.exist?(dst_path)).to be true
-  end
-
-  def mk_thumbnail_derivative(work)
-    mkdir_derivative(work, 'thumbnail')
-    dst_path = thumbnail_path(work)
-    FileUtils.copy(sample_thumbnail, dst_path)
-    expect(File.exist?(dst_path)).to be true
-  end
-end

data/spec/models/iiif_print/derivative_attachment_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-module IiifPrint
-  RSpec.describe DerivativeAttachment, type: :model do
-    it "requires some columns to be considered complete" do
-      model = described_class.create
-      # attempt save without required data; expect failure
-      expect { model.save! }.to raise_exception(ActiveRecord::RecordInvalid)
-    end
-
-    it "saves when constructed with all field values" do
-      model = described_class.create(
-        fileset_id: 'a1b2c3d4e5',
-        path: '/path/to/somefile',
-        destination_name: 'txt'
-      )
-      # attempt save without required data; expect failure
-      expect { model.save! }.not_to raise_exception
-    end
-
-    it "saves when all fields completely set" do
-      model = described_class.create
-      model.fileset_id = 'someid123'
-      model.path = '/path/to/somefile'
-      model.destination_name = 'txt'
-      expect { model.save! }.not_to raise_exception
-    end
-
-    it "saves when only path, destination_name set" do
-      model = described_class.create
-      model.fileset_id = nil
-      model.path = '/path/to/somefile'
-      model.destination_name = 'txt'
-      expect { model.save! }.not_to raise_exception
-    end
-  end
-end

data/spec/models/iiif_print/iiif_search_decorator_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::IiifSearchDecorator do
-  let(:iiif_config) { { object_relation_field: 'is_page_of_ssim' } }
-  let(:parent_document) { double(SolrDocument, id: 'abc123') }
-  let(:iiif_search) { BlacklightIiifSearch::IiifSearch.new(params, iiif_config, parent_document) }
-
-  describe '#solr_params' do
-    subject { iiif_search.solr_params }
-
-    context 'when q is nil' do
-      let(:params) { { q: nil } }
-
-      it 'returns nil:nil' do
-        expect(subject).to eq({ q: 'nil:nil' })
-      end
-    end
-
-    context 'when q is not nil' do
-      let(:params) { { q: 'catscan' } }
-
-      it 'returns a query with the search term and filters for child or parent id' do
-        expect(subject).to eq({ q: "catscan AND (is_page_of_ssim:\"abc123\" OR id:\"abc123\")", rows: 50, page: nil })
-      end
-    end
-  end
-end

data/spec/models/iiif_print/ingest_file_relation_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-module IiifPrint
-  RSpec.describe IngestFileRelation, type: :model do
-    def make_test_records
-      # two unique values
-      described_class.create(
-        file_path: '/some/path/to/this',
-        derivative_path: '/some/path/to/that'
-      )
-      described_class.create(
-        file_path: '/some/path/to/this',
-        derivative_path: '/some/path/to/other_thing'
-      )
-      # a duplicate will save, presumption is that dupes are filtered on query:
-      described_class.create(
-        file_path: '/some/path/to/this',
-        derivative_path: '/some/path/to/other_thing'
-      )
-    end
-
-    it "will not save unless record is complete" do
-      model = described_class.create
-      # attempt save without required data; expect failure
-      expect { model.save! }.to raise_exception(ActiveRecord::RecordInvalid)
-      model2 = described_class.create
-      model2.file_path = '/path/to/sourcefile.tiff'
-      expect { model2.save! }.to raise_exception(ActiveRecord::RecordInvalid)
-      model3 = described_class.create
-      model3.derivative_path = '/path/to/sourcefile.tiff'
-      expect { model3.save! }.to raise_exception(ActiveRecord::RecordInvalid)
-    end
-
-    it "will save sufficiently constructed record" do
-      model = described_class.create(
-        file_path: '/path/to/this',
-        derivative_path: '/path/to/that'
-      )
-      expect { model.save! }.not_to raise_exception
-    end
-
-    it "will save when all fields completely set" do
-      model = described_class.create
-      model.file_path = '/path/to/sourcefile.tiff'
-      model.derivative_path = '/path/to/derived.jp2'
-      expect { model.save! }.not_to raise_exception
-    end
-
-    it "can query derivative paths for primary file" do
-      make_test_records
-      result = described_class.derivatives_for_file('/some/path/to/this')
-      expect(result).to be_an Array
-      expect(result.size).to eq 2
-    end
-  end
-end

data/spec/models/solr_document_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-RSpec.describe SolrDocument do
-  let(:solr_doc) { described_class.new(id: 'foo', file_set_ids_ssim: ['bar']) }
-
-  describe 'file_set_ids' do
-    it 'responds to #file_set_ids' do
-      expect(solr_doc).to respond_to(:file_set_ids)
-    end
-
-    it 'returns the correct value' do
-      expect(solr_doc.file_set_ids).to eq(['bar'])
-    end
-  end
-end

data/spec/presenters/iiif_print/iiif_manifest_presenter_behavior_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe IiifPrint::IiifManifestPresenterBehavior do
-  let(:attributes) do
-    { "id" => "abc123",
-      "title_tesim" => ['Page the first'],
-      "description_tesim" => ['A book or something'],
-      "creator_tesim" => ['Arthur McAuthor'] }
-  end
-  let(:solr_document) { SolrDocument.new(attributes) }
-  let(:presenter) { Hyrax::IiifManifestPresenter.new(solr_document) }
-  let(:test_request) { ActionDispatch::TestRequest.new({}) }
-
-  describe '#search_service' do
-    it 'returns the correct URL for the IIIF Search service' do
-      expect(presenter.search_service).to include("#{solr_document.id}/iiif_search")
-    end
-  end
-
-  context 'with IIIF external support' do
-    let(:presenter) { Hyrax::IiifManifestPresenter::DisplayImagePresenter.new(solr_document) }
-    let(:id) { 'abc123' }
-    let(:url) { 'external_iiif_url' }
-    let(:iiif_info_url_builder) { ->(file_id, base_url) { "#{base_url}/#{file_id}" } }
-
-    before { allow(solr_document).to receive(:image?).and_return(true) }
-
-    context 'when external iiif is enabled' do
-      before do
-        allow(ENV).to receive(:[])
-        allow(ENV).to receive(:[]).with('EXTERNAL_IIIF_URL').and_return(url)
-        allow(presenter).to receive(:latest_file_id).and_return(id)
-      end
-
-      describe '#display_image' do
-        it 'renders a external url' do
-          expect(presenter.display_image.iiif_endpoint.url).to eq "#{url}/#{id}"
-          expect(presenter.display_image.iiif_endpoint.profile).to eq "http://iiif.io/api/image/2/level2.json"
-        end
-      end
-
-      describe '#display_content' do
-        it 'renders a external url' do
-          expect(presenter.display_content.iiif_endpoint.url).to eq "#{url}/#{id}"
-          expect(presenter.display_content.iiif_endpoint.profile).to eq "http://iiif.io/api/image/2/level2.json"
-        end
-      end
-    end
-
-    context 'when external iiif is not enabled' do
-      before do
-        allow(presenter).to receive(:latest_file_id).and_return(id)
-        allow(Hyrax.config).to receive(:iiif_image_server?).and_return(true)
-        allow(Hyrax.config).to receive(:iiif_info_url_builder).and_return(iiif_info_url_builder)
-      end
-
-      describe '#display_image' do
-        it 'does not render a external url' do
-          expect(presenter.display_image.iiif_endpoint.url).to eq "localhost/#{id}"
-        end
-      end
-
-      describe '#display_content' do
-        it 'does not render a external url' do
-          expect(presenter.display_content.iiif_endpoint.url).to eq "localhost/#{id}"
-        end
-      end
-    end
-  end
-end