hyrax 2.9.6 → 3.0.0.pre.beta1

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

@@ -0,0 +1,52 @@
+RSpec.describe Hyrax::My::WorksSearchBuilder 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) }
+
+  describe "#to_hash" do
+    before do
+      # 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 works that we are the depositor of" do
+      expect(subject).to eq ["{!terms f=has_model_ssim}GenericWork",
+                             "depositor"]
+    end
+  end
+
+  describe ".default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    let(:expected_filters) do
+      [
+        :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,
+        :filter_models,
+        :show_only_resources_deposited_by_current_user
+      ]
+    end
+
+    it { is_expected.to eq expected_filters }
+  end
+end

data/spec/search_builders/hyrax/parent_collection_search_builder_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Hyrax::ParentCollectionSearchBuilder do
+  let(:solr_params) { { fq: [] } }
+  let(:item) { double(id: '12345', member_of_collection_ids: ['col1']) }
+  let(:builder) { described_class.new(solr_params, context) }
+  let(:context) { double("context", blacklight_config: CatalogController.blacklight_config, item: item) }
+
+  describe '#include_item_ids' do
+    let(:subject) { builder.include_item_ids(solr_params) }
+
+    it 'updates solr_parameters[:fq]' do
+      subject
+      expect(solr_params[:fq]).to include("{!terms f=id}col1")
+    end
+  end
+end

data/spec/search_builders/hyrax/single_admin_set_search_builder_spec.rb

@@ -0,0 +1,20 @@
+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_builders/hyrax/stats/work_status_search_builder_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Hyrax::Stats::WorkStatusSearchBuilder do
+  let(:context) do
+    double(blacklight_config: CatalogController.blacklight_config,
+           current_ability: ability)
+  end
+  let(:ability) do
+    instance_double(Ability, admin?: true)
+  end
+  let(:instance) { described_class.new(context) }
+
+  describe "#query" do
+    subject { instance.query }
+
+    it "sets required parameters" do
+      expect(subject['facet.field']).to eq ["suppressed_bsi"]
+      expect(subject['facet.missing']).to eq true
+      expect(subject['rows']).to eq 0
+    end
+  end
+
+  describe "#only_works?" do
+    subject { instance.send(:only_works?) }
+
+    it { is_expected.to be true }
+  end
+
+  describe "::default_processor_chain" do
+    subject { described_class.default_processor_chain }
+
+    it { is_expected.to include(:filter_models) }
+  end
+end

data/spec/search_builders/hyrax/work_relation_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Hyrax::WorkRelation, :clean_repo 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_builders/hyrax/work_search_builder_spec.rb

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,205 @@
+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) { 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(: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

@@ -0,0 +1,114 @@
+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

data/spec/services/hyrax/admin_set_member_service_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe Hyrax::AdminSetMemberService, clean_repo: true do
+  let(:blacklight_config) { CatalogController.blacklight_config }
+  let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
+  let(:current_ability) { instance_double(Ability, admin?: true) }
+  let(:scope) { double('Scope', current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
+
+  let(:admin_set) { build(:admin_set) }
+  let(:builder) { described_class.new(scope: scope, collection: admin_set, params: { "id" => admin_set.id.to_s }) }
+  let(:subject) { builder.available_member_works }
+  let(:ids) { subject.response[:docs].map { |col| col[:id] } }
+
+  describe '#available_member_works' do
+    let!(:work1) { create(:generic_work, admin_set: admin_set) }
+    let!(:work2) { create(:generic_work) }
+    let!(:work3) { create(:generic_work, admin_set: admin_set) }
+
+    it 'returns the members of the admin set' do
+      expect(ids).to contain_exactly(work1.id, work3.id)
+    end
+  end
+end