hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/actors/hyrax/actors/initialize_workflow_actor_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Actors::InitializeWorkflowActor do
+  let(:user) { create(:user) }
+  let(:ability) { ::Ability.new(user) }
+  let(:curation_concern) { build(:generic_work) }
+  let(:attributes) { { title: ['test'] } }
+
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+      middleware.use Hyrax::Actors::GenericWorkActor
+    end
+    stack.build(terminator)
+  end
+
+  describe 'the next actor' do
+    it 'passes the attributes on' do
+      expect(terminator).to receive(:create).with(Hyrax::Actors::Environment)
+      subject.create(env)
+    end
+  end
+
+  describe 'create' do
+    let(:curation_concern) { build(:generic_work, admin_set: admin_set) }
+    let!(:admin_set) { create(:admin_set, with_permission_template: { with_workflows: true }) }
+
+    it 'creates an entity' do
+      expect do
+        expect(subject.create(env)).to be true
+      end.to change { Sipity::Entity.count }.by(1)
+    end
+  end
+end

data/spec/actors/hyrax/actors/interpret_visibility_actor_spec.rb

@@ -0,0 +1,445 @@
+RSpec.describe Hyrax::Actors::InterpretVisibilityActor do
+  let(:user) { create(:user) }
+  let(:ability) { ::Ability.new(user) }
+  let(:curation_concern) { GenericWork.new }
+  let(:attributes) { { admin_set_id: admin_set.id } }
+  let(:admin_set) { create(:admin_set) }
+  let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:one_year_from_today) { Time.zone.today + 1.year }
+  let(:two_years_from_today) { Time.zone.today + 2.years }
+  let(:date) { Time.zone.today + 2 }
+  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+      middleware.use Hyrax::Actors::GenericWorkActor
+    end
+    stack.build(terminator)
+  end
+
+  describe 'the next actor' do
+    let(:terminator) { instance_double(Hyrax::Actors::Terminator) }
+
+    before do
+      allow(curation_concern).to receive(:save).and_return(true)
+    end
+
+    context 'when visibility is set to open' do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          visibility_during_embargo: 'restricted',
+          visibility_after_embargo: 'open',
+          embargo_release_date: date.to_s }
+      end
+
+      it 'does not receive the embargo attributes' do
+        expect(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
+          expect(k.attributes).to eq("visibility" => 'open')
+          false
+        end
+        subject.create(env)
+      end
+    end
+
+    context 'when visibility is set to embargo' do
+      let(:attributes) do
+        { 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 }
+      end
+
+      it 'does not receive the visibility attribute' do
+        expect(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
+          expect(k.attributes.keys).not_to include(:visibility)
+          false
+        end
+        subject.create(env)
+      end
+
+      context 'when embargo_release_date is not set' do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+
+        it 'does not clear the visibility attributes' do
+          expect(subject.create(env)).to be false
+          expect(attributes).to eq(visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO)
+        end
+      end
+    end
+
+    context 'when visibility is set to lease' do
+      let(:attributes) do
+        { 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 }
+      end
+
+      it 'removes lease attributes' do
+        expect(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
+          expect(k.attributes.keys).not_to include(:visibility)
+          false
+        end
+        subject.create(env)
+      end
+
+      context 'when lease_expiration_date is not set' do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE } }
+
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(env)).to be false
+          expect(attributes).to eq(visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE)
+        end
+      end
+    end
+  end
+
+  describe 'create' do
+    context 'with embargo' do
+      let(:attributes) do
+        { 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',
+          license: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+      end
+
+      context 'with a valid embargo date (and no template requirements)' do
+        let(:date) { Time.zone.today + 2 }
+
+        it 'interprets and apply embargo and lease visibility settings' do
+          subject.create(env)
+          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 "embargo with invalid embargo date" do
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: 'ffff' }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template # Ensuring permission_template is loaded
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date.'
+        end
+      end
+
+      context 'when embargo_release_date is in the past' do
+        let(:date) { Time.zone.today - 2 }
+
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date.'
+        end
+      end
+
+      context "embargo with missing embargo date" do
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+
+        it "returns false and logs error on visibility field" do
+          permission_template # Ensuring permission_template is loaded
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:visibility].first).to eq 'When setting visibility to "embargo" you must also specify embargo release date.'
+        end
+      end
+
+      context "embargo with date = one year from today, and required embargo of 6 months or less" do
+        let(:permission_template) { create(:permission_template, source_id: admin_set.id, release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS) }
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:embargo_release_date].first).to eq 'Release date specified does not match permission template release requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with date = one year from today, and required embargo of 1 year or less" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "embargo with date that doesn't match a required, fixed date" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
+                 release_date: one_year_from_today.to_s)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: two_years_from_today.to_s }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:embargo_release_date].first).to eq 'Release date specified does not match permission template release requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with date matching the required, fixed date" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
+                 release_date: two_years_from_today.to_s)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: two_years_from_today.to_s }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "embargo with valid embargo date and invalid post-embargo visibility" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+        end
+
+        it "returns false and logs error on visibility field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:visibility_after_embargo].first).to eq 'Visibility after embargo does not match permission template visibility requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with valid embargo date and valid post-embargo visibility" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "embargo with public visibility and public visibility required (no specified release_period in template)" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "embargo with public visibility and authenticated visibility required (no specified release_period in template)" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns false and logs error on visibility field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:visibility_after_embargo].first).to eq 'Visibility after embargo does not match permission template visibility requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo when no release delays are allowed" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns false and logs error on visiblity field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:visibility].first).to eq 'Visibility specified does not match permission template "no release delay" requirement for selected AdminSet.'
+        end
+      end
+
+      context "no embargo/lease when no release delays are allowed" do
+        let(:permission_template) { create(:permission_template, source_id: admin_set.id, release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY) }
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "visibility public (no embargo) when visibility required to be authenticated" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED)
+        end
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns false and logs an error on visibility field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:visibility].first).to eq 'Visibility specified does not match permission template visibility requirement for selected AdminSet.'
+        end
+      end
+
+      context "visibility public (no embargo) and visibility required to be public" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+
+      context "lease specified with any release/visibility requirements" do
+        let(:permission_template) do
+          create(:permission_template,
+                 source_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+            lease_expiration_date: one_year_from_today.to_s,
+            visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns false and logs an error on visibility field" do
+          permission_template.reload
+          expect(subject.create(env)).to be false
+          expect(env.curation_concern.errors[:visibility].first).to eq 'Lease option is not allowed by permission template for selected AdminSet.'
+        end
+      end
+
+      context "lease specified with NO release/visibility requirements" do
+        let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+            lease_expiration_date: one_year_from_today.to_s,
+            visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(env)).to be true
+        end
+      end
+    end
+
+    context 'with lease' do
+      let(:attributes) do
+        { 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',
+          license: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+      end
+
+      context 'with a valid lease date' do
+        let(:date) { Time.zone.today + 2 }
+
+        it 'interprets and apply embargo and lease visibility settings' do
+          subject.create(env)
+          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) { Time.zone.today - 2 }
+
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(env)).to be false
+          expect(curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
+        end
+      end
+    end
+  end
+end

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