sufia 7.2.0 → 7.3.0.rc1

data/spec/presenters/sufia/select_type_list_presenter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+# Note: test app generates multiple work types (concerns) now
+describe Sufia::SelectTypeListPresenter do
+  let(:instance) { described_class.new(user) }
+  let(:user) { nil }
+
+  describe "#many?" do
+    subject { instance.many? }
+
+    context 'without a logged in user' do
+      it { is_expected.to be false }
+    end
+
+    context 'with a logged in user' do
+      let(:user) { create(:user) }
+      it { is_expected.to be true }
+      context "if authorized_models returns only one" do
+        before do
+          allow(instance).to receive(:authorized_models).and_return([double])
+        end
+        it { is_expected.to be false }
+      end
+    end
+  end
+end

data/spec/presenters/sufia/select_type_presenter_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe Sufia::SelectTypePresenter do
+  let(:instance) { described_class.new(model) }
+  let(:model) { GenericWork }
+
+  describe "#icon_class" do
+    subject { instance.icon_class }
+    it { is_expected.to eq 'fa fa-file-text-o' }
+  end
+
+  describe "#description" do
+    subject { instance.description }
+    it { is_expected.to eq 'Generic work works' }
+  end
+
+  describe "#name" do
+    subject { instance.name }
+    it { is_expected.to eq 'Generic Work' }
+  end
+end

data/spec/search_builder/sufia/admin_set_search_builder_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Sufia::AdminSetSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:ability) do
+    instance_double(Ability,
+                    admin?: false,
+                    user_groups: [],
+                    current_user: user)
+  end
+  let(:user) { create(:user) }
+  let(:builder) { described_class.new(context, access) }
+  subject { builder.to_h }
+
+  context "when searching for read access" do
+    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",
+                                   "-suppressed_bsi:true"]
+    end
+  end
+
+  context "when searching for deposit access" do
+    let(:access) { :deposit }
+    let(:permission_template1) { create(:permission_template, admin_set_id: 7) }
+    let(:permission_template2) { create(:permission_template, admin_set_id: 8) }
+    let(:permission_template3) { create(:permission_template, admin_set_id: 9) }
+
+    before do
+      create(:permission_template_access,
+             permission_template: permission_template1,
+             agent_type: 'user',
+             agent_id: user.user_key,
+             access: 'deposit')
+      create(:permission_template_access,
+             permission_template: permission_template2,
+             agent_type: 'user',
+             agent_id: user.user_key,
+             access: 'manage')
+      create(:permission_template_access,
+             permission_template: permission_template3,
+             agent_type: 'user',
+             agent_id: user.user_key,
+             access: 'view')
+    end
+
+    it 'is successful' do
+      expect(subject['fq']).to eq ["{!terms f=id}7,8",
+                                   "{!terms f=has_model_ssim}AdminSet",
+                                   "-suppressed_bsi:true"]
+    end
+  end
+end

data/spec/search_builder/sufia/catalog_search_builder_spec.rb

@@ -1,22 +1,48 @@
 describe Sufia::CatalogSearchBuilder do
-  let(:builder) { described_class.new([], self) }
-  let(:solr_params) { { q: user_query } }
+  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 } }
+  let(:user_query) { "find me" }
 
-  context "with a user query" do
-    let(:user_query) { "find me" }
-    it "creates a valid solr join for works and files" do
-      builder.show_works_or_works_that_contain_files(solr_params)
-      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}\""
+  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
 
-  context "with out a user query" do
-    let(:user_query) { nil }
-    it "does not modify the query" do
-      builder.show_works_or_works_that_contain_files(solr_params)
-      expect(solr_params[:user_query]).to be_nil
-      expect(solr_params[:q]).to be_nil
+  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
 end

data/spec/search_builder/sufia/find_works_search_builder_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Sufia::FindWorksSearchBuilder do
+  let(:controller) { Qa::TermsController.new }
+  let(:user) { create(:user) }
+  let(:ability) { instance_double(Ability, admin?: false, user_groups: [], current_user: user) }
+  let(:q) { "foo" }
+  let(:params) { ActionController::Parameters.new(q: q, id: work.id, user: user.email, controller: "qa/terms", action: "search", vocab: "find_works") }
+
+  let(:context) do
+    double(current_ability: ability,
+           current_user: user,
+           params: params)
+  end
+  let!(:work) { create(:generic_work, :public, title: ['foo'], user: user) }
+
+  let(:builder) { described_class.new(context) }
+  let(:solr_params) { Blacklight::Solr::Request.new }
+
+  describe "#filter_on_title" do
+    subject { builder.filter_on_title(solr_params) }
+    it "is successful" do
+      subject
+      expect(solr_params[:fq]).to eq [ActiveFedora::SolrQueryBuilder.construct_query(title_tesim: q)]
+    end
+  end
+
+  describe "#show_only_other_works" do
+    subject { builder.show_only_other_works(solr_params) }
+    it "is successful" do
+      subject
+      expect(solr_params[:fq]).to eq ["-" + ActiveFedora::SolrQueryBuilder.construct_query_for_ids([work.id])]
+    end
+  end
+
+  describe "#show_only_works_not_child" do
+    subject { builder.show_only_works_not_child(solr_params) }
+    it "is successful" do
+      subject
+      ids = ActiveFedora::SolrService.query("{!field f=id}#{work.id}", fl: "member_ids_ssim").flat_map { |x| x.fetch("member_ids_ssim", []) }
+      expect(solr_params[:fq]).to eq ["-" + ActiveFedora::SolrQueryBuilder.construct_query_for_ids([ids])]
+    end
+  end
+
+  describe "#show_only_works_not_parent" do
+    subject { builder.show_only_works_not_parent(solr_params) }
+    it "is successful" do
+      subject
+      expect(solr_params[:fq]).to eq ["-" + ActiveFedora::SolrQueryBuilder.construct_query(member_ids_ssim: work.id)]
+    end
+  end
+
+  describe "#only_works?" do
+    subject { builder.only_works? }
+    it "is successful" do
+      subject
+      expect(subject). to eq true
+    end
+  end
+end

data/spec/search_builder/sufia/my_shares_search_builder_spec.rb

@@ -10,6 +10,8 @@ describe Sufia::MySharesSearchBuilder do
   end
   let(:builder) { described_class.new(scope) }
 
+  let(:solr_params) { { q: user_query } }
+
   before do
     allow(builder).to receive(:gated_discovery_filters).and_return(["access_filter1", "access_filter2"])
     allow(ActiveFedora::SolrQueryBuilder).to receive(:construct_query_for_rel)
@@ -21,7 +23,8 @@ describe Sufia::MySharesSearchBuilder do
 
   it "filters things we have access to in which we are not the depositor" do
     expect(subject).to eq ["access_filter1 OR access_filter2",
-                           "{!terms f=has_model_ssim}GenericWork,Collection",
+                           "{!terms f=has_model_ssim}GenericWork,Atlas,Collection",
+                           "-suppressed_bsi:true",
                            "-depositor"]
   end
 end

data/spec/search_builder/sufia/single_admin_set_search_builder_spec.rb

@@ -12,6 +12,10 @@ RSpec.describe Sufia::SingleAdminSetSearchBuilder do
       expect(builder).to receive(:find_one)
     end
     subject { builder.with(id: '123').query.fetch('fq') }
-    it { is_expected.to match_array ["", "{!terms f=has_model_ssim}AdminSet"] }
+    it do
+      is_expected.to match_array ["",
+                                  "-suppressed_bsi:true",
+                                  "{!terms f=has_model_ssim}AdminSet"]
+    end
   end
 end

data/spec/services/sufia/actor_factory_spec.rb

@@ -1,18 +1,22 @@
-describe Sufia::ActorFactory do
+describe Sufia::ActorFactory, :no_clean do
   let(:work) { GenericWork.new }
   let(:user) { double }
 
   describe '.stack_actors' do
     subject { described_class.stack_actors(work) }
     it do
-      is_expected.to eq [Sufia::CreateWithRemoteFilesActor,
+      is_expected.to eq [CurationConcerns::OptimisticLockValidator,
+                         Sufia::CreateWithRemoteFilesActor,
                          Sufia::CreateWithFilesActor,
                          CurationConcerns::Actors::AddToCollectionActor,
                          CurationConcerns::Actors::AddToWorkActor,
                          CurationConcerns::Actors::AssignRepresentativeActor,
                          CurationConcerns::Actors::AttachFilesActor,
                          CurationConcerns::Actors::ApplyOrderActor,
-                         CurationConcerns::Actors::InterpretVisibilityActor,
+                         Sufia::InterpretVisibilityActor,
+                         Sufia::DefaultAdminSetActor,
+                         CurationConcerns::Actors::InitializeWorkflowActor,
+                         Sufia::ApplyPermissionTemplateActor,
                          CurationConcerns::Actors::GenericWorkActor]
     end
   end
@@ -21,16 +25,20 @@ describe Sufia::ActorFactory do
     subject { described_class.build(work, user) }
     it "has the correct stack frames" do
       expect(subject.more_actors).to eq [
+        Sufia::CreateWithRemoteFilesActor,
         Sufia::CreateWithFilesActor,
         CurationConcerns::Actors::AddToCollectionActor,
         CurationConcerns::Actors::AddToWorkActor,
         CurationConcerns::Actors::AssignRepresentativeActor,
         CurationConcerns::Actors::AttachFilesActor,
         CurationConcerns::Actors::ApplyOrderActor,
-        CurationConcerns::Actors::InterpretVisibilityActor,
+        Sufia::InterpretVisibilityActor,
+        Sufia::DefaultAdminSetActor,
+        CurationConcerns::Actors::InitializeWorkflowActor,
+        Sufia::ApplyPermissionTemplateActor,
         CurationConcerns::Actors::GenericWorkActor
       ]
-      expect(subject.first_actor_class).to eq Sufia::CreateWithRemoteFilesActor
+      expect(subject.first_actor_class).to eq CurationConcerns::OptimisticLockValidator
     end
   end
 

data/spec/services/sufia/admin_set_create_service_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe Sufia::AdminSetCreateService do
+  let(:admin_set) { AdminSet.new(title: ['test']) }
+  let(:service) { described_class.new(admin_set, user) }
+  let(:user) { create(:user) }
+
+  describe "#create" do
+    subject { service.create }
+
+    context "when the admin_set is valid" do
+      it "is successful" do
+        expect do
+          expect(subject).to be true
+        end.to change { admin_set.persisted? }.from(false).to(true)
+        expect(admin_set.read_groups).to eq ['public']
+        expect(admin_set.edit_groups).to eq ['admin']
+        expect(admin_set.creator).to eq [user.user_key]
+      end
+    end
+
+    context "when the admin_set is invalid" do
+      let(:admin_set) { AdminSet.new } # Missing title
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/services/sufia/admin_set_service_spec.rb

@@ -1,27 +1,114 @@
 require 'spec_helper'
 
-RSpec.describe Sufia::AdminSetService do
-  let(:admin_set) { AdminSet.new(title: ['test']) }
-  let(:service) { described_class.new(admin_set, user) }
+RSpec.describe Sufia::AdminSetService, :no_clean do
+  let(:controller) { ::CatalogController.new }
+  let(:context) do
+    double(current_ability: Ability.new(user),
+           repository: controller.repository,
+           blacklight_config: controller.blacklight_config)
+  end
+  let(:service) { described_class.new(context) }
   let(:user) { create(:user) }
 
-  describe "#create" do
-    subject { service.create }
-
-    context "when the admin_set is valid" do
-      it "is successful" do
-        expect do
-          expect(subject).to be true
-        end.to change { admin_set.persisted? }.from(false).to(true)
-        expect(admin_set.read_groups).to eq ['public']
-        expect(admin_set.edit_groups).to eq ['admin']
-        expect(admin_set.creator).to eq [user.user_key]
+  describe '#search_results_with_work_count' do
+    let(:access) { :read }
+    subject { service.search_results_with_work_count(access) }
+    let(:documents) { [doc1, doc2, doc3] }
+    let(:doc1) { SolrDocument.new(id: 'xyz123') }
+    let(:doc2) { SolrDocument.new(id: 'yyx123') }
+    let(:doc3) { SolrDocument.new(id: 'zxy123') }
+    let(:connection) { instance_double(RSolr::Client) }
+    let(:results) do
+      { 'facet_counts' =>
+        {
+          'facet_fields' =>
+            {
+              'isPartOf_ssim' => [doc1.id, 8, doc2.id, 2]
+            }
+        } }
+    end
+
+    before do
+      allow(service).to receive(:search_results).and_return(documents)
+      allow(ActiveFedora::SolrService.instance).to receive(:conn).and_return(connection)
+      allow(connection).to receive(:get).with("select", params: { fq: "{!terms f=isPartOf_ssim}xyz123,yyx123,zxy123",
+                                                                  "facet.field" => "isPartOf_ssim" }).and_return(results)
+    end
+
+    it "returns rows with document in the first column and count in the second column" do
+      expect(subject).to eq [[doc1, 8], [doc2, 2], [doc3, nil]]
+    end
+  end
+
+  describe "#select_options" do
+    subject { service.select_options }
+
+    context "with permission_template visibility" do
+      let(:solr_doc1) { instance_double(SolrDocument, id: '123', to_s: 'Public Set') }
+      let(:solr_doc2) { instance_double(SolrDocument, id: '345', to_s: 'Private Set') }
+      let!(:permission_template1) { create(:permission_template, admin_set_id: '123', visibility: 'open') }
+      let!(:permission_template2) { create(:permission_template, admin_set_id: '345', visibility: 'restricted') }
+
+      before do
+        allow(service).to receive(:search_results)
+          .with(:read)
+          .and_return([solr_doc1, solr_doc2])
+      end
+
+      it do
+        is_expected.to eq [['Public Set', '123', { 'data-visibility' => 'open' }],
+                           ['Private Set', '345', { 'data-visibility' => 'restricted' }]]
+      end
+    end
+
+    context "with permission_template release_date" do
+      let(:today) { Time.zone.today }
+      let(:solr_doc1) { instance_double(SolrDocument, id: '123', to_s: 'Fixed Release Date Set') }
+      let(:solr_doc2) { instance_double(SolrDocument, id: '345', to_s: 'No Delay Set') }
+      let(:solr_doc3) { instance_double(SolrDocument, id: '567', to_s: 'One Year Max Embargo Set') }
+      let(:solr_doc4) { instance_double(SolrDocument, id: '789', to_s: 'Release Before Date Set') }
+      let!(:permission_template1) { create(:permission_template, admin_set_id: '123', release_period: Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED, release_date: today + 2.days) }
+      let!(:permission_template2) { create(:permission_template, admin_set_id: '345', release_period: Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY) }
+      let!(:permission_template3) { create(:permission_template, admin_set_id: '567', release_period: Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR) }
+      let!(:permission_template4) { create(:permission_template, admin_set_id: '789', release_period: Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE, release_date: today + 1.month) }
+
+      before do
+        allow(service).to receive(:search_results)
+          .with(:read)
+          .and_return([solr_doc1, solr_doc2, solr_doc3, solr_doc4])
+      end
+
+      it do
+        is_expected.to eq [['Fixed Release Date Set', '123', { 'data-release-date' => today + 2.days }],
+                           ['No Delay Set', '345', { 'data-release-date' => today }],
+                           ['One Year Max Embargo Set', '567', { 'data-release-date' => today + 1.year, 'data-release-before-date' => true }],
+                           ['Release Before Date Set', '789', { 'data-release-date' => today + 1.month, 'data-release-before-date' => true }]]
       end
     end
 
-    context "when the admin_set is invalid" do
-      let(:admin_set) { AdminSet.new } # Missing title
-      it { is_expected.to be false }
+    context "with empty permission_template" do
+      let(:solr_doc1) { instance_double(SolrDocument, id: '123', to_s: 'Empty Template Set') }
+      let!(:permission_template1) { create(:permission_template, admin_set_id: '567') }
+
+      before do
+        allow(service).to receive(:search_results)
+          .with(:read)
+          .and_return([solr_doc1])
+      end
+
+      it { is_expected.to eq [['Empty Template Set', '123', {}]] }
+    end
+
+    context "with no permission_template" do
+      let(:solr_doc1) { instance_double(SolrDocument, id: '123', to_s: 'No Template Set') }
+
+      before do
+        allow(service).to receive(:search_results)
+          .with(:read)
+          .and_return([solr_doc1])
+      end
+
+      it { is_expected.to eq [['No Template Set', '123', {}]] }
     end
   end
 end