hyrax 3.0.0.pre.rc1 → 3.0.0.pre.rc2

data/spec/controllers/hyrax/static_controller_spec.rb

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

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

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

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

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

data/spec/controllers/hyrax/users_controller_spec.rb

@@ -1,151 +0,0 @@
-RSpec.describe Hyrax::UsersController, type: :controller do
-  let(:user) { create(:user) }
-
-  before { sign_in user }
-
-  describe "#show" do
-    it "show the user profile if user exists" do
-      get :show, params: { id: user.user_key }
-      expect(response).to be_success
-      expect(assigns[:presenter]).to be_kind_of Hyrax::UserProfilePresenter
-    end
-
-    it "redirects to root if user does not exist" do
-      get :show, params: { id: 'johndoe666' }
-      expect(response).to redirect_to(root_path)
-      expect(flash[:alert]).to include("User 'johndoe666' does not exist")
-    end
-  end
-
-  describe "#index" do
-    let!(:u1) { create(:user) }
-    let!(:u2) { create(:user) }
-
-    before do
-      allow(Flipflop).to receive(:hide_users_list?).and_return(false)
-    end
-
-    describe "requesting html" do
-      before do
-        # These user types are excluded:
-        User.audit_user
-        User.batch_user
-        create(:user, :guest)
-      end
-
-      it "excludes the audit_user and batch_user" do
-        get :index
-        expect(assigns[:users].to_a).to match_array [user, u1, u2]
-        expect(response).to be_successful
-      end
-
-      it "sorts by the user key when login is specified" do
-        get :index, params: { sort: 'login' }
-        expect(assigns[:users].to_a).to match_array [user, u1, u2]
-      end
-
-      it "sorts by the user key when login desc is specified" do
-        get :index, params: { sort: 'login desc' }
-        expect(assigns[:users].to_a).to match_array [user, u1, u2]
-      end
-    end
-
-    describe "requesting json" do
-      render_views
-
-      it "displays users" do
-        get :index, params: { format: :json }
-        expect(response).to be_successful
-        json = JSON.parse(response.body).fetch('users')
-        expect(json.map { |u| u['id'] }).to include(u1.id, u2.id)
-        expect(json.map { |u| u['text'] }).to include(u1.email, u2.email)
-      end
-    end
-
-    describe "query users" do
-      it "finds the expected user via email" do
-        get :index, params: { uq: u1.email }
-        expect(assigns[:users]).to include(u1)
-        expect(assigns[:users]).not_to include(u2)
-        expect(response).to be_successful
-      end
-
-      context "by display name" do
-        let!(:u1) { create(:user, display_name: "Dr. Curator") }
-        let!(:u2) { create(:user, display_name: "Jr. Architect") }
-
-        it "finds the expected user via display name" do
-          #
-          # allow_any_instance_of(User).to receive(:display_name).and_return("Dr. Curator", "Jr.Archivist")
-          get :index, params: { uq: u1.display_name }
-          expect(assigns[:users]).to include(u1)
-          expect(assigns[:users]).not_to include(u2)
-          expect(response).to be_successful
-        end
-      end
-
-      it "uses the base query" do
-        u3 = create(:user)
-        allow(controller).to receive(:base_query).and_return(["email == \"#{u3.email}\""])
-        get :index
-        expect(assigns[:users]).to include(u3)
-        expect(assigns[:users]).not_to include(u1, u2)
-        u3.destroy
-      end
-    end
-  end
-
-  describe 'user list access' do
-    context 'with hide_users_list?=enabled' do
-      before do
-        allow(Flipflop).to receive(:hide_users_list?).and_return(true)
-      end
-
-      describe 'with registered user' do
-        it 'renders the user list' do
-          get :index
-          expect(response.code).to eq '200'
-          expect(response).to render_template(:index)
-        end
-
-        it 'does return .json results' do
-          get :index, params: { format: :json }
-          expect(response).to be_successful
-        end
-      end
-
-      describe 'with unauthenticated user' do
-        before do
-          sign_out user
-        end
-
-        it 'does not render the user list' do
-          get :index
-          expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
-          expect(response).to have_http_status(302)
-          expect(response).to redirect_to('/users/sign_in')
-        end
-
-        it 'does not return .json results' do
-          get :index, params: { format: :json }
-          expect(response).not_to be_successful
-        end
-      end
-    end
-
-    context 'with hide_users_list?=disabled' do
-      before do
-        sign_out user
-        allow(Flipflop).to receive(:hide_users_list?).and_return(false)
-      end
-
-      describe 'with unauthenticated user' do
-        it 'renders the user list' do
-          get :index
-          expect(response.code).to eq '200'
-          expect(response).to render_template(:index)
-        end
-      end
-    end
-  end
-end