hyrax 2.6.0 → 2.9.0

data/spec/controllers/hyrax/api/zotero_controller_spec.rb

@@ -1,162 +0,0 @@
-RSpec.describe Hyrax::API::ZoteroController, type: :controller do
-  let(:user) { create(:user) }
-
-  subject { response }
-
-  context 'with an HTTP GET to /api/zotero' do
-    context 'with an unauthenticated client' do
-      before { get :initiate }
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
-      end
-    end
-
-    context 'with an unregistered user' do
-      before do
-        allow_any_instance_of(Ability).to receive(:can?).with(:create, GenericWork).and_return(false)
-        sign_in user
-        get :initiate
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(subject).to redirect_to(root_path)
-        expect(flash[:alert]).to eq 'You are not authorized to perform this operation'
-      end
-    end
-
-    context 'with an invalid key/secret combo' do
-      before do
-        allow(Hyrax::Zotero).to receive(:config) { broken_config }
-        sign_in user
-
-        stub_request(:get,
-                     %r{https://www.zotero.org/oauth/request\?oauth_callback=http://test\.host/api/zotero/callback&oauth_consumer_key=%7B:client_key=%3E%22foo%22,%20:client_secret=%3E%22bar%22%7D})
-          .to_return(status: 401, body: "oauth_problem=consumer_key_unknown")
-        get :initiate
-      end
-
-      let(:broken_config) { Hash.new(client_key: 'foo', client_secret: 'bar') }
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(subject).to redirect_to(root_path)
-        expect(flash[:alert]).to eq 'Invalid Zotero client key pair'
-      end
-    end
-
-    describe 'redirects to Zotero' do
-      before do
-        allow(controller).to receive(:client) { client }
-        allow(client).to receive(:get_request_token) { token }
-        allow_any_instance_of(User).to receive(:zotero_token=)
-        sign_in user
-        get :initiate
-      end
-
-      let(:token) do
-        object_double(OAuth::RequestToken.new(client),
-                      authorize_url: 'https://www.zotero.org/oauth/authorize?identity=1&oauth_callback=http%3A%2F%2Ftest.host%2Fapi%2Fzotero%2Fcallback&oauth_token=bc2502f2750983c57224')
-      end
-      let(:client) do
-        OAuth::Consumer.new(Hyrax::Zotero.config['client_key'],
-                            Hyrax::Zotero.config['client_secret'],
-                            site: 'https://www.zotero.org',
-                            scheme: :query_string,
-                            http_method: :get,
-                            request_token_path: '/oauth/request',
-                            access_token_path: '/oauth/access',
-                            authorize_path: '/oauth/authorize')
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(flash[:alert]).to be_nil
-        expect(subject.headers['Location']).to include('oauth_callback=http%3A%2F%2Ftest.host%2Fapi%2Fzotero%2Fcallback')
-      end
-    end
-  end
-
-  context 'with an HTTP POST/GET to /api/zotero/callback' do
-    context 'with an unauthenticated user' do
-      before { get :callback }
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
-      end
-    end
-
-    context 'with a user who is not permitted to make works' do
-      before do
-        allow_any_instance_of(Ability).to receive(:can?).with(:create, GenericWork).and_return(false)
-        sign_in user
-        get :callback
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(subject).to redirect_to(root_path)
-        expect(flash[:alert]).to eq 'You are not authorized to perform this operation'
-      end
-    end
-
-    context 'with a request lacking an oauth_token' do
-      before do
-        sign_in user
-        get :callback
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(subject).to redirect_to(routes.url_helpers.edit_dashboard_profile_path(user, locale: 'en'))
-        expect(flash[:alert]).to eq 'Malformed request from Zotero'
-      end
-    end
-
-    context 'with a non-matching token' do
-      before do
-        sign_in user
-        get :callback, params: { oauth_token: 'woohoo', oauth_verifier: '12345' }
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(subject).to redirect_to(routes.url_helpers.edit_dashboard_profile_path(user, locale: 'en'))
-        expect(flash[:alert]).to eq 'You have not yet connected to Zotero'
-      end
-    end
-
-    context 'with a signed-in, valid user' do
-      before do
-        allow_any_instance_of(User).to receive(:zotero_token) { user_token }
-        allow(Hyrax::Arkivo::CreateSubscriptionJob).to receive(:perform_later)
-        sign_in user
-        get :callback, params: { oauth_token: token_string, oauth_verifier: pin }
-      end
-
-      let(:token_string) { 'woohoo' }
-      let(:pin) { '12345' }
-      let(:user_token) do
-        double('token',
-               params: { oauth_token: token_string },
-               get_access_token: access_token)
-      end
-      let(:zuserid) { 'myzuser' }
-      let(:access_token) do
-        double('access', params: { userID: zuserid })
-      end
-
-      specify do
-        expect(subject).to have_http_status(302)
-        expect(Hyrax::Arkivo::CreateSubscriptionJob).to have_received(:perform_later)
-        expect(subject).to redirect_to(routes.url_helpers.dashboard_profile_path(user, locale: 'en'))
-        expect(flash[:alert]).to be_nil
-        expect(flash[:notice]).to eq 'Successfully connected to Zotero!'
-        expect(user.reload.zotero_userid).to eq zuserid
-      end
-    end
-  end
-end

data/spec/controllers/hyrax/batch_edits_controller_spec.rb

@@ -1,232 +0,0 @@
-RSpec.describe Hyrax::BatchEditsController, type: :controller do
-  let(:user) { create(:user) }
-
-  before do
-    sign_in user
-    allow_any_instance_of(User).to receive(:groups).and_return([])
-    request.env["HTTP_REFERER"] = 'test.host/original_page'
-  end
-
-  describe "#edit" do
-    let(:one) { create(:work, creator: ["Fred"], title: ["abc"], language: ['en']) }
-    let(:two) { create(:work, creator: ["Wilma"], title: ["abc2"], publisher: ['Rand McNally'], language: ['en'], resource_type: ['bar']) }
-    let(:three) { create(:work, creator: ["Dino"], title: ["abc3"]) }
-
-    before do
-      controller.batch = [one.id, two.id, three.id]
-      expect(controller).to receive(:can?).with(:edit, one.id).and_return(true)
-      expect(controller).to receive(:can?).with(:edit, two.id).and_return(true)
-      expect(controller).to receive(:can?).with(:edit, three.id).and_return(false)
-    end
-
-    it "is successful" do
-      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'))
-      get :edit
-      expect(response).to be_successful
-      expect(response).to render_template('dashboard')
-      expect(assigns[:form].model.creator).to match_array ["Fred", "Wilma"]
-    end
-  end
-
-  describe "update" do
-    let(:user) { build(:user) }
-    let(:admin_set) { create(:admin_set) }
-    let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
-    let!(:workflow) { create(:workflow, allows_access_grant: true, active: true, permission_template_id: permission_template.id) }
-    let!(:one) do
-      create(:work, admin_set_id: admin_set.id, creator: ["Fred"], title: ["abc"], language: ['en'], user: user)
-    end
-
-    let!(:two) do
-      create(:work, admin_set_id: admin_set.id, creator: ["Fred"], title: ["abc"], language: ['en'], user: user)
-    end
-
-    let!(:three) do
-      create(:work, admin_set_id: admin_set.id, creator: ["Fred"], title: ["abc"], language: ['en'])
-    end
-
-    let!(:file_set) do
-      create(:file_set, creator: ["Fred"])
-    end
-
-    let(:release_date) { Time.zone.today + 2 }
-
-    let(:mycontroller) { "hyrax/my/works" }
-
-    before do
-      one.members << file_set
-      one.save!
-
-      # TODO: why aren't we just submitting batch_document_ids[] as a parameter?
-      controller.batch = [one.id, two.id, three.id]
-      expect(controller).to receive(:can?).with(:edit, one.id).and_return(true)
-      expect(controller).to receive(:can?).with(:edit, two.id).and_return(true)
-      expect(controller).to receive(:can?).with(:edit, three.id).and_return(false)
-    end
-
-    it "is successful" do
-      put :update, params: { update_type: "delete_all" }
-      expect(response).to redirect_to(dashboard_path(locale: 'en'))
-      expect { GenericWork.find(one.id) }.to raise_error(Ldp::Gone)
-      expect { GenericWork.find(two.id) }.to raise_error(Ldp::Gone)
-      expect(GenericWork).to exist(three.id)
-    end
-
-    it "redirects to the return controller" do
-      put :update, params: { update_type: "delete_all", return_controller: mycontroller }
-      expect(response).to redirect_to(Hyrax::Engine.routes.url_for(controller: mycontroller, only_path: true, locale: 'en'))
-    end
-
-    it "updates the records" do
-      put :update, params: { update_type: "update", generic_work: { subject: ["zzz"] } }
-      expect(response).to be_redirect
-      expect(GenericWork.find(one.id).subject).to eq ["zzz"]
-      expect(GenericWork.find(two.id).subject).to eq ["zzz"]
-      expect(GenericWork.find(three.id).subject).to be_empty
-    end
-
-    it "updates permissions" do
-      put :update, params: { update_type: "update", generic_work: { visibility: "authenticated" } }
-      expect(response).to be_redirect
-
-      work1 = GenericWork.find(one.id)
-      expect(work1.visibility).to eq "authenticated"
-      expect(work1.file_sets.map(&:visibility)).to eq ["authenticated"]
-
-      expect(GenericWork.find(two.id).visibility).to eq "authenticated"
-      expect(GenericWork.find(three.id).visibility).to eq "restricted"
-    end
-
-    it 'creates leases' do
-      put :update, params: { update_type: "update",
-                             generic_work: { visibility: "lease", lease_expiration_date: release_date, visibility_during_lease: 'open', visibility_after_lease: 'restricted' } }
-      expect(response).to be_redirect
-
-      work1 = GenericWork.find(one.id)
-      expect(work1.visibility).to eq "open"
-      expect(work1.visibility_during_lease).to eq 'open'
-      expect(work1.visibility_after_lease).to eq 'restricted'
-      expect(work1.lease_expiration_date).to eq release_date
-      expect(work1.file_sets.map(&:visibility)).to eq ['open']
-      expect(work1.file_sets.map(&:visibility_during_lease)).to eq ['open']
-      expect(work1.file_sets.map(&:visibility_after_lease)).to eq ['restricted']
-      expect(work1.file_sets.map(&:lease_expiration_date)).to eq [release_date]
-
-      work2 = GenericWork.find(two.id)
-      expect(work2.visibility).to eq 'open'
-      expect(work2.visibility_during_lease).to eq 'open'
-      expect(work2.visibility_after_lease).to eq 'restricted'
-      expect(work2.lease_expiration_date).to eq release_date
-
-      work3 = GenericWork.find(three.id)
-      expect(work3.visibility).to eq 'restricted'
-      expect(work3.visibility_during_lease).to be_nil
-      expect(work3.visibility_after_lease).to be_nil
-      expect(work3.lease_expiration_date).to be_nil
-    end
-
-    it 'creates embargoes' do
-      put :update, params: { update_type: "update",
-                             generic_work: { visibility: "embargo", embargo_release_date: release_date, visibility_during_embargo: 'authenticated', visibility_after_embargo: 'open' } }
-      expect(response).to be_redirect
-
-      work1 = GenericWork.find(one.id)
-      expect(work1.visibility).to eq "authenticated"
-      expect(work1.visibility_during_embargo).to eq 'authenticated'
-      expect(work1.visibility_after_embargo).to eq 'open'
-      expect(work1.embargo_release_date).to eq release_date
-      expect(work1.file_sets.map(&:visibility)).to eq ['authenticated']
-      expect(work1.file_sets.map(&:visibility_during_embargo)).to eq ['authenticated']
-      expect(work1.file_sets.map(&:visibility_after_embargo)).to eq ['open']
-      expect(work1.file_sets.map(&:embargo_release_date)).to eq [release_date]
-
-      work2 = GenericWork.find(two.id)
-      expect(work2.visibility).to eq 'authenticated'
-      expect(work2.visibility_during_embargo).to eq 'authenticated'
-      expect(work2.visibility_after_embargo).to eq 'open'
-      expect(work2.embargo_release_date).to eq release_date
-
-      work3 = GenericWork.find(three.id)
-      expect(work3.visibility).to eq 'restricted'
-      expect(work3.visibility_during_embargo).to be_nil
-      expect(work3.visibility_after_embargo).to be_nil
-      expect(work3.embargo_release_date).to be_nil
-    end
-
-    context 'with roles' do
-      it 'updates roles' do
-        put :update, params: { update_type: "update", generic_work: { permissions_attributes: [{ type: 'person', access: 'read', name: 'foo@bar.com' }] } }
-        expect(response).to be_redirect
-
-        work1 = GenericWork.find(one.id)
-        expect(work1.read_users).to include "foo@bar.com"
-        expect(work1.file_sets.map(&:read_users)).to eq [["foo@bar.com"]]
-
-        expect(GenericWork.find(two.id).read_users).to eq ["foo@bar.com"]
-        expect(GenericWork.find(three.id).read_users).to eq []
-      end
-    end
-  end
-
-  describe "#destroy_collection" do
-    let(:user) { create(:user) }
-
-    let(:collection1) do
-      create(:public_collection_lw, title: ["My First Collection"],
-                                    description: ["My incredibly detailed description of the collection"],
-                                    user: user)
-    end
-
-    let(:collection2) do
-      create(:public_collection_lw, title: ["My Other Collection"],
-                                    description: ["My incredibly detailed description of the other collection"],
-                                    user: user)
-    end
-
-    let!(:work1) { create(:work, title: ["First of the Assets"], member_of_collections: [collection1], user: user) }
-    let(:work2)  { create(:work, title: ["Second of the Assets"], user: user) }
-
-    let(:mycontroller) { "hyrax/my/works" }
-    let(:curation_concern) { create(:work1, user: user) }
-
-    context 'when user has edit access' do
-      it "deletes collections with and without works in it" do
-        controller.batch = [collection1.id, collection2.id]
-        delete :destroy_collection, params: { update_type: "delete_all" }
-        expect { Collection.find(collection1.id) }.to raise_error(Ldp::Gone)
-        expect { Collection.find(collection2.id) }.to raise_error(Ldp::Gone)
-      end
-    end
-
-    context 'when user does not have edit access' do
-      let(:user2) { create(:user) }
-
-      let(:collection3) do
-        create(:public_collection_lw, title: ["User2's Collection"],
-                                      description: ["Collection created by user2"],
-                                      user: user2)
-      end
-
-      before do
-        allow(controller).to receive(:current_user).and_return(user2)
-      end
-
-      it "fails to delete collections when user does not have edit access" do
-        controller.batch = [collection1.id, collection3.id]
-        delete :destroy_collection, params: { update_type: "delete_all" }
-        expect(Collection.exists?(collection1.id)).to eq true
-        expect(Collection.exists?(collection2.id)).to eq true
-      end
-
-      it "deletes collections where user has edit access, failing to delete those where user does not have edit access" do
-        controller.batch = [collection1.id, collection3.id]
-        delete :destroy_collection, params: { update_type: "delete_all" }
-        expect(Collection.exists?(collection1.id)).to eq true
-        expect(Collection.exists?(collection2.id)).to eq true
-        expect { Collection.find(collection3.id) }.to raise_error(Ldp::Gone)
-      end
-    end
-  end
-end

data/spec/controllers/hyrax/batch_uploads_controller_spec.rb

@@ -1,131 +0,0 @@
-RSpec.describe Hyrax::BatchUploadsController do
-  let(:user) { create(:user) }
-  let(:expected_types) do
-    { '1' => 'Article',
-      '2' => ['Article', 'Text'] }
-  end
-  let(:expected_individual_params) do
-    { '1' => 'foo',
-      '2' => 'bar' }
-  end
-  let(:expected_shared_params) do
-    { 'keyword' => [], 'visibility' => 'open', :model => 'GenericWork' }
-  end
-  let(:batch_upload_item) do
-    { keyword: [""], visibility: 'open', payload_concern: 'GenericWork' }
-  end
-  let(:post_params) do
-    {
-      title: expected_individual_params,
-      resource_type: expected_types,
-      uploaded_files: ['1', '2'],
-      batch_upload_item: batch_upload_item
-    }
-  end
-
-  before do
-    sign_in user
-  end
-
-  describe "#new" do
-    it "is successful" do
-      get :new
-      expect(response).to be_successful
-      expect(assigns[:form]).to be_kind_of Hyrax::Forms::BatchUploadForm
-      expect(response).to render_template('hyrax/dashboard')
-    end
-  end
-
-  describe "#create" do
-    context 'when feature is disabled' do
-      before do
-        allow(Flipflop).to receive(:batch_upload?).and_return(false)
-      end
-      it 'redirects with an error message' do
-        post :create, params: post_params.merge(format: :html)
-        expect(response).to redirect_to Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en')
-        expect(flash[:alert]).to include('Feature disabled by administrator')
-      end
-      context 'when json is requested' do
-        it 'returns an HTTP 403' do
-          post :create, params: post_params.merge(format: :json)
-          expect(response).to have_http_status(403)
-          expect(response.body).to include('Feature disabled by administrator')
-        end
-      end
-    end
-
-    context "with expected params" do
-      it 'spawns a job, redirects to dashboard, and has an html_safe flash notice' do
-        expect(BatchCreateJob).to receive(:perform_later)
-          .with(user,
-                expected_individual_params,
-                expected_types,
-                ['1', '2'],
-                expected_shared_params,
-                Hyrax::BatchCreateOperation)
-        post :create, params: post_params
-        expect(response).to redirect_to Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en')
-        expect(flash[:notice]).to be_html_safe
-        expect(flash[:notice]).to include("Your files are being processed")
-      end
-    end
-
-    context 'with missing resource_type' do
-      let(:post_params) do
-        {
-          title: expected_individual_params,
-          uploaded_files: ['1', '2'],
-          batch_upload_item: batch_upload_item
-        }
-      end
-
-      it 'is successful' do
-        expect(BatchCreateJob).to receive(:perform_later)
-          .with(user,
-                expected_individual_params,
-                {},
-                ['1', '2'],
-                expected_shared_params,
-                a_kind_of(Hyrax::BatchCreateOperation))
-        post :create, params: post_params
-        expect(response).to redirect_to Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en')
-        expect(flash[:notice]).to include("Your files are being processed")
-      end
-    end
-
-    context "when submitting works on behalf of other user" do
-      let(:batch_upload_item) do
-        {
-          payload_concern: NamespacedWorks::NestedWork,
-          permissions_attributes: [
-            { type: "group", name: "public", access: "read" }
-          ],
-          on_behalf_of: 'elrayle'
-        }
-      end
-
-      it 'redirects to managed works page' do
-        allow(BatchCreateJob).to receive(:perform_later)
-        post :create, params: post_params
-        expect(response).to redirect_to Hyrax::Engine.routes.url_helpers.dashboard_works_path(locale: 'en')
-      end
-    end
-  end
-
-  describe "#attributes_for_actor" do
-    subject { controller.send(:attributes_for_actor) }
-
-    before do
-      controller.params = post_params
-    end
-    let(:expected_shared_params) do
-      ActionController::Parameters.new(keyword: [], visibility: 'open').permit!
-    end
-
-    it "excludes uploaded_files and title" do
-      expect(subject).not_to include('title', :title, 'uploaded_files', :uploaded_files)
-      expect(subject).to eq expected_shared_params
-    end
-  end
-end