hyrax 2.9.5 → 3.0.0.pre.beta1

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

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

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

@@ -0,0 +1,109 @@
+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)
+          expect(user.mailbox.inbox.last.last_message.subject).to eq 'Proxy Depositor Added'
+          expect(user.mailbox.inbox.last.last_message.body).to eq 'You have assigned ' + grantee.user_key + ' as a proxy depositor'
+        end
+
+        it 'sends a message to the grantee' do
+          expect { request_to_grant_proxy }.to change { grantee.mailbox.inbox.count }.by(1)
+          expect(grantee.mailbox.inbox.last.last_message.subject).to eq 'Proxy Depositor Added'
+          expect(grantee.mailbox.inbox.last.last_message.body).to eq user.user_key + ' has assigned you as a proxy depositor'
+        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

@@ -0,0 +1,145 @@
+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
+
+    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.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.content_type).to eq 'image/png'
+        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

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