hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/resource_sync_controller_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe Hyrax::ResourceSyncController do
+  before do
+    Rails.cache.clear
+  end
+
+  describe "source_description" do
+    let(:writer) { double }
+    let(:document) { '<xml>' }
+    let(:capability_list) { Hyrax::Engine.routes.url_helpers.capability_list_url(host: 'test.host') }
+
+    it "is successful" do
+      allow(Hyrax::ResourceSync::SourceDescriptionWriter).to receive(:new).with(capability_list_url: capability_list).and_return(writer)
+      expect(writer).to receive(:write).and_return(document)
+      get :source_description
+      expect(response.content_type).to eq 'application/xml'
+      expect(response.body).to eq document
+    end
+  end
+
+  describe "capability_list" do
+    let(:writer) { double }
+    let(:document) { '<xml>' }
+    let(:capability_list) { Hyrax::Engine.routes.url_helpers.capability_list_url(host: 'test.host') }
+
+    it "is successful" do
+      allow(Hyrax::ResourceSync::CapabilityListWriter).to receive(:new).with(resource_list_url: "http://test.host/resourcelist",
+                                                                             change_list_url: "http://test.host/changelist",
+                                                                             description_url: "http://test.host/.well-known/resourcesync").and_return(writer)
+      expect(writer).to receive(:write).and_return(document)
+      get :capability_list
+      expect(response.content_type).to eq 'application/xml'
+      expect(response.body).to eq document
+    end
+  end
+
+  describe "resource_list" do
+    before do
+      Rails.cache.clear
+    end
+
+    let(:writer) { double }
+    let(:document) { '<xml>' }
+    let(:capability_list) { Hyrax::Engine.routes.url_helpers.capability_list_url(host: 'test.host') }
+
+    it "is successful" do
+      allow(Hyrax::ResourceSync::ResourceListWriter).to receive(:new).with(capability_list_url: capability_list, resource_host: "test.host").and_return(writer)
+      expect(writer).to receive(:write).and_return(document)
+      get :resource_list
+      expect(response.content_type).to eq 'application/xml'
+      expect(response.body).to eq document
+    end
+  end
+
+  describe "change_list" do
+    before do
+      Rails.cache.clear
+    end
+
+    let(:writer) { double }
+    let(:document) { '<xml>' }
+    let(:capability_list) { Hyrax::Engine.routes.url_helpers.capability_list_url(host: 'test.host') }
+
+    it "is successful" do
+      allow(Hyrax::ResourceSync::ChangeListWriter).to receive(:new).with(capability_list_url: capability_list, resource_host: "test.host").and_return(writer)
+      expect(writer).to receive(:write).and_return(document)
+      get :change_list
+      expect(response.content_type).to eq 'application/xml'
+      expect(response.body).to eq document
+    end
+  end
+end

data/spec/controllers/hyrax/single_use_links_controller_spec.rb

@@ -0,0 +1,100 @@
+RSpec.describe Hyrax::SingleUseLinksController, type: :controller do
+  routes { Hyrax::Engine.routes }
+
+  let(:user) { create(:user) }
+  let(:file) { create(:file_set, user: user) }
+
+  describe "::show_presenter" do
+    subject { described_class }
+
+    its(:show_presenter) { is_expected.to eq(Hyrax::SingleUseLinkPresenter) }
+  end
+
+  describe "logged in user with edit permission" do
+    let(:hash) { "some-dummy-sha2-hash" }
+
+    before { sign_in user }
+
+    context "POST create" do
+      before do
+        expect(Digest::SHA2).to receive(:new).and_return(hash)
+      end
+
+      describe "creating a single-use download link" do
+        it "returns a link for downloading" do
+          post 'create_download', params: { id: file }
+          expect(response).to be_success
+          expect(response.body).to eq Hyrax::Engine.routes.url_helpers.download_single_use_link_url(hash, host: request.host, locale: 'en')
+        end
+      end
+
+      describe "creating a single-use show link" do
+        it "returns a link for showing" do
+          post 'create_show', params: { id: file }
+          expect(response).to be_success
+          expect(response.body).to eq Hyrax::Engine.routes.url_helpers.show_single_use_link_url(hash, host: request.host, locale: 'en')
+        end
+      end
+    end
+
+    context "GET index" do
+      describe "viewing existing links" do
+        before { get :index, params: { id: file } }
+        subject { response }
+
+        it { is_expected.to be_success }
+      end
+    end
+
+    context "DELETE destroy" do
+      let!(:link) { create(:download_link) }
+
+      it "deletes the link" do
+        expect { delete :destroy, params: { id: file, link_id: link } }.to change { SingleUseLink.count }.by(-1)
+        expect(response).to be_success
+      end
+    end
+  end
+
+  describe "logged in user without edit permission" do
+    let(:other_user) { create(:user) }
+    let(:file) { create(:file_set, user: user, read_users: [other_user]) }
+
+    before { sign_in other_user }
+    subject { response }
+
+    describe "creating a single-use download link" do
+      before { post 'create_download', params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+
+    describe "creating a single-use show link" do
+      before { post 'create_show', params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+
+    describe "viewing existing links" do
+      before { get :index, params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+  end
+
+  describe "unknown user" do
+    subject { response }
+
+    describe "creating a single-use download link" do
+      before { post 'create_download', params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+
+    describe "creating a single-use show link" do
+      before { post 'create_show', params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+
+    describe "viewing existing links" do
+      before { get :index, params: { id: file } }
+      it { is_expected.not_to be_success }
+    end
+  end
+end

data/spec/controllers/hyrax/single_use_links_viewer_controller_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Hyrax::SingleUseLinksViewerController do
+  routes { Hyrax::Engine.routes }
+  let(:user) { build(:user) }
+  let(:file) do
+    create(:file_set, label: 'world.png', user: user)
+  end
+
+  describe "retrieval links" do
+    let :show_link do
+      SingleUseLink.create item_id: file.id, path: Rails.application.routes.url_helpers.hyrax_file_set_path(id: file, locale: 'en')
+    end
+
+    let :download_link do
+      Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file)
+      SingleUseLink.create item_id: file.id, path: Hyrax::Engine.routes.url_helpers.download_path(id: file, locale: 'en')
+    end
+
+    let(:show_link_hash) { show_link.download_key }
+    let(:download_link_hash) { download_link.download_key }
+
+    describe "GET 'download'" do
+      let(:expected_content) { ActiveFedora::Base.find(file.id).original_file.content }
+
+      it "downloads the file and deletes the link from the database" do
+        expect(controller).to receive(:send_file_headers!).with(filename: 'world.png', disposition: 'attachment', type: 'image/png')
+        get :download, params: { id: download_link_hash }
+        expect(response.body).to eq expected_content
+        expect(response).to be_success
+        expect { SingleUseLink.find_by_download_key!(download_link_hash) }.to raise_error ActiveRecord::RecordNotFound
+      end
+
+      context "when the key is not found" do
+        before { SingleUseLink.find_by_download_key!(download_link_hash).destroy }
+
+        it "returns 404" do
+          get :download, params: { id: download_link_hash }
+          expect(response).to render_template("hyrax/single_use_links_viewer/single_use_error", "layouts/error")
+        end
+      end
+    end
+
+    describe "GET 'show'" do
+      it "renders the file set's show page and deletes the link from the database" do
+        get 'show', params: { id: show_link_hash }
+        expect(response).to be_success
+        expect(assigns[:presenter].id).to eq file.id
+        expect { SingleUseLink.find_by_download_key!(show_link_hash) }.to raise_error ActiveRecord::RecordNotFound
+      end
+
+      context "when the key is not found" do
+        before { SingleUseLink.find_by_download_key!(show_link_hash).destroy }
+        it "returns 404" do
+          get :show, params: { id: show_link_hash }
+          expect(response).to render_template("hyrax/single_use_links_viewer/single_use_error", "layouts/error")
+        end
+      end
+
+      it "returns 404 on attempt to get show path with download hash" do
+        get :show, params: { id: download_link_hash }
+        expect(response).to render_template("hyrax/single_use_links_viewer/single_use_error", "layouts/error")
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/static_controller_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Hyrax::StaticController, type: :controller do
+  routes { Hyrax::Engine.routes }
+  describe "#mendeley" do
+    it "renders page" do
+      get "mendeley"
+      expect(response).to be_success
+      expect(response).to render_template "layouts/homepage"
+    end
+    it "renders no layout with javascript" do
+      get :mendeley, xhr: true
+      expect(response).to be_success
+      expect(response).not_to render_template "layouts/homepage"
+    end
+  end
+
+  describe "#zotero" do
+    it "renders page" do
+      get "zotero"
+      expect(response).to be_success
+      expect(response).to render_template "layouts/homepage"
+    end
+    it "renders no layout with javascript" do
+      get :zotero, xhr: true
+      expect(response).to be_success
+      expect(response).not_to render_template "layouts/homepage"
+    end
+  end
+end

data/spec/controllers/hyrax/stats_controller_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Hyrax::StatsController do
+  let(:user) { create(:user) }
+  let(:usage) { double }
+
+  before do
+    allow_any_instance_of(User).to receive(:groups).and_return([])
+  end
+  routes { Hyrax::Engine.routes }
+  describe '#file' do
+    let(:file_set) { create(:file_set, user: user) }
+
+    context 'when user has access to file' do
+      before do
+        sign_in user
+        request.env['HTTP_REFERER'] = 'http://test.host/foo'
+      end
+
+      it 'renders the stats view' do
+        expect(Hyrax::FileUsage).to receive(:new).with(file_set.id).and_return(usage)
+        expect(controller).to receive(:add_breadcrumb).with('Home', Hyrax::Engine.routes.url_helpers.root_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.title'), Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.my.works'), Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with(I18n.t('hyrax.file_set.browse_view'), Rails.application.routes.url_helpers.hyrax_file_set_path(file_set, locale: 'en'))
+        get :file, params: { id: file_set }
+        expect(response).to be_success
+        expect(response).to render_template('stats/file')
+      end
+    end
+
+    context "user is not signed in but the file is public" do
+      let(:file_set) { create(:file_set, :public, user: user) }
+
+      it 'renders the stats view' do
+        get :file, params: { id: file_set }
+        expect(response).to be_success
+        expect(response).to render_template('stats/file')
+      end
+    end
+
+    context 'when user lacks access to file' do
+      let(:file_set) { create(:file_set) }
+
+      before do
+        sign_in user
+      end
+
+      it 'redirects to root_url' do
+        get :file, params: { id: file_set }
+        expect(response).to redirect_to(Hyrax::Engine.routes.url_helpers.root_path(locale: 'en'))
+      end
+    end
+  end
+
+  describe 'work' do
+    let(:work) { create(:generic_work, user: user) }
+
+    before do
+      sign_in user
+      request.env['HTTP_REFERER'] = 'http://test.host/foo'
+    end
+
+    it 'renders the stats view' do
+      expect(Hyrax::WorkUsage).to receive(:new).with(work.id).and_return(usage)
+      expect(controller).to receive(:add_breadcrumb).with('Home', Hyrax::Engine.routes.url_helpers.root_path(locale: 'en'))
+      expect(controller).to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.my.works'), Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en'))
+      expect(controller).to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.title'), Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+      expect(controller).to receive(:add_breadcrumb).with('Test title', main_app.hyrax_generic_work_path(work, locale: 'en'))
+      get :work, params: { id: work }
+      expect(response).to be_success
+      expect(response).to render_template('stats/work')
+    end
+  end
+end

data/spec/controllers/hyrax/transfers_controller_spec.rb

@@ -0,0 +1,200 @@
+RSpec.describe Hyrax::TransfersController, type: :controller do
+  describe "without a signed in user" do
+    describe "#index" do
+      it "redirects to sign in" do
+        get :index
+        expect(flash[:alert]).to eq "You need to sign in or sign up before continuing."
+        expect(response).to redirect_to main_app.new_user_session_path
+      end
+    end
+  end
+
+  describe "with a signed in user" do
+    let(:another_user) { create(:user) }
+    let(:user) { create(:user) }
+
+    before do
+      sign_in user
+    end
+
+    describe "#index" do
+      it "is successful" do
+        expect(controller).to receive(:add_breadcrumb).exactly(3).times
+        get :index
+        expect(response).to be_success
+        expect(assigns[:presenter]).to be_instance_of Hyrax::TransfersPresenter
+      end
+    end
+
+    describe "#new" do
+      let(:work) { create(:work, user: user) }
+
+      context 'when user is the depositor' do
+        it "is successful" do
+          expect(controller).to receive(:add_breadcrumb).exactly(3).times
+          sign_in user
+          get :new, params: { id: work.id }
+          expect(response).to be_success
+          expect(assigns[:work]).to eq(work)
+          expect(assigns[:proxy_deposit_request]).to be_kind_of ProxyDepositRequest
+          expect(assigns[:proxy_deposit_request].work_id).to eq(work.id)
+        end
+      end
+    end
+
+    describe "#create" do
+      let(:work) { create(:work, user: user) }
+
+      it "is successful" do
+        expect do
+          post :create, params: {
+            id: work.id,
+            proxy_deposit_request: {
+              transfer_to: another_user.user_key,
+              sender_comment: 'Hi mom!'
+            }
+          }
+        end.to change(ProxyDepositRequest, :count).by(1)
+        expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+        expect(flash[:notice]).to eq('Transfer request created')
+        proxy_request = another_user.proxy_deposit_requests.first
+        expect(proxy_request.work_id).to eq(work.id)
+        expect(proxy_request.sending_user).to eq(user)
+        expect(proxy_request.sender_comment).to eq 'Hi mom!'
+        # AND A NOTIFICATION SHOULD HAVE BEEN CREATED
+        notification = another_user.reload.mailbox.inbox[0].messages[0]
+        expect(notification.subject).to eq("Ownership Change Request")
+        expect(notification.body).to eq("<a href=\"#{routes.url_helpers.user_path(user)}\">#{user.name}</a> " \
+                                        "wants to transfer a work to you. Review all " \
+                                        "<a href=\"#{routes.url_helpers.transfers_path}\">transfer requests</a>")
+      end
+      it "gives an error if the user is not found" do
+        expect do
+          post :create, params: { id: work.id, proxy_deposit_request: { transfer_to: 'foo' } }
+        end.not_to change(ProxyDepositRequest, :count)
+        expect(assigns[:proxy_deposit_request].errors[:transfer_to]).to eq(['must be an existing user'])
+        expect(assigns[:work]).to be_instance_of GenericWork
+        expect(response).to be_success
+      end
+    end
+
+    describe "#accept", perform_enqueued: [ContentDepositorChangeEventJob] do
+      context "when I am the receiver" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(another_user.user_key)
+            w.save!
+            w.request_transfer_to(user)
+          end
+        end
+
+        it "is successful when retaining access rights" do
+          put :accept, params: { id: user.proxy_deposit_requests.first }
+          expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+          expect(flash[:notice]).to eq("Transfer complete")
+          expect(assigns[:proxy_deposit_request].status).to eq('accepted')
+          expect(incoming_work.reload.edit_users).to match_array [another_user.user_key, user.user_key]
+        end
+        it "is successful when resetting access rights" do
+          put :accept, params: { id: user.proxy_deposit_requests.first, reset: true }
+          expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+          expect(flash[:notice]).to eq("Transfer complete")
+          expect(assigns[:proxy_deposit_request].status).to eq('accepted')
+          expect(incoming_work.reload.edit_users).to eq([user.user_key])
+        end
+        it "handles sticky requests" do
+          put :accept, params: { id: user.proxy_deposit_requests.first, sticky: true }
+          expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+          expect(flash[:notice]).to eq("Transfer complete")
+          expect(assigns[:proxy_deposit_request].status).to eq('accepted')
+          expect(user.can_receive_deposits_from).to include(another_user)
+        end
+      end
+
+      context "accepting one that isn't mine" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(user.user_key)
+            w.save!
+            w.request_transfer_to(another_user)
+          end
+        end
+
+        it "does not allow me" do
+          put :accept, params: { id: another_user.proxy_deposit_requests.first }
+          expect(response).to redirect_to root_path
+          expect(flash[:alert]).to eq("You are not authorized to access this page.")
+        end
+      end
+    end
+
+    describe "#reject" do
+      context "when I am the receiver" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(another_user.user_key)
+            w.save!
+            w.request_transfer_to(user)
+          end
+        end
+
+        it "is successful" do
+          put :reject, params: { id: user.proxy_deposit_requests.first }
+          expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+          expect(flash[:notice]).to eq("Transfer rejected")
+          expect(assigns[:proxy_deposit_request].status).to eq('rejected')
+        end
+      end
+
+      context "accepting one that isn't mine" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(user.user_key)
+            w.save!
+            w.request_transfer_to(another_user)
+          end
+        end
+
+        it "does not allow me" do
+          put :reject, params: { id: another_user.proxy_deposit_requests.first }
+          expect(response).to redirect_to root_path
+          expect(flash[:alert]).to eq("You are not authorized to access this page.")
+        end
+      end
+    end
+
+    describe "#destroy" do
+      context "when I am the sender" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(user.user_key)
+            w.save!
+            w.request_transfer_to(another_user)
+          end
+        end
+
+        it "is successful" do
+          delete :destroy, params: { id: another_user.proxy_deposit_requests.first }
+          expect(response).to redirect_to routes.url_helpers.transfers_path(locale: 'en')
+          expect(flash[:notice]).to eq("Transfer canceled")
+        end
+      end
+
+      context "accepting one that isn't mine" do
+        let!(:incoming_work) do
+          GenericWork.new(title: ['incoming']) do |w|
+            w.apply_depositor_metadata(another_user.user_key)
+            w.save!
+            w.request_transfer_to(user)
+          end
+        end
+
+        it "does not allow me" do
+          delete :destroy, params: { id: user.proxy_deposit_requests.first }
+          expect(response).to redirect_to root_path
+          expect(flash[:alert]).to eq("You are not authorized to access this page.")
+        end
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/trophies_controller_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe Hyrax::TrophiesController do
+  describe "#toggle_trophy" do
+    let(:user) { create(:user) }
+    let(:work) { create(:work, user: user) }
+
+    context "for a work we have edit access on" do
+      before do
+        sign_in user
+      end
+      it "creates a trophy for a work" do
+        post :toggle_trophy, params: { id: work.id }
+        expect(response).to be_success
+        json = JSON.parse(response.body)
+        expect(json['user_id']).to eq user.id
+        expect(json['work_id']).to eq work.id
+      end
+      context 'where the trophy already exists' do
+        before do
+          user.trophies.create(work_id: work.id)
+        end
+        it 'destroys the trophy' do
+          expect { post :toggle_trophy, params: { id: work.id } }
+            .to change { Trophy.count }.by(-1)
+
+          expect(response).to be_success
+          json = JSON.parse(response.body)
+          expect(json['user_id']).to eq user.id
+          expect(json['work_id']).to eq work.id
+        end
+      end
+    end
+
+    context "for a work that we don't have edit access on" do
+      it "does not create a trophy" do
+        post :toggle_trophy, params: { id: work.id }
+        expect(response).not_to be_success
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/uploads_controller_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe Hyrax::UploadsController do
+  let(:user) { create(:user) }
+
+  describe "#create" do
+    let(:file) { fixture_file_upload('/world.png', 'image/png') }
+
+    context "when signed in" do
+      before do
+        sign_in user
+      end
+      it "is successful" do
+        post :create, params: { files: [file], format: 'json' }
+        expect(response).to be_success
+        expect(assigns(:upload)).to be_kind_of Hyrax::UploadedFile
+        expect(assigns(:upload)).to be_persisted
+        expect(assigns(:upload).user).to eq user
+      end
+    end
+
+    context "when not signed in" do
+      it "is unauthorized" do
+        post :create, params: { files: [file], format: 'json' }
+        expect(response.status).to eq 401
+      end
+    end
+  end
+
+  describe "#destroy" do
+    let(:file) { File.open(fixture_path + '/world.png') }
+    let(:uploaded_file) { create(:uploaded_file, file: file, user: user) }
+
+    context "when signed in" do
+      before do
+        sign_in user
+      end
+      it "destroys the uploaded file" do
+        delete :destroy, params: { id: uploaded_file }
+        expect(response.status).to eq 204
+        expect(assigns[:upload]).to be_destroyed
+        expect(File.exist?(uploaded_file.file.file.file)).to be false
+      end
+
+      context "for a file that doesn't belong to me" do
+        let(:uploaded_file) { create(:uploaded_file, file: file) }
+
+        it "doesn't destroy" do
+          delete :destroy, params: { id: uploaded_file }
+          expect(response.status).to eq 401
+        end
+      end
+    end
+
+    context "when not signed in" do
+      it "is redirected to sign in" do
+        delete :destroy, params: { id: uploaded_file }
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+      end
+    end
+  end
+end