hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/featured_work_lists_controller_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Hyrax::FeaturedWorkListsController, type: :controller do
+  describe "#create" do
+    before do
+      expect(controller).to receive(:authorize!).with(:update, FeaturedWork)
+    end
+
+    let(:feature1) { create(:featured_work) }
+    let(:feature2) { create(:featured_work) }
+
+    it "is successful" do
+      post :create, params: {
+        format: :json,
+        featured_work_list: {
+          featured_works_attributes: [{ id: feature1.id, order: "2" }, { id: feature2.id, order: "1" }]
+        }
+      }
+      expect(feature1.reload.order).to eq 2
+    end
+  end
+end

data/spec/controllers/hyrax/featured_works_controller_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe Hyrax::FeaturedWorksController, type: :controller do
+  describe "#create" do
+    before do
+      sign_in create(:user)
+      expect(controller).to receive(:authorize!).with(:create, FeaturedWork).and_return(true)
+    end
+
+    context "when there are no featured works" do
+      it "creates one" do
+        expect do
+          post :create, params: { id: '1234abcd', format: :json }
+        end.to change { FeaturedWork.count }.by(1)
+        expect(response).to be_successful
+      end
+    end
+
+    context "when there are 5 featured works" do
+      before do
+        5.times do |n|
+          FeaturedWork.create(work_id: n.to_s)
+        end
+      end
+      it "does not create another" do
+        expect do
+          post :create, params: { id: '1234abcd', format: :json }
+        end.not_to change { FeaturedWork.count }
+        expect(response.status).to eq 422
+      end
+    end
+  end
+
+  describe "#destroy" do
+    before do
+      sign_in create(:user)
+      expect(controller).to receive(:authorize!).with(:destroy, FeaturedWork).and_return(true)
+    end
+
+    context "when the work exists" do
+      before { create(:featured_work, work_id: '1234abcd') }
+
+      it "removes it" do
+        expect do
+          delete :destroy, params: { id: '1234abcd', format: :json }
+        end.to change { FeaturedWork.count }.by(-1)
+        expect(response.status).to eq 204
+      end
+    end
+
+    context "when it was already removed" do
+      it "doesn't raise an error" do
+        delete :destroy, params: { id: '1234abcd', format: :json }
+        expect(response.status).to eq 204
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/file_sets_controller_spec.rb

@@ -0,0 +1,322 @@
+RSpec.describe Hyrax::FileSetsController do
+  routes { Rails.application.routes }
+  let(:user) { create(:user) }
+  let(:actor) { controller.send(:actor) }
+
+  context "when signed in" do
+    before do
+      sign_in user
+    end
+
+    describe "#destroy" do
+      context "file_set with a parent" do
+        let(:file_set) do
+          create(:file_set, user: user)
+        end
+        let(:work) do
+          create(:work, title: ['test title'], user: user)
+        end
+
+        let(:delete_message) { double('delete message') }
+
+        before do
+          work.ordered_members << file_set
+          work.save!
+        end
+
+        it "deletes the file" do
+          expect(ContentDeleteEventJob).to receive(:perform_later).with(file_set.id, user)
+          expect do
+            delete :destroy, params: { id: file_set }
+          end.to change { FileSet.exists?(file_set.id) }.from(true).to(false)
+          expect(response).to redirect_to main_app.hyrax_generic_work_path(work, locale: 'en')
+        end
+      end
+    end
+
+    describe "#edit" do
+      let(:parent) do
+        create(:work, :public, user: user)
+      end
+      let(:file_set) do
+        create(:file_set, user: user).tap do |file_set|
+          parent.ordered_members << file_set
+          parent.save!
+        end
+      end
+
+      before do
+        binary = StringIO.new("hey")
+        Hydra::Works::AddFileToFileSet.call(file_set, binary, :original_file, versioning: true)
+        request.env['HTTP_REFERER'] = 'http://test.host/foo'
+      end
+
+      it "sets the breadcrumbs and versions presenter" 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'))
+        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 :edit, params: { id: file_set }
+
+        expect(response).to be_success
+        expect(assigns[:file_set]).to eq file_set
+        expect(assigns[:version_list]).to be_kind_of Hyrax::VersionListPresenter
+        expect(assigns[:parent]).to eq parent
+        expect(response).to render_template(:edit)
+        expect(response).to render_template('dashboard')
+      end
+    end
+
+    describe "#update" do
+      let(:file_set) do
+        create(:file_set, user: user)
+      end
+
+      context "when updating metadata" do
+        it "spawns a content update event job" do
+          expect(ContentUpdateEventJob).to receive(:perform_later).with(file_set, user)
+          post :update, params: {
+            id: file_set,
+            file_set: {
+              title: ['new_title'],
+              keyword: [''],
+              permissions_attributes: [{ type: 'person',
+                                         name: 'archivist1',
+                                         access: 'edit' }]
+            }
+          }
+          expect(response).to redirect_to main_app.hyrax_file_set_path(file_set, locale: 'en')
+        end
+      end
+
+      context "when updating the attached file" do
+        let(:actor) { double }
+
+        before do
+          allow(Hyrax::Actors::FileActor).to receive(:new).and_return(actor)
+        end
+
+        it "spawns a ContentNewVersionEventJob", perform_enqueued: [IngestJob] do
+          expect(ContentNewVersionEventJob).to receive(:perform_later).with(file_set, user)
+          expect(actor).to receive(:ingest_file).with(JobIoWrapper).and_return(true)
+          file = fixture_file_upload('/world.png', 'image/png')
+          post :update, params: { id: file_set, filedata: file, file_set: { keyword: [''], permissions_attributes: [{ type: 'person', name: 'archivist1', access: 'edit' }] } }
+          post :update, params: { id: file_set, file_set: { files: [file], keyword: [''], permissions_attributes: [{ type: 'person', name: 'archivist1', access: 'edit' }] } }
+        end
+      end
+
+      context "with two existing versions from different users", :perform_enqueued do
+        let(:file1)       { "world.png" }
+        let(:file2)       { "image.jpg" }
+        let(:second_user) { create(:user) }
+        let(:version1)    { "version1" }
+        let(:actor1)      { Hyrax::Actors::FileSetActor.new(file_set, user) }
+        let(:actor2)      { Hyrax::Actors::FileSetActor.new(file_set, second_user) }
+
+        before do
+          ActiveJob::Base.queue_adapter.filter = [IngestJob]
+          actor1.create_content(fixture_file_upload(file1))
+          actor2.create_content(fixture_file_upload(file2))
+        end
+
+        describe "restoring a previous version" do
+          context "as the first user" do
+            before do
+              sign_in user
+              post :update, params: { id: file_set, revision: version1 }
+            end
+
+            let(:restored_content) { file_set.reload.original_file }
+            let(:versions)         { restored_content.versions }
+            let(:latest_version)   { Hyrax::VersioningService.latest_version_of(restored_content) }
+
+            it "restores the first versions's content and metadata" do
+              # expect(restored_content.mime_type).to eq "image/png"
+              expect(restored_content).to be_a(Hydra::PCDM::File)
+              expect(restored_content.original_name).to eq file1
+              expect(versions.all.count).to eq 3
+              expect(versions.last.label).to eq latest_version.label
+              expect(Hyrax::VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [user.user_key]
+            end
+          end
+
+          context "as a user without edit access" do
+            before do
+              sign_in second_user
+            end
+
+            it "is unauthorized" do
+              post :update, params: { id: file_set, revision: version1 }
+              expect(response.code).to eq '401'
+              expect(response).to render_template 'unauthorized'
+              expect(response).to render_template('dashboard')
+            end
+          end
+        end
+      end
+
+      it "adds new groups and users" do
+        post :update, params: {
+          id: file_set,
+          file_set: { keyword: [''],
+                      permissions_attributes: [
+                        { type: 'person', name: 'user1', access: 'edit' },
+                        { type: 'group', name: 'group1', access: 'read' }
+                      ] }
+        }
+
+        expect(assigns[:file_set].read_groups).to eq ["group1"]
+        expect(assigns[:file_set].edit_users).to include("user1", user.user_key)
+      end
+
+      it "updates existing groups and users" do
+        file_set.edit_groups = ['group3']
+        file_set.save
+        post :update, params: {
+          id: file_set,
+          file_set: { keyword: [''],
+                      permissions_attributes: [
+                        { id: file_set.permissions.last.id, type: 'group', name: 'group3', access: 'read' }
+                      ] }
+        }
+
+        expect(assigns[:file_set].read_groups).to eq(["group3"])
+      end
+
+      context "when there's an error saving" do
+        let(:file_set) do
+          create(:file_set, user: user)
+        end
+
+        before do
+          allow(FileSet).to receive(:find).and_return(file_set)
+        end
+        it "draws the edit page" do
+          expect(file_set).to receive(:valid?).and_return(false)
+          post :update, params: { id: file_set, file_set: { keyword: [''] } }
+          expect(response.code).to eq '422'
+          expect(response).to render_template('edit')
+          expect(response).to render_template('dashboard')
+          expect(assigns[:file_set]).to eq file_set
+        end
+      end
+    end
+
+    describe "#edit" do
+      let(:file_set) do
+        create(:file_set, read_groups: ['public'])
+      end
+
+      let(:file) do
+        Hydra::Derivatives::IoDecorator.new(File.open(fixture_path + '/world.png'),
+                                            'image/png', 'world.png')
+      end
+
+      before do
+        Hydra::Works::UploadFileToFileSet.call(file_set, file)
+      end
+
+      context "someone else's files" do
+        it "sets flash error" do
+          get :edit, params: { id: file_set }
+          expect(response.code).to eq '401'
+          expect(response).to render_template('unauthorized')
+          expect(response).to render_template('dashboard')
+        end
+      end
+    end
+
+    describe "#show" do
+      let(:file_set) do
+        create(:file_set, title: ['test file'], user: user)
+      end
+
+      context "without a referer" do
+        it "shows me the file and set 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: file_set }
+          expect(response).to be_successful
+          expect(flash).to be_empty
+          expect(assigns[:presenter]).to be_kind_of Hyrax::FileSetPresenter
+          expect(assigns[:presenter].id).to eq file_set.id
+          expect(assigns[:presenter].events).to be_kind_of Array
+          expect(assigns[:presenter].fixity_check_status).to eq 'Fixity checks have not yet been run on this object'
+        end
+      end
+
+      context "with a referer" do
+        let(:work) do
+          create(:generic_work, :public,
+                 title: ['test title'],
+                 user: user)
+        end
+
+        before do
+          request.env['HTTP_REFERER'] = 'http://test.host/foo'
+          work.ordered_members << file_set
+          work.save!
+          file_set.save!
+        end
+
+        it "shows me the 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('Works', Hyrax::Engine.routes.url_helpers.my_works_path(locale: 'en'))
+          expect(controller).to receive(:add_breadcrumb).with('test title', main_app.hyrax_generic_work_path(work.id, locale: 'en'))
+          expect(controller).to receive(:add_breadcrumb).with('test file', main_app.hyrax_file_set_path(file_set, locale: 'en'))
+          get :show, params: { id: file_set }
+          expect(response).to be_successful
+        end
+      end
+    end
+
+    context 'someone elses (public) files' do
+      let(:creator) { create(:user, email: 'archivist1@example.com') }
+      let(:public_file_set) { create(:file_set, user: creator, read_groups: ['public']) }
+
+      before { sign_in user }
+
+      describe '#edit' do
+        it 'gives me the unauthorized page' do
+          get :edit, params: { id: public_file_set }
+          expect(response.code).to eq '401'
+          expect(response).to render_template(:unauthorized)
+          expect(response).to render_template('dashboard')
+        end
+      end
+
+      describe '#show' do
+        it 'allows access to the file' do
+          get :show, params: { id: public_file_set }
+          expect(response).to be_success
+        end
+      end
+    end
+  end
+
+  context 'when not signed in' do
+    let(:private_file_set) { create(:file_set) }
+    let(:public_file_set) { create(:file_set, read_groups: ['public']) }
+
+    describe '#edit' do
+      it 'requires login' do
+        get :edit, params: { id: public_file_set }
+        expect(response).to fail_redirect_and_flash(main_app.new_user_session_path, 'You need to sign in or sign up before continuing.')
+      end
+    end
+
+    describe '#show' do
+      it 'denies access to private files' do
+        get :show, params: { id: private_file_set }
+        expect(response).to fail_redirect_and_flash(main_app.new_user_session_path(locale: 'en'), 'You are not authorized to access this page.')
+      end
+
+      it 'allows access to public files' do
+        expect(controller).to receive(:additional_response_formats).with(ActionController::MimeResponds::Collector)
+        get :show, params: { id: public_file_set }
+        expect(response).to be_success
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/fixity_checks_controller_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Hyrax::FixityChecksController do
+  routes { Hyrax::Engine.routes }
+  let(:user) { create(:user) }
+  let(:file_set) { create(:file_set, user: user) }
+  let(:binary) { File.open(fixture_path + '/world.png') }
+  let(:file) { Hydra::Derivatives::IoDecorator.new(binary, 'image/png', 'world.png') }
+
+  before { Hydra::Works::UploadFileToFileSet.call(file_set, file) }
+
+  context "when signed in" do
+    describe "POST create" do
+      before do
+        sign_in user
+        post :create, params: { file_set_id: file_set }, xhr: true
+      end
+      let(:json_response) { JSON.parse(response.body) }
+
+      it "returns json with the result" do
+        expect(response).to be_success
+        # json is a structure like this:
+        #   { file_id => [{ "checked_uri" => "...4-4d71-83ba-1bc52a5e4300/fcr:versions/version1", "passed" => true },
+        #                 { "checked_uri" => ".../version2", "passed" => false },
+        #                 ...] }
+        json_response.each_value do |array_of_checks|
+          array_of_checks.each do |check_hash|
+            expect(check_hash.keys).to include("file_set_id", "file_id", "checked_uri", "passed", "expected_result", "created_at")
+            expect(check_hash["passed"]).to be_in([true, false])
+          end
+        end
+        fixity_results = json_response.values.flatten.collect { |result| result["passed"] }
+        expect(fixity_results.all? { |r| r == true }).to be true
+      end
+    end
+  end
+
+  context "when not signed in" do
+    describe "POST create" do
+      it "returns json with the result" do
+        post :create, params: { file_set_id: file_set }, xhr: true
+        expect(response.code).to eq '401'
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/generic_works_controller_json_spec.rb

@@ -0,0 +1,92 @@
+# This tests the Hyrax::WorksControllerBehavior module
+# which is included into .internal_test_app/app/controllers/hyrax/generic_works_controller.rb
+RSpec.describe Hyrax::GenericWorksController do
+  routes { Rails.application.routes }
+
+  let(:user) { create(:user) }
+
+  before { sign_in user }
+
+  context "JSON" do
+    let(:admin_set) { create(:admin_set, id: 'admin_set_1', with_permission_template: { with_active_workflow: true }) }
+
+    let(:resource) { create(:private_generic_work, user: user, admin_set_id: admin_set.id) }
+    let(:resource_request) { get :show, params: { id: resource, format: :json } }
+
+    subject { response }
+
+    describe "unauthorized" do
+      before do
+        sign_out user
+        resource_request
+      end
+      it { is_expected.to respond_unauthorized }
+    end
+
+    describe "forbidden" do
+      before do
+        sign_in create(:user)
+        resource_request
+      end
+      it { is_expected.to respond_forbidden }
+    end
+
+    describe 'created' do
+      let(:actor) { double(create: create_status) }
+      let(:create_status) { true }
+      let(:model) { stub_model(GenericWork) }
+
+      before do
+        allow(Hyrax::CurationConcern).to receive(:actor).and_return(actor)
+        allow(controller).to receive(:curation_concern).and_return(model)
+        post :create, params: { generic_work: { title: ['a title'] }, format: :json }
+      end
+
+      it "returns 201, renders show template sets location header" do
+        # Ensure that @curation_concern is set for jbuilder template to use
+        expect(assigns[:curation_concern]).to be_instance_of GenericWork
+        expect(controller).to render_template('hyrax/base/show')
+        expect(response.code).to eq "201"
+        expect(response.location).to eq main_app.hyrax_generic_work_path(model, locale: 'en')
+      end
+    end
+
+    # The clean is here because this test depends on the repo not having an AdminSet/PermissionTemplate created yet
+    describe 'failed create', :clean_repo do
+      before { post :create, params: { generic_work: {}, format: :json } }
+      it "returns 422 and the errors" do
+        created_resource = assigns[:curation_concern]
+        expect(response).to respond_unprocessable_entity(errors: created_resource.errors.messages.as_json)
+      end
+    end
+
+    describe 'found' do
+      before { resource_request }
+      it "returns json of the work" do
+        # Ensure that @curation_concern is set for jbuilder template to use
+        expect(assigns[:curation_concern]).to be_instance_of GenericWork
+        expect(controller).to render_template('hyrax/base/show')
+        expect(response.code).to eq "200"
+      end
+    end
+
+    describe 'updated' do
+      before { put :update, params: { id: resource, generic_work: { title: ['updated title'] }, format: :json } }
+      it "returns 200, renders show template sets location header" do
+        # Ensure that @curation_concern is set for jbuilder template to use
+        expect(assigns[:curation_concern]).to be_instance_of GenericWork
+        expect(controller).to render_template('hyrax/base/show')
+        expect(response.code).to eq "200"
+        created_resource = assigns[:curation_concern]
+        expect(response.location).to eq main_app.hyrax_generic_work_path(created_resource, locale: 'en')
+      end
+    end
+
+    describe 'failed update' do
+      before { post :update, params: { id: resource, generic_work: { title: [''] }, format: :json } }
+      it "returns 422 and the errors" do
+        expect(response).to respond_unprocessable_entity(errors: { title: ["Your work must have a title."] })
+      end
+    end
+  end
+end