hyrax 2.9.5 → 3.0.0.pre.beta1

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

@@ -0,0 +1,54 @@
+RSpec.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
+
+  context 'deactivating an expired lease', clean_repo: true do
+    let(:lease_attributes) do
+      { lease_date: Date.tomorrow.to_s,
+        current_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+        future_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+    end
+    let(:leased_work) { create(:leased_work, with_lease_attributes: lease_attributes) }
+    let(:subject) { described_class.new(leased_work) }
+
+    it 'destroys and reindexes the new permission appropriately in solr', with_nested_reindexing: true do
+      allow(leased_work.lease).to receive(:active?).and_return false
+      subject.destroy
+      expect(::SolrDocument.find(leased_work.id)[:visibility_ssi]).to eq(Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED)
+    end
+  end
+end

data/spec/actors/hyrax/actors/model_actor_spec.rb

@@ -0,0 +1,24 @@
+module MusicalWork
+  class Cover < ActiveFedora::Base
+  end
+end
+
+class Hyrax::Actors::MusicalWork
+  class CoverActor < ::Hyrax::Actors::AbstractActor
+  end
+end
+
+RSpec.describe Hyrax::Actors::ModelActor do
+  let(:work) { MusicalWork::Cover.new }
+  let(:depositor) { create(:user) }
+  let(:depositor_ability) { ::Ability.new(depositor) }
+  let(:env) { Hyrax::Actors::Environment.new(work, depositor_ability, {}) }
+
+  describe '#model_actor' do
+    subject { described_class.new('¯\_(ツ)_/¯').send(:model_actor, env) }
+
+    it "preserves the namespacing" do
+      is_expected.to be_kind_of Hyrax::Actors::MusicalWork::CoverActor
+    end
+  end
+end

data/spec/actors/hyrax/actors/optimistic_lock_validator_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Hyrax::Actors::OptimisticLockValidator do
+  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
+  let(:ability) { ::Ability.new(depositor) }
+
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:depositor) { create(:user) }
+  let(:work) { create(:generic_work) }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+    end
+    stack.build(terminator)
+  end
+
+  describe "update" do
+    before do
+      allow(terminator).to receive(:update).and_return(true)
+    end
+
+    subject { middleware.update(env) }
+
+    context "when version is blank" do
+      let(:attributes) { { version: '' } }
+
+      it { is_expected.to be true }
+    end
+
+    context "when version is provided" do
+      context "and the version is current" do
+        let(:attributes) { { 'version' => work.etag } }
+
+        it "returns true and calls the next actor without the version attribute" do
+          expect(terminator).to receive(:update).with(Hyrax::Actors::Environment) do |k|
+            expect(k.attributes).to eq({})
+            true
+          end
+          expect(subject).to be true
+        end
+      end
+
+      context "and the version is not current" do
+        let(:attributes) { { 'version' => "W/\"ab2e8552cb5f7f00f91d2b223eca45849c722301\"" } }
+
+        it "returns false and sets an error" do
+          expect(subject).to be false
+          expect(work.errors[:base]).to include "Your changes could not be saved because another " \
+            "user (or background job) updated this Generic work after you began editing. Please " \
+            "make sure all file attachments have completed successfully and try again. This form " \
+            "has refreshed with the most recent saved copy of the Generic work."
+        end
+      end
+    end
+  end
+end

data/spec/actors/hyrax/actors/ordered_members_actor_spec.rb

@@ -0,0 +1,59 @@
+require 'redlock'
+
+RSpec.describe Hyrax::Actors::OrderedMembersActor do
+  include ActionDispatch::TestProcess
+
+  let(:user)          { create(:user) }
+  let(:actor)         { described_class.new([file_set], user) }
+  let(:file_set) { build(:file_set) }
+  let(:work) { create(:generic_work) }
+
+  describe 'attaching to a work' do
+    before do
+      allow(actor).to receive(:acquire_lock_for).and_yield
+      actor.attach_ordered_members_to_work(work)
+    end
+
+    context 'when a work is provided' do
+      it 'adds the FileSet to the parent work' do
+        expect(file_set.parents).to eq [work]
+        expect(work.reload.file_sets).to include(file_set)
+      end
+    end
+
+    context 'with multiple file_sets' do
+      let(:work_v1) { create(:generic_work) } # this version of the work has no members
+
+      before do # another file_set is added
+        work.ordered_members << create(:file_set)
+        work.save!
+      end
+
+      it "now contains two file_sets" do
+        expect(work.members.size).to eq 2
+      end
+    end
+
+    context 'with multiple versions' do
+      let(:work_v1) { create(:generic_work) } # this version of the work has no members
+
+      before do # another version of the same work is saved with a member
+        work_v2 = ActiveFedora::Base.find(work_v1.id)
+        work_v2.ordered_members << create(:file_set)
+        work_v2.save!
+      end
+
+      it "writes to the most up to date version" do
+        actor.attach_ordered_members_to_work(work_v1)
+        expect(work_v1.members.size).to eq 2
+      end
+    end
+  end
+
+  describe "#runs callbacks" do
+    it 'runs callbacks' do
+      expect(FileSetAttachedEventJob).to receive(:perform_later).with(file_set, user)
+      actor.attach_ordered_members_to_work(work)
+    end
+  end
+end

data/spec/actors/hyrax/actors/transactional_request_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Hyrax::Actors::TransactionalRequest do
+  let(:bad_actor) do
+    Class.new(Hyrax::Actors::AbstractActor) do
+      def create(attributes)
+        next_actor.create(attributes) && raise('boom')
+      end
+    end
+  end
+
+  let(:good_actor) do
+    Class.new(Hyrax::Actors::AbstractActor) do
+      def create(_attributes)
+        FactoryBot.create(:user)
+      end
+    end
+  end
+
+  let(:ability) { ::Ability.new(depositor) }
+  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:depositor) { instance_double(User, new_record?: true, guest?: true, id: nil, user_key: nil) }
+  let(:work) { double(:work) }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+      middleware.use bad_actor
+      middleware.use good_actor
+    end
+    stack.build(terminator)
+  end
+
+  describe "create" do
+    let(:attributes) { {} }
+
+    subject { middleware.create(env) }
+
+    it "rolls back any database changes" do
+      expect do
+        expect { subject }.to raise_error 'boom'
+      end.not_to change { User.count } # Note the above good actor creates a user
+    end
+  end
+end

data/spec/actors/hyrax/actors/transfer_request_actor_spec.rb

@@ -0,0 +1,43 @@
+require 'rails_helper'
+
+RSpec.describe Hyrax::Actors::TransferRequestActor do
+  let(:ability) { ::Ability.new(depositor) }
+  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:depositor) { create(:user) }
+  let(:work) do
+    build(:generic_work, on_behalf_of: proxied_to)
+  end
+  let(:attributes) { {} }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+    end
+    stack.build(terminator)
+  end
+
+  describe "create" do
+    context "when on_behalf_of is blank" do
+      let(:proxied_to) { '' }
+
+      it "returns true" do
+        expect(middleware.create(env)).to be true
+      end
+    end
+
+    context "when proxied_to is provided" do
+      let(:proxied_to) { 'james@example.com' }
+
+      before do
+        create(:user, email: proxied_to)
+        allow(terminator).to receive(:create).and_return(true)
+      end
+
+      it "adds the template users to the work" do
+        expect(ContentDepositorChangeEventJob).to receive(:perform_later).with(work, User)
+        expect(middleware.create(env)).to be true
+      end
+    end
+  end
+end

data/spec/authorities/qa/authorities/collections_spec.rb

@@ -0,0 +1,68 @@
+RSpec.describe Qa::Authorities::Collections, :clean_repo do
+  let(:controller) { Qa::TermsController.new }
+  let(:user1) { build(:user) }
+  let(:user2) { build(:user) }
+  let(:q) { "foo" }
+  let(:service) { described_class.new }
+  let!(:collection1) { build(:private_collection_lw, id: 'col-1-own', title: ['foo foo'], user: user1, with_permission_template: true, with_solr_document: true) }
+  let!(:collection2) { build(:private_collection_lw, id: 'col-2-own', title: ['bar'], user: user1, with_permission_template: true, with_solr_document: true) }
+  let!(:collection3) { build(:private_collection_lw, id: 'col-3-own', title: ['another foo'], user: user1, with_permission_template: true, with_solr_document: true) }
+  let!(:collection4) { build(:private_collection_lw, id: 'col-4-none', title: ['foo foo foo'], user: user2, with_permission_template: true, with_solr_document: true) }
+  let!(:collection5) do
+    build(:private_collection_lw, id: 'col-5-mgr', title: ['foo for you'], user: user2,
+                                  with_permission_template: { manage_users: [user1] }, with_solr_document: true)
+  end
+  let!(:collection6) do
+    build(:private_collection_lw, id: 'col-6-dep', title: ['foo too'], user: user2,
+                                  with_permission_template: { deposit_users: [user1] }, with_solr_document: true)
+  end
+  let!(:collection7) do
+    build(:private_collection_lw, id: 'col-7-view', title: ['foo bar baz'], user: user2,
+                                  with_permission_template: { view_users: [user1] }, with_solr_document: true)
+  end
+  let!(:collection8) do
+    build(:private_collection_lw, id: 'col-8-mgr', title: ['bar for you'], user: user2,
+                                  with_permission_template: { manage_users: [user1] }, with_solr_document: true)
+  end
+  let!(:collection9) do
+    build(:private_collection_lw, id: 'col-9-dep', title: ['bar too'], user: user2,
+                                  with_permission_template: { deposit_users: [user1] }, with_solr_document: true)
+  end
+  let!(:collection10) do
+    build(:private_collection_lw, id: 'col-10-view', title: ['bar bar baz'], user: user2,
+                                  with_permission_template: { view_users: [user1] }, with_solr_document: true)
+  end
+
+  before do
+    allow(controller).to receive(:params).and_return(params)
+    allow(controller).to receive(:current_user).and_return(user1)
+  end
+
+  subject { service.search(q, controller) }
+
+  describe '#search' do
+    context 'when access is read' do
+      let(:params) { ActionController::Parameters.new(q: q, access: 'read') }
+
+      it 'displays a list of read collections for the current user' do
+        expect(subject.map { |result| result[:id] }).to match_array [collection1.id, collection3.id, collection5.id, collection6.id, collection7.id]
+      end
+    end
+
+    context 'when access is edit' do
+      let(:params) { ActionController::Parameters.new(q: q, access: 'edit') }
+
+      it 'displays a list of edit collections for the current user' do
+        expect(subject.map { |result| result[:id] }).to match_array [collection1.id, collection3.id, collection5.id]
+      end
+    end
+
+    context 'when access is deposit' do
+      let(:params) { ActionController::Parameters.new(q: q, access: 'deposit') }
+
+      it 'displays a list of edit and deposit collections for the current user' do
+        expect(subject.map { |result| result[:id] }).to match_array [collection1.id, collection3.id, collection5.id, collection6.id]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+RSpec.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 }
+  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) }
+
+  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
+
+  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/channels/hyrax/application_cable/channel_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Hyrax::ApplicationCable::Channel do
+  subject { described_class.new(connection, identifier) }
+
+  let(:connection) { double('connection', identifiers: []) }
+  let(:identifier) { double }
+
+  describe 'behaves like an ActionCable::Channel::Base' do
+    it { is_expected.to respond_to(:perform_action) }
+    it { is_expected.to respond_to(:unsubscribe_from_channel) }
+    it { is_expected.to respond_to(:stop_all_streams) }
+    it { is_expected.to respond_to(:stream_for) }
+    it { is_expected.to respond_to(:stream_from) }
+  end
+end

data/spec/channels/hyrax/application_cable/connection_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Hyrax::ApplicationCable::Connection do
+  subject { described_class.new(server, env) }
+
+  let(:server) { ActionCable::Server::Base.new }
+  let(:env) { {} }
+
+  describe '#connect' do
+    # rubocop:disable RSpec/SubjectStub
+    before do
+      allow(subject).to receive(:user_id).and_return(user_id)
+    end
+    # rubocop:enable RSpec/SubjectStub
+
+    context 'when user is found' do
+      let(:user) { create(:user) }
+      let(:user_id) { user.id }
+
+      it 'sets #current_user to the found user instance' do
+        expect { subject.connect }.to change { subject.current_user }.from(nil).to(user)
+      end
+    end
+
+    context 'when user is not found' do
+      # rubocop:disable RSpec/SubjectStub
+      before do
+        allow(subject).to receive(:session).and_raise(NoMethodError)
+      end
+      # rubocop:enable RSpec/SubjectStub
+
+      let(:user_id) { nil }
+
+      it 'rejects the unauthorized connection' do
+        expect { subject.connect }.to raise_error(ActionCable::Connection::Authorization::UnauthorizedError)
+      end
+    end
+  end
+end