hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/services/hyrax/multiple_membership_checker_spec.rb

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

data/spec/services/hyrax/noid_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Hyrax::Noid do
+  let(:class_with_noids) do
+    Class.new do
+      include Hyrax::Noid
+      attr_reader :id
+      def initialize(id:)
+        @id = id
+      end
+    end
+  end
+  let(:object) { class_with_noids.new(id: 1234) }
+
+  describe 'when noids are not enabled' do
+    before { expect(Hyrax.config).to receive(:enable_noids?).and_return(false) }
+    subject { object.assign_id }
+
+    it { is_expected.to be_nil }
+    it 'will not update the id (as the name might imply)' do
+      expect { object.assign_id }.not_to change { object.id }
+    end
+  end
+
+  describe 'when noids is enabled' do
+    let(:service) { double(mint: 5678) }
+
+    before do
+      expect(Hyrax.config).to receive(:enable_noids?).and_return(true)
+      expect(object).to receive(:service).and_return(service)
+    end
+    subject { object.assign_id }
+
+    it { is_expected.to eq(service.mint) }
+    it 'will not update the id (as the name might imply)' do
+      expect { object.assign_id }.not_to change { object.id }
+    end
+  end
+end

data/spec/services/hyrax/permission_template_applicator_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe Hyrax::PermissionTemplateApplicator do
+  subject(:applicator) { described_class.new(template: template) }
+  let(:manage_groups)  { ['edit_group_1', 'edit_group_2'] }
+  let(:manage_users)   { ['moomin', 'snork'] }
+  let(:template)       { :not_a_template }
+  let(:view_groups)    { ['read_group_1', 'read_group_2'] }
+  let(:view_users)     { ['snufkin', 'too-ticky'] }
+  let(:work)           { build(:work) }
+
+  describe '.apply' do
+    it 'initializes with template' do
+      expect(described_class.apply(template))
+        .to have_attributes(template: template)
+    end
+  end
+
+  describe '#apply_to' do
+    let(:template) do
+      create(:permission_template,
+             manage_groups: manage_groups,
+             manage_users:  manage_users,
+             view_groups:   view_groups,
+             view_users:    view_users)
+    end
+
+    it 'applies edit groups' do
+      edit_after_application = work.edit_groups + manage_groups
+
+      expect { applicator.apply_to(model: work) }
+        .to change { work.edit_groups }
+        .to contain_exactly(*edit_after_application)
+    end
+
+    it 'applies edit users' do
+      edit_after_application = work.edit_users + manage_users
+
+      expect { applicator.apply_to(model: work) }
+        .to change { work.edit_users }
+        .to contain_exactly(*edit_after_application)
+    end
+
+    it 'applies read groups' do
+      read_after_application = work.read_groups + view_groups
+
+      expect { applicator.apply_to(model: work) }
+        .to change { work.read_groups }
+        .to contain_exactly(*read_after_application)
+    end
+
+    it 'applies read users' do
+      read_after_application = work.read_users + view_users
+
+      expect { applicator.apply_to(model: work) }
+        .to change { work.read_users }
+        .to contain_exactly(*read_after_application)
+    end
+  end
+
+  describe '#template' do
+    let(:new_template) { :not_another_template }
+
+    it 'has a template attribute' do
+      expect { applicator.template = new_template }
+        .to change { applicator.template }
+        .from(template)
+        .to new_template
+    end
+  end
+end

data/spec/services/hyrax/persist_derivatives_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Hyrax::PersistDerivatives do
+  before do
+    allow(Hyrax.config).to receive(:derivatives_path).and_return('tmp')
+  end
+
+  describe '.output_file' do
+    subject { described_class.output_file(directives, &block) }
+
+    let(:directives) { { url: "file:/tmp/12/34/56/7-thumbnail.jpeg" } }
+    let(:destination_name) { 'thumbnail' }
+
+    let(:block) { -> { true } }
+
+    it 'yields to the file' do
+      expect(FileUtils).to receive(:mkdir_p).with('/tmp/12/34/56')
+      expect(File).to receive(:open).with('/tmp/12/34/56/7-thumbnail.jpeg', 'wb') do |*_, &blk|
+        expect(blk).to be(block)
+      end
+      subject
+    end
+  end
+end

data/spec/services/hyrax/persist_directly_contained_output_file_service_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Hyrax::PersistDirectlyContainedOutputFileService do
+  # PersistDirectlyContainedOutputFileService is used by FullTextExtract.output_file_service
+  let(:file_set) { create(:file_set, user: user) }
+  let(:user) { build(:user) }
+  let(:content) { "fake file content" }
+  let(:resource) { file_set.reload.extracted_text }
+
+  subject(:call) do
+    described_class.call(content,
+                         format: 'txt',
+                         url: file_set.uri,
+                         container: 'extracted_text')
+  end
+
+  it "persists the file to the specified destination on the given object" do
+    expect(call).to be true
+    expect(resource.content).to eq("fake file content")
+    expect(resource.content.encoding).to eq(Encoding::UTF_8)
+  end
+end

data/spec/services/hyrax/qa_select_service_spec.rb

@@ -0,0 +1,109 @@
+RSpec.describe Hyrax::QaSelectService do
+  let(:authority_map) do
+    [
+      HashWithIndifferentAccess.new(term: 'Active Label', label: 'Active Label', id: 'active-id', active: true),
+      HashWithIndifferentAccess.new(term: 'Inactive Label', label: 'Inactive Label', id: 'inactive-id', active: false),
+      HashWithIndifferentAccess.new(label: 'Active No Term', id: 'active-no-term-id', active: true)
+    ]
+  end
+
+  let(:authority) { FakeAuthority }
+  let(:authority_name) { 'respect_my' }
+  let(:qa_select_service) { described_class.new(authority_name) }
+
+  before do
+    allow(Qa::Authorities::Local).to receive(:subauthority_for).with(authority_name).and_return(authority.new(authority_map))
+  end
+
+  describe '#select_all_options' do
+    subject { qa_select_service.select_all_options }
+
+    it 'will be Array of Arrays<label, id>' do
+      expect(subject).to eq([['Active Label', 'active-id'], ['Inactive Label', 'inactive-id'], ['Active No Term', 'active-no-term-id']])
+    end
+  end
+
+  describe '#select_active_options' do
+    subject { qa_select_service.select_active_options }
+
+    it 'will be Array of Arrays<label, id>' do
+      expect(subject).to eq([['Active Label', 'active-id'], ['Active No Term', 'active-no-term-id']])
+    end
+
+    context 'when a key has no active property' do
+      let(:no_state) { HashWithIndifferentAccess.new(term: 'term', label: 'label', id: 'no-state') }
+
+      before { authority_map << no_state }
+
+      it 'raises KeyError' do
+        expect { subject }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '#label' do
+    context 'for item with a "term" propery' do
+      subject { qa_select_service.label('active-id') }
+
+      it { is_expected.to be_a(String) }
+    end
+    context 'for item without a "term" property' do
+      it 'will raise KeyError' do
+        expect { qa_select_service.label('active-no-term-id') }
+          .to raise_error(KeyError)
+      end
+
+      it 'accepts a block for a backup value' do
+        expect(qa_select_service.label('active-no-term-id') { :backup })
+          .to eq :backup
+      end
+    end
+  end
+
+  describe '#active?' do
+    context 'for item with an "active" property' do
+      subject { qa_select_service.active?('active-id') }
+
+      it { is_expected.to be_truthy }
+    end
+    context 'for item without an "active" property' do
+      let(:authority_map) do
+        [
+          HashWithIndifferentAccess.new(term: 'term', label: 'label', id: 'with-term-no-active-state-id')
+        ]
+      end
+
+      it 'will raise KeyError' do
+        expect { qa_select_service.active?('with-term-no-active-state-id') }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '#include_current_value' do
+    let(:render_opts) { [] }
+    let(:html_opts)   { { class: 'moomin' } }
+
+    let(:authority_map) do
+      [
+        HashWithIndifferentAccess.new(term: 'Active Label', label: 'Active Label', id: 'active-id', active: true),
+        HashWithIndifferentAccess.new(term: 'Inactive Label', label: 'Inactive Label', id: 'inactive-id', active: false),
+        HashWithIndifferentAccess.new(label: 'Inactive No Term', id: 'inactive-no-term-id', active: false)
+      ]
+    end
+
+    it 'adds an inactive current value' do
+      expect(qa_select_service.include_current_value('inactive-id', :idx, render_opts, html_opts))
+        .to eq [[['Inactive Label', 'inactive-id']], { class: 'moomin force-select' }]
+    end
+
+    it 'adds an inactive current value with fallback label' do
+      expect(qa_select_service.include_current_value('inactive-no-term-id', :idx, render_opts, html_opts))
+        .to eq [[['inactive-no-term-id', 'inactive-no-term-id']], { class: 'moomin force-select' }]
+    end
+
+    it 'does not add an active current value' do
+      expect(qa_select_service.include_current_value('active-id', :idx, render_opts.dup, html_opts.dup))
+        .to eq [render_opts, html_opts]
+    end
+  end
+end

data/spec/services/hyrax/quick_classification_query_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe Hyrax::QuickClassificationQuery do
+  let(:user) { create(:user) }
+
+  context "with no options" do
+    let(:query) { described_class.new(user) }
+
+    describe "#all?" do
+      subject { query.all? }
+
+      it { is_expected.to be true }
+    end
+
+    describe '#each' do
+      let(:thing) { double }
+
+      before do
+        # Ensure that no other test has altered the configuration:
+        allow(Hyrax.config).to receive(:registered_curation_concern_types).and_return(['GenericWork'])
+      end
+      it "calls the block once for every model" do
+        expect(thing).to receive(:test).with(GenericWork)
+        query.each do |f|
+          thing.test(f)
+        end
+      end
+    end
+  end
+
+  context "with models" do
+    let(:query) { described_class.new(user, models: ['dataset']) }
+
+    describe "#all?" do
+      subject { query.all? }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/services/hyrax/repository_fixity_check_service_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Hyrax::RepositoryFixityCheckService do
+  let!(:file) do
+    create(:file_set).tap do |file|
+      file.add_file(File.open(fixture_path + '/world.png'), path: 'content', original_name: 'world.png')
+    end
+  end
+
+  # The clean is here so that there is only one object that gets fixity checked
+  describe "#fixity_check_everything", :clean_repo do
+    it "fixity checks everything" do
+      # make sure the fixity check gets called
+      expect_any_instance_of(Hyrax::FileSetFixityCheckService).to receive(:fixity_check)
+      described_class.fixity_check_everything
+    end
+  end
+end

data/spec/services/hyrax/resource_types_service_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe Hyrax::ResourceTypesService do
+  describe "select_options" do
+    subject { described_class.select_options }
+
+    it "has a select list" do
+      expect(subject.first).to eq ["Article", "Article"]
+      expect(subject.size).to eq 20
+    end
+  end
+
+  describe "label" do
+    subject { described_class.label("Video") }
+
+    it { is_expected.to eq 'Video' }
+  end
+
+  describe "microdata_type" do
+    subject { described_class.microdata_type(id) }
+
+    context "when the id is in the i18n" do
+      let(:id) { "Map or Cartographic Material" }
+
+      it { is_expected.to eq 'http://schema.org/Map' }
+    end
+
+    context "when the id is not in the i18n" do
+      let(:id) { "missing" }
+
+      it { is_expected.to eq 'http://schema.org/CreativeWork' }
+    end
+
+    context "when the id is nil" do
+      let(:id) { nil }
+
+      it { is_expected.to eq 'http://schema.org/CreativeWork' }
+    end
+  end
+end

data/spec/services/hyrax/rights_statement_service_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Hyrax::RightsStatementService do
+  let(:service) { described_class.new }
+
+  describe "#select_active_options" do
+    it "returns active terms" do
+      expect(service.select_active_options).to include(["In Copyright", "http://rightsstatements.org/vocab/InC/1.0/"], ["No Known Copyright", "http://rightsstatements.org/vocab/NKC/1.0/"])
+    end
+  end
+end

data/spec/services/hyrax/statistics/collections/over_time_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Hyrax::Statistics::Collections::OverTime do
+  let(:service) { described_class.new }
+
+  describe "#points", :clean_repo do
+    before do
+      create(:collection)
+    end
+
+    subject { service.points }
+
+    it "is a list of points" do
+      expect(subject.size).to eq 5
+      expect(subject.first[1]).to eq 0
+      expect(subject.to_a.last[1]).to eq 1
+    end
+  end
+end

data/spec/services/hyrax/statistics/depositors/summary_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe Hyrax::Statistics::Depositors::Summary, :clean_repo do
+  let(:user1) { create(:user) }
+  let(:user2) { create(:user) }
+  let!(:old_work) { create(:work, user: user1) }
+  let(:two_days_ago_date) { Time.zone.now - 2.days }
+
+  let(:start_date) { nil }
+  let(:end_date) { nil }
+  let!(:work1) { create(:work, user: user1) }
+  let!(:work2) { create(:work, user: user2) }
+  let!(:collection1) { create(:public_collection, user: user1) }
+  let(:service) { described_class.new(start_date, end_date) }
+
+  before do
+    allow(old_work).to receive(:create_date).and_return(two_days_ago_date.to_datetime)
+    old_work.update_index
+  end
+
+  describe '.depositors' do
+    it 'is a convenience method' do
+      summary_object = double(depositors: :the_depositors)
+      expect(described_class).to receive(:new).with('a_start_date', 'an_end_date').and_return(summary_object)
+      expect(described_class.depositors(start_date: 'a_start_date', end_date: 'an_end_date')).to eq(:the_depositors)
+    end
+  end
+
+  describe "#depositors" do
+    subject { service.depositors }
+
+    context "when dates are empty" do
+      it "gathers user deposits" do
+        expect(subject).to eq [{ key: user1.user_key, deposits: 2, user: user1 },
+                               { key: user2.user_key, deposits: 1, user: user2 }]
+      end
+    end
+
+    context "when dates are present" do
+      let(:start_date) { 1.day.ago.beginning_of_day }
+      let(:end_date) { 0.days.ago.end_of_day }
+
+      it "gathers user deposits during a date range" do
+        expect(subject).to match_array [{ key: user1.user_key, deposits: 1, user: user1 },
+                                        { key: user2.user_key, deposits: 1, user: user2 }]
+      end
+    end
+
+    context "when a depositor is not found" do
+      before do
+        allow(service).to receive(:results).and_return('bob' => '')
+      end
+
+      it "raises an error" do
+        expect { subject }.to raise_error "Unable to find user 'bob'\nResults was: {\"bob\"=>\"\"}"
+      end
+    end
+  end
+
+  describe "#query" do
+    subject { service.send(:query) }
+
+    it "sets facet.limit to the number of users" do
+      allow(User).to receive(:count).and_return(14)
+      expect(subject['facet.limit']).to eq 14
+    end
+  end
+end

data/spec/services/hyrax/statistics/file_sets/by_format_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Hyrax::Statistics::FileSets::ByFormat, :clean_repo do
+  describe ".query" do
+    let(:fs1) { build(:file_set, id: '1234567') }
+    let(:fs2) { build(:file_set, id: '2345678') }
+    let(:fs3) { build(:file_set, id: '3456789') }
+    let(:fs4) { build(:file_set, id: '4567890') }
+
+    before do
+      allow(fs1).to receive_messages(mime_type: 'text/plain', format_label: ["plain text"])
+      fs1.update_index
+      allow(fs2).to receive_messages(mime_type: 'image/jpg', format_label: ["JPEG image"])
+      fs2.update_index
+      allow(fs3).to receive_messages(mime_type: 'image/tiff', format_label: ["TIFF image"])
+      fs3.update_index
+      allow(fs4).to receive_messages(mime_type: 'image/jpg', format_label: ["JPEG image"])
+      fs4.update_index
+    end
+
+    subject { described_class.query }
+
+    it "is a list of categories" do
+      expect(subject).to eq [{ label: 'jpg (JPEG image)', data: 2 },
+                             { label: 'plain (plain text)', data: 1 },
+                             { label: 'tiff (TIFF image)', data: 1 }]
+      expect(subject.first.label).to eq 'jpg (JPEG image)'
+      expect(subject.first.value).to eq 2
+    end
+  end
+end