hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/batch_edits_controller_spec.rb

@@ -0,0 +1,232 @@
+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, title: ["My First Collection"],
+                                 description: ["My incredibly detailed description of the collection"],
+                                 user: user)
+    end
+
+    let(:collection2) do
+      create(:public_collection, 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, 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

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

data/spec/controllers/hyrax/citations_controller_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Hyrax::CitationsController do
+  describe "#work" do
+    let(:user) { create(:user) }
+    let(:work) { create(:work, user: user) }
+
+    context "with an authenticated_user" do
+      before do
+        sign_in user
+        request.env['HTTP_REFERER'] = 'http://test.host/foo'
+        create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s)
+      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('Dashboard', Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+        get :work, params: { id: work }
+        expect(response).to be_successful
+        expect(response).to render_template('layouts/hyrax/1_column')
+        expect(assigns(:presenter)).to be_kind_of Hyrax::WorkShowPresenter
+      end
+    end
+
+    context "with an unauthenticated user" do
+      it "is not successful" do
+        get :work, params: { id: work }
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+        expect(flash[:alert]).to eq "You are not authorized to access this page."
+        expect(session['user_return_to']).to eq request.url
+      end
+    end
+  end
+  describe "#file" do
+    let(:user) { create(:user) }
+    let(:file_set) { create(:file_set, user: user) }
+
+    context "with an authenticated_user" do
+      before do
+        sign_in user
+        request.env['HTTP_REFERER'] = 'http://test.host/foo'
+      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('Dashboard', Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+        get :file, params: { id: file_set }
+        expect(response).to be_successful
+        expect(response).to render_template('layouts/hyrax/1_column')
+        expect(assigns(:presenter)).to be_kind_of Hyrax::FileSetPresenter
+      end
+    end
+
+    context "with an unauthenticated user" do
+      it "is not successful" do
+        get :file, params: { id: file_set }
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+        expect(flash[:alert]).to eq "You are not authorized to access this page."
+        expect(session['user_return_to']).to eq request.url
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/collections_controller_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe Hyrax::CollectionsController do
+  routes { Hyrax::Engine.routes }
+  let(:user)  { create(:user) }
+  let(:other) { build(:user) }
+
+  let(:collection) do
+    create(:public_collection, title: ["My collection"],
+                               description: ["My incredibly detailed description of the collection"],
+                               user: user)
+  end
+
+  let(:asset1)         { create(:work, title: ["First of the Assets"], user: user) }
+  let(:asset2)         { create(:work, title: ["Second of the Assets"], user: user) }
+  let(:asset3)         { create(:work, title: ["Third of the Assets"], user: user) }
+  let(:asset4)         { create(:collection, title: ["First subcollection"], user: user) }
+  let(:asset5)         { create(:collection, title: ["Second subcollection"], user: user) }
+  let(:unowned_asset)  { create(:work, user: other) }
+
+  let(:collection_attrs) do
+    { title: ['My First Collection'], description: ["The Description\r\n\r\nand more"] }
+  end
+
+  describe "#show" do # public landing page
+    context "when signed in" do
+      before do
+        sign_in user
+        [asset1, asset2, asset3, asset4, asset5].each do |asset|
+          asset.member_of_collections = [collection]
+          asset.save
+        end
+      end
+
+      it "returns the collection and its members" do # rubocop:disable RSpec/ExampleLength
+        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'))
+        get :show, params: { id: collection }
+        expect(response).to be_successful
+        expect(response).to render_template("layouts/hyrax/1_column")
+        expect(assigns[:presenter]).to be_kind_of Hyrax::CollectionPresenter
+        expect(assigns[:presenter].title).to match_array collection.title
+        expect(assigns[:member_docs].map(&:id)).to match_array [asset1, asset2, asset3].map(&:id)
+        expect(assigns[:subcollection_docs].map(&:id)).to match_array [asset4, asset5].map(&:id)
+        expect(assigns[:members_count]).to eq(3)
+        expect(assigns[:subcollection_count]).to eq(2)
+      end
+
+      context "and searching" do
+        it "returns some works and subcollections" do
+          # "/collections/4m90dv529?utf8=%E2%9C%93&cq=King+Louie&sort="
+          get :show, params: { id: collection, cq: "Second" }
+          expect(assigns[:presenter]).to be_kind_of Hyrax::CollectionPresenter
+          expect(assigns[:member_docs].map(&:id)).to match_array [asset2].map(&:id)
+          expect(assigns[:subcollection_docs].map(&:id)).to match_array [asset5].map(&:id)
+          expect(assigns[:members_count]).to eq(1)
+          expect(assigns[:subcollection_count]).to eq(1)
+        end
+      end
+
+      context 'when the page parameter is passed' do
+        it 'loads the collection (paying no attention to the page param)' do
+          get :show, params: { id: collection, page: '2' }
+          expect(response).to be_successful
+          expect(assigns[:presenter]).to be_kind_of Hyrax::CollectionPresenter
+          expect(assigns[:presenter].to_s).to eq 'My collection'
+        end
+      end
+
+      context "without a referer" do
+        it "sets breadcrumbs" 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'))
+          get :show, params: { id: collection }
+          expect(response).to be_successful
+        end
+      end
+
+      context "with a referer" do
+        before do
+          request.env['HTTP_REFERER'] = 'http://test.host/foo'
+        end
+
+        it "sets breadcrumbs" 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('Dashboard', Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+          expect(controller).to receive(:add_breadcrumb).with('Collections', Hyrax::Engine.routes.url_helpers.my_collections_path(locale: 'en'))
+          expect(controller).to receive(:add_breadcrumb).with('My collection', collection_path(collection.id, locale: 'en'), "aria-current" => "page")
+          get :show, params: { id: collection }
+          expect(response).to be_successful
+        end
+      end
+    end
+
+    context "not signed in" do
+      it "does not show me files in the collection" do
+        get :show, params: { id: collection }
+        expect(assigns[:member_docs].count).to eq 0
+        expect(assigns[:subcollection_docs].count).to eq 0
+      end
+    end
+
+    context "without a referer" do
+      it "sets breadcrumbs" do
+        expect(controller).not_to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.title'), Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+        expect(controller).not_to receive(:add_breadcrumb).with('Your Collections', Hyrax::Engine.routes.url_helpers.my_collections_path(locale: 'en'))
+        expect(controller).not_to receive(:add_breadcrumb).with('My collection', collection_path(collection.id, locale: 'en'))
+
+        get :show, params: { id: collection }
+        expect(response).to be_successful
+      end
+    end
+
+    context "with a referer" do
+      before do
+        request.env['HTTP_REFERER'] = 'http://test.host/foo'
+      end
+
+      it "sets breadcrumbs" do
+        expect(controller).not_to receive(:add_breadcrumb).with(I18n.t('hyrax.dashboard.title'), Hyrax::Engine.routes.url_helpers.dashboard_path(locale: 'en'))
+        expect(controller).not_to receive(:add_breadcrumb).with('Your Collections', Hyrax::Engine.routes.url_helpers.my_collections_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with('My collection', collection_path(collection.id, locale: 'en'), "aria-current" => "page")
+        get :show, params: { id: collection }
+        expect(response).to be_successful
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/contact_form_controller_spec.rb

@@ -0,0 +1,96 @@
+RSpec.describe Hyrax::ContactFormController do
+  let(:user) { create(:user) }
+  let(:required_params) do
+    {
+      category: "Depositing content",
+      name: "Rose Tyler",
+      email: "rose@timetraveler.org",
+      subject: "The Doctor",
+      message: "Run."
+    }
+  end
+
+  before { sign_in(user) }
+
+  describe "#new" do
+    subject { response }
+
+    before { get :new }
+    it { is_expected.to be_success }
+  end
+
+  describe "#create" do
+    subject { flash }
+
+    before { post :create, params: { contact_form: params } }
+    context "with the required parameters" do
+      let(:params) { required_params }
+
+      its(:notice) { is_expected.to eq("Thank you for your message!") }
+    end
+
+    context "without a category" do
+      let(:params)  { required_params.except(:category) }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Category can't be blank") }
+    end
+
+    context "without a name" do
+      let(:params)  { required_params.except(:name) }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Name can't be blank") }
+    end
+
+    context "without an email" do
+      let(:params)  { required_params.except(:email) }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Email can't be blank") }
+    end
+
+    context "without a subject" do
+      let(:params)  { required_params.except(:subject) }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Subject can't be blank") }
+    end
+
+    context "without a message" do
+      let(:params)  { required_params.except(:message) }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Message can't be blank") }
+    end
+
+    context "with an invalid email" do
+      let(:params)  { required_params.merge(email: "bad-wolf") }
+
+      its([:error]) { is_expected.to eq("Sorry, this message was not sent successfully. Email is invalid") }
+    end
+  end
+
+  describe "#after_deliver" do
+    context "with a successful email" do
+      it "calls #after_deliver" do
+        expect(controller).to receive(:after_deliver)
+        post :create, params: { contact_form: required_params }
+      end
+    end
+    context "with an unsuccessful email" do
+      it "does not call #after_deliver" do
+        expect(controller).not_to receive(:after_deliver)
+        post :create, params: { contact_form: required_params.except(:email) }
+      end
+    end
+  end
+
+  context "when encoutering a RuntimeError" do
+    let(:logger) { double(info?: true) }
+
+    before do
+      allow(controller).to receive(:logger).and_return(logger)
+      allow(Hyrax::ContactMailer).to receive(:contact).and_raise(RuntimeError)
+    end
+    it "is logged via Rails" do
+      expect(logger).to receive(:error).with("Contact form failed to send: #<RuntimeError: RuntimeError>")
+      post :create, params: { contact_form: required_params }
+    end
+  end
+end