hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/routing/single_use_link_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe 'Routes for single use links', type: :routing do
+  routes { Hyrax::Engine.routes }
+
+  describe 'Single Use Link Viewer' do
+    it 'routes to #show' do
+      expect(show_single_use_link_path('abc123')).to eq '/single_use_link/show/abc123'
+      expect(get("/single_use_link/show/abc123")).to route_to("hyrax/single_use_links_viewer#show", id: 'abc123')
+    end
+
+    it 'routes to #download' do
+      expect(download_single_use_link_path('abc123')).to eq '/single_use_link/download/abc123'
+      expect(get("/single_use_link/download/abc123")).to route_to("hyrax/single_use_links_viewer#download", id: 'abc123')
+    end
+  end
+
+  describe 'Single Use Link Generator' do
+    it 'routes to #create_show' do
+      expect(generate_show_single_use_link_path('abc123')).to eq '/single_use_link/generate_show/abc123'
+      expect(post("/single_use_link/generate_show/abc123")).to route_to("hyrax/single_use_links#create_show", id: 'abc123')
+    end
+
+    it 'routes to #create_download' do
+      expect(generate_download_single_use_link_path('abc123')).to eq '/single_use_link/generate_download/abc123'
+      expect(post("/single_use_link/generate_download/abc123")).to route_to("hyrax/single_use_links#create_download", id: 'abc123')
+    end
+  end
+end

data/spec/routing/stats_route_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe "stats routes", type: :routing do
+  routes { Hyrax::Engine.routes }
+
+  context "for works" do
+    it 'routes to the controller' do
+      expect(get: '/works/7/stats').to route_to(controller: 'hyrax/stats', action: 'work', id: '7')
+    end
+    it 'builds a url' do
+      expect(url_for(controller: 'hyrax/stats', action: 'work', id: '7', only_path: true)).to eql('/works/7/stats')
+    end
+  end
+
+  context "for files" do
+    it 'routes to the controller' do
+      expect(get: '/files/7/stats').to route_to(controller: 'hyrax/stats', action: 'file', id: '7')
+    end
+    it 'builds a url' do
+      expect(url_for(controller: 'hyrax/stats', action: 'file', id: '7', only_path: true)).to eql('/files/7/stats')
+    end
+  end
+end

data/spec/search_builders/hyrax/abstract_type_relation_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe Hyrax::AbstractTypeRelation, :clean_repo do
+  before do
+    stub_const 'AnotherWork', Class.new
+  end
+  it 'returns nil when no allowable types exist' do
+    allow(subject).to receive(:allowable_types).and_return([])
+    expect(subject.search_model_clause).to be_nil
+  end
+  it 'returns GenericWork when allowable types exist' do
+    allow(subject).to receive(:allowable_types).and_return([GenericWork])
+    expect(subject.search_model_clause).to include('GenericWork')
+  end
+  it 'returns both works when allowable types exist' do
+    allow(subject).to receive(:allowable_types).and_return([GenericWork, AnotherWork])
+    expect(subject.search_model_clause).to include('GenericWork')
+    expect(subject.search_model_clause).to include('AnotherWork')
+  end
+end

data/spec/search_builders/hyrax/admin_admin_set_member_search_builder_spec.rb

@@ -0,0 +1,39 @@
+RSpec.describe Hyrax::AdminAdminSetMemberSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:user_groups) { [] }
+  let(:ability) do
+    instance_double(Ability,
+                    admin?: true,
+                    user_groups: user_groups,
+                    current_user: user)
+  end
+  let(:user) { create(:user) }
+  let(:admin_set) { double(id: '123') }
+  let(:builder) { described_class.new(scope: context, collection: admin_set) }
+
+  describe '#filter_models' do
+    before do
+      # This prevents any generated classes from interfering with this test:
+      allow(builder).to receive(:work_classes).and_return([GenericWork])
+      builder.filter_models(solr_params)
+    end
+    let(:solr_params) { { fq: [] } }
+
+    it 'searches for valid work types' do
+      expect(solr_params[:fq].first).to include('{!terms f=has_model_ssim}GenericWork,Collection')
+    end
+    it 'does not limit to active only' do
+      expect(solr_params[:fq].first).not_to include('-suppressed_bsi:true')
+    end
+  end
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include :in_admin_set }
+    it { is_expected.not_to include :only_active_works }
+  end
+end

data/spec/search_builders/hyrax/admin_set_search_builder_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Hyrax::AdminSetSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:ability) do
+    ::Ability.new(user)
+  end
+  let(:user) { create(:user) }
+  let(:builder) { described_class.new(context, access) }
+
+  describe '#filter_models' do
+    before { builder.filter_models(solr_params) }
+    let(:access) { :read }
+    let(:solr_params) { { fq: [] } }
+
+    it 'adds AdminSet to query' do
+      expect(solr_params[:fq].first).to include('{!terms f=has_model_ssim}AdminSet')
+    end
+  end
+
+  describe "#gated_discovery_filters" do
+    subject { builder.gated_discovery_filters }
+
+    context "when access is :deposit" do
+      let(:access) { :deposit }
+
+      context "and user has access" do
+        before do
+          allow(Hyrax::Collections::PermissionsService).to receive(:source_ids_for_deposit).and_return([7, 8])
+        end
+
+        it { is_expected.to eq ["{!terms f=id}7,8"] }
+      end
+
+      context "and user has no access" do
+        it { is_expected.to eq ["{!terms f=id}"] }
+      end
+    end
+  end
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include(:filter_models, :add_access_controls_to_solr_params) }
+  end
+
+  describe "#to_h" do
+    subject { builder.to_h }
+
+    context "when searching for read access" do
+      before do
+        # we just want to look at the user part of the access filters
+        allow(ability).to receive(:user_groups).and_return([])
+      end
+      let(:access) { :read }
+
+      it 'is successful' do
+        expect(subject['fq']).to eq ["edit_access_person_ssim:#{user.user_key} OR " \
+                                       "discover_access_person_ssim:#{user.user_key} OR " \
+                                       "read_access_person_ssim:#{user.user_key}",
+                                     "{!terms f=has_model_ssim}AdminSet"]
+      end
+    end
+
+    context "when searching for deposit access" do
+      let(:access) { :deposit }
+
+      before do
+        allow(Hyrax::Collections::PermissionsService).to receive(:source_ids_for_deposit).and_return([7, 8])
+      end
+
+      it 'is successful' do
+        expect(subject['fq']).to eq ["{!terms f=id}7,8", "{!terms f=has_model_ssim}AdminSet"]
+      end
+    end
+  end
+end

data/spec/search_builders/hyrax/catalog_search_builder_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe Hyrax::CatalogSearchBuilder do
+  let(:context) { double }
+  let(:builder) { described_class.new(context).with(blacklight_params) }
+  let(:solr_params) { Blacklight::Solr::Request.new }
+  let(:blacklight_params) { { q: user_query, search_field: 'all_fields' } }
+  let(:user_query) { "find me" }
+
+  describe "#show_works_or_works_that_contain_files" do
+    subject { builder.show_works_or_works_that_contain_files(solr_params) }
+
+    context "with a user query" do
+      it "creates a valid solr join for works and files" do
+        subject
+        expect(solr_params[:user_query]).to eq user_query
+        expect(solr_params[:q]).to eq "{!lucene}_query_:\"{!dismax v=$user_query}\" _query_:\"{!join from=id to=file_set_ids_ssim}{!dismax v=$user_query}\""
+      end
+    end
+
+    context "without a user query" do
+      let(:blacklight_params) { {} }
+
+      it "does not modify the query" do
+        subject
+        expect(solr_params[:user_query]).to be_nil
+        expect(solr_params[:q]).to be_nil
+      end
+    end
+
+    context "when doing a fielded search" do
+      let(:blacklight_params) { { q: user_query, search_field: 'depositor' } }
+      # Blacklight sets up these values when we've done a fielded search.
+      # Here we're ensuring they aren't wiped out
+      let(:solr_params) { Blacklight::Solr::Request.new("q" => "{!qf=depositor_ssim pf=depositor_ssim}\"#{user_query}\"") }
+
+      it "does not modify the query" do
+        subject
+        expect(solr_params[:user_query]).to be_nil
+        expect(solr_params[:q]).to eq '{!qf=depositor_ssim pf=depositor_ssim}"find me"'
+      end
+    end
+  end
+
+  describe "#show_only_active_records" do
+    subject { builder.show_only_active_records(solr_params) }
+
+    it "includes suppressed switch" do
+      subject
+      expect(solr_params[:fq]).to eq ["-suppressed_bsi:true"]
+    end
+  end
+
+  describe "#filter_collection_facet_for_access" do
+    let(:user) { build(:user) }
+    let(:ability) { Ability.new(user) }
+    let(:context) { double(current_ability: ability) }
+
+    subject { builder.filter_collection_facet_for_access(solr_params) }
+
+    context 'with an admin' do
+      let(:user) { build(:admin) }
+
+      it "does nothing if user is an admin" do
+        subject
+        expect(solr_params['f.member_of_collection_ids_ssim.facet.matches']).to be_blank
+      end
+    end
+
+    context 'when the user has view access to collections' do
+      let(:collection_ids) { ['abcd12345', 'efgh67890'] }
+
+      before do
+        allow(Hyrax::Collections::PermissionsService).to receive(:collection_ids_for_view).with(ability: ability).and_return(collection_ids)
+      end
+
+      it "includes a regex of the ids of collections" do
+        subject
+        expect(solr_params['f.member_of_collection_ids_ssim.facet.matches']).to eq '^abcd12345$|^efgh67890$'
+      end
+    end
+
+    it "includes an empty regex when user doesn't have access to view any collections" do
+      subject
+      expect(solr_params['f.member_of_collection_ids_ssim.facet.matches']).to eq '^$'
+    end
+  end
+end

data/spec/search_builders/hyrax/collection_member_search_builder_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe Hyrax::CollectionMemberSearchBuilder do
+  let(:context) { double("context", blacklight_config: CatalogController.blacklight_config) }
+  let(:solr_params) { { fq: [] } }
+  let(:include_models) { :both }
+  let(:collection) { build(:collection, id: '12345') }
+  let(:builder) { described_class.new(scope: context, collection: collection, search_includes_models: include_models) }
+
+  describe ".default_processor_chain" do
+    subject { builder.default_processor_chain }
+
+    it { is_expected.to include :member_of_collection }
+  end
+
+  describe '#member_of_collection' do
+    let(:subject) { builder.member_of_collection(solr_params) }
+
+    it 'updates solr_parameters[:fq]' do
+      subject
+      expect(solr_params[:fq]).to include("#{builder.collection_membership_field}:#{collection.id}")
+    end
+  end
+
+  describe '#models' do
+    let(:work_classes) { [GenericWork] }
+    let(:collection_classes) { [Collection] }
+    let(:subject) { builder.models }
+
+    context 'when search_include_models: :works' do
+      let(:include_models) { :works }
+
+      it 'returns only work members' do
+        expect(subject).to eq(Hyrax.config.curation_concerns)
+      end
+    end
+
+    context 'when search_include_models: :collections' do
+      let(:include_models) { :collections }
+
+      it 'returns only collection members' do
+        expect(subject).to eq(collection_classes)
+      end
+    end
+
+    context 'when search_include_models anything else' do
+      let(:search_includes_models) { "anything" }
+
+      it 'returns both work and collection members' do
+        expect(subject).to include(*work_classes)
+        expect(subject).to include(*collection_classes)
+      end
+    end
+  end
+end

data/spec/search_builders/hyrax/collection_search_builder_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe Hyrax::CollectionSearchBuilder do
+  let(:scope) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:user) { create(:user) }
+  let(:ability) { ::Ability.new(user) }
+  let(:builder) { described_class.new(scope).with_access(access) }
+
+  describe '#sort_field' do
+    let(:access) { :read }
+
+    subject { builder.sort_field }
+
+    it { is_expected.to eq('title_si') }
+  end
+
+  describe '#models' do
+    let(:access) { :read }
+
+    subject { builder.models }
+
+    it { is_expected.to eq([Collection]) }
+  end
+
+  describe '#discovery_permissions' do
+    subject { builder.discovery_permissions }
+
+    context 'when access is read' do
+      let(:access) { :read }
+
+      it { is_expected.to eq %w[edit read] }
+    end
+
+    context 'when access is edit' do
+      let(:access) { :edit }
+
+      it { is_expected.to eq %w[edit] }
+    end
+
+    context 'when access is deposit' do
+      let(:access) { :deposit }
+
+      it { is_expected.to eq %w[deposit] }
+    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/collections_search_builder_spec.rb

@@ -0,0 +1,103 @@
+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) { build(: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
+    let(:user2) { build(:user) }
+    let!(:collection) { build(:collection_lw, user: user2, with_permission_template: permissions, with_solr_document: true) }
+
+    subject { builder.gated_discovery_filters }
+
+    context "user has manage access" do
+      let(:permissions) { { manage_users: [user] } }
+
+      it { is_expected.to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "user has deposit access" do
+      let(:permissions) { { deposit_users: [user] } }
+
+      it { is_expected.to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "user has view access" do
+      let(:permissions) { { view_users: [user] } }
+
+      it { is_expected.not_to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "does not include registered group for read access" do
+      let(:permissions) { { view_groups: ['registered'] } }
+
+      it { is_expected.not_to include ["{!terms f=id}#{collection.id}"] }
+    end
+
+    context "does not include public group for read access" do
+      let(:permissions) { { view_groups: ['public'] } }
+
+      let(:expected_discovery_filters) do
+        # all filters except no additional ids added for deposit collections
+        [
+          ["({!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
+
+    context "user has deposit access and registered has deposit access" do
+      # make sure that having registered deposit access, which isn't included, doesn't
+      # remove the user specific deposit access
+      let(:permissions) { { deposit_users: [user], view_groups: ['registered'] } }
+
+      it { is_expected.to include ["{!terms f=id}#{collection.id}"] }
+    end
+  end
+end