test_hyrax 0.0.1.alpha

data/spec/actors/hyrax/actors/lease_actor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Hyrax::Actors::LeaseActor do
+  let(:actor) { described_class.new(work) }
+
+  let(:work) do
+    GenericWork.new do |work|
+      work.apply_depositor_metadata 'foo'
+      work.title = ["test"]
+      work.visibility_during_lease = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.visibility_after_lease = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      work.lease_expiration_date = release_date.to_s
+      work.save(validate: false)
+    end
+  end
+
+  describe "#destroy" do
+    before do
+      actor.destroy
+    end
+
+    context "with an active lease" do
+      let(:release_date) { Time.zone.today + 2 }
+
+      it "removes the lease" do
+        expect(work.reload.lease_expiration_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      end
+    end
+
+    context 'with an expired lease' do
+      let(:release_date) { Time.zone.today - 2 }
+      it "removes the lease" do
+        expect(work.reload.lease_expiration_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      end
+    end
+  end
+end

data/spec/actors/hyrax/apply_permission_template_actor_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::ApplyPermissionTemplateActor do
+  let(:create_actor) do
+    double('create actor', create: true,
+                           curation_concern: work,
+                           update: true,
+                           user: depositor)
+  end
+  let(:actor) do
+    Hyrax::Actors::ActorStack.new(work, depositor, [described_class])
+  end
+  let(:depositor) { create(:user) }
+  let(:work) { build(:generic_work) }
+  let(:attributes) { { admin_set_id: admin_set.id } }
+  let(:admin_set) { create(:admin_set) }
+  let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id) }
+
+  describe "create" do
+    context "when admin_set_id is blank" do
+      let(:attributes) { { admin_set_id: '' } }
+
+      it "returns true" do
+        expect(actor.create(attributes)).to be true
+      end
+    end
+
+    context "when admin_set_id is provided" do
+      let(:attributes) { { admin_set_id: admin_set.id } }
+      before do
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'user',
+               agent_id: 'hannah',
+               access: 'manage')
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'group',
+               agent_id: 'librarians',
+               access: 'manage')
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'user',
+               agent_id: 'gary',
+               access: 'view')
+        create(:permission_template_access,
+               permission_template: permission_template,
+               agent_type: 'group',
+               agent_id: 'readers',
+               access: 'view')
+        allow(Hyrax::Actors::RootActor).to receive(:new).and_return(create_actor)
+        allow(create_actor).to receive(:create).and_return(true)
+      end
+
+      it "adds the template users to the work" do
+        expect(actor.create(attributes)).to be true
+        expect(work.edit_users).to include 'hannah'
+        expect(work.edit_groups).to include 'librarians'
+        expect(work.read_users).to include 'gary'
+        expect(work.read_groups).to include 'readers'
+      end
+    end
+  end
+end

data/spec/actors/hyrax/create_with_files_actor_spec.rb

@@ -0,0 +1,49 @@
+describe Hyrax::CreateWithFilesActor do
+  let(:create_actor) do
+    double('create actor', create: true,
+                           curation_concern: work,
+                           update: true,
+                           user: user)
+  end
+  let(:actor) do
+    Hyrax::Actors::ActorStack.new(work, user, [described_class])
+  end
+  let(:user) { create(:user) }
+  let(:uploaded_file1) { Hyrax::UploadedFile.create(user: user) }
+  let(:uploaded_file2) { Hyrax::UploadedFile.create(user: user) }
+  let(:work) { create(:generic_work, user: user) }
+  let(:uploaded_file_ids) { [uploaded_file1.id, uploaded_file2.id] }
+  let(:attributes) { { uploaded_files: uploaded_file_ids } }
+
+  [:create, :update].each do |mode|
+    context "on #{mode}" do
+      before do
+        allow(Hyrax::Actors::RootActor).to receive(:new).and_return(create_actor)
+        allow(create_actor).to receive(mode).and_return(true)
+      end
+      context "when uploaded_file_ids include nil" do
+        let(:uploaded_file_ids) { [nil, uploaded_file1.id, nil] }
+        it "will discard those nil values when attempting to find the associated UploadedFile" do
+          expect(AttachFilesToWorkJob).to receive(:perform_later)
+          expect(Hyrax::UploadedFile).to receive(:find).with([uploaded_file1.id]).and_return([uploaded_file1])
+          actor.public_send(mode, attributes)
+        end
+      end
+
+      context "when uploaded_file_ids belong to me" do
+        it "attaches files" do
+          expect(AttachFilesToWorkJob).to receive(:perform_later).with(GenericWork, [uploaded_file1, uploaded_file2])
+          expect(actor.public_send(mode, attributes)).to be true
+        end
+      end
+
+      context "when uploaded_file_ids don't belong to me" do
+        let(:uploaded_file2) { Hyrax::UploadedFile.create }
+        it "doesn't attach files" do
+          expect(AttachFilesToWorkJob).not_to receive(:perform_later)
+          expect(actor.public_send(mode, attributes)).to be false
+        end
+      end
+    end
+  end
+end

data/spec/actors/hyrax/create_with_remote_files_actor_spec.rb

@@ -0,0 +1,67 @@
+describe Hyrax::CreateWithRemoteFilesActor do
+  let(:create_actor) do
+    double('create actor', create: true,
+                           curation_concern: work,
+                           user: user)
+  end
+  let(:actor) do
+    Hyrax::Actors::ActorStack.new(work, user, [described_class])
+  end
+  let(:user) { create(:user) }
+  let(:work) { create(:generic_work, user: user) }
+  let(:url1) { "https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt" }
+  let(:url2) { "https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf" }
+  let(:file) { "file:///local/file/here.txt" }
+
+  let(:remote_files) do
+    [{ url: url1,
+       expires: "2014-03-31T20:37:36.214Z",
+       file_name: "filepicker-demo.txt.txt" },
+     { url: url2,
+       expires: "2014-03-31T20:37:36.731Z",
+       file_name: "Getting+Started.pdf" }]
+  end
+  let(:attributes) { { remote_files: remote_files } }
+
+  before do
+    allow(Hyrax::Actors::RootActor).to receive(:new).and_return(create_actor)
+    allow(create_actor).to receive(:create).and_return(true)
+  end
+
+  context "with source uris that are remote" do
+    let(:remote_files) do
+      [{ url: url1,
+         expires: "2014-03-31T20:37:36.214Z",
+         file_name: "filepicker-demo.txt.txt" },
+       { url: url2,
+         expires: "2014-03-31T20:37:36.731Z",
+         file_name: "Getting+Started.pdf" }]
+    end
+
+    it "attaches files" do
+      expect(ImportUrlJob).to receive(:perform_later).with(FileSet, Hyrax::Operation).twice
+      expect(actor.create(attributes)).to be true
+    end
+  end
+
+  context "with source uris that are local files" do
+    let(:remote_files) do
+      [{ url: file,
+         expires: "2014-03-31T20:37:36.214Z",
+         file_name: "here.txt" }]
+    end
+
+    it "attaches files" do
+      expect(IngestLocalFileJob).to receive(:perform_later).with(FileSet, "/local/file/here.txt", user)
+      expect(actor.create(attributes)).to be true
+    end
+
+    context "with spaces" do
+      let(:file) { "file:///local/file/ pigs .txt" }
+      it "attaches files" do
+        expect(IngestLocalFileJob).to receive(:perform_later).with(FileSet, "/local/file/ pigs .txt", user)
+        expect(actor.create(attributes)).to be true
+      end
+    end
+  end
+end

data/spec/actors/hyrax/default_admin_set_actor_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::DefaultAdminSetActor do
+  let(:next_actor) do
+    double('next actor', create: true,
+                         curation_concern: work,
+                         update: true,
+                         user: depositor)
+  end
+  let(:actor) do
+    Hyrax::Actors::ActorStack.new(work, depositor, [described_class])
+  end
+  let(:depositor) { create(:user) }
+  let(:work) { build(:generic_work) }
+  let(:admin_set) { create(:admin_set) }
+  let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id) }
+
+  describe "create" do
+    before do
+      allow(Hyrax::Actors::RootActor).to receive(:new).and_return(next_actor)
+    end
+
+    context "when admin_set_id is blank" do
+      let(:attributes) { { admin_set_id: '' } }
+      let(:default_id) { described_class::DEFAULT_ID }
+
+      it "creates the default AdminSet with a PermissionTemplate and calls the next actor with the default admin set id" do
+        expect(next_actor).to receive(:create).with(admin_set_id: default_id).and_return(true)
+        expect { actor.create(attributes) }.to change { AdminSet.count }.by(1)
+          .and change { Hyrax::PermissionTemplate.count }.by(1)
+      end
+    end
+
+    context "when admin_set_id is provided" do
+      let(:attributes) { { admin_set_id: admin_set.id } }
+
+      it "uses the provided id and returns true" do
+        expect(next_actor).to receive(:create).with(attributes).and_return(true)
+        expect(actor.create(attributes)).to be true
+      end
+    end
+  end
+end

data/spec/authorities/qa/authorities/find_works_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Qa::Authorities::FindWorks do
+  let(:controller) { Qa::TermsController.new }
+  let(:user1) { create(:user) }
+  let(:user2) { create(:user) }
+  let(:ability) { instance_double(Ability, admin?: false, user_groups: [], current_user: user1) }
+  let(:q) { "foo" }
+  let(:params) { ActionController::Parameters.new(q: q, id: work1.id, user: user1.email, controller: "qa/terms", action: "search", vocab: "find_works") }
+  let(:service) { described_class.new }
+
+  before do
+    allow(controller).to receive(:params).and_return(params)
+    allow(controller).to receive(:current_user).and_return(user1)
+    allow(controller).to receive(:current_ability).and_return(ability)
+  end
+
+  let!(:work1) { create(:generic_work, :public, title: ['foo'], user: user1) }
+  let!(:work2) { create(:generic_work, :public, title: ['foo foo'], user: user1) }
+  let!(:work3) { create(:generic_work, :public, title: ['bar'], user: user1) }
+  let!(:work4) { create(:generic_work, :public, title: ['another foo'], user: user1) }
+  let!(:work5) { create(:generic_work, :public, title: ['foo foo foo'], user: user2) }
+
+  subject { service.search(q, controller) }
+
+  describe '#search' do
+    context "works by all users" do
+      it 'displays a list of other works deposited by current user' do
+        expect(subject.map { |result| result[:id] }).to match_array [work2.id, work4.id]
+      end
+    end
+
+    context "when work has child works" do
+      before do
+        work4.ordered_members << work1
+        work4.save!
+      end
+
+      it 'displays a list of other works deposited by current user, exluding the child work' do
+        expect(subject.map { |result| result[:id] }).to match_array [work2.id]
+      end
+    end
+
+    context "when work has parent works" do
+      before do
+        work1.ordered_members << work4
+        work1.save!
+      end
+
+      it 'displays a list of other works deposited by current user, excluding the parent work' do
+        expect(subject.map { |result| result[:id] }).to match_array [work2.id]
+      end
+    end
+  end
+end

data/spec/config/hyrax_events_spec.rb

@@ -0,0 +1,49 @@
+describe "hyrax_events using Hyrax callbacks" do
+  let(:curation_concern) { create(:work) }
+  let(:file_set) { create(:file_set) }
+  let(:user) { create(:user) }
+
+  describe "after_create_concern" do
+    it "queues a ContentDepositEventJob" do
+      expect(ContentDepositEventJob).to receive(:perform_later).with(curation_concern, user)
+      Hyrax.config.callback.run(:after_create_concern, curation_concern, user)
+    end
+  end
+
+  describe "after_create_fileset" do
+    it "queues a FileSetAttachedEventJob" do
+      expect(FileSetAttachedEventJob).to receive(:perform_later).with(file_set, user)
+      Hyrax.config.callback.run(:after_create_fileset, file_set, user)
+    end
+  end
+
+  describe "after_revert_content" do
+    let(:revision) { "revision1" }
+    it "queues a ContentRestoredVersionEventJob" do
+      expect(ContentRestoredVersionEventJob).to receive(:perform_later).with(file_set, user, revision)
+      Hyrax.config.callback.run(:after_revert_content, file_set, user, revision)
+    end
+  end
+
+  describe "after_update_content" do
+    it "queues a ContentNewVersionEventJob" do
+      expect(ContentNewVersionEventJob).to receive(:perform_later).with(file_set, user)
+      Hyrax.config.callback.run(:after_update_content, file_set, user)
+    end
+  end
+
+  describe "after_update_metadata" do
+    it "queues a ContentUpdateEventJob" do
+      expect(ContentUpdateEventJob).to receive(:perform_later).with(curation_concern, user)
+      Hyrax.config.callback.run(:after_update_metadata, curation_concern, user)
+    end
+  end
+
+  describe "after_destroy" do
+    let(:id) { curation_concern.id }
+    it "queues a ContentDeleteEventJob" do
+      expect(ContentDeleteEventJob).to receive(:perform_later).with(id, user)
+      Hyrax.config.callback.run(:after_destroy, id, user)
+    end
+  end
+end

data/spec/controllers/catalog_controller_spec.rb

@@ -0,0 +1,132 @@
+describe CatalogController, type: :controller do
+  routes { Rails.application.class.routes }
+
+  let(:user) { create(:user) }
+
+  before do
+    sign_in user
+  end
+
+  describe "#index" do
+    let(:rocks) do
+      GenericWork.new(id: 'rock123', title: ['Rock Documents'], read_groups: ['public'])
+    end
+
+    let(:clouds) do
+      GenericWork.new(id: 'cloud123', title: ['Cloud Documents'], read_groups: ['public'],
+                      contributor: ['frodo'])
+    end
+
+    before do
+      objects.each { |obj| ActiveFedora::SolrService.add(obj.to_solr) }
+      ActiveFedora::SolrService.commit
+    end
+
+    context 'with a non-work file' do
+      let(:file) { FileSet.new(id: 'file123') }
+      let(:objects) { [file, rocks, clouds] }
+
+      it 'finds works, not files' do
+        get :index
+        expect(response).to be_success
+        expect(response).to render_template('catalog/index')
+
+        ids = assigns(:document_list).map(&:id)
+        expect(ids).to include rocks.id
+        expect(ids).to include clouds.id
+        expect(ids).not_to include file.id
+      end
+    end
+
+    context 'with collections' do
+      let(:collection) { create(:public_collection, keyword: ['rocks']) }
+      let(:objects) { [collection, rocks, clouds] }
+
+      it 'finds collections' do
+        get :index, params: { q: 'rocks' }, xhr: true
+        expect(response).to be_success
+        doc_list = assigns(:document_list)
+        expect(doc_list.map(&:id)).to match_array [collection.id, rocks.id]
+      end
+    end
+
+    describe 'term search' do
+      let(:objects) { [rocks, clouds] }
+      it 'finds works with the given search term' do
+        get :index, params: { q: 'rocks', owner: 'all' }
+        expect(response).to be_success
+        expect(response).to render_template('catalog/index')
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(rocks.id)
+      end
+    end
+
+    describe 'facet search' do
+      let(:objects) { [rocks, clouds] }
+      before do
+        get :index, params: { 'f' => { 'contributor_tesim' => ['frodo'] } }
+      end
+
+      it 'finds faceted works' do
+        expect(response).to be_success
+        expect(response).to render_template('catalog/index')
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(clouds.id)
+      end
+    end
+
+    describe 'full-text search', skip: 'Will GenericWorks have a full_text search?' do
+      let(:objects) { [rocks, clouds] }
+      it 'finds matching records' do
+        get :index, params: { q: 'full_textfull_text' }
+        expect(response).to be_success
+        expect(response).to render_template('catalog/index')
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(clouds.id)
+      end
+    end
+
+    context 'works by file metadata' do
+      let(:objects) do
+        [double(to_solr: file1), double(to_solr: file2),
+         double(to_solr: work1), double(to_solr: work2)]
+      end
+
+      let(:work1) do
+        { has_model_ssim: ["GenericWork"], id: "ff365c76z", title_tesim: ["me too"],
+          file_set_ids_ssim: ["ff365c78h", "ff365c79s"],
+          read_access_group_ssim: ["public"], edit_access_person_ssim: ["user1@example.com"] }
+      end
+
+      let(:work2) do
+        { has_model_ssim: ["GenericWork"], id: "ff365c777", title_tesim: ["find me"],
+          file_set_ids_ssim: [],
+          read_access_group_ssim: ["public"], edit_access_person_ssim: ["user2@example.com"] }
+      end
+
+      let(:file1) do
+        { has_model_ssim: ["FileSet"], id: "ff365c78h", title_tesim: ["find me"],
+          file_set_ids_ssim: [],
+          edit_access_person_ssim: [user.user_key] }
+      end
+
+      let(:file2) do
+        { has_model_ssim: ["FileSet"], id: "ff365c79s", title_tesim: ["other file"],
+          file_set_ids_ssim: [],
+          edit_access_person_ssim: [user.user_key] }
+      end
+
+      it "finds work and work that contains file with title" do
+        get :index, params: { q: 'find me' }
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id], work2[:id])
+      end
+
+      it "finds work that contains file with title" do
+        get :index, params: { q: 'other file' }
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id])
+      end
+
+      it "finds work with title" do
+        get :index, params: { q: 'me too' }
+        expect(assigns(:document_list).map(&:id)).to contain_exactly(work1[:id])
+      end
+    end
+  end # describe "#index"
+end