zizia 1.0.1

data/spec/zizia/hyrax_basic_metadata_mapper_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Zizia::HyraxBasicMetadataMapper do
+  let(:mapper) { described_class.new }
+
+  # Properties defined in Hyrax::CoreMetadata
+  let(:core_fields) do
+    [:depositor, :title, :date_modified]
+  end
+
+  # Properties defined in Hyrax::BasicMetadata
+  let(:basic_fields) do
+    [:label, :relative_path, :import_url,
+     :resource_type, :creator, :contributor,
+     :description, :keyword, :license,
+     :rights_statement, :publisher, :date_created,
+     :subject, :language, :identifier, :based_near,
+     :related_url, :bibliographic_citation, :source]
+  end
+
+  let(:tenejo_fields) do
+    [:visibility]
+  end
+
+  it_behaves_like 'a Zizia::Mapper' do
+    let(:metadata) do
+      { title: ['A Title for a Record'],
+        my_custom_field: ['This gets ignored'] }
+    end
+    let(:expected_fields) { core_fields + basic_fields + tenejo_fields }
+  end
+
+  context 'with metadata, but some missing fields' do
+    before { mapper.metadata = metadata }
+    let(:metadata) do
+      { 'depositor' => 'someone@example.org',
+        'title' => 'A Title',
+        'language' => 'English' }
+    end
+
+    it 'provides methods for the fields, even fields that aren\'t included in the metadata' do
+      expect(metadata).to include('title')
+      expect(mapper).to respond_to(:title)
+
+      expect(metadata).not_to include('label')
+      expect(mapper).to respond_to(:label)
+    end
+
+    it 'returns single values for single-value fields' do
+      expect(mapper.depositor).to eq 'someone@example.org'
+      expect(mapper.date_modified).to eq nil
+      expect(mapper.label).to eq nil
+      expect(mapper.relative_path).to eq nil
+      expect(mapper.import_url).to eq nil
+    end
+
+    it 'returns array values for multi-value fields' do
+      expect(mapper.title).to eq ['A Title']
+      expect(mapper.language).to eq ['English']
+      expect(mapper.keyword).to eq []
+      expect(mapper.subject).to eq []
+    end
+  end
+
+  context 'fields with multiple values' do
+    before { mapper.metadata = metadata }
+    let(:metadata) do
+      { 'title' => 'A Title',
+        'language' => 'English|~|French|~|Japanese' }
+    end
+
+    it 'splits the values using the delimiter' do
+      expect(mapper.title).to eq ['A Title']
+      expect(mapper.language).to eq ['English', 'French', 'Japanese']
+      expect(mapper.keyword).to eq []
+    end
+
+    it 'can set a different delimiter' do
+      expect(mapper.delimiter).to eq '|~|'
+      mapper.delimiter = 'ಠ_ಠ'
+      expect(mapper.delimiter).to eq 'ಠ_ಠ'
+    end
+  end
+
+  describe 'lenient headers' do
+    context 'headers with capital letters' do
+      before { mapper.metadata = metadata }
+      let(:metadata) do
+        { 'Title' => 'A Title',
+          'Related URL' => 'http://example.com',
+          'Abstract or Summary' => 'desc1|~|desc2',
+          'visiBILITY' => 'open',
+          'Depositor' => 'someone@example.org',
+          'DATE_modified' => 'mod date',
+          'laBel' => 'label',
+          'relative_PATH' => 'rel path',
+          'import_URL' => 'imp url' }
+      end
+
+      it 'matches the correct fields' do
+        expect(mapper.title).to eq ['A Title']
+        expect(mapper.related_url).to eq ['http://example.com']
+        expect(mapper.description).to eq ['desc1', 'desc2']
+        expect(mapper.creator).to eq []
+        expect(mapper.visibility).to eq 'open'
+        expect(mapper.depositor).to eq 'someone@example.org'
+        expect(mapper.date_modified).to eq 'mod date'
+        expect(mapper.label).to eq 'label'
+        expect(mapper.relative_path).to eq 'rel path'
+        expect(mapper.import_url).to eq 'imp url'
+      end
+    end
+
+    context 'headers with sloppy whitespace' do
+      before { mapper.metadata = metadata }
+      let(:metadata) do
+        { ' Title ' => 'A Title',
+          " Related URL \n " => 'http://example.com',
+          ' visiBILITY ' => 'open' }
+      end
+
+      it 'matches the correct fields' do
+        expect(mapper.title).to eq ['A Title']
+        expect(mapper.related_url).to eq ['http://example.com']
+        expect(mapper.visibility).to eq 'open'
+      end
+    end
+
+    context 'Visibility values in the CSV should match the Edit UI' do
+      load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
+      include_context 'with a work type'
+      context 'public is a synonym for open' do
+        before { mapper.metadata = metadata }
+        let(:metadata) do
+          { ' Title ' => 'A Title',
+            " Related URL \n " => 'http://example.com',
+            ' visiBILITY ' => 'PubLIC' }
+        end
+
+        it 'transforms public to open regardless of capitalization' do
+          expect(mapper.title).to eq ['A Title']
+          expect(mapper.related_url).to eq ['http://example.com']
+          expect(mapper.visibility).to eq 'open'
+        end
+      end
+      context 'institution name is a synonym for authenticated' do
+        before { mapper.metadata = metadata }
+        let(:metadata) do
+          { ' Title ' => 'A Title',
+            " Related URL \n " => 'http://example.com',
+            ' visiBILITY ' => 'my_institution' }
+        end
+
+        it 'transforms institution name to authenticated regardless of capitalization' do
+          expect(mapper.title).to eq ['A Title']
+          expect(mapper.related_url).to eq ['http://example.com']
+          expect(mapper.visibility).to eq 'authenticated'
+        end
+      end
+      context 'full institution name is a synonym for authenticated' do
+        before { mapper.metadata = metadata }
+        let(:metadata) do
+          { ' Title ' => 'A Title',
+            " Related URL \n " => 'http://example.com',
+            ' visiBILITY ' => 'my full institution name' }
+        end
+
+        it 'transforms full institution name to authenticated regardless of capitalization' do
+          expect(mapper.title).to eq ['A Title']
+          expect(mapper.related_url).to eq ['http://example.com']
+          expect(mapper.visibility).to eq 'authenticated'
+        end
+      end
+    end
+
+    # When someone accidentally has too many commas in the CSV rows
+    context 'headers with a nil' do
+      before { mapper.metadata = metadata }
+      let(:metadata) do
+        { ' Title ' => 'A Title',
+          nil => nil }
+      end
+
+      it 'doesn\'t raise an error for missing fields' do
+        expect(mapper.depositor).to eq nil
+      end
+    end
+  end
+end

data/spec/zizia/hyrax_record_importer_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Zizia::HyraxRecordImporter, :clean do
+  subject(:importer) do
+    described_class.new(error_stream: error_stream, info_stream: info_stream)
+  end
+
+  load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
+  include_context 'with a work type'
+
+  let(:error_stream) { [] }
+  let(:info_stream)  { [] }
+  let(:record)       { Zizia::InputRecord.from(metadata: metadata) }
+
+  context 'collection id' do
+    subject(:importer) do
+      described_class.new(attributes: { collection_id: collection_id })
+    end
+    let(:collection_id) { '123' }
+
+    it 'can have a collection id' do
+      expect(importer.collection_id).to eq collection_id
+    end
+  end
+
+  context 'with no attached files' do
+    let(:metadata) do
+      {
+        'title' => 'A Title',
+        'language' => 'English',
+        'visibility' => 'open'
+      }
+    end
+
+    it 'creates a work for record' do
+      expect { importer.import(record: record) }
+        .to change { Work.count }
+        .by 1
+    end
+  end
+
+  # Instead of having a files field in the mapper, which will create a
+  # Hyrax::UploadedFile for each file before attaching it, some importers will
+  # use a remote_files strategy and instead treat each file as a remote file and
+  # fetch it at object creation time. This might be faster, and we might eventually
+  # want to adopt it as our default. For now, do not raise an error if there is no
+  # `files` field in the mapper being used.
+  context 'with no files filed in the mapper' do
+    let(:metadata) do
+      {
+        'title' => 'A Title',
+        'language' => 'English',
+        'visibility' => 'open'
+      }
+    end
+    let(:record) { Zizia::InputRecord.from(metadata: metadata, mapper: Zizia::MetadataMapper.new) }
+
+    it 'creates a work for record' do
+      expect { importer.import(record: record) }
+        .to change { Work.count }
+        .by 1
+    end
+  end
+
+  context 'with attached files' do
+    before do
+      ENV['IMPORT_PATH'] = File.expand_path('../fixtures/images', File.dirname(__FILE__))
+    end
+    let(:metadata) do
+      {
+        'title' => 'A Title',
+        'language' => 'English',
+        'visibility' => 'open',
+        'files' => 'zizia.png|~|cat.png'
+      }
+    end
+    it 'finds a file even if it is in a subdirectory' do
+      expect(importer.find_file_path('cat.png')).to eq "#{ENV['IMPORT_PATH']}/animals/cat.png"
+    end
+    it 'creates a work for record' do
+      expect { importer.import(record: record) }
+        .to change { Work.count }
+        .by 1
+    end
+    it 'makes an uploaded file object for each file attachment' do
+      expect { importer.import(record: record) }
+        .to change { Hyrax::UploadedFile.count }
+        .by 2
+    end
+  end
+
+  context 'with attached files, alternate capitalization and whitespace in "files" header' do
+    before do
+      ENV['IMPORT_PATH'] = File.expand_path('../fixtures/images', File.dirname(__FILE__))
+    end
+    let(:metadata) do
+      {
+        'title' => 'A Title',
+        'visibility' => 'open',
+        ' Files' => 'zizia.png|~|cat.png'
+      }
+    end
+
+    it 'makes an uploaded file object for each file attachment' do
+      expect { importer.import(record: record) }
+        .to change { Hyrax::UploadedFile.count }
+        .by 2
+    end
+  end
+
+  context 'with missing files' do
+    before do
+      ENV['IMPORT_PATH'] = File.expand_path('../fixtures/images', File.dirname(__FILE__))
+    end
+    it 'raises an exception' do
+      expect { importer.find_file_path('foo.png') }.to raise_exception(RuntimeError)
+    end
+  end
+
+  describe '#set_depositor' do
+    let(:metadata) { { 'title' => 'A Title' } }
+
+    context 'when no depositor is set' do
+      it 'sets the Hyrax default batch user' do
+        expect(importer.depositor.user_key).to eq 'batchuser@example.com'
+      end
+    end
+
+    context 'when depositor is passed to initializer' do
+      subject(:importer) { described_class.new(error_stream: error_stream, info_stream: info_stream, attributes: { depositor_id: user.user_key }) }
+
+      let(:user) { ::User.new(id: '123', user_key: 'special_user@example.com') }
+      before { allow(::User).to receive(:find).and_return(user) }
+
+      it 'sets it to the passed-in depositor' do
+        expect(importer.depositor.user_key).to eq 'special_user@example.com'
+      end
+    end
+
+    context 'when depositor is set in metadata' do
+      let(:metadata) do
+        { 'title' => 'A Title',
+          'Depositor' => 'metadata_user@example.com' }
+      end
+
+      it 'sets the Hyrax default batch user' do
+        expect(importer.depositor.user_key).to eq 'batchuser@example.com'
+        # TODO: expect(importer.depositor.user_key).to eq 'metadata_user@example.com'
+        # The metadata depositor should probably override any passed-in or default depositor.
+      end
+    end
+  end
+  # When submitting location data (a.k.a., the "based near" attribute) via the UI,
+  # Hyrax expects to receive a `based_near_attributes` hash in a specific format.
+  # We need to take geonames urls as provided by the customer and transform them to
+  # mimic what the Hyrax UI would ordinarily produce. These will get turned into
+  # Hyrax::ControlledVocabularies::Location objects upon ingest.
+  context 'with location uris' do
+    let(:based_near) { ['http://www.geonames.org/5667009/montana.html', 'http://www.geonames.org/6252001/united-states.html'] }
+    let(:expected_bn_hash) do
+      {
+        "0" => {
+          "id" => "http://sws.geonames.org/5667009/", "_destroy" => ""
+        },
+        "1" => {
+          "id" => "http://sws.geonames.org/6252001/", "_destroy" => ""
+        }
+      }
+    end
+    it "gets a sws uri from a geonames uri" do
+      expect(importer.uri_to_sws("http://www.geonames.org/6252001/united-states.html")).to eq "http://sws.geonames.org/6252001/"
+    end
+    it 'transforms an array of geonames uris into the expected based_near_attributes hash' do
+      expect(importer.based_near_attributes(based_near)).to eq expected_bn_hash
+    end
+  end
+end

data/spec/zizia/importer_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::Importer do
+  load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
+  include_context 'with a work type'
+
+  subject(:importer) { described_class.new(parser: parser) }
+  let(:parser)       { FakeParser.new(file: input) }
+  let(:input)        { [{ 'title' => '1' }, { 'title' => '2' }, { 'title' => '3' }] }
+
+  let(:fake_record_importer) do
+    Class.new do
+      attr_accessor :batch_id, :success_count, :failure_count
+
+      def import(record:)
+        records << record.attributes
+      end
+
+      def records
+        @records ||= []
+      end
+    end
+  end
+
+  describe '#records' do
+    it 'reflects the parsed records' do
+      expect(importer.records.map(&:attributes))
+        .to contain_exactly(*parser.records.map(&:attributes))
+    end
+  end
+
+  describe '#import' do
+    let(:record_importer) { fake_record_importer.new }
+
+    before { importer.record_importer = record_importer }
+
+    it 'sends records to the record importer' do
+      expect { importer.import }
+        .to change { record_importer.records }
+        .from(be_empty)
+        .to a_collection_containing_exactly(*importer.records.map(&:attributes))
+    end
+  end
+end

data/spec/zizia/input_record_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::InputRecord do
+  load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
+  include_context 'with a work type'
+  subject(:record) { described_class.from(metadata: metadata) }
+
+  let(:metadata) do
+    { 'title' => 'Comet in Moominland',
+      'abstract or summary' => 'A book about moomins.' }
+  end
+
+  it 'defaults to a Hyrax Mapper' do
+    expect(described_class.new).to have_attributes(mapper: an_instance_of(Zizia::HyraxBasicMetadataMapper))
+  end
+
+  it 'has metadata and a mapper' do
+    is_expected
+      .to have_attributes(mapper: an_instance_of(Zizia::HyraxBasicMetadataMapper))
+  end
+
+  describe '#attributes' do
+    it 'handles basic text fields' do
+      expect(record.attributes).to include(:title, :description)
+    end
+
+    it 'does not include representative_file' do
+      expect(record.attributes).not_to include(:representative_file)
+    end
+  end
+
+  describe '#representative_file' do
+    it 'is nil if mapper does not provide a representative file' do
+      expect(record.representative_file).to be_nil
+    end
+
+    context 'when mapper provides representative_file' do
+      let(:representative_file) { :A_DUMMY_FILE }
+
+      before do
+        allow(record.mapper)
+          .to receive(:representative_file)
+          .and_return(representative_file)
+      end
+
+      it 'is the file from the mapper' do
+        expect(record.representative_file).to eql representative_file
+      end
+    end
+  end
+
+  describe 'mapped fields' do
+    it 'has methods for metadata fields' do
+      expect(record.title).to contain_exactly metadata['title']
+    end
+
+    it 'has methods for additional mapped metadata fields' do
+      expect(record.description).to contain_exactly metadata['abstract or summary']
+    end
+
+    it 'knows it responds to methods for metadata fields' do
+      expect(record).to respond_to :title
+    end
+
+    it 'knows it responds to methods for additional metadata fields' do
+      expect(record).to respond_to :description
+    end
+  end
+end

data/spec/zizia/parser_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::Parser do
+  subject(:parser) { described_class.new(file: file) }
+  let(:file)       { :fake_file }
+
+  it_behaves_like 'a Zizia::Parser'
+
+  describe '.for' do
+    it 'raises an error' do
+      expect { described_class.for(file: file) }.to raise_error TypeError
+    end
+
+    context 'with a matching parser subclass' do
+      before(:context) do
+        ##
+        # An importer that matches all types
+        class MyFakeParser < described_class
+          class << self
+            def match?(**_opts)
+              true
+            end
+          end
+        end
+
+        class NestedParser < MyFakeParser; end
+      end
+
+      after(:context) do
+        Object.send(:remove_const, :MyFakeParser)
+        Object.send(:remove_const, :NestedParser)
+      end
+
+      it 'returns an importer instance' do
+        expect(described_class.for(file: file)).to be_a NestedParser
+      end
+    end
+  end
+
+  describe '#records' do
+    it 'raises NotImplementedError' do
+      expect { parser.records }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/zizia/record_importer_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::RecordImporter, :clean do
+  subject(:importer) do
+    described_class.new(error_stream: error_stream, info_stream: info_stream)
+  end
+
+  let(:error_stream) { [] }
+  let(:info_stream)  { [] }
+  let(:record)       { Zizia::InputRecord.from(metadata: metadata) }
+  let(:metadata) do
+    {
+      'title' => 'A Title',
+      'language' => 'English',
+      'visibility' => 'open'
+    }
+  end
+
+  it 'raises an error when no work type exists' do
+    expect { importer.import(record: record) }
+      .to raise_error 'No curation_concern found for import'
+  end
+
+  context 'with a registered work type' do
+    load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
+    include_context 'with a work type'
+
+    it 'creates a work for record' do
+      expect { importer.import(record: record) }
+        .to change { Work.count }
+        .by 1
+    end
+
+    it 'writes to the info stream before and after create' do
+      expect { importer.import(record: record) }
+        .to change { info_stream }
+        .to contain_exactly(/^Creating record/, /^Record created/)
+    end
+
+    context 'when input record errors with LDP errors' do
+      let(:ldp_error) { Ldp::PreconditionFailed }
+
+      before { allow(record).to receive(:attributes).and_raise(ldp_error) }
+
+      it 'writes errors to the error stream (no reraise!)' do
+        expect { importer.import(record: record) }
+          .to change { error_stream }
+          .to contain_exactly(an_instance_of(ldp_error))
+      end
+    end
+
+    context 'when input record errors unexpectedly' do
+      let(:custom_error) { Class.new(RuntimeError) }
+
+      before { allow(record).to receive(:attributes).and_raise(custom_error) }
+
+      it 'writes errors to the error stream' do
+        expect { begin; importer.import(record: record); rescue; end }
+          .to change { error_stream }
+          .to contain_exactly(an_instance_of(custom_error))
+      end
+
+      it 'reraises error' do
+        expect { importer.import(record: record) }.to raise_error(custom_error)
+      end
+    end
+  end
+end

data/spec/zizia/title_validator_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::TitleValidator do
+  subject(:validator) { described_class.new(error_stream: []) }
+
+  let(:invalid_parser) do
+    FakeParser.new(file: [{ 'title' => 'moomin' }, {}, {}])
+  end
+
+  it_behaves_like 'a Zizia::Validator' do
+    let(:valid_parser) { FakeParser.new(file: [{ 'title' => 'moomin' }]) }
+  end
+
+  describe '#validate' do
+    it 'populates errors for records with missing titles' do
+      expect(validator.validate(parser: invalid_parser))
+        .to contain_exactly(an_instance_of(described_class::Error),
+                            an_instance_of(described_class::Error))
+    end
+  end
+end

data/spec/zizia/validator_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::Validator do
+  it_behaves_like 'a Zizia::Validator' do
+    let(:valid_parser) { :any }
+  end
+end

data/spec/zizia/version_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia::VERSION do
+  it { is_expected.to be_a String }
+end

data/spec/zizia_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zizia do
+  describe '#config' do
+    it 'can set a default error stream' do
+      expect { described_class.config { |c| c.default_error_stream = STDOUT } }
+        .to change { described_class.config.default_error_stream }
+        .to(STDOUT)
+    end
+
+    it 'can set a default info stream' do
+      expect { described_class.config { |c| c.default_info_stream = STDOUT } }
+        .to change { described_class.config.default_info_stream }
+        .to(STDOUT)
+    end
+  end
+end