hyrax 2.6.0 → 2.9.0

data/spec/search_builders/hyrax/work_relation_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe Hyrax::WorkRelation, :clean_repo do
-  let!(:work) { create(:generic_work) }
-  let!(:file_set) { create(:file_set) }
-  let!(:collection) { build(:collection_lw) }
-
-  it 'has works and not collections or file sets' do
-    expect(subject).to eq [work]
-  end
-end

data/spec/search_builders/hyrax/work_search_builder_spec.rb

@@ -1,106 +0,0 @@
-RSpec.describe Hyrax::WorkSearchBuilder do
-  let(:me) { create(:user) }
-  let(:config) { CatalogController.blacklight_config }
-  let(:scope) do
-    double('The scope',
-           blacklight_config: config,
-           current_ability: Ability.new(me),
-           current_user: me)
-  end
-  let(:builder) { described_class.new(scope).with(params) }
-  let(:params) { { id: '123abc' } }
-
-  before do
-    allow(builder).to receive(:gated_discovery_filters).and_return(["access_filter1", "access_filter2"])
-
-    # This prevents any generated classes from interfering with this test:
-    allow(builder).to receive(:work_classes).and_return([GenericWork])
-  end
-
-  describe "#query" do
-    subject { builder.query }
-
-    let(:doc) { instance_double(SolrDocument) }
-
-    before do
-      allow(SolrDocument).to receive(:find).and_return(doc)
-    end
-
-    context "when the current_work has a workflow entity" do
-      before do
-        expect(Hyrax::Workflow::PermissionQuery).to receive(:scope_permitted_workflow_actions_available_for_current_state)
-          .with(user: me,
-                entity: doc).and_return(roles)
-      end
-      context "and the current user has a role" do
-        let(:roles) { [double] }
-
-        it "filters for id, access, suppressed and type" do
-          expect(subject[:fq]).to eq ["access_filter1 OR access_filter2",
-                                      "{!terms f=has_model_ssim}GenericWork,Collection",
-                                      "{!raw f=id}123abc"]
-        end
-      end
-      context "and the current user doesn't have a role" do
-        let(:roles) { [] }
-
-        context "and the current user is not the depositor" do
-          before do
-            allow(builder).to receive(:depositor?).and_return(false)
-          end
-
-          it "filters for id, access, suppressed and type" do
-            expect(subject[:fq]).to eq ["access_filter1 OR access_filter2",
-                                        "{!terms f=has_model_ssim}GenericWork,Collection",
-                                        "-suppressed_bsi:true",
-                                        "{!raw f=id}123abc"]
-          end
-        end
-
-        context "and the current user is the depositor" do
-          before do
-            allow(builder).to receive(:depositor?).and_return(true)
-          end
-
-          it "filters for id, access, suppressed and type" do
-            expect(subject[:fq]).to eq ["access_filter1 OR access_filter2",
-                                        "{!terms f=has_model_ssim}GenericWork,Collection",
-                                        "{!raw f=id}123abc"]
-          end
-        end
-      end
-    end
-
-    context "when the current_work doesn't have a workflow entity" do
-      before do
-        expect(Hyrax::Workflow::PermissionQuery).to receive(:scope_permitted_workflow_actions_available_for_current_state)
-          .and_raise(PowerConverter::ConversionError.new(double, {}))
-      end
-
-      context "and the current user is not the depositor" do
-        before do
-          allow(builder).to receive(:depositor?).and_return(false)
-        end
-
-        it "filters for id, access, suppressed and type" do
-          expect(subject[:fq]).to eq ["access_filter1 OR access_filter2",
-                                      "{!terms f=has_model_ssim}GenericWork,Collection",
-                                      "-suppressed_bsi:true",
-                                      "{!raw f=id}123abc"]
-        end
-      end
-
-      context "and the current user is the depositor" do
-        before do
-          allow(builder).to receive(:depositor?).and_return(true)
-        end
-
-        it "filters for id, access, suppressed and type" do
-          expect(subject[:fq]).to eq ["access_filter1 OR access_filter2",
-                                      "{!terms f=has_model_ssim}GenericWork,Collection",
-                                      "{!raw f=id}123abc"]
-        end
-      end
-    end
-  end
-end

data/spec/search_builders/hyrax/works_search_builder_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe Hyrax::WorksSearchBuilder do
-  describe "::default_processor_chain" do
-    subject { described_class.default_processor_chain }
-
-    let(:blacklight_filters) do
-      # These filters are in Blacklight::Solr::SearchBuilderBehavior
-      [
-        :default_solr_parameters,
-        :add_query_to_solr,
-        :add_facet_fq_to_solr,
-        :add_facetting_to_solr,
-        :add_solr_fields_to_query,
-        :add_paging_to_solr,
-        :add_sorting_to_solr,
-        :add_group_config_to_solr,
-        :add_facet_paging_to_solr,
-        :add_access_controls_to_solr_params
-      ]
-    end
-
-    it { is_expected.to eq blacklight_filters + [:filter_models] }
-  end
-end

data/spec/services/hyrax/abstract_message_service_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe Hyrax::AbstractMessageService do
-  let(:file_set) { double }
-  let(:user) { build(:user) }
-  let(:klass) do
-    Class.new(described_class) do
-      def message
-        'You have won!'
-      end
-
-      def subject
-        'Attention!'
-      end
-    end
-  end
-
-  subject { klass.new(file_set, user) }
-
-  describe '#call' do
-    it 'invokes Hyrax::MessengerService to deliver the message' do
-      expect(Hyrax::MessengerService).to receive(:deliver)
-        .with(::User.audit_user, user, 'You have won!', 'Attention!').once
-      subject.call
-    end
-  end
-end

data/spec/services/hyrax/adapters/nesting_index_adapter_spec.rb

@@ -1,205 +0,0 @@
-require 'samvera/nesting_indexer/adapters/interface_behavior_spec'
-
-RSpec.describe Hyrax::Adapters::NestingIndexAdapter do
-  it_behaves_like 'a Samvera::NestingIndexer::Adapter'
-
-  describe '.find_preservation_document_by' do
-    let(:id) { '123' }
-
-    subject { described_class.find_preservation_document_by(id: id) }
-
-    context 'with a not found fedora document ' do
-      let(:id) { 'so-very-missing-no-document-here' }
-
-      it 'raises ActiveFedora::ObjectNotFound' do
-        expect { subject }.to raise_error(ActiveFedora::ObjectNotFoundError)
-      end
-    end
-    context 'with fedora document that does not have #member_of_collection_ids' do
-      let(:document) { double("Document", id: id) }
-
-      before do
-        expect(ActiveFedora::Base).to receive(:find).with(document.id).and_return(document)
-      end
-
-      it { is_expected.to be_a(Samvera::NestingIndexer::Documents::PreservationDocument) }
-    end
-    context 'with fedora document that has #member_of_collection_ids' do
-      let(:document) { double("Document", id: id, member_of_collection_ids: ['456', '789']) }
-
-      before do
-        expect(ActiveFedora::Base).to receive(:find).with(document.id).and_return(document)
-      end
-
-      it { is_expected.to be_a(Samvera::NestingIndexer::Documents::PreservationDocument) }
-    end
-  end
-
-  describe '.find_index_document_by' do
-    subject { described_class.find_index_document_by(id: id) }
-
-    context 'with id not in solr, it builds from Fedora' do
-      let(:id) { 'so-very-missing-no-document-here' }
-      let(:document) { double("Document", id: id, fetch: nil) }
-      let(:object) { double("Object_to_reindex", id: id, to_solr: document) }
-
-      before do
-        allow(ActiveFedora::Base).to receive(:find).with(id).and_return(object)
-      end
-
-      it { is_expected.to be_a(Samvera::NestingIndexer::Documents::IndexDocument) }
-    end
-
-    context 'with a found id' do
-      let(:id) { "abc-def-ghi" }
-      let(:document) { { id: id } }
-
-      before do
-        ActiveFedora::SolrService.delete(id)
-        ActiveFedora::SolrService.add(document, commit: true)
-      end
-
-      it { is_expected.to be_a(Samvera::NestingIndexer::Documents::IndexDocument) }
-    end
-  end
-
-  describe '.each_perservation_document_id_and_parent_ids', clean_repo: true do
-    let!(:nested_parent) { build(:collection_lw, member_of_collections: []) }
-    let!(:nested_with_parent) { create(:collection_lw, member_of_collections: [nested_parent]) }
-    let!(:work) { create(:generic_work) }
-    let(:count_of_items) { ActiveFedora::Base.descendant_uris(ActiveFedora.fedora.base_uri, exclude_uri: true).count }
-
-    it 'uses direct add to Solr on non-nested objects but yields the document and parent_ids to allow nesting logic to fire' do
-      # The two collections and the work are handled via the nesting indexer.
-      # we expect remaining repository objects to reindex via to_solr.
-      expect(ActiveFedora::SolrService).to receive(:add).exactly(count_of_items - 3).times
-      yielded = []
-      described_class.each_perservation_document_id_and_parent_ids do |document_id, parent_ids|
-        yielded << [document_id, parent_ids]
-      end
-      # collections or works with parents do not yield, so parent_ids should always be an empty array, and nested_with_parent is not yielded.
-      expect(yielded).to contain_exactly([work.id, []], [nested_parent.id, []])
-    end
-  end
-
-  describe '.each_child_document_of', clean_repo: true do
-    let(:ancestors_key) { described_class.solr_field_name_for_storing_ancestors }
-    let(:pathnames_key) { described_class.solr_field_name_for_storing_pathnames }
-    let(:index_document_class) { Samvera::NestingIndexer::Documents::IndexDocument }
-    let(:parent) { { id: document.id } }
-    let(:document) { index_document_class.new(id: 'parent-1', pathnames: ['parent-1'], parent_ids: [], ancestors: []) }
-    let(:children) do
-      [{ id: 'child-1',
-         member_of_collection_ids_ssim: [document.id],
-         ancestors_key => [document.id],
-         pathnames_key => ['child-1'] },
-       { id: 'child-2',
-         member_of_collection_ids_ssim: [document.id],
-         ancestors_key => [document.id] }]
-    end
-    let(:not_my_children) do
-      [{ id: 'youre-not-my-dad-1',
-         member_of_collection_ids_ssim: ['parent-2'],
-         ancestors_key => ['parent-2'],
-         pathnames_key => ['youre-not-my-dad-1'] },
-       { id: 'i-am-your-grandchild',
-         member_of_collection_ids_ssim: ['parent-3'],
-         ancestors_key => ['parent-1/parent-3'],
-         pathnames_key => ['i-am-your-grandchild'] }]
-    end
-
-    before do
-      ([parent] + children + not_my_children).each do |doc|
-        ActiveFedora::SolrService.add(doc, commit: true)
-      end
-    end
-
-    context 'with full reindexing extent' do
-      it 'yields all of the child solr-documents of the given document' do
-        child_index_documents = []
-        described_class.each_child_document_of(document: document, extent: Hyrax::Adapters::NestingIndexAdapter::FULL_REINDEX) do |doc|
-          child_index_documents << doc
-        end
-        expect(child_index_documents.count).to eq(2)
-        child_index_documents.each do |child|
-          expect(child).to be_a(index_document_class)
-          expect(child.ancestors).to eq([document.id])
-        end
-      end
-    end
-
-    context 'with limited reindexing extent' do
-      it 'yields only child documents without pathnames' do
-        child_index_documents = []
-        described_class.each_child_document_of(document: document, extent: Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX) do |doc|
-          child_index_documents << doc
-        end
-        expect(child_index_documents.count).to eq(1)
-        child_index_documents.each do |child|
-          expect(child).to be_a(index_document_class)
-          expect(child.ancestors).to eq([document.id])
-        end
-      end
-    end
-  end
-
-  describe '.write_nesting_document_to_index_layer' do
-    let(:work) { create(:work) }
-    let(:query_for_works_solr_document) { ->(id:) { ActiveFedora::SolrService.query(ActiveFedora::SolrQueryBuilder.construct_query_for_ids([id])).first } }
-
-    # rubocop:disable RSpec/ExampleLength
-    it 'will append parent_ids, ancestors, pathnames, and deepest_nested_depth to the SOLR document' do
-      previous_solr_keys = work.to_solr.keys
-      expect(previous_solr_keys).not_to include(described_class.solr_field_name_for_storing_ancestors)
-      expect(previous_solr_keys).not_to include(described_class.solr_field_name_for_storing_parent_ids)
-      expect(previous_solr_keys).not_to include(described_class.solr_field_name_for_storing_pathnames)
-      expect(previous_solr_keys).not_to include(described_class.solr_field_name_for_deepest_nested_depth)
-
-      existing_queried_solr_document = query_for_works_solr_document.call(id: work.id)
-      expect(existing_queried_solr_document).not_to be_key(described_class.solr_field_name_for_storing_ancestors)
-      expect(existing_queried_solr_document).not_to be_key(described_class.solr_field_name_for_storing_parent_ids)
-      expect(existing_queried_solr_document).not_to be_key(described_class.solr_field_name_for_storing_pathnames)
-      expect(existing_queried_solr_document).not_to be_key(described_class.solr_field_name_for_deepest_nested_depth)
-
-      nesting_document = Samvera::NestingIndexer::Documents::IndexDocument.new(
-        id: work.id,
-        parent_ids: ['123'],
-        pathnames: ["123#{Samvera::NestingIndexer::Documents::ANCESTOR_AND_PATHNAME_DELIMITER}#{work.id}"],
-        ancestors: ['123']
-      )
-      returned_solr_document = described_class.write_nesting_document_to_index_layer(nesting_document: nesting_document)
-
-      expect(returned_solr_document.fetch(described_class.solr_field_name_for_storing_ancestors)).to eq(nesting_document.ancestors)
-      expect(returned_solr_document.fetch(described_class.solr_field_name_for_storing_parent_ids)).to eq(nesting_document.parent_ids)
-      expect(returned_solr_document.fetch(described_class.solr_field_name_for_storing_pathnames)).to eq(nesting_document.pathnames)
-      expect(returned_solr_document.fetch(described_class.solr_field_name_for_deepest_nested_depth)).to eq(nesting_document.deepest_nested_depth)
-
-      newly_queried_solr_document = query_for_works_solr_document.call(id: work.id)
-      expect(newly_queried_solr_document.fetch(described_class.solr_field_name_for_storing_ancestors)).to eq(nesting_document.ancestors)
-      expect(newly_queried_solr_document.fetch(described_class.solr_field_name_for_storing_parent_ids)).to eq(nesting_document.parent_ids)
-      expect(newly_queried_solr_document.fetch(described_class.solr_field_name_for_storing_pathnames)).to eq(nesting_document.pathnames)
-      expect(newly_queried_solr_document.fetch(described_class.solr_field_name_for_deepest_nested_depth)).to eq(nesting_document.deepest_nested_depth)
-    end
-    # rubocop:enable RSpec/ExampleLength
-  end
-
-  describe '.solr_field_name_for_storing_ancestors' do
-    subject { described_class.solr_field_name_for_storing_ancestors }
-
-    it { is_expected.to match(/_ssim$/) }
-  end
-
-  describe '.solr_field_name_for_deepest_nested_depth' do
-    subject { described_class.solr_field_name_for_deepest_nested_depth }
-
-    it 'is expected to be a single value integer' do
-      expect(subject).to match(/_isi$/)
-    end
-  end
-
-  describe '.solr_field_name_for_storing_parent_ids' do
-    subject { described_class.solr_field_name_for_storing_parent_ids }
-
-    it { is_expected.to match(/_ssim$/) }
-  end
-end

data/spec/services/hyrax/admin_set_create_service_spec.rb

@@ -1,114 +0,0 @@
-RSpec.describe Hyrax::AdminSetCreateService do
-  let(:user) { create(:user) }
-
-  describe '.create_default_admin_set', :clean_repo do
-    let(:admin_set) { AdminSet.find(AdminSet::DEFAULT_ID) }
-
-    # It is important to test the side-effects as a default admin set is a fundamental assumption for Hyrax.
-    it 'creates AdminSet, Hyrax::PermissionTemplate, Sipity::Workflow(s), and activates a Workflow', slow: true do
-      described_class.create_default_admin_set(admin_set_id: AdminSet::DEFAULT_ID, title: AdminSet::DEFAULT_TITLE)
-      expect(admin_set.permission_template).to be_persisted
-      expect(admin_set.active_workflow).to be_persisted
-      # 7 responsibilities because:
-      #  * 1 agent (admin group), multiplied by
-      #  * 2 available workflows, multiplied by
-      #  * 3 roles (from Hyrax::RoleRegistry), plus
-      #  * 1 depositing role for the registered group in the default workflow, equals
-      #  * 7
-      expect(Sipity::WorkflowResponsibility.count).to eq 7
-      expect(admin_set.read_groups).not_to include('public')
-      expect(admin_set.edit_groups).to eq ['admin']
-      # 2 access grants because:
-      #  * 1 providing deposit access to registered group
-      #  * 1 providing manage access to admin group
-      expect(admin_set.permission_template.access_grants.count).to eq 2
-      # Agents should be created for both the 'admin' and 'registered' groups
-      expect(Sipity::Agent.distinct.pluck(:proxy_for_id)).to include('admin', 'registered')
-      expect(Sipity::Agent.distinct.pluck(:proxy_for_type)).to include('Hyrax::Group')
-    end
-  end
-
-  describe ".call" do
-    subject { described_class.call(admin_set: admin_set, creating_user: user) }
-
-    let(:admin_set) { AdminSet.new(title: ['test']) }
-
-    context "when using the default admin set", :clean_repo do
-      let(:admin_set) { AdminSet.new(id: AdminSet::DEFAULT_ID) }
-
-      it 'will raise ActiveFedora::IllegalOperation if you attempt to a default admin set' do
-        expect { subject }.to raise_error(RuntimeError)
-      end
-    end
-
-    it "is a convenience method for .new#create" do
-      service = instance_double(described_class)
-      expect(described_class).to receive(:new).and_return(service)
-      expect(service).to receive(:create)
-      subject
-    end
-  end
-
-  describe "an instance" do
-    subject { service }
-
-    let(:workflow_importer) { double(call: true) }
-    let(:admin_set) { AdminSet.new(title: ['test']) }
-    let(:service) { described_class.new(admin_set: admin_set, creating_user: user, workflow_importer: workflow_importer) }
-
-    its(:default_workflow_importer) { is_expected.to respond_to(:call) }
-
-    describe "#create" do
-      subject { service.create }
-
-      context "when the admin_set is valid" do
-        let(:permission_template) { Hyrax::PermissionTemplate.find_by(source_id: admin_set.id) }
-        let(:grants) { permission_template.access_grants }
-        let(:available_workflows) { [create(:workflow), create(:workflow)] }
-
-        # rubocop:disable RSpec/AnyInstance
-        before do
-          allow_any_instance_of(Hyrax::PermissionTemplate).to receive(:available_workflows).and_return(available_workflows)
-          # Load expected Sipity roles, which were likely cleaned by DatabaseCleaner
-          Hyrax.config.persist_registered_roles!
-        end
-        # rubocop:enable RSpec/AnyInstance
-
-        it "creates an AdminSet, PermissionTemplate, Workflows, activates the default workflow, and sets access" do
-          expect(Sipity::Workflow).to receive(:activate!).with(permission_template: kind_of(Hyrax::PermissionTemplate), workflow_name: Hyrax.config.default_active_workflow_name)
-          expect do
-            expect(subject).to be true
-          end.to change { admin_set.persisted? }.from(false).to(true)
-                                                .and change { Sipity::WorkflowResponsibility.count }.by(12)
-          # 12 responsibilities because:
-          #  * 2 agents (user + admin group), multiplied by
-          #  * 2 available workflows, multiplied by
-          #  * 3 roles (from Hyrax::RoleRegistry), equals
-          #  * 12
-          expect(admin_set.edit_users).to match_array([user.user_key])
-          expect(admin_set.edit_groups).to match_array(['admin'])
-          expect(admin_set.read_users).to match_array([])
-          expect(admin_set.read_groups).not_to include('public')
-          expect(admin_set.creator).to eq [user.user_key]
-
-          expect(workflow_importer).to have_received(:call).with(permission_template: permission_template)
-          expect(permission_template).to be_persisted
-          expect(grants.count).to eq 2
-          expect(grants.pluck(:agent_type)).to include('group', 'user')
-          expect(grants.pluck(:agent_id)).to include('admin', user.user_key)
-          expect(grants.pluck(:access)).to include('manage')
-        end
-      end
-
-      context "when the admin_set is invalid" do
-        let(:admin_set) { AdminSet.new } # Missing title
-
-        it { is_expected.to be false }
-        it 'will not call the workflow_importer' do
-          subject
-          expect(workflow_importer).not_to have_received(:call)
-        end
-      end
-    end
-  end
-end