zizia 3.1.0.alpha.01 → 4.0.0.alpha.01

data/spec/zizia/hyrax_basic_metadata_mapper_spec.rb

@@ -1,190 +0,0 @@
-# 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

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Zizia::HyraxRecordImporter, :clean do
-  subject(:importer) do
-    described_class.new
-  end
-
-  load File.expand_path("../../support/shared_contexts/with_work_type.rb", __FILE__)
-  include_context 'with a work type'
-
-  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(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

@@ -1,46 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-# 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/record_importer_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Zizia::RecordImporter, :clean do
-  subject(:importer) do
-    described_class.new
-  end
-
-  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
-
-    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 'catches the error' do
-        expect { importer.import(record: record) }.not_to raise_error(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 'reraises error' do
-        expect { importer.import(record: record) }.to raise_error(custom_error)
-      end
-    end
-  end
-end

data/spec/zizia/title_validator_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Zizia::TitleValidator do
-  subject(:validator) { described_class.new }
-
-  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

@@ -1,9 +0,0 @@
-# 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

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

data/spec/zizia_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-class FakeMetadataMapper
-end
-
-describe Zizia do
-  describe '#config' do
-    it 'has a default metadata mapper' do
-      expect(described_class.config.metadata_mapper_class).to eq Zizia::HyraxBasicMetadataMapper
-    end
-
-    it 'can set a default metadata mapper' do
-      expect { described_class.config { |c| c.metadata_mapper_class = FakeMetadataMapper } }
-        .to change { described_class.config.metadata_mapper_class }
-        .to(FakeMetadataMapper)
-    end
-  end
-end

data/zizia.gemspec

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('../lib', __FILE__)
-require 'zizia/version'
-
-Gem::Specification.new do |gem|
-  gem.name          = 'zizia'
-  gem.version       = Zizia::VERSION
-  gem.platform      = Gem::Platform::RUBY
-  gem.authors       = ['Data Curation Experts']
-  gem.email         = ['administrator@curationexperts.com']
-  gem.summary       = 'Hyrax importers.'
-  gem.license       = 'Apache-2.0'
-  gem.files         = %w[AUTHORS CHANGELOG.md README.md LICENSE] +
-                      Dir.glob('lib/**/*.rb')
-  gem.require_paths = %w[lib]
-
-  gem.required_ruby_version = '>= 2.3.4'
-
-  gem.add_dependency 'active-fedora'
-  gem.add_dependency 'rails', '~> 5.1.7'
-  gem.add_dependency 'carrierwave'
-  gem.add_dependency 'redcarpet'
-  gem.add_dependency 'sassc-rails'
-
-  gem.add_development_dependency 'yard'
-  gem.add_development_dependency 'bixby'
-  gem.add_development_dependency 'hyrax', '~> 2.5'
-  gem.add_development_dependency 'hyrax-spec'
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rspec-rails'
-  gem.add_development_dependency 'rspec_junit_formatter'
-  gem.add_development_dependency 'coveralls'
-  gem.add_development_dependency 'solr_wrapper',   '~> 2.1'
-  gem.add_development_dependency 'fcrepo_wrapper', '~> 0.9'
-  gem.add_development_dependency 'byebug'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'sqlite3'
-
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
-end