hyrax 2.0.3 → 2.1.0.beta1

data/spec/search_builders/hyrax/dashboard/collections_search_builder_spec.rb

@@ -0,0 +1,92 @@
+RSpec.describe Hyrax::Dashboard::CollectionsSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability,
+           current_user: user)
+  end
+  let(:ability) do
+    ::Ability.new(user)
+  end
+  let(:user) { create(:user, groups: 'registered') }
+  let(:builder) { described_class.new(context) }
+
+  describe '#models' do
+    subject { builder.models }
+
+    it { is_expected.to eq([AdminSet, Collection]) }
+  end
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include :show_only_managed_collections_for_non_admins }
+  end
+
+  describe '#discovery_permissions' do
+    subject { builder.discovery_permissions }
+
+    it { is_expected.to eq %w[edit read] }
+  end
+
+  describe "#show_only_managed_collections_for_non_admins" do
+    subject { builder.show_only_managed_collections_for_non_admins(solr_params) }
+
+    let(:solr_params) { Blacklight::Solr::Request.new }
+
+    it "has filter that excludes depositor" do
+      subject
+      expect(solr_params[:fq]).to eq ["(-_query_:\"{!raw f=depositor_ssim}#{user.user_key}\" OR -(_query_:\"{!raw f=has_model_ssim}AdminSet\" AND _query_:\"{!raw f=creator_ssim}#{user.user_key}\"))"]
+    end
+
+    context "as admin" do
+      let(:user) { create(:user, groups: 'admin') }
+
+      it "does nothing" do
+        subject
+        expect(solr_params[:fq]).to eq []
+      end
+    end
+  end
+
+  describe "#gated_discovery_filters" do
+    subject { builder.gated_discovery_filters }
+
+    let(:collection) { create(:collection) }
+    let(:permission_template) { create(:permission_template, source_id: collection.id) }
+
+    context "user has deposit access" do
+      before do
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'user',
+               agent_id: user.user_key,
+               access: 'deposit')
+      end
+
+      it { is_expected.to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "group has deposit access" do
+      before do
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'group',
+               agent_id: 'registered',
+               access: 'deposit')
+      end
+
+      it { is_expected.to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "does not include public group for read access" do
+      let(:expected_discovery_filters) do
+        [
+          ["({!terms f=edit_access_group_ssim}public,registered)"],
+          ["edit_access_person_ssim:#{user.user_key}", "read_access_person_ssim:#{user.user_key}"]
+        ]
+      end
+
+      it { is_expected.to eq expected_discovery_filters }
+    end
+  end
+end

data/spec/search_builders/hyrax/dashboard/nested_collections_search_builder_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Hyrax::Dashboard::NestedCollectionsSearchBuilder do
+  let(:collection) { double(id: 'Collection_123', collection_type_gid: 'gid/abc') }
+  let(:scope) { double(current_ability: ability, blacklight_config: CatalogController.blacklight_config) }
+  let(:access) { :read }
+  let(:user) { create(:user) }
+  let(:ability) { ::Ability.new(user) }
+  let(:nesting_attributes) { double(parents: ['Parent_1', 'Parent_2'], pathnames: ['Parent_1/Collection_123', 'Parent_2/Collection_123'], ancestors: ['Parent_1', 'Parent_2'], depth: 2) }
+  let(:test_nest_direction) { :as_parent }
+  let(:builder) { described_class.new(scope: scope, access: access, collection: collection, nesting_attributes: nesting_attributes, nest_direction: test_nest_direction) }
+
+  describe '#query' do
+    subject { builder.query }
+
+    it { is_expected.to be_a(Hash) }
+  end
+
+  describe '#default_processor_chain' do
+    subject { builder.default_processor_chain }
+
+    it { is_expected.to include(:with_pagination) }
+    it { is_expected.to include(:show_only_other_collections_of_the_same_collection_type) }
+  end
+
+  describe '#show_only_other_collections_of_the_same_collection_type' do
+    let(:solr_params) { {} }
+
+    subject { builder.show_only_other_collections_of_the_same_collection_type(solr_params) }
+
+    context 'when nesting :as_parent' do
+      let(:test_nest_direction) { :as_parent }
+
+      it 'will exclude the given collection and its parents' do
+        subject
+        expect(solr_params.fetch(:fq)).to contain_exactly(
+          "-{!terms f=id}#{collection.id},#{nesting_attributes.parents.first},#{nesting_attributes.parents.last}",
+          "_query_:\"{!field f=collection_type_gid_ssim}#{collection.collection_type_gid}\"",
+          "-_query_:\"{!lucene df=nesting_collection__pathnames_ssim}*#{collection.id}*\""
+        )
+      end
+    end
+
+    context 'when nesting :as_child' do
+      let(:test_nest_direction) { :as_child }
+
+      it 'will build the search for valid children' do
+        subject
+        # rubocop:disable Metrics/LineLength
+        expect(solr_params.fetch(:fq)).to contain_exactly(
+          "-{!terms f=id}#{collection.id}",
+          "_query_:\"{!field f=collection_type_gid_ssim}#{collection.collection_type_gid}\"",
+          "-_query_:\"{!lucene q.op=OR df=nesting_collection__pathnames_ssim}#{nesting_attributes.pathnames.first} #{nesting_attributes.pathnames.last} #{nesting_attributes.ancestors.first} #{nesting_attributes.ancestors.last}\"",
+          "-_query_:\"{!field f=nesting_collection__parent_ids_ssim}#{collection.id}\""
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+  end
+
+  describe '#gated_discovery_filters' do
+    subject { builder.gated_discovery_filters(access, ability) }
+
+    context 'when access is :deposit' do
+      let(:access) { "deposit" }
+      let!(:collection) { create(:collection, with_permission_template: attributes) }
+
+      context 'and user has access' do
+        let(:attributes) { { deposit_users: [user.user_key] } }
+
+        it { is_expected.to eq ["{!terms f=id}#{collection.id}"] }
+      end
+
+      context 'and group has access' do
+        let(:attributes) { { deposit_groups: ['registered'] } }
+
+        it { is_expected.to eq ["{!terms f=id}#{collection.id}"] }
+      end
+
+      context "and user has no access" do
+        let(:attributes) { true }
+
+        it { is_expected.to eq ["{!terms f=id}"] }
+      end
+    end
+  end
+end

data/spec/search_builders/hyrax/dashboard/works_search_builder_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Hyrax::Dashboard::WorksSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability,
+           current_user: user)
+  end
+  let(:ability) do
+    ::Ability.new(user)
+  end
+  let(:user) { create(:user, groups: 'registered') }
+  let(:builder) { described_class.new(context) }
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include :show_only_managed_works_for_non_admins }
+  end
+
+  describe '#discovery_permissions' do
+    subject { builder.discovery_permissions }
+
+    it { is_expected.to eq %w[edit read] }
+  end
+
+  describe "#show_only_managed_works_for_non_admins" do
+    subject { builder.show_only_managed_works_for_non_admins(solr_params) }
+
+    let(:solr_params) { Blacklight::Solr::Request.new }
+
+    it "has filter that excludes depositor" do
+      subject
+      expect(solr_params[:fq]).to eq ["-_query_:\"{!raw f=depositor_ssim}#{user.user_key}\""]
+    end
+
+    context "as admin" do
+      let(:user) { create(:user, groups: 'admin') }
+
+      it "does nothing" do
+        subject
+        expect(solr_params[:fq]).to eq []
+      end
+    end
+  end
+end

data/spec/search_builders/hyrax/my/collections_search_builder_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::My::CollectionsSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability,
+           current_user: user)
+  end
+  let(:ability) do
+    ::Ability.new(user)
+  end
+  let(:user) { create(:user) }
+  let(:builder) { described_class.new(context) }
+
+  describe '#models' do
+    subject { builder.models }
+
+    it { is_expected.to eq([AdminSet, Collection]) }
+  end
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include :show_only_collections_deposited_by_current_user }
+  end
+
+  describe "#show_only_collections_deposited_by_current_user" do
+    subject { builder.show_only_collections_deposited_by_current_user(solr_params) }
+
+    let(:solr_params) { Blacklight::Solr::Request.new }
+
+    it "has filter that excludes depositor" do
+      subject
+      expect(solr_params[:fq]).to eq ["(_query_:\"{!raw f=depositor_ssim}#{user.user_key}\" OR (_query_:\"{!raw f=has_model_ssim}AdminSet\" AND _query_:\"{!raw f=creator_ssim}#{user.user_key}\"))"]
+    end
+  end
+end

data/spec/search_builders/hyrax/work_search_builder_spec.rb

@@ -44,11 +44,29 @@ RSpec.describe Hyrax::WorkSearchBuilder do
       context "and the current user doesn't have a role" do
         let(:roles) { [] }
 
-        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"]
+        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
@@ -58,11 +76,30 @@ RSpec.describe Hyrax::WorkSearchBuilder do
         expect(Hyrax::Workflow::PermissionQuery).to receive(:scope_permitted_workflow_actions_available_for_current_state)
           .and_raise(PowerConverter::ConversionError.new(double, {}))
       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"]
+
+      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

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

@@ -0,0 +1,191 @@
+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 a not found id ' do
+      let(:id) { 'so-very-missing-no-document-here' }
+
+      it 'raises RuntimeError' do
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    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) { create(:collection, member_of_collections: []) }
+    let!(:nested_with_parent) { create(:collection, 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(: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] },
+       { 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'] },
+       { id: 'i-am-your-grandchild',
+         member_of_collection_ids_ssim: ['parent-3'],
+         ancestors_key => ['parent-1/parent-3'] }]
+    end
+
+    before do
+      ([parent] + children + not_my_children).each do |doc|
+        ActiveFedora::SolrService.add(doc, commit: true)
+      end
+    end
+
+    it 'yields all of the child solr-documents of the given document' do
+      child_index_documents = []
+      described_class.each_child_document_of(document: document) 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
+
+  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 '.write_document_attributes_to_index_layer' do
+    it 'is not implemented and deprecated' do
+      expect do
+        described_class.write_document_attributes_to_index_layer(
+          id: 1, parent_ids: 2, ancestors: 3, pathnames: 4, deepest_nested_depth: 5
+        )
+      end.to raise_error(NotImplementedError)
+    end
+  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