hyrax 2.6.0 → 2.9.0

data/spec/services/hyrax/fixity_check_failure_service_spec.rb

@@ -1,29 +0,0 @@
-RSpec.describe Hyrax::FixityCheckFailureService do
-  let!(:depositor) { create(:user) }
-  let!(:log_date) { '2015-07-15 03:06:59' }
-  let(:inbox) { depositor.mailbox.inbox }
-  let(:file) { Hydra::PCDM::File.new }
-  let(:version_uri) { "#{file.uri}/fcr:versions/version1" }
-  let(:file_set) do
-    create(:file_set, user: depositor, title: ["World Icon"]).tap { |fs| fs.original_file = file }
-  end
-
-  let(:checksum_audit_log) do
-    ChecksumAuditLog.new(file_set_id: file_set.id,
-                         file_id: file_set.original_file.id,
-                         checked_uri: version_uri,
-                         created_at: log_date,
-                         updated_at: log_date,
-                         passed: false)
-  end
-
-  describe "#call" do
-    subject { described_class.new(file_set, checksum_audit_log: checksum_audit_log) }
-
-    it "sends failing mail" do
-      subject.call
-      expect(inbox.count).to eq(1)
-      inbox.each { |msg| expect(msg.last_message.subject).to eq('Failing Fixity Check') }
-    end
-  end
-end

data/spec/services/hyrax/graph_exporter_spec.rb

@@ -1,58 +0,0 @@
-RSpec.describe Hyrax::GraphExporter do
-  let(:work) { create(:work_with_one_file, visibility: 'open') }
-  let(:document) { double(id: work.id) }
-  let(:request) { double(host: 'localhost') }
-  let(:service) { described_class.new(document, request) }
-
-  describe "fetch" do
-    subject { service.fetch }
-
-    let(:ttl) { subject.dump(:ntriples) }
-
-    it "transforms suburis to hashcodes" do
-      expect(ttl).to match %r{<http://localhost/concern/generic_works/#{work.id}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://projecthydra.org/works/models#Work>}
-      expect(ttl).to match %r{<http://purl\.org/dc/terms/title> "Test title"}
-      expect(ttl).to match %r{<http://www\.w3\.org/ns/auth/acl#accessControl> <http://localhost/catalog/}
-
-      query = subject.query([RDF::URI("http://localhost/concern/generic_works/#{work.id}"),
-                             RDF::URI("http://www.iana.org/assignments/relation/first"),
-                             nil])
-      proxy = query.to_a.first.object
-
-      expect(proxy.to_s).to match %r{http://localhost/concern/generic_works/#{work.id}/list_source#g\d+}
-
-      # It includes the list nodes on the graph
-      expect(subject.query([proxy, nil, nil]).count).to eq 2
-    end
-
-    context "when a Ldp::NotFound is raised" do
-      let(:mock_service) { instance_double(Hydra::ContentNegotiation::CleanGraphRepository) }
-
-      before do
-        allow(service).to receive(:clean_graph_repository).and_return(mock_service)
-        allow(mock_service).to receive(:find).and_raise(Ldp::NotFound)
-      end
-      it "raises a error that the controller catches and handles" do
-        expect { subject }.to raise_error ActiveFedora::ObjectNotFoundError
-      end
-    end
-
-    context 'with a nested work' do
-      let(:work) do
-        NamespacedWorks::NestedWork
-          .create(title: ['Comet in Moominland'],
-                  created_attributes: [{ start: DateTime.now.utc - 1, finish: DateTime.now.utc },
-                                       { start: DateTime.now.utc - 2, finish: DateTime.now.utc }])
-      end
-
-      it 'includes each nested resources once' do
-        resource_fragments = work.created.map { |ts| ts.rdf_subject.fragment }
-        mapped_fragments   = subject.query(predicate: RDF.type, object: RDF::Vocab::EDM.TimeSpan)
-                                    .subjects
-                                    .map(&:fragment)
-
-        expect(mapped_fragments).to contain_exactly(*resource_fragments)
-      end
-    end
-  end
-end

data/spec/services/hyrax/iiif_authorization_service_spec.rb

@@ -1,43 +0,0 @@
-RSpec.describe Hyrax::IIIFAuthorizationService do
-  let(:user) { create(:user) }
-  let(:ability) { Ability.new(user) }
-  let(:controller) { double(current_ability: ability) }
-  let(:service) { described_class.new(controller) }
-  let(:file_set_id) { 'mp48sc763' }
-  let(:image_id) { "#{file_set_id}/files/0b957460-99b4-4c31-902f-0fc23eefb972" }
-  let(:image) { Riiif::Image.new(image_id) }
-
-  describe "#can?" do
-    context "when the user has read access to the FileSet" do
-      before { allow(ability).to receive(:test_read).with(file_set_id).and_return(true) }
-
-      context "info" do
-        subject { service.can?(:info, image) }
-
-        it { is_expected.to be true }
-      end
-
-      context "show" do
-        subject { service.can?(:show, image) }
-
-        it { is_expected.to be true }
-      end
-    end
-
-    context "when the user doesn't have read access to the FileSet" do
-      before { allow(ability).to receive(:test_read).with(file_set_id).and_return(false) }
-
-      context "info" do
-        subject { service.can?(:info, image) }
-
-        it { is_expected.to be false }
-      end
-
-      context "show" do
-        subject { service.can?(:show, image) }
-
-        it { is_expected.to be false }
-      end
-    end
-  end
-end

data/spec/services/hyrax/import_url_failure_service_spec.rb

@@ -1,23 +0,0 @@
-
-RSpec.describe Hyrax::ImportUrlFailureService do
-  let!(:depositor) { create(:user) }
-  let(:inbox) { depositor.mailbox.inbox }
-  let(:file) do
-    create(:file_set, user: depositor)
-  end
-
-  before do
-    allow(file.errors).to receive(:full_messages).and_return(['huge mistake'])
-  end
-
-  describe "#call" do
-    before do
-      described_class.new(file, depositor).call
-    end
-
-    it "sends failing mail" do
-      expect(inbox.count).to eq(1)
-      expect(inbox.first.last_message.subject).to eq('File Import Error')
-    end
-  end
-end

data/spec/services/hyrax/lease_service_spec.rb

@@ -1,50 +0,0 @@
-RSpec.describe Hyrax::LeaseService do
-  subject { described_class }
-
-  let(:future_date) { 2.days.from_now }
-  let(:past_date) { 2.days.ago }
-
-  let!(:work_with_expired_lease1) do
-    build(:generic_work, lease_expiration_date: past_date.to_s).tap do |work|
-      work.save(validate: false)
-    end
-  end
-
-  let!(:work_with_expired_lease2) do
-    build(:generic_work, lease_expiration_date: past_date.to_s).tap do |work|
-      work.save(validate: false)
-    end
-  end
-
-  let!(:work_with_lease_in_effect) { create(:generic_work, lease_expiration_date: future_date.to_s) }
-  let!(:work_without_lease) { create(:generic_work) }
-
-  describe '#assets_with_expired_leases' do
-    it 'returns an array of assets with expired lease' do
-      returned_pids = subject.assets_with_expired_leases.map(&:id)
-      expect(returned_pids).to include work_with_expired_lease1.id, work_with_expired_lease2.id
-      expect(returned_pids).not_to include work_with_lease_in_effect.id, work_without_lease.id
-    end
-  end
-
-  describe '#assets_under_lease' do
-    it 'returns an array of assets with active leases' do
-      returned_pids = subject.assets_under_lease.map(&:id)
-      expect(returned_pids).to include work_with_expired_lease1.id, work_with_expired_lease2.id, work_with_lease_in_effect.id
-      expect(returned_pids).not_to include work_without_lease.id
-    end
-  end
-
-  describe '#assets_with_deactivated_leases' do
-    before do
-      work_with_expired_lease1.deactivate_lease!
-      work_with_expired_lease1.save!
-      work_with_lease_in_effect.deactivate_lease!
-      work_with_lease_in_effect.save!
-    end
-    it 'returns an array of assets with deactivated leases' do
-      returned_pids = subject.assets_with_deactivated_leases.map(&:id)
-      expect(returned_pids).to include work_with_expired_lease1.id, work_with_lease_in_effect.id
-    end
-  end
-end

data/spec/services/hyrax/license_service_spec.rb

@@ -1,34 +0,0 @@
-RSpec.describe Hyrax::LicenseService do
-  before do
-    # Configure QA to use fixtures
-    qa_fixtures = { local_path: File.expand_path('spec/fixtures/authorities') }
-    allow(Qa::Authorities::Local).to receive(:config).and_return(qa_fixtures)
-  end
-  let(:service) { described_class.new }
-
-  describe "#select_active_options" do
-    it "returns active terms" do
-      expect(service.select_active_options).to include(["First Active Term", "demo_id_01"], ["Second Active Term", "demo_id_02"])
-    end
-
-    it "does not return inactive terms" do
-      expect(service.select_active_options).not_to include(["Third is an Inactive Term", "demo_id_03"], ["Fourth is an Inactive Term", "demo_id_04"])
-    end
-  end
-
-  describe "#select_all_options" do
-    it "returns both active and inactive terms" do
-      expect(service.select_all_options).to include(["Fourth is an Inactive Term", "demo_id_04"], ["First Active Term", "demo_id_01"])
-    end
-  end
-
-  describe "#label" do
-    it "resolves for ids of active terms" do
-      expect(service.label('demo_id_01')).to eq("First Active Term")
-    end
-
-    it "resolves for ids of inactive terms" do
-      expect(service.label('demo_id_03')).to eq("Third is an Inactive Term")
-    end
-  end
-end

data/spec/services/hyrax/lock_manager_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe Hyrax::LockManager do
-  subject do
-    described_class.new(Hyrax.config.lock_time_to_live,
-                        Hyrax.config.lock_retry_count,
-                        Hyrax.config.lock_retry_delay)
-  end
-
-  describe "lock", unless: ENV['TRAVIS'] do
-    it "calls the block" do
-      expect { |probe| subject.lock('foobar', &probe) }.to yield_with_no_args
-    end
-  end
-end

data/spec/services/hyrax/messenger_service_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe Hyrax::MessengerService do
-  describe '#deliver' do
-    let(:sender) { create(:user) }
-    let(:recipients) { create(:user) }
-    let(:body) { 'Quite an excellent message' }
-    let(:subject) { 'IMPORTANT' }
-    let(:other_arg) { 'Did I make it?' }
-
-    it 'invokes Hyrax::MessengerService to deliver the message' do
-      expect(sender).to receive(:send_message).with(recipients, body, subject, other_arg)
-      expect(StreamNotificationsJob).to receive(:perform_later).with(recipients)
-      described_class.deliver(sender, recipients, body, subject, other_arg)
-    end
-  end
-end

data/spec/services/hyrax/microdata_spec.rb

@@ -1,94 +0,0 @@
-module Hyrax
-  RSpec.describe Microdata do
-    let(:yml_path) { File.join(fixture_path, 'config', 'schema_org.yml') }
-    let(:yml_path_secondary) { File.join(fixture_path, 'config', 'schema_org_second.yml') }
-
-    before do
-      described_class.load_paths = yml_path
-    end
-
-    after do
-      # Need to reset as this is an instance variable
-      described_class.clear_load_paths!
-    end
-
-    describe '.load_paths' do
-      subject { described_class.load_paths }
-
-      it { is_expected.to be_a(Array) }
-      it 'can be appended to' do
-        expect { subject << yml_path_secondary }.to change { described_class.load_paths.size }.by(1)
-      end
-    end
-    describe '.load_paths=' do
-      it 'replaces the existing' do
-        expect do
-          described_class.load_paths = yml_path_secondary
-        end.to change { described_class.load_paths }.to([yml_path_secondary])
-      end
-    end
-    describe '.fetch' do
-      describe 'with one file in the load path' do
-        describe 'with a default' do
-          describe 'and a miss on the key' do
-            it 'will be the given default value' do
-              expect(described_class.fetch('going.to.miss', default: "and a miss")).to eq('and a miss')
-            end
-          end
-          describe 'and hit on the key' do
-            subject { described_class.fetch('name.value') }
-
-            it 'will be the registered value' do
-              expect(subject).to eq('firstName')
-            end
-          end
-        end
-        describe 'without a default' do
-          describe 'and a miss on the key' do
-            subject { described_class.fetch('going.to.miss') }
-
-            it { is_expected.to be_nil }
-          end
-          describe 'and hit on the key' do
-            subject { described_class.fetch('name.value') }
-
-            it 'will be the registered value' do
-              expect(subject).to eq('firstName')
-            end
-          end
-        end
-      end
-      describe 'with multiple files in the load path' do
-        before do
-          described_class.load_paths = [yml_path, yml_path_secondary]
-        end
-        describe 'and a miss on the key' do
-          it 'will be the given default value' do
-            expect(described_class.fetch('going.to.miss', default: "and a miss")).to eq('and a miss')
-          end
-        end
-        describe 'and what would be a hit on the first and second loaded file' do
-          subject { described_class.fetch('name.value') }
-
-          it 'will be the second value loaded' do
-            expect(subject).to eq('secondFirstName')
-          end
-        end
-        describe 'and a hit on the first loaded file but not the second' do
-          subject { described_class.fetch('first_only.value') }
-
-          it 'will be the first loaded value' do
-            expect(subject).to eq('iAmTheFirstOnly')
-          end
-        end
-        describe 'and a hit on the second loaded file but not the first' do
-          subject { described_class.fetch('second_only.value') }
-
-          it 'will be the first loaded value' do
-            expect(subject).to eq('iAmTheSecondOnly')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/services/hyrax/multiple_membership_checker_spec.rb

@@ -1,155 +0,0 @@
-RSpec.describe Hyrax::MultipleMembershipChecker, :clean_repo do
-  let(:item) { double }
-
-  describe '#initialize' do
-    subject { described_class.new(item: item) }
-
-    it 'exposes an attr_reader' do
-      expect(subject.item).to eq item
-    end
-  end
-
-  describe '#check' do
-    let(:checker) { described_class.new(item: item) }
-    let(:collection_ids) { ['foobar'] }
-    let(:included) { false }
-    let!(:collection_type) { create(:collection_type, title: 'Greedy', allow_multiple_membership: false) }
-
-    subject { checker.check(collection_ids: collection_ids, include_current_members: included) }
-
-    context 'when there are no single-membership collection types' do
-      before do
-        allow(Hyrax::CollectionType).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: []).and_return([])
-      end
-
-      it 'returns nil' do
-        expect(checker).to receive(:single_membership_types).and_return([])
-        expect(subject).to be nil
-      end
-    end
-
-    context 'when collection_ids is empty' do
-      let(:collection_ids) { [] }
-
-      it 'returns nil' do
-        expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_call_original
-        expect(Collection).not_to receive(:where)
-        expect(subject).to be nil
-      end
-    end
-
-    context 'when there are no single-membership collection instances' do
-      it 'returns nil' do
-        expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_return([])
-        expect(Collection).not_to receive(:where)
-        expect(subject).to be nil
-      end
-    end
-
-    context 'when multiple single-membership collection instances are not in the list' do
-      let(:collection) { build(:collection_lw, id: 'collection0', collection_type: collection_type, with_solr_document: true) }
-      let(:collections) { [collection] }
-      let(:collection_ids) { collections.map(&:id) }
-
-      it 'returns nil' do
-        expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_call_original
-        expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: [collection_type.gid]).once.and_return(collections)
-        expect(subject).to be nil
-      end
-    end
-
-    context 'when multiple single-membership collection instances are in the list, not including current members' do
-      let(:collection1) { build(:collection_lw, id: 'collection1', title: ['Foo'], collection_type: collection_type, with_solr_document: true) }
-      let(:collection2) { build(:collection_lw, id: 'collection2', title: ['Bar'], collection_type: collection_type, with_solr_document: true) }
-      let(:collections) { [collection1, collection2] }
-      let(:collection_ids) { collections.map(&:id) }
-
-      before do
-        allow(Collection).to receive(:find).with(collection1.id).and_return(collection1)
-        allow(Collection).to receive(:find).with(collection2.id).and_return(collection2)
-      end
-
-      it 'returns an error' do
-        expect(item).not_to receive(:member_of_collection_ids)
-        expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_call_original
-        expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: [collection_type.gid]).once.and_return(collections)
-        expect(subject).to eq 'Error: You have specified more than one of the same single-membership collection type (type: Greedy, collections: Foo and Bar)'
-      end
-
-      context 'with multiple single membership collection types' do
-        let!(:collection_type_2) { create(:collection_type, title: 'Doc', allow_multiple_membership: false) }
-        let(:collection_types) { [collection_type.gid, collection_type_2.gid] }
-
-        it 'returns an error' do
-          expect(item).not_to receive(:member_of_collection_ids)
-          expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_call_original
-          expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: collection_types).once.and_return(collections)
-          expect(subject).to eq 'Error: You have specified more than one of the same single-membership collection type (type: Greedy, collections: Foo and Bar)'
-        end
-      end
-    end
-
-    context 'when multiple single-membership collection instances are in the list, including current members' do
-      let(:collection1) { build(:collection_lw, id: 'collection1', title: ['Foo'], collection_type: collection_type, with_solr_document: true) }
-      let(:collection2) { build(:collection_lw, id: 'collection2', title: ['Bar'], collection_type: collection_type, with_solr_document: true) }
-      let(:collections) { [collection1] }
-      let(:collection_ids) { collections.map(&:id) }
-      let(:included) { true }
-
-      before do
-        allow(item).to receive(:member_of_collection_ids).once.and_return([collection2.id])
-      end
-
-      it 'returns an error' do
-        expect(item).to receive(:member_of_collection_ids)
-        expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: [collection_type.gid]).once.and_return(collections)
-        expect(Collection).to receive(:where).with(id: [collection2.id], collection_type_gid_ssim: [collection_type.gid]).once.and_return([collection2])
-        expect(subject).to eq 'Error: You have specified more than one of the same single-membership collection type (type: Greedy, collections: Foo and Bar)'
-      end
-
-      context 'with multiple single membership collection types' do
-        let!(:collection_type_2) { create(:collection_type, title: 'Doc', allow_multiple_membership: false) }
-        let(:collection_types) { [collection_type.gid, collection_type_2.gid] }
-
-        it 'returns an error' do
-          expect(item).to receive(:member_of_collection_ids)
-          expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: collection_types).once.and_return(collections)
-          expect(Collection).to receive(:where).with(id: [collection2.id], collection_type_gid_ssim: collection_types).once.and_return([collection2])
-          expect(subject).to eq 'Error: You have specified more than one of the same single-membership collection type (type: Greedy, collections: Foo and Bar)'
-        end
-      end
-    end
-
-    context 'when multiple single-membership collection instances are in the list, but are different collection types' do
-      let(:collection1) { build(:collection_lw, title: ['Foo'], collection_type: collection_type, with_solr_document: true) }
-      let(:collection2) { build(:collection_lw, title: ['Bar'], collection_type: collection_type_2, with_solr_document: true) }
-      let(:collections) { [collection1, collection2] }
-      let(:collection_ids) { collections.map(&:id) }
-      let(:collection_type_2) { create(:collection_type, title: 'Doc', allow_multiple_membership: false) }
-      let(:collection_types) { [collection_type.gid, collection_type_2.gid] }
-
-      it 'returns nil' do
-        expect(item).not_to receive(:member_of_collection_ids)
-        expect(checker).to receive(:single_membership_collections).with(collection_ids).once.and_call_original
-        expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: collection_types).once.and_return(collections)
-        expect(subject).to be nil
-      end
-
-      context 'when including current members' do
-        let(:collections) { [collection1] }
-        let(:included) { true }
-
-        before do
-          allow(item).to receive(:member_of_collection_ids).once.and_return([collection2.id])
-        end
-
-        it 'returns nil' do
-          expect(item).to receive(:member_of_collection_ids)
-          expect(Collection).to receive(:where).with(id: collection_ids, collection_type_gid_ssim: collection_types).once.and_return(collections)
-          expect(Collection).to receive(:where).with(id: [collection2.id], collection_type_gid_ssim: collection_types).once.and_return([collection2])
-          expect(subject).to be nil
-        end
-      end
-    end
-  end
-end