curation_concerns 0.1.0

data/spec/abilities/generic_work_abilities_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require "cancan/matchers"
+
+describe "User" do
+  describe "Abilities" do
+    subject { Ability.new(current_user) }
+
+    let(:generic_work) { FactoryGirl.create(:private_generic_work, user: creating_user ) }
+    let(:user) { FactoryGirl.create(:user) }
+
+    describe 'without embargo' do
+      describe 'creator of object' do
+        let(:creating_user) { user }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should be_able_to(:read, generic_work)
+          should be_able_to(:update, generic_work)
+          should be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'as a repository manager' do
+        let(:manager_user) { FactoryGirl.create(:admin) }
+        let(:creating_user) { user }
+        let(:current_user) { manager_user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should be_able_to(:read, generic_work)
+          should be_able_to(:update, generic_work)
+          should be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'another authenticated user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should_not be_able_to(:read, generic_work)
+          should_not be_able_to(:update, generic_work)
+          should_not be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'a nil user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { nil }
+        it {
+          should_not be_able_to(:create, GenericWork.new)
+          should_not be_able_to(:read, generic_work)
+          should_not be_able_to(:update, generic_work)
+          should_not be_able_to(:destroy, generic_work)
+        }
+      end
+    end
+  end
+end

data/spec/actors/curation_concerns/generic_file_actor_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe CurationConcerns::GenericFileActor do
+  include ActionDispatch::TestProcess
+
+  let(:user) { FactoryGirl.create(:user) }
+  let(:generic_file) { FactoryGirl.create(:generic_file) }
+  let(:actor) { CurationConcerns::GenericFileActor.new(generic_file, user) }
+  let(:uploaded_file) { fixture_file_upload('/world.png','image/png') }
+
+  describe "creating metadata and content" do
+    let(:batch_id) { nil }
+    let(:work_id) { nil }
+    subject { generic_file.reload }
+    before do
+      allow(actor).to receive(:save_characterize_and_record_committer).and_return("true")
+      actor.create_metadata(batch_id, work_id)
+      actor.create_content(uploaded_file)
+    end
+    context "when a work_id is provided" do
+      let(:work) { FactoryGirl.create(:generic_work) }
+      let(:work_id) { work.id }
+      it "adds the generic file to the parent work" do
+        expect(subject.generic_works).to eq [work]
+        expect(work.reload.generic_files).to include(subject)
+      end
+    end
+  end
+
+  describe "#create_content" do
+    let(:deposit_message) { double('deposit message') }
+    let(:characterize_message) { double('characterize message') }
+    before do
+      allow(CurationConcerns.queue).to receive(:push)
+    end
+
+    it "uses the provided mime_type" do
+      actor.create_content(uploaded_file)
+      expect(generic_file.original_file.mime_type).to eq "image/png"
+    end
+
+    context "when generic_file.title is empty and generic_file.label is not" do
+      let(:file)       { "world.png" }
+      let(:long_name)  { "an absurdly long title that goes on way to long and messes up the display of the page which should not need to be this big in order to show this impossibly long, long, long, oh so long string" }
+      let(:short_name) { "Nice Short Name" }
+      let(:actor)      { CurationConcerns::GenericFileActor.new(generic_file, user) }
+      before do
+        allow(generic_file).to receive(:label).and_return(short_name)
+        allow(CurationConcerns.queue).to receive(:push)
+        actor.create_content(fixture_file_upload(file))
+      end
+      subject { generic_file.title }
+      it { is_expected.to eql [short_name] }
+    end
+
+    context "with two existing versions from different users" do
+
+      let(:file1)       { "world.png" }
+      let(:file2)       { "small_file.txt" }
+      let(:actor1)      { CurationConcerns::GenericFileActor.new(generic_file, user) }
+      let(:actor2)      { CurationConcerns::GenericFileActor.new(generic_file, second_user) }
+
+      let(:second_user) { FactoryGirl.find_or_create(:archivist) }
+      let(:versions)     { generic_file.original_file.versions }
+
+      before do
+        allow(CurationConcerns.queue).to receive(:push)
+        actor1.create_content(fixture_file_upload(file1))
+        actor2.create_content(fixture_file_upload(file2))
+      end
+
+      it "should have two versions" do
+        expect(versions.all.count).to eq 2
+      end
+
+      it "should have the current version" do
+        expect(CurationConcerns::VersioningService.latest_version_of(generic_file.original_file).label).to eq 'version2'
+        expect(generic_file.original_file.content).to eq fixture_file_upload(file2).read
+        expect(generic_file.original_file.mime_type).to eq "text/plain"
+        expect(generic_file.original_file.original_name).to eq file2
+      end
+
+      it "should use the first version for the object's title and label" do
+        expect(generic_file.label).to eql(file1)
+        expect(generic_file.title.first).to eql(file1)
+      end
+
+      it "should note the user for each version" do
+        expect(VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq [user.user_key]
+        expect(VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [second_user.user_key]
+      end
+    end
+  end
+
+  context "when a label is already specified" do
+    let(:label)    { "test_file.png" }
+    let(:new_file) { "foo.jpg" }
+    let(:generic_file_with_label) do
+      GenericFile.new.tap do |f|
+        f.apply_depositor_metadata(user.user_key)
+        f.label = label
+      end
+    end
+    let(:actor) { CurationConcerns::GenericFileActor.new(generic_file_with_label, user)}
+
+    before do
+      allow(actor).to receive(:save_characterize_and_record_committer).and_return("true")
+      allow(Hydra::Works::UploadFileToGenericFile).to receive(:call)
+      actor.create_content(Tempfile.new(new_file))
+    end
+
+    it "will retain the object's original label" do
+      expect(generic_file_with_label.label).to eql(label)
+    end
+  end
+end

data/spec/actors/curation_concerns/manages_embargoes_actor_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+describe CurationConcerns::ManagesEmbargoesActor do
+
+  let(:model) {
+    Class.new(CurationConcerns::BaseActor) {
+      include CurationConcerns::ManagesEmbargoesActor
+    }
+  }
+
+  let(:user) { User.new }
+  let(:curation_concern) { GenericWork.new }
+  let(:attributes) {{}}
+  subject {
+    model.new(curation_concern, user, attributes)
+  }
+  let(:date) { Date.today+2 }
+
+  context "#interpret_visibility" do
+    it "should interpret lease and embargo visibility" do
+      expect(subject).to receive(:interpret_lease_visibility).and_return(true)
+      expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
+      expect(subject.interpret_visibility).to be true
+    end
+    it "should collect failures from interpreting lease & embargo visibility" do
+      expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
+      expect(subject).to receive(:interpret_lease_visibility).and_return(false)
+      expect(subject.interpret_visibility).to be false
+    end
+  end
+
+  context "#interpret_embargo_visibility" do
+    context 'when visibility is not set to embargo' do
+      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+                           visibility_during_embargo: 'restricted', visibility_after_embargo: 'open' } }
+      it "removes the embargo attributes and returns true" do
+        expect(subject.interpret_embargo_visibility).to be true
+        expect(subject.attributes.keys).to eq ['visibility']
+      end
+    end
+
+    context "when visibility is set to embargo" do
+      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+                           visibility_during_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
+                           visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+                           embargo_release_date: date.to_s } }
+
+      it "should apply the embargo remove embargo attributes except for embargo_release_date and return true" do
+        expect(subject.curation_concern).to receive(:apply_embargo).with(date.to_s, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        expect(subject.interpret_embargo_visibility).to be true
+        expect(subject.attributes.keys).to eq ['embargo_release_date']
+      end
+
+      context "when embargo_release_date is not set" do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+        it "should set error on curation_concern and return false" do
+          expect(subject.interpret_embargo_visibility).to be false
+          expect(subject.curation_concern.errors[:visibility].first).to eq 'When setting visibility to "embargo" you must also specify embargo release date.'
+        end
+      end
+
+    end
+  end
+
+  context "#interpret_lease_visibility" do
+    context 'when visibility is not set to lease' do
+      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+                           visibility_during_lease: 'open', visibility_after_lease: 'restricted' } }
+      it "removes the lease attributes and returns true" do
+        expect(subject.interpret_lease_visibility).to be true
+        expect(subject.attributes.keys).to eq ['visibility']
+      end
+    end
+
+    context "when visibility is set to lease" do
+      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+                           visibility_during_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
+                           visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+                           lease_expiration_date: date.to_s } }
+
+      it "should apply the lease, remove lease attributes except for lease_expiration_date and return true" do
+        expect(subject.curation_concern).to receive(:apply_lease).with(date.to_s, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        expect(subject.interpret_lease_visibility).to be true
+        expect(subject.attributes.keys).to eq ['lease_expiration_date']
+      end
+
+      context "when lease_expiration_date is not set" do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE } }
+        it "should set error on curation_concern and return false" do
+          expect(subject.interpret_lease_visibility).to be false
+          expect(subject.curation_concern.errors[:visibility].first).to eq 'When setting visibility to "lease" you must also specify lease expiration date.'
+        end
+      end
+    end
+  end
+end

data/spec/actors/curation_concerns/work_actor_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe CurationConcerns::GenericWorkActor do
+  include ActionDispatch::TestProcess
+
+  let(:user) { FactoryGirl.create(:user) }
+  let(:file) { curation_concerns_fixture_file_upload('files/image.png', 'image/png') }
+
+  subject {
+    CurationConcerns::CurationConcern.actor(curation_concern, user, attributes)
+  }
+
+  describe '#create' do
+    let(:curation_concern) { GenericWork.new }
+
+    context 'failure' do
+      let(:attributes) {{}}
+
+      it 'returns false' do
+        expect_any_instance_of(CurationConcerns::GenericWorkActor).to receive(:save).and_return(false)
+        allow(subject).to receive(:attach_files).and_return(true)
+        expect(subject.create).to be false
+      end
+    end
+
+    context 'valid attributes' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+
+      context 'with embargo' do
+        let(:attributes) { { title: ["New embargo"], visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+                           visibility_during_embargo: "authenticated", embargo_release_date: date.to_s,
+                           visibility_after_embargo: "open", visibility_during_lease: "open",
+                           lease_expiration_date: "2014-06-12", visibility_after_lease: "restricted",
+                           rights: ["http://creativecommons.org/licenses/by/3.0/us/"] } }
+
+        context "with a valid embargo date" do
+          let(:date) { Date.today + 2 }
+          it "should interpret and apply embargo and lease visibility settings" do
+            subject.create
+            expect(curation_concern).to be_persisted
+            expect(curation_concern.visibility_during_embargo).to eq 'authenticated'
+            expect(curation_concern.visibility_after_embargo).to eq 'open'
+            expect(curation_concern.visibility).to eq 'authenticated'
+          end
+        end
+
+        context "when embargo_release_date is in the past" do
+          let(:date) { Date.today-2 }
+          it "should set error on curation_concern and return false" do
+            expect(subject.create).to be false
+            expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date'
+          end
+        end
+      end
+
+      context 'with lease' do
+        let(:attributes) { { title: ["New embargo"], visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+                           visibility_during_embargo: "authenticated", embargo_release_date: '2099-05-12',
+                           visibility_after_embargo: "open", visibility_during_lease: "open",
+                           lease_expiration_date: date.to_s, visibility_after_lease: "restricted",
+                           rights: ["http://creativecommons.org/licenses/by/3.0/us/"] } }
+
+        context "with a valid lease date" do
+          let(:date) { Date.today + 2 }
+          it "should interpret and apply embargo and lease visibility settings" do
+            subject.create
+            expect(curation_concern).to be_persisted
+            expect(curation_concern.embargo_release_date).to be_nil
+            expect(curation_concern.visibility_during_lease).to eq 'open'
+            expect(curation_concern.visibility_after_lease).to eq 'restricted'
+            expect(curation_concern.visibility).to eq 'open'
+          end
+        end
+
+        context "when lease_expiration_date is in the past" do
+          let(:date) { Date.today-2 }
+          it "should set error on curation_concern and return false" do
+            expect(subject.create).to be false
+            expect(subject.curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
+          end
+        end
+      end
+
+      context 'with a file' do
+        let(:attributes) {
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap {|a|
+            a[:files] = file
+          }
+        }
+
+        context 'authenticated visibility' do
+          it 'should stamp each file with the access rights' do
+            s2 = double('characterize job')
+            allow(CharacterizeJob).to receive(:new).and_return(s2)
+            expect(CurationConcerns.queue).to receive(:push).with(s2).once
+            expect(subject.create).to be true
+            expect(curation_concern).to be_persisted
+            expect(curation_concern.date_uploaded).to eq Date.today
+            expect(curation_concern.date_modified).to eq Date.today
+            expect(curation_concern.depositor).to eq user.user_key
+            expect(curation_concern.representative).to_not be_nil
+            expect(curation_concern.generic_files.size).to eq 1
+            # Sanity test to make sure the file we uploaded is stored and has same permission as parent.
+            generic_file = curation_concern.generic_files.first
+            file.rewind
+            expect(generic_file.original_file.content).to eq file.read
+
+            expect(curation_concern).to be_authenticated_only_access
+            expect(generic_file).to be_authenticated_only_access
+          end
+        end
+      end
+
+      context 'with multiple files file' do
+        let(:attributes) {
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap {|a|
+            a[:files] = [file, file]
+          }
+        }
+
+        context 'authenticated visibility' do
+          it 'should stamp each file with the access rights' do
+            s2 = double('characterize job')
+            allow(CharacterizeJob).to receive(:new).and_return(s2)
+            expect(CurationConcerns.queue).to receive(:push).with(s2).twice
+
+            expect(subject.create).to be true
+            expect(curation_concern).to be_persisted
+            expect(curation_concern.date_uploaded).to eq Date.today
+            expect(curation_concern.date_modified).to eq Date.today
+            expect(curation_concern.depositor).to eq user.user_key
+
+            expect(curation_concern.generic_files.size).to eq 2
+            # Sanity test to make sure the file we uploaded is stored and has same permission as parent.
+
+            expect(curation_concern).to be_authenticated_only_access
+          end
+        end
+      end
+
+      context "with a present and a blank title" do
+        let(:attributes) {
+          FactoryGirl.attributes_for(:generic_work, title: ['this is present', ''])
+        }
+
+        it 'should stamp each link with the access rights' do
+          expect(subject.create).to be true
+          expect(curation_concern).to be_persisted
+          expect(curation_concern.title).to eq ['this is present']
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:curation_concern) { FactoryGirl.create(:generic_work, user: user)}
+
+    context 'failure' do
+      let(:attributes) {{}}
+
+      it 'returns false' do
+        expect_any_instance_of(CurationConcerns::GenericWorkActor).to receive(:save).and_return(false)
+        expect(subject.update).to be false
+      end
+    end
+
+    context 'valid attributes' do
+      let(:attributes) {{}}
+      it "should interpret and apply embargo and lease visibility settings" do
+        expect(subject).to receive(:interpret_lease_visibility).and_return(true)
+        expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
+        subject.update
+      end
+    end
+
+    context 'adding to collections' do
+      let!(:collection1) { FactoryGirl.create(:collection, user: user) }
+      let!(:collection2) { FactoryGirl.create(:collection, user: user) }
+      let(:attributes) {
+        FactoryGirl.attributes_for(:generic_work, collection_ids: [collection2.id])
+      }
+      before do
+        curation_concern.apply_depositor_metadata(user.user_key)
+        curation_concern.save!
+        collection1.add_member(curation_concern)
+      end
+
+      it "remove from the old collection and adds to the new collection" do
+        curation_concern.reload
+        expect(curation_concern.parent_collections).to eq [collection1]
+        # before running actor.update, the work is in collection1
+
+        expect(subject.update).to be true
+
+        curation_concern.reload
+        expect(curation_concern.identifier).to be_blank
+        expect(curation_concern).to be_persisted
+        # after running actor.update, the work is in collection2 and no longer in collection1
+        expect(curation_concern.parent_collections).to eq [collection2]
+      end
+    end
+  end
+end

data/spec/controllers/catalog_controller_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe CatalogController do
+  before do
+    ActiveFedora::Base.delete_all
+  end
+
+  describe "when logged in" do
+    let(:user)    { FactoryGirl.create(:user) }
+    let!(:work1)  { FactoryGirl.create(:work_with_one_file, user: user) }
+    let!(:work2)  { FactoryGirl.create(:public_generic_work) }
+    let!(:collection) { FactoryGirl.create(:collection, user: user) }
+    let!(:file)   { work1.generic_files.first }
+    before do
+      sign_in user
+    end
+
+    context "when there is private content" do
+      let!(:private_work) { FactoryGirl.create(:private_generic_work) }
+
+      it "excludes it" do
+        get 'index'
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
+      end
+    end
+
+    context "Searching all content" do
+      it "should exclude linked resources" do
+        get 'index'
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
+      end
+    end
+
+    context "Searching all works" do
+      it "should return all the works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).count).to eq 2
+        [work1.id, work2.id].each do |work_id|
+          expect(assigns(:document_list).map(&:id)).to include(work_id)
+        end
+      end
+    end
+
+    context "Searching all collections" do
+      it "should return all the works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to eq [collection.id]
+      end
+    end
+
+    context "searching just my works" do
+      it "should return just my works" do
+        get 'index', works: 'mine', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to eq [work1.id]
+      end
+    end
+
+    context "searching for one kind of work" do
+      it "returns just the specified type" do
+        get 'index', 'f' => {'human_readable_type_sim' => 'Generic Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work1.id, work2.id)
+      end
+    end
+
+    context "when json is requested for autosuggest of related works" do
+      let!(:work) { FactoryGirl.create(:generic_work, user: user, title: ["All my #{srand}"]) }
+      it "should return json" do
+        xhr :get, :index, format: :json, q: work.title
+        json = JSON.parse(response.body)
+        # Grab the doc corresponding to work and inspect the json
+        work_json = json["docs"].first
+        expect(work_json).to eq("pid"=>work.id, "title"=> "#{work.title.first} (#{work.human_readable_type})")
+      end
+    end
+
+  end
+
+  describe "when logged in as a repository manager" do
+    let(:creating_user) { FactoryGirl.create(:user) }
+    let(:manager_user) { FactoryGirl.create(:user) }
+    let!(:work1) { FactoryGirl.create(:private_generic_work, user: creating_user) }
+    let!(:work2) { FactoryGirl.create(:embargoed_work, user: creating_user) }
+    let!(:collection) { FactoryGirl.create(:collection, user: creating_user) }
+
+    before do
+      allow_any_instance_of(User).to receive(:groups).and_return(['admin'])
+      sign_in manager_user
+    end
+
+    context "searching all works" do
+      it "should return other users' private works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work1.id)
+      end
+      it "should return other users' embargoed works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work2.id)
+      end
+      it "should return other users' private collections" do
+        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(collection.id)
+      end
+    end
+
+  end
+end

data/spec/controllers/curation_concerns/classify_concerns_controller_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe CurationConcerns::ClassifyConcernsController do
+  routes { CurationConcerns::Engine.routes }
+  let(:user) { FactoryGirl.create(:user) }
+
+  describe '#new' do
+    it 'requires authentication' do
+      get :new
+      expect(response).to redirect_to(main_app.user_session_path)
+    end
+    it 'renders when signed in' do
+      sign_in(user)
+      get :new
+      expect(response).to be_successful
+    end
+  end
+
+  describe '#create' do
+    context 'without logging in' do
+      it 'redirect to login page if user is not logged in' do
+        post :create, classify: { curation_concern_type: 'GenericWork' }
+        expect(response).to redirect_to(main_app.user_session_path)
+      end
+    end
+
+    context 'when logged in' do
+      before do
+        sign_in(user)
+        # Had to stub the actual handling of curation_concern paths since those paths live outside the engine while the path to this controller lives inside the engine.
+        expect(subject).to receive(:new_polymorphic_path).with([:curation_concerns, GenericWork]).and_return(main_app.new_curation_concerns_generic_work_path)
+      end
+
+      let(:new_curation_concern_generic_work_path) { "/stub/path" }
+
+      it 'requires authentication' do
+        post :create, classify_concern: { curation_concern_type: 'GenericWork' }
+        expect(response).to redirect_to(main_app.new_curation_concerns_generic_work_path)
+      end
+   end
+
+  end
+end