hyrax 2.6.0 → 2.9.0

data/spec/channels/hyrax/notifications_channel_spec.rb

@@ -1,45 +0,0 @@
-RSpec.describe Hyrax::NotificationsChannel do
-  subject { described_class.new(connection, nil) }
-
-  let(:connection) { Hyrax::ApplicationCable::Connection.new(server, {}) }
-  let(:server) { ActionCable::Server::Base.new }
-  let(:user) { create(:user) }
-
-  before do
-    allow(connection).to receive(:find_verified_user).and_return(user)
-    connection.connect
-  end
-
-  describe '#current_user' do
-    it 'has a current user instance from its connection' do
-      expect(subject.current_user).to eq user
-    end
-  end
-
-  describe '#update_locale' do
-    let(:data) { { 'locale' => 'zh' } }
-
-    it 'updates the current user instance with the locale' do
-      expect { subject.update_locale(data) }.to change { user.preferred_locale }
-        .from(nil).to(data['locale'])
-    end
-  end
-
-  describe '#subscribed' do
-    # rubocop:disable RSpec/SubjectStub
-    it 'calls #stream_for with the current user instance' do
-      expect(subject).to receive(:stream_for).with(user).once
-      subject.subscribed
-    end
-    # rubocop:enable RSpec/SubjectStub
-  end
-
-  describe '#unsubscribed' do
-    # rubocop:disable RSpec/SubjectStub
-    it 'calls #stop_all_streams' do
-      expect(subject).to receive(:stop_all_streams).once
-      subject.unsubscribed
-    end
-    # rubocop:enable RSpec/SubjectStub
-  end
-end

data/spec/config/hyrax_events_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe "hyrax_events using Hyrax callbacks" do
-  let(:curation_concern) { create(:work) }
-  let(:file_set) { create(:file_set) }
-  let(:user) { create(:user) }
-
-  describe "after_create_concern" do
-    it "queues a ContentDepositEventJob" do
-      expect(ContentDepositEventJob).to receive(:perform_later).with(curation_concern, user)
-      Hyrax.config.callback.run(:after_create_concern, curation_concern, user)
-    end
-  end
-
-  describe "after_create_fileset" do
-    it "queues a FileSetAttachedEventJob" do
-      expect(FileSetAttachedEventJob).to receive(:perform_later).with(file_set, user)
-      Hyrax.config.callback.run(:after_create_fileset, file_set, user)
-    end
-  end
-
-  describe "after_revert_content" do
-    let(:revision) { "revision1" }
-
-    it "queues a ContentRestoredVersionEventJob" do
-      expect(ContentRestoredVersionEventJob).to receive(:perform_later).with(file_set, user, revision)
-      Hyrax.config.callback.run(:after_revert_content, file_set, user, revision)
-    end
-  end
-
-  describe "after_update_metadata" do
-    it "queues a ContentUpdateEventJob" do
-      expect(ContentUpdateEventJob).to receive(:perform_later).with(curation_concern, user)
-      Hyrax.config.callback.run(:after_update_metadata, curation_concern, user)
-    end
-  end
-
-  describe "after_destroy" do
-    let(:id) { curation_concern.id }
-
-    it "queues a ContentDeleteEventJob" do
-      expect(ContentDeleteEventJob).to receive(:perform_later).with(id, user)
-      Hyrax.config.callback.run(:after_destroy, id, user)
-    end
-  end
-end

data/spec/controllers/catalog_controller_spec.rb

@@ -1,135 +0,0 @@
-RSpec.describe CatalogController, type: :controller do
-  routes { Rails.application.class.routes }
-
-  let(:user) { create(:user) }
-
-  before do
-    sign_in user
-  end
-
-  describe "#index" do
-    let(:rocks) do
-      GenericWork.new(id: 'rock123', title: ['Rock Documents'], read_groups: ['public'])
-    end
-
-    let(:clouds) do
-      GenericWork.new(id: 'cloud123', title: ['Cloud Documents'], read_groups: ['public'],
-                      contributor: ['frodo'])
-    end
-
-    before do
-      objects.each { |obj| ActiveFedora::SolrService.add(obj.to_solr) }
-      ActiveFedora::SolrService.commit
-    end
-
-    context 'with a non-work file' do
-      let(:file) { FileSet.new(id: 'file123') }
-      let(:objects) { [file, rocks, clouds] }
-
-      it 'finds works, not files' do
-        get :index
-        expect(response).to be_success
-        expect(response).to render_template('catalog/index')
-
-        ids = assigns(:document_list).map(&:id)
-        expect(ids).to include rocks.id
-        expect(ids).to include clouds.id
-        expect(ids).not_to include file.id
-      end
-    end
-
-    context 'with collections' do
-      let(:collection) { create(:public_collection_lw, keyword: ['rocks']) }
-      let(:objects) { [collection, rocks, clouds] }
-
-      it 'finds collections' do
-        get :index, params: { q: 'rocks' }, xhr: true
-        expect(response).to be_success
-        doc_list = assigns(:document_list)
-        expect(doc_list.map(&:id)).to match_array [collection.id, rocks.id]
-      end
-    end
-
-    describe 'term search', :clean_repo do
-      let(:objects) { [rocks, clouds] }
-
-      it 'finds works with the given search term' do
-        get :index, params: { q: 'rocks', owner: 'all' }
-        expect(response).to be_success
-        expect(response).to render_template('catalog/index')
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(rocks.id)
-      end
-    end
-
-    describe 'facet search' do
-      let(:objects) { [rocks, clouds] }
-
-      before do
-        get :index, params: { 'f' => { 'contributor_tesim' => ['frodo'] } }
-      end
-
-      it 'finds faceted works' do
-        expect(response).to be_success
-        expect(response).to render_template('catalog/index')
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(clouds.id)
-      end
-    end
-
-    describe 'full-text search', skip: 'Will GenericWorks have a full_text search?' do
-      let(:objects) { [rocks, clouds] }
-
-      it 'finds matching records' do
-        get :index, params: { q: 'full_textfull_text' }
-        expect(response).to be_success
-        expect(response).to render_template('catalog/index')
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(clouds.id)
-      end
-    end
-
-    context 'works by file metadata' do
-      let(:objects) do
-        [double(to_solr: file1), double(to_solr: file2),
-         double(to_solr: work1), double(to_solr: work2)]
-      end
-
-      let(:work1) do
-        { has_model_ssim: ["GenericWork"], id: "ff365c76z", title_tesim: ["me too"],
-          file_set_ids_ssim: ["ff365c78h", "ff365c79s"],
-          read_access_group_ssim: ["public"], edit_access_person_ssim: ["user1@example.com"] }
-      end
-
-      let(:work2) do
-        { has_model_ssim: ["GenericWork"], id: "ff365c777", title_tesim: ["find me"],
-          file_set_ids_ssim: [],
-          read_access_group_ssim: ["public"], edit_access_person_ssim: ["user2@example.com"] }
-      end
-
-      let(:file1) do
-        { has_model_ssim: ["FileSet"], id: "ff365c78h", title_tesim: ["find me"],
-          file_set_ids_ssim: [],
-          edit_access_person_ssim: [user.user_key] }
-      end
-
-      let(:file2) do
-        { has_model_ssim: ["FileSet"], id: "ff365c79s", title_tesim: ["other file"],
-          file_set_ids_ssim: [],
-          edit_access_person_ssim: [user.user_key] }
-      end
-
-      it "finds a work and a work that contains a file set with a matching title" do
-        get :index, params: { q: 'find me', search_field: 'all_fields' }
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id], work2[:id])
-      end
-
-      it "finds a work that contains a file set with a matching title" do
-        get :index, params: { q: 'other file', search_field: 'all_fields' }
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id])
-      end
-
-      it "finds a work with a matching title" do
-        get :index, params: { q: 'me too', search_field: 'all_fields' }
-        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id])
-      end
-    end
-  end
-end

data/spec/controllers/hyrax/accepts_batches_controller_spec.rb

@@ -1,67 +0,0 @@
-class AcceptsBatchesController < ApplicationController
-  include Hyrax::Collections::AcceptsBatches
-end
-
-RSpec.describe AcceptsBatchesController, type: :controller do
-  describe 'batch' do
-    it 'accepts batch from parameters' do
-      controller.params['batch_document_ids'] = %w[abc xyz]
-      expect(controller.batch).to eq(%w[abc xyz])
-    end
-    describe ':all' do
-      let(:current_user) { double(user_key: 'vanessa') }
-      let(:mock_service) { instance_double(Hyrax::Collections::SearchService) }
-
-      before do
-        doc1 = double(id: 123)
-        doc2 = double(id: 456)
-        allow(Hyrax::Collections::SearchService).to receive(:new).and_return(mock_service)
-        expect(mock_service).to receive(:last_search_documents).and_return([doc1, doc2])
-        allow(controller).to receive(:current_user).and_return(current_user)
-      end
-      it 'adds every document in the current resultset to the batch' do
-        controller.params['batch_document_ids'] = 'all'
-        expect(controller.batch).to eq([123, 456])
-      end
-    end
-  end
-
-  describe 'should allow filtering for access' do
-    let(:allowed) { [1, 2, 3] }
-    let(:disallowed) { [5, 6, 7] }
-
-    before do
-      subject.batch = allowed + disallowed
-    end
-    it 'using filter_docs_with_access!' do
-      allowed.each { |doc_id| expect(subject).to receive(:can?).with(:foo, doc_id).and_return(true) }
-      disallowed.each { |doc_id| expect(subject).to receive(:can?).with(:foo, doc_id).and_return(false) }
-      subject.send(:filter_docs_with_access!, :foo)
-      expect(flash[:notice]).to eq("You do not have permission to edit the documents: #{disallowed.join(', ')}")
-    end
-    it 'using filter_docs_with_edit_access!' do
-      allowed.each { |doc_id| expect(subject).to receive(:can?).with(:edit, doc_id).and_return(true) }
-      disallowed.each { |doc_id| expect(subject).to receive(:can?).with(:edit, doc_id).and_return(false) }
-      subject.send(:filter_docs_with_edit_access!)
-      expect(flash[:notice]).to eq("You do not have permission to edit the documents: #{disallowed.join(', ')}")
-    end
-    it 'using filter_docs_with_read_access!' do
-      allowed.each { |doc_id| expect(subject).to receive(:can?).with(:read, doc_id).and_return(true) }
-      disallowed.each { |doc_id| expect(subject).to receive(:can?).with(:read, doc_id).and_return(false) }
-      subject.send(:filter_docs_with_read_access!)
-      expect(flash[:notice]).to eq("You do not have permission to edit the documents: #{disallowed.join(', ')}")
-    end
-    it "and be sassy if you didn't select anything" do
-      subject.batch = []
-      subject.send(:filter_docs_with_read_access!)
-      expect(flash[:notice]).to eq('Select something first')
-    end
-  end
-
-  it 'checks for empty' do
-    controller.batch = %w[77826928 94120425]
-    expect(controller.check_for_empty_batch?).to eq(false)
-    controller.batch = []
-    expect(controller.check_for_empty_batch?).to eq(true)
-  end
-end

data/spec/controllers/hyrax/admin/admin_sets_controller_spec.rb

@@ -1,284 +0,0 @@
-RSpec.describe Hyrax::Admin::AdminSetsController do
-  routes { Hyrax::Engine.routes }
-  let(:user) { create(:user) }
-
-  context "a non admin" do
-    describe "#index" do
-      it 'is unauthorized' do
-        get :index
-        expect(response).to be_redirect
-      end
-    end
-
-    describe "#new" do
-      it 'is unauthorized' do
-        get :new
-        expect(response).to be_redirect
-      end
-    end
-
-    describe "#show" do
-      before do
-        sign_in user
-        controller.instance_variable_set(:@admin_set, admin_set)
-      end
-
-      context "when user has access through public group" do
-        # Even though the user can view this admin set, they should not be able to view
-        # it on the admin page.
-        let(:admin_set) { create(:adminset_lw, with_solr_document: true, with_permission_template: { view_groups: ['public'] }) }
-
-        it 'is unauthorized' do
-          get :show, params: { id: admin_set }
-          expect(response).to be_redirect
-        end
-      end
-
-      context "when user has access through registered group" do
-        # Even though the user can view this admin set, the should not be able to view
-        # it on the admin page.
-        let(:admin_set) { create(:adminset_lw, with_solr_document: true, with_permission_template: { view_groups: ['registered'] }) }
-
-        it 'is unauthorized' do
-          get :show, params: { id: admin_set }
-          expect(response).to be_redirect
-        end
-      end
-
-      context "when user is directly granted view access" do
-        # Even though the user can view this admin set, the should not be able to view
-        # it on the admin page.
-        let(:admin_set) { create(:adminset_lw, with_solr_document: true, with_permission_template: { view_users: [user.user_key] }) }
-
-        before do
-          create(:work, :public, admin_set: admin_set)
-        end
-
-        it 'defines a presenter' do
-          get :show, params: { id: admin_set }
-          expect(response).to be_success
-          expect(assigns[:presenter]).to be_kind_of Hyrax::AdminSetPresenter
-          expect(assigns[:presenter].id).to eq admin_set.id
-        end
-      end
-    end
-
-    describe "#edit" do
-      before do
-        sign_in user
-      end
-
-      context "when user is directly granted manage access" do
-        # Even though the user can view this admin set, the should not be able to view
-        # it on the admin page.
-        let(:admin_set) { create(:adminset_lw, with_solr_document: true, with_permission_template: { manage_users: [user.user_key] }) }
-        let(:admin_set2) { create(:adminset_lw, with_solr_document: true, with_permission_template: true) }
-
-        context 'and user is accessing the managed set' do
-          before do
-            controller.instance_variable_set(:@admin_set, admin_set)
-          end
-
-          it 'defines a form' do
-            get :edit, params: { id: admin_set }
-            expect(response).to be_success
-            expect(assigns[:form]).to be_kind_of Hyrax::Forms::AdminSetForm
-          end
-        end
-
-        context 'and user attempts to access another admin set' do
-          before do
-            controller.instance_variable_set(:@admin_set, admin_set2)
-          end
-
-          it 'is unauthorized' do
-            get :edit, params: { id: admin_set2 }
-            expect(response).to be_redirect
-          end
-        end
-      end
-    end
-
-    describe "#files" do
-      let(:admin_set) { create(:admin_set) }
-
-      it 'is unauthorized' do
-        get :files, params: { id: admin_set }, format: :json
-        expect(response).to be_unauthorized
-      end
-    end
-  end
-
-  context "as an admin" do
-    before do
-      sign_in user
-      allow(controller).to receive(:authorize!).and_return(true)
-    end
-
-    describe "#index" do
-      it 'allows an authorized user to view the page' do
-        get :index
-        expect(response).to be_success
-        expect(assigns[:admin_sets]).to be_kind_of Array
-      end
-    end
-
-    describe "#new" do
-      it 'allows an authorized user to view the page' do
-        get :new
-        expect(response).to be_success
-      end
-    end
-
-    describe "#create" do
-      before do
-        controller.admin_set_create_service = service
-      end
-
-      context "when it's successful" do
-        let(:service) do
-          lambda do |admin_set:, **_kargs|
-            admin_set.id = 123
-            # https://github.com/samvera/active_fedora/issues/1251
-            allow(admin_set).to receive(:persisted?).and_return(true)
-            true
-          end
-        end
-
-        it 'creates file sets' do
-          post :create, params: { admin_set: { title: 'Test title',
-                                               description: 'test description',
-                                               workflow_name: 'default' } }
-          admin_set = assigns(:admin_set)
-          expect(response).to redirect_to(edit_admin_admin_set_path(admin_set))
-        end
-      end
-
-      context "when it fails" do
-        let(:service) { ->(**_kargs) { false } }
-
-        it 'shows the new form' do
-          post :create, params: { admin_set: { title: 'Test title',
-                                               description: 'test description' } }
-          expect(response).to render_template 'new'
-        end
-      end
-    end
-
-    describe "#show" do
-      context "when it's successful" do
-        let(:admin_set) { create(:admin_set, edit_users: [user]) }
-
-        before do
-          create(:work, :public, admin_set: admin_set)
-        end
-
-        it 'defines a presenter' do
-          get :show, params: { id: admin_set }
-          expect(response).to be_success
-          expect(assigns[:presenter]).to be_kind_of Hyrax::AdminSetPresenter
-          expect(assigns[:presenter].id).to eq admin_set.id
-        end
-      end
-    end
-
-    describe "#edit" do
-      let(:admin_set) { create(:admin_set, edit_users: [user]) }
-
-      it 'defines a form' do
-        get :edit, params: { id: admin_set }
-        expect(response).to be_success
-        expect(assigns[:form]).to be_kind_of Hyrax::Forms::AdminSetForm
-      end
-    end
-
-    describe "#files" do
-      let(:admin_set) { create(:admin_set, edit_users: [user]) }
-
-      it 'shows a list of member files' do
-        get :files, params: { id: admin_set }, format: :json
-        expect(response).to be_success
-      end
-    end
-
-    describe "#update" do
-      let(:admin_set) { create(:admin_set, edit_users: [user]) }
-
-      it 'updates a record' do
-        patch :update, params: { id: admin_set,
-                                 admin_set: { title: "Improved title" } }
-        expect(response).to redirect_to(edit_admin_admin_set_path)
-        expect(assigns[:admin_set].title).to eq ['Improved title']
-      end
-    end
-
-    describe "#destroy" do
-      let(:admin_set) { create(:admin_set, edit_users: [user]) }
-
-      context "with empty admin set" do
-        it "deletes the admin set" do
-          controller.request.set_header("HTTP_REFERER", "/admin/admin_sets")
-          delete :destroy, params: { id: admin_set }
-
-          expect(response).to have_http_status(:found)
-          expect(response).to redirect_to(my_collections_path)
-          expect(flash[:notice]).to eq "Administrative set successfully deleted"
-          expect(AdminSet.exists?(admin_set.id)).to be false
-        end
-      end
-
-      context "with empty admin set and referrer from the my/collections dashboard" do
-        it "deletes the admin set" do
-          controller.request.set_header("HTTP_REFERER", "/my/collections")
-          delete :destroy, params: { id: admin_set }
-
-          expect(response).to have_http_status(:found)
-          expect(response).to redirect_to(my_collections_path)
-          expect(flash[:notice]).to eq "Administrative set successfully deleted"
-          expect(AdminSet.exists?(admin_set.id)).to be false
-        end
-      end
-
-      context "with empty admin set and referrer from the /collections dashboard" do
-        it "deletes the admin set" do
-          controller.request.set_header("HTTP_REFERER", "/collections")
-          delete :destroy, params: { id: admin_set }
-
-          expect(response).to have_http_status(:found)
-          expect(response).to redirect_to(dashboard_collections_path)
-          expect(flash[:notice]).to eq "Administrative set successfully deleted"
-          expect(AdminSet.exists?(admin_set.id)).to be false
-        end
-      end
-
-      context "with a non-empty admin set" do
-        let(:work) { create(:generic_work, user: user) }
-
-        before do
-          admin_set.members << work
-          admin_set.reload
-        end
-        it "doesn't delete the admin set (or work)" do
-          delete :destroy, params: { id: admin_set }
-          expect(response).to have_http_status(:found)
-          expect(response).to redirect_to(admin_admin_set_path(admin_set))
-          expect(flash[:alert]).to eq "Administrative set cannot be deleted as it is not empty"
-          expect(AdminSet.exists?(admin_set.id)).to be true
-          expect(GenericWork.exists?(work.id)).to be true
-        end
-      end
-
-      context "with the default admin set" do
-        let(:admin_set) { create(:admin_set, edit_users: [user], id: AdminSet::DEFAULT_ID) }
-
-        it "doesn't delete the admin set" do
-          delete :destroy, params: { id: admin_set }
-          expect(response).to have_http_status(:found)
-          expect(response).to redirect_to(admin_admin_set_path(admin_set))
-          expect(flash[:alert]).to eq "Administrative set cannot be deleted as it is the default set"
-          expect(AdminSet.exists?(admin_set.id)).to be true
-        end
-      end
-    end
-  end
-end