test_hyrax 0.0.1.alpha

data/spec/search_builder/hyrax/catalog_search_builder_spec.rb

@@ -0,0 +1,48 @@
+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 } }
+  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
+end

data/spec/search_builder/hyrax/embargo_search_builder_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Hyrax::EmbargoSearchBuilder do
+  let(:context) { double }
+  let(:search_builder) { described_class.new(context) }
+
+  describe "#processor_chain" do
+    subject { search_builder.processor_chain }
+    it { is_expected.to eq [:with_pagination, :with_sorting, :only_active_embargoes] }
+  end
+
+  describe "#with_sorting" do
+    subject { {} }
+    before { search_builder.with_sorting(subject) }
+    it { is_expected.to eq(sort: 'embargo_release_date_dtsi desc') }
+  end
+end

data/spec/search_builder/hyrax/file_set_search_builder_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Hyrax::FileSetSearchBuilder do
+  let(:processor_chain) { [:filter_models] }
+  let(:ability) { double('ability') }
+  let(:context) { double('context') }
+  let(:user) { double('user') }
+  let(:solr_params) { { fq: [] } }
+
+  subject { described_class.new(context) }
+  describe '#filter_models' do
+    before { subject.filter_models(solr_params) }
+
+    it 'adds FileSet to query' do
+      expect(solr_params[:fq].first).to include('{!terms f=has_model_ssim}FileSet')
+    end
+  end
+
+  describe '#find_one' do
+    before do
+      allow(subject).to receive(:blacklight_params).and_return(id: '12345')
+      subject.find_one(solr_params)
+    end
+
+    it 'adds id to query' do
+      expect(solr_params[:fq].first).to include('{!raw f=id}12345')
+    end
+  end
+end

data/spec/search_builder/hyrax/find_works_search_builder_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Hyrax::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/hyrax/lease_search_builder_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Hyrax::LeaseSearchBuilder do
+  let(:context) { double }
+  let(:search_builder) { described_class.new(context) }
+
+  describe "#processor_chain" do
+    subject { search_builder.processor_chain }
+    it { is_expected.to eq [:with_pagination, :with_sorting, :only_active_leases] }
+  end
+
+  describe "#with_sorting" do
+    subject { {} }
+    before { search_builder.with_sorting(subject) }
+    it { is_expected.to eq(sort: 'lease_expiration_date_dtsi desc') }
+  end
+end

data/spec/search_builder/hyrax/my_shares_search_builder_spec.rb

@@ -0,0 +1,34 @@
+describe Hyrax::MySharesSearchBuilder do
+  let(:me) { create(:user) }
+  let(:config) { CatalogController.blacklight_config }
+  let(:scope) do
+    double('The scope',
+           blacklight_config: config,
+           params: {},
+           current_ability: Ability.new(me),
+           current_user: me)
+  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"])
+
+    # This prevents any generated classes from interfering with this test:
+    allow(builder).to receive(:work_classes).and_return([GenericWork])
+
+    allow(ActiveFedora::SolrQueryBuilder).to receive(:construct_query_for_rel)
+      .with(depositor: me.user_key)
+      .and_return("depositor")
+  end
+
+  subject { builder.to_hash['fq'] }
+
+  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",
+                           "-suppressed_bsi:true",
+                           "-depositor"]
+  end
+end

data/spec/search_builder/hyrax/single_admin_set_search_builder_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::SingleAdminSetSearchBuilder do
+  let(:ability) { instance_double(Ability, admin?: true) }
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:builder) { described_class.new(context) }
+  describe "#query" do
+    before do
+      expect(builder).to receive(:find_one)
+    end
+    subject { builder.with(id: '123').query.fetch('fq') }
+    it do
+      is_expected.to match_array ["",
+                                  "{!terms f=has_model_ssim}AdminSet"]
+    end
+  end
+end

data/spec/search_builder/hyrax/work_relation_spec.rb

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

data/spec/search_builder/hyrax/work_search_builder_spec.rb

@@ -0,0 +1,65 @@
+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) { [] }
+        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
+    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
+      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
+  end
+end

data/spec/services/hyrax/actor_factory_spec.rb

@@ -0,0 +1,49 @@
+describe Hyrax::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 [Hyrax::CreateWithRemoteFilesActor,
+                         Hyrax::CreateWithFilesActor,
+                         Hyrax::Actors::AddAsMemberOfCollectionsActor,
+                         Hyrax::Actors::AddToWorkActor,
+                         Hyrax::Actors::AssignRepresentativeActor,
+                         Hyrax::Actors::AttachFilesActor,
+                         Hyrax::Actors::ApplyOrderActor,
+                         Hyrax::Actors::InterpretVisibilityActor,
+                         Hyrax::DefaultAdminSetActor,
+                         Hyrax::ApplyPermissionTemplateActor,
+                         Hyrax::Actors::GenericWorkActor,
+                         Hyrax::Actors::InitializeWorkflowActor]
+    end
+  end
+
+  describe '.build' do
+    subject { described_class.build(work, user) }
+    it "has the correct stack frames" do
+      expect(subject.more_actors).to eq [
+        Hyrax::CreateWithFilesActor,
+        Hyrax::Actors::AddAsMemberOfCollectionsActor,
+        Hyrax::Actors::AddToWorkActor,
+        Hyrax::Actors::AssignRepresentativeActor,
+        Hyrax::Actors::AttachFilesActor,
+        Hyrax::Actors::ApplyOrderActor,
+        Hyrax::Actors::InterpretVisibilityActor,
+        Hyrax::DefaultAdminSetActor,
+        Hyrax::ApplyPermissionTemplateActor,
+        Hyrax::Actors::GenericWorkActor,
+        Hyrax::Actors::InitializeWorkflowActor
+      ]
+      expect(subject.first_actor_class).to eq Hyrax::CreateWithRemoteFilesActor
+    end
+  end
+
+  describe 'Hyrax::CurationConcern.actor' do
+    it "calls the Hyrax::ActorFactory" do
+      expect(described_class).to receive(:build)
+      Hyrax::CurationConcern.actor(work, user)
+    end
+  end
+end

data/spec/services/hyrax/admin_set_create_service_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::AdminSetCreateService do
+  let(:admin_set) { AdminSet.new(title: ['test']) }
+  let(:service) { described_class.new(admin_set, user) }
+  let(:user) { create(:user) }
+
+  describe ".call" do
+    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)
+      described_class.call(admin_set, user)
+    end
+  end
+
+  describe "#create" do
+    subject { service.create }
+
+    context "when the admin_set is valid" do
+      let(:permission_template) { Hyrax::PermissionTemplate.find_by(admin_set_id: admin_set.id) }
+      let(:grant) { permission_template.access_grants.first }
+      it "is creates an AdminSet, PermissionTemplate and sets access" 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(grant.agent_id).to eq user.user_key
+        expect(grant.access).to eq 'manage'
+        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/hyrax/admin_set_service_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::AdminSetService 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 "#search_results" do
+    subject { service.search_results(access) }
+    let!(:as1) { create(:admin_set, :public, title: ['foo']) }
+    let!(:as2) { create(:admin_set, :public, title: ['bar']) }
+    let!(:as3) { create(:admin_set, edit_users: [user.user_key], title: ['baz']) }
+    before do
+      create(:collection, :public) # this should never be returned.
+    end
+
+    context "with read access" do
+      let(:access) { :read }
+      it "returns three admin sets" do
+        expect(subject.map(&:id)).to match_array [as1.id, as2.id, as3.id]
+      end
+    end
+
+    context "with edit access" do
+      let(:access) { :edit }
+      it "returns one admin set" do
+        expect(subject.map(&:id)).to match_array [as3.id]
+      end
+    end
+  end
+
+  context "with injection" do
+    let(:service) { described_class.new(context, search_builder) }
+    subject { service.search_results(access) }
+    let(:access) { :edit }
+    let(:search_builder) { double(new: search_builder_instance) }
+    let(:search_builder_instance) { double }
+
+    it "calls the injected search builder" do
+      expect(search_builder_instance).to receive(:reverse_merge).and_return({})
+      subject
+    end
+  end
+
+  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 integer count value in the second column" do
+      expect(subject).to eq [[doc1, 8], [doc2, 2], [doc3, 0]]
+    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: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED, release_date: today + 2.days) }
+      let!(:permission_template2) { create(:permission_template, admin_set_id: '345', release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY) }
+      let!(:permission_template3) { create(:permission_template, admin_set_id: '567', release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR) }
+      let!(:permission_template4) { create(:permission_template, admin_set_id: '789', release_period: Hyrax::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 "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: solr_doc1.id) }
+
+      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: 'foo') }
+      before do
+        allow(service).to receive(:search_results).with(:read).and_return([solr_doc1])
+      end
+      it 'will an raise exception' do
+        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end