hyrax 2.6.0 → 2.9.0

data/spec/controllers/hyrax/dashboard/works_controller_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe Hyrax::Dashboard::WorksController, type: :controller do
-  describe "#search_builder_class" do
-    subject { controller.search_builder_class }
-
-    it { is_expected.to eq Hyrax::Dashboard::WorksSearchBuilder }
-  end
-
-  describe "#search_facet_path" do
-    subject { controller.send(:search_facet_path, id: 'keyword_sim') }
-
-    it { is_expected.to eq "/dashboard/works/facet/keyword_sim?locale=en" }
-  end
-end

data/spec/controllers/hyrax/dashboard_controller_spec.rb

@@ -1,42 +0,0 @@
-RSpec.describe Hyrax::DashboardController, type: :controller do
-  context "with an unauthenticated user" do
-    it "redirects to sign-in page" do
-      get :show
-      expect(response).to be_redirect
-      expect(flash[:alert]).to eq("You need to sign in or sign up before continuing.")
-    end
-  end
-
-  context "with an authenticated user" do
-    let(:user) { create(:user) }
-
-    before do
-      sign_in user
-    end
-
-    it "renders the dashboard with the user's info" do
-      get :show
-      expect(response).to be_successful
-      expect(assigns(:presenter)).to be_instance_of Hyrax::Dashboard::UserPresenter
-      expect(response).to render_template('show_user')
-    end
-  end
-
-  context 'with an admin user' do
-    let(:service) { instance_double(Hyrax::AdminSetService, search_results_with_work_count: results) }
-    let(:results) { instance_double(Array) }
-    let(:user) { create(:admin) }
-
-    before do
-      sign_in user
-      allow(Hyrax::AdminSetService).to receive(:new).and_return(service)
-    end
-
-    it "is successful" do
-      get :show
-      expect(response).to be_success
-      expect(assigns[:admin_set_rows]).to eq results
-      expect(response).to render_template('show_admin')
-    end
-  end
-end

data/spec/controllers/hyrax/depositors_controller_spec.rb

@@ -1,105 +0,0 @@
-RSpec.describe Hyrax::DepositorsController do
-  let(:user) { create(:user) }
-  let(:grantee) { create(:user) }
-
-  let(:grant_proxy_params) do
-    {
-      user_id: user.user_key,
-      grantee_id: grantee.user_key,
-      format: 'json'
-    }
-  end
-
-  let(:revoke_proxy_params) do
-    {
-      user_id: user.user_key,
-      id: grantee.user_key,
-      format: 'json'
-    }
-  end
-
-  context "as a logged in user" do
-    before do
-      sign_in user
-    end
-
-    describe "#create" do
-      context 'when the grantee has not yet been designated as a depositor' do
-        let(:request_to_grant_proxy) { post :create, params: grant_proxy_params }
-
-        it 'is successful' do
-          expect { request_to_grant_proxy }.to change { ProxyDepositRights.count }.by(1)
-          expect(response).to be_success
-        end
-
-        it 'sends a message to the grantor' do
-          expect { request_to_grant_proxy }.to change { user.mailbox.inbox.count }.by(1)
-        end
-
-        it 'sends a message to the grantee' do
-          expect { request_to_grant_proxy }.to change { grantee.mailbox.inbox.count }.by(1)
-        end
-      end
-
-      context 'when the grantee is already an allowed depositor' do
-        # For this test we just set the grantor to be eq to grantee.
-        let(:redundant_request_to_grant_proxy) do
-          post :create, params: grant_proxy_params.merge(grantee_id: user.user_key)
-        end
-
-        it 'does not add the user, and returns a 200, with empty response body' do
-          expect { redundant_request_to_grant_proxy }.to change { ProxyDepositRights.count }.by(0)
-          expect(response).to be_success
-          expect(response.body).to be_blank
-        end
-
-        it 'does not send a message to the user' do
-          expect { redundant_request_to_grant_proxy }.not_to change { user.mailbox.inbox.count }
-        end
-      end
-    end
-
-    describe "destroy" do
-      before do
-        user.can_receive_deposits_from << grantee
-      end
-
-      it "is successful" do
-        expect { delete :destroy, params: revoke_proxy_params }.to change { ProxyDepositRights.count }.by(-1)
-      end
-    end
-
-    describe "index" do
-      it "renders the page with user proxy info" do
-        expect(controller).to receive(:add_breadcrumb).with('Home', root_path)
-        expect(controller).to receive(:add_breadcrumb).with('Dashboard', dashboard_path)
-        expect(controller).to receive(:add_breadcrumb).with('Manage Proxies', depositors_path)
-        get :index
-        expect(response).to be_successful
-        expect(response).to render_template('dashboard')
-      end
-    end
-  end
-
-  context "as a user without access" do
-    before do
-      sign_in create(:user)
-    end
-
-    describe "create" do
-      it "is not successful" do
-        post :create, params: grant_proxy_params
-        expect(response).to redirect_to root_path
-        expect(flash[:alert]).to eq "You are not authorized to access this page."
-      end
-    end
-
-    describe "destroy" do
-      it "is not successful" do
-        delete :destroy, params: revoke_proxy_params
-        expect(response).to redirect_to root_path
-        expect(flash[:alert]).to eq "You are not authorized to access this page."
-      end
-    end
-  end
-end

data/spec/controllers/hyrax/downloads_controller_spec.rb

@@ -1,159 +0,0 @@
-RSpec.describe Hyrax::DownloadsController do
-  routes { Hyrax::Engine.routes }
-
-  describe '#show' do
-    let(:user) { create(:user) }
-    let(:file_set) do
-      create(:file_with_work, user: user, content: File.open(fixture_path + '/image.png'))
-    end
-    let(:default_image) { ActionController::Base.helpers.image_path 'default.png' }
-
-    it 'raises an error if the object does not exist' do
-      expect do
-        get :show, params: { id: '8675309' }
-      end.to raise_error Blacklight::Exceptions::InvalidSolrID
-    end
-
-    context "when user doesn't have access" do
-      let(:another_user) { create(:user) }
-
-      before { sign_in another_user }
-
-      it 'returns :unauthorized status with image content' do
-        get :show, params: { id: file_set.to_param }
-        expect(response).to have_http_status(:unauthorized)
-        expect(response).not_to redirect_to default_image
-        expect(response.content_type).to eq 'image/png'
-      end
-    end
-
-    context "when user isn't logged in" do
-      context "and the unauthorized image exists" do
-        before do
-          allow(File).to receive(:exist?).and_return(true)
-        end
-
-        it 'returns :unauthorized status with image content' do
-          get :show, params: { id: file_set.to_param }
-          expect(response).to have_http_status(:unauthorized)
-          expect(response).not_to redirect_to default_image
-          expect(response.content_type).to eq 'image/png'
-        end
-      end
-
-      context "and the unauthorized image doesn't exist" do
-        before do
-          allow(File).to receive(:exist?).and_return(false)
-        end
-
-        it 'redirects to the default image' do
-          get :show, params: { id: file_set.to_param }
-          expect(response).to redirect_to default_image
-        end
-      end
-
-      it 'authorizes the resource using only the id' do
-        expect(controller).to receive(:authorize!).with(:download, file_set.id)
-        get :show, params: { id: file_set.to_param }
-      end
-    end
-
-    context "when the user has access" do
-      before { sign_in user }
-
-      it 'sends the original file' do
-        get :show, params: { id: file_set }
-        expect(response.body).to eq file_set.original_file.content
-      end
-
-      context "with an alternative file" do
-        context "that is persisted" do
-          let(:file) { File.open(fixture_path + '/world.png', 'rb') }
-          let(:content) { file.read }
-
-          before do
-            allow(Hyrax::DerivativePath).to receive(:derivative_path_for_reference).and_return(fixture_path + '/world.png')
-          end
-
-          it 'sends requested file content' do
-            get :show, params: { id: file_set, file: 'thumbnail' }
-            expect(response).to be_success
-            expect(response.body).to eq content
-            expect(response.headers['Content-Length']).to eq "4218"
-            expect(response.headers['Accept-Ranges']).to eq "bytes"
-          end
-
-          it 'retrieves the thumbnail without contacting Fedora' do
-            expect(ActiveFedora::Base).not_to receive(:find).with(file_set.id)
-            get :show, params: { id: file_set, file: 'thumbnail' }
-          end
-
-          context "stream" do
-            it "head request" do
-              request.env["HTTP_RANGE"] = 'bytes=0-15'
-              head :show, params: { id: file_set, file: 'thumbnail' }
-              expect(response.headers['Content-Length']).to eq '4218'
-              expect(response.headers['Accept-Ranges']).to eq 'bytes'
-              expect(response.headers['Content-Type']).to start_with 'image/png'
-            end
-
-            it "sends the whole thing" do
-              request.env["HTTP_RANGE"] = 'bytes=0-4217'
-              get :show, params: { id: file_set, file: 'thumbnail' }
-              expect(response.headers["Content-Range"]).to eq 'bytes 0-4217/4218'
-              expect(response.headers["Content-Length"]).to eq '4218'
-              expect(response.headers['Accept-Ranges']).to eq 'bytes'
-              expect(response.headers['Content-Type']).to start_with "image/png"
-              expect(response.headers["Content-Disposition"]).to eq "inline; filename=\"world.png\""
-              expect(response.body).to eq content
-              expect(response.status).to eq 206
-            end
-
-            it "sends the whole thing when the range is open ended" do
-              request.env["HTTP_RANGE"] = 'bytes=0-'
-              get :show, params: { id: file_set, file: 'thumbnail' }
-              expect(response.body).to eq content
-            end
-
-            it "gets a range not starting at the beginning" do
-              request.env["HTTP_RANGE"] = 'bytes=4200-4217'
-              get :show, params: { id: file_set, file: 'thumbnail' }
-              expect(response.headers["Content-Range"]).to eq 'bytes 4200-4217/4218'
-              expect(response.headers["Content-Length"]).to eq '18'
-            end
-
-            it "gets a range not ending at the end" do
-              request.env["HTTP_RANGE"] = 'bytes=4-11'
-              get :show, params: { id: file_set, file: 'thumbnail' }
-              expect(response.headers["Content-Range"]).to eq 'bytes 4-11/4218'
-              expect(response.headers["Content-Length"]).to eq '8'
-            end
-          end
-        end
-
-        context "that isn't persisted" do
-          it "raises an error if the requested file does not exist" do
-            expect do
-              get :show, params: { id: file_set, file: 'thumbnail' }
-            end.to raise_error ActiveFedora::ObjectNotFoundError
-          end
-        end
-      end
-
-      it "raises an error if the requested association does not exist" do
-        expect do
-          get :show, params: { id: file_set, file: 'non-existant' }
-        end.to raise_error ActiveFedora::ObjectNotFoundError
-      end
-    end
-  end
-
-  describe "derivative_download_options" do
-    before do
-      allow(controller).to receive(:default_file).and_return 'world.png'
-    end
-    subject { controller.send(:derivative_download_options) }
-
-    it { is_expected.to eq(disposition: 'inline', type: 'image/png') }
-  end
-end

data/spec/controllers/hyrax/embargoes_controller_spec.rb

@@ -1,147 +0,0 @@
-RSpec.describe Hyrax::EmbargoesController do
-  let(:user) { create(:user) }
-  let(:a_work) { create(:generic_work, user: user) }
-  let(:not_my_work) { create(:generic_work) }
-  before { sign_in user }
-
-  describe '#index' do
-    context 'when I am NOT a repository manager' do
-      it 'redirects' do
-        get :index
-        expect(response).to redirect_to root_path
-      end
-    end
-    context 'when I am a repository manager' do
-      let(:user) { create(:user, groups: ['admin']) }
-
-      it 'shows me the page' do
-        expect(controller).to receive(:add_breadcrumb).with('Home', root_path)
-        expect(controller).to receive(:add_breadcrumb).with('Dashboard', dashboard_path)
-        expect(controller).to receive(:add_breadcrumb).with('Manage Embargoes', embargoes_path)
-        get :index
-        expect(response).to be_success
-        expect(response).to render_template('dashboard')
-      end
-    end
-  end
-
-  describe '#edit' do
-    context 'when I do not have edit permissions for the object' do
-      it 'redirects' do
-        get :edit, params: { id: not_my_work }
-        expect(response.status).to eq 302
-        expect(flash[:alert]).to eq 'You are not authorized to access this page.'
-      end
-    end
-    context 'when I have permission to edit the object' do
-      it 'shows me the page' do
-        expect(controller).to receive(:add_breadcrumb).with('Home', root_path)
-        expect(controller).to receive(:add_breadcrumb).with('Dashboard', dashboard_path)
-        expect(controller).to receive(:add_breadcrumb).with('Manage Embargoes', embargoes_path)
-        expect(controller).to receive(:add_breadcrumb).with('Update Embargo', '#')
-        get :edit, params: { id: a_work }
-        expect(response).to be_success
-        expect(response).to render_template('dashboard')
-      end
-    end
-  end
-
-  describe '#destroy' do
-    context 'when I do not have edit permissions for the object' do
-      it 'denies access' do
-        get :destroy, params: { id: not_my_work }
-        expect(response).to fail_redirect_and_flash(root_path, 'You are not authorized to access this page.')
-      end
-    end
-
-    context 'when I have permission to edit the object' do
-      before do
-        expect(Hyrax::Actors::EmbargoActor).to receive(:new).with(a_work).and_return(actor)
-      end
-
-      let(:actor) { double }
-
-      context 'that has no files' do
-        it 'deactivates embargo and redirects' do
-          expect(actor).to receive(:destroy)
-          get :destroy, params: { id: a_work }
-          expect(response).to redirect_to edit_embargo_path(a_work)
-        end
-      end
-
-      context 'that has files' do
-        before do
-          a_work.members << create(:file_set)
-          a_work.save!
-        end
-
-        it 'deactivates embargo and checks to see if we want to copy the visibility to files' do
-          expect(actor).to receive(:destroy)
-          get :destroy, params: { id: a_work }
-          expect(response).to redirect_to confirm_permission_path(a_work)
-        end
-      end
-    end
-  end
-
-  describe '#update' do
-    context 'when I have permission to edit the object' do
-      let(:file_set) { create(:file_set, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED) }
-      let(:release_date) { Time.zone.today + 2 }
-
-      before do
-        a_work.members << file_set
-        a_work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-        a_work.visibility_during_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-        a_work.visibility_after_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-        a_work.embargo_release_date = release_date.to_s
-        a_work.embargo.save(validate: false)
-        a_work.save(validate: false)
-      end
-
-      context 'with an expired embargo' do
-        let(:release_date) { Time.zone.today - 2 }
-
-        it 'deactivates embargo, update the visibility and redirect' do
-          patch :update, params: { batch_document_ids: [a_work.id], embargoes: { '0' => { copy_visibility: a_work.id } } }
-          expect(a_work.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          expect(file_set.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          expect(response).to redirect_to embargoes_path
-          expect(flash[:notice]).to be_present
-        end
-      end
-
-      context 'with an expired embargo and filesets in batch_document_ids and in embargoes' do
-        let(:file_set2) { create(:file_set, id: 'fileset_2', visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED) }
-        let(:file_set3) { create(:file_set, id: 'fileset_3', visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED) }
-        let(:release_date) { Time.zone.today - 2 }
-        let(:batch) { [file_set2.id, a_work.id] }
-        before do
-          file_set2.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-          file_set2.visibility_during_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-          file_set2.visibility_after_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          file_set2.embargo_release_date = release_date.to_s
-          file_set2.embargo.save(validate: false)
-          file_set2.save(validate: false)
-          file_set3.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-          file_set3.visibility_during_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-          file_set3.visibility_after_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          file_set3.embargo_release_date = release_date.to_s
-          file_set3.embargo.save(validate: false)
-          file_set3.save(validate: false)
-        end
-
-        it 'deactivates embargo, updates the visibility and redirects' do
-          allow(controller).to receive(:filter_docs_with_edit_access!).and_return(true)
-          patch :update, params: { batch_document_ids: batch, embargoes: { '0' => { copy_visibility: file_set2.id }, '1' => { copy_visibility: a_work.id } } }
-          expect(a_work.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          expect(file_set.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          expect(file_set2.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-          expect(file_set3.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-          expect(response).to redirect_to embargoes_path
-          expect(flash[:notice]).to be_present
-        end
-      end
-    end
-  end
-end