hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/services/hyrax/user_stat_importer_spec.rb

@@ -0,0 +1,315 @@
+RSpec.describe Hyrax::UserStatImporter do
+  before do
+    allow(Hyrax.config).to receive(:analytic_start_date) { dates[0] }
+
+    allow(FileViewStat).to receive(:ga_statistics) do |_date, file|
+      case file
+      when bilbo_file_1
+        bilbo_file_1_pageview_stats
+      when bilbo_file_2
+        bilbo_file_2_pageview_stats
+      else
+        frodo_file_1_pageview_stats
+      end
+    end
+
+    allow(FileDownloadStat).to receive(:ga_statistics) do |_date, file|
+      case file
+      when bilbo_file_1
+        bilbo_file_1_download_stats
+      when bilbo_file_2
+        bilbo_file_2_download_stats
+      else
+        frodo_file_1_download_stats
+      end
+    end
+
+    allow(WorkViewStat).to receive(:ga_statistics) do |_date, work|
+      case work
+      when bilbo_work_1
+        bilbo_work_1_pageview_stats
+      when bilbo_work_2
+        bilbo_work_2_pageview_stats
+      else
+        frodo_work_1_pageview_stats
+      end
+    end
+  end
+
+  let(:bilbo) { create(:user, email: 'bilbo@example.com') }
+  let(:frodo) { create(:user, email: 'frodo@example.com') }
+  let!(:gollum) { create(:user, email: 'gollum@example.com') }
+
+  let!(:bilbo_file_1) do
+    create(:file_set, id: 'xyzbilbo1', user: bilbo)
+  end
+
+  let!(:bilbo_file_2) do
+    create(:file_set, id: 'xyzbilbo2', user: bilbo)
+  end
+
+  let!(:frodo_file_1) do
+    create(:file_set, id: 'xyzfrodo1', user: frodo)
+  end
+
+  # work
+  let!(:bilbo_work_1) do
+    create(:work, id: 'xyzbilbowork1', user: bilbo)
+  end
+
+  let!(:bilbo_work_2) do
+    create(:work, id: 'xyzbilbowork2', user: bilbo)
+  end
+
+  let!(:frodo_work_1) do
+    create(:work, id: 'xyzfrodowork1', user: frodo)
+  end
+
+  let(:dates) do
+    ldates = []
+    4.downto(0) { |idx| ldates << (Time.zone.today - idx.day) }
+    ldates
+  end
+
+  let(:date_strs) do
+    ldate_strs = []
+    dates.each { |date| ldate_strs << date.strftime("%Y%m%d") }
+    ldate_strs
+  end
+
+  # This is what the data looks like that's returned from Google Analytics via the Legato gem.
+  let(:bilbo_file_1_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 1),
+      SpecStatistic.new(date: date_strs[1], pageviews: 2),
+      SpecStatistic.new(date: date_strs[2], pageviews: 3),
+      SpecStatistic.new(date: date_strs[3], pageviews: 4),
+      SpecStatistic.new(date: date_strs[4], pageviews: 5)
+    ]
+  end
+
+  let(:bilbo_file_2_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 11),
+      SpecStatistic.new(date: date_strs[1], pageviews: 12),
+      SpecStatistic.new(date: date_strs[2], pageviews: 13),
+      SpecStatistic.new(date: date_strs[3], pageviews: 14),
+      SpecStatistic.new(date: date_strs[4], pageviews: 15)
+    ]
+  end
+
+  let(:frodo_file_1_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 2),
+      SpecStatistic.new(date: date_strs[1], pageviews: 4),
+      SpecStatistic.new(date: date_strs[2], pageviews: 1),
+      SpecStatistic.new(date: date_strs[3], pageviews: 1),
+      SpecStatistic.new(date: date_strs[4], pageviews: 9)
+    ]
+  end
+
+  # work
+  let(:bilbo_work_1_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 1),
+      SpecStatistic.new(date: date_strs[1], pageviews: 2),
+      SpecStatistic.new(date: date_strs[2], pageviews: 3),
+      SpecStatistic.new(date: date_strs[3], pageviews: 4),
+      SpecStatistic.new(date: date_strs[4], pageviews: 5)
+    ]
+  end
+
+  let(:bilbo_work_2_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 11),
+      SpecStatistic.new(date: date_strs[1], pageviews: 12),
+      SpecStatistic.new(date: date_strs[2], pageviews: 13),
+      SpecStatistic.new(date: date_strs[3], pageviews: 14),
+      SpecStatistic.new(date: date_strs[4], pageviews: 15)
+    ]
+  end
+
+  let(:frodo_work_1_pageview_stats) do
+    [
+      SpecStatistic.new(date: date_strs[0], pageviews: 2),
+      SpecStatistic.new(date: date_strs[1], pageviews: 4),
+      SpecStatistic.new(date: date_strs[2], pageviews: 1),
+      SpecStatistic.new(date: date_strs[3], pageviews: 1),
+      SpecStatistic.new(date: date_strs[4], pageviews: 9)
+    ]
+  end
+
+  let(:bilbo_file_1_download_stats) do
+    [
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo1", date: date_strs[0], totalEvents: "2"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo1", date: date_strs[1], totalEvents: "3"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo1", date: date_strs[2], totalEvents: "5"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo1", date: date_strs[3], totalEvents: "3"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo1", date: date_strs[4], totalEvents: "7")
+    ]
+  end
+
+  let(:bilbo_file_2_download_stats) do
+    [
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo2", date: date_strs[0], totalEvents: "1"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo2", date: date_strs[1], totalEvents: "4"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo2", date: date_strs[2], totalEvents: "3"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo2", date: date_strs[3], totalEvents: "2"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "bilbo2", date: date_strs[4], totalEvents: "3")
+    ]
+  end
+
+  let(:frodo_file_1_download_stats) do
+    [
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "frodo1", date: date_strs[0], totalEvents: "5"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "frodo1", date: date_strs[1], totalEvents: "4"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "frodo1", date: date_strs[2], totalEvents: "2"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "frodo1", date: date_strs[3], totalEvents: "1"),
+      SpecStatistic.new(eventCategory: "Files", eventAction: "Downloaded", eventLabel: "frodo1", date: date_strs[4], totalEvents: "6")
+    ]
+  end
+
+  describe 'with empty cache' do
+    it 'for each user it adds one entry per day to the cache' do
+      described_class.new.import
+
+      bilbos_stats = UserStat.where(user_id: bilbo.id).order(date: :asc)
+      expect(bilbos_stats.count).to eq 4
+
+      bilbos_stats.each_with_index do |actual_values, i|
+        expected_file_views = bilbo_file_1_pageview_stats[i].pageviews + bilbo_file_2_pageview_stats[i].pageviews
+        expected_work_views = bilbo_work_1_pageview_stats[i].pageviews + bilbo_work_2_pageview_stats[i].pageviews
+        expected_file_downloads = bilbo_file_1_download_stats[i].totalEvents.to_i + bilbo_file_2_download_stats[i].totalEvents.to_i
+        expected_values = { date: dates[i], views: expected_file_views, work_views: expected_work_views, downloads: expected_file_downloads }
+        assert_stats_match(expected_values, actual_values)
+      end
+
+      frodos_stats = UserStat.where(user_id: frodo.id).order(date: :asc)
+      expect(frodos_stats.count).to eq 4
+
+      frodos_stats.each_with_index do |actual_values, i|
+        expected_file_views = frodo_file_1_pageview_stats[i].pageviews
+        expected_work_views = frodo_work_1_pageview_stats[i].pageviews
+        expected_file_downloads = frodo_file_1_download_stats[i].totalEvents.to_i
+        expected_values = { date: dates[i], views: expected_file_views, work_views: expected_work_views, downloads: expected_file_downloads }
+        assert_stats_match(expected_values, actual_values)
+      end
+
+      expect(UserStat.count).to eq bilbos_stats.count + frodos_stats.count
+    end
+
+    context "when Google analytics throws an error" do
+      let(:importer) { described_class.new }
+
+      before do
+        # Specify retry_options to make test run faster.
+        allow(importer).to receive(:retry_options).and_return(tries: 4, base_interval: 0.2, multiplier: 1.0, rand_factor: 0.0)
+      end
+
+      context "both error out completely" do
+        before do
+          expect(FileDownloadStat).to receive(:ga_statistics).exactly(12).times.and_raise(StandardError.new("GA error"))
+          expect(WorkViewStat).to receive(:ga_statistics).exactly(12).times.and_raise(StandardError.new("GA error"))
+          expect(FileViewStat).to receive(:ga_statistics).exactly(12).times.and_raise(StandardError.new("GA error"))
+        end
+
+        it "stops after 4 tries on each of the 3 files" do
+          importer.import
+          expect(UserStat.count).to eq 0
+        end
+      end
+
+      context "Only View stats error out completely" do
+        before do
+          expect(FileViewStat).to receive(:ga_statistics).exactly(12).times.and_raise(StandardError.new("GA error"))
+        end
+        it "gathers the download stats even though the view stats are failing" do
+          importer.import
+          expect(UserStat.count).to eq 8 # 2 users for 4 days
+          UserStat.all.each do |stat|
+            expect(stat.file_views).to eq 0
+            expect(stat.work_views).not_to eq 0
+            expect(stat.file_downloads).not_to eq 0
+          end
+        end
+      end
+
+      context "Only Download stats error out completely" do
+        before do
+          expect(FileDownloadStat).to receive(:ga_statistics).exactly(12).times.and_raise(StandardError.new("GA error"))
+        end
+        it "gathers the view stats even though the download stats are failing" do
+          importer.import
+          expect(UserStat.count).to eq 8 # 2 users for 4 days
+          UserStat.all.each do |stat|
+            expect(stat.file_views).not_to eq 0
+            expect(stat.work_views).not_to eq 0
+            expect(stat.file_downloads).to eq 0
+          end
+        end
+      end
+    end
+  end
+
+  describe 'with existing data in cache' do
+    before do
+      [dates[0], dates[1]].each_with_index do |date, i|
+        UserStat.create!(user_id: bilbo.id, date: date, file_views: 100 + i, file_downloads: 200 + i, work_views: 300)
+      end
+      UserStat.create!(user_id: frodo.id, date: dates[0], file_views: 300, file_downloads: 400, work_views: 500)
+    end
+
+    it "doesn't duplicate entries for existing dates" do
+      expect(User.count).to eq 3
+      expect(UserStat.count).to eq 3
+
+      described_class.new.import
+
+      bilbos_stats = UserStat.where(user_id: bilbo.id).order(date: :asc)
+      expect(bilbos_stats.count).to eq 4
+
+      expect(bilbos_stats[0].file_views).to eq(bilbo_file_1_pageview_stats[0].pageviews + bilbo_file_2_pageview_stats[0].pageviews)
+      expect(bilbos_stats[0].file_downloads).to eq(bilbo_file_1_download_stats[0].totalEvents.to_i + bilbo_file_2_download_stats[0].totalEvents.to_i)
+
+      expect(bilbos_stats[1].file_views).to eq(bilbo_file_1_pageview_stats[1].pageviews + bilbo_file_2_pageview_stats[1].pageviews)
+      expect(bilbos_stats[1].file_downloads).to eq(bilbo_file_1_download_stats[1].totalEvents.to_i + bilbo_file_2_download_stats[1].totalEvents.to_i)
+
+      frodos_stats = UserStat.where(user_id: frodo.id).order(date: :asc)
+      expect(frodos_stats.count).to eq 4
+
+      expect(frodos_stats[0].file_views).to eq(frodo_file_1_pageview_stats[0].pageviews)
+
+      expect(frodos_stats[0].file_downloads).to eq(frodo_file_1_download_stats[0].totalEvents.to_i)
+    end
+
+    it "processes the oldest records first" do
+      # Since Gollum has no stats it will be the first one processed.
+      # Followed by Frodo and Bilbo.
+      sorted_ids = described_class.new.sorted_users.map(&:id)
+      expect(sorted_ids).to eq([gollum.id, frodo.id, bilbo.id])
+    end
+
+    context "a user is already up to date" do
+      let(:importer) { described_class.new }
+
+      before do
+        allow(importer).to receive(:sorted_users).and_return([gollum, frodo, bilbo])
+        UserStat.create!(user_id: bilbo.id, date: dates[3], file_views: 999, file_downloads: 555)
+      end
+
+      it "skips if we already have uptodate information" do
+        expect(importer).to receive(:file_ids_for_user).with(gollum).and_call_original
+        expect(importer).to receive(:file_ids_for_user).with(frodo).and_call_original
+        expect(importer).not_to receive(:file_ids_for_user).with(bilbo)
+        importer.import
+      end
+    end
+  end
+end
+
+def assert_stats_match(expected_value, actual_value)
+  expect(actual_value.date).to eq expected_value[:date]
+  expect(actual_value.file_views).to eq expected_value[:views]
+  expect(actual_value.work_views).to eq expected_value[:work_views]
+  expect(actual_value.file_downloads).to eq expected_value[:downloads]
+end

data/spec/services/hyrax/versioning_service_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Hyrax::VersioningService do
+  describe '#latest_version_of' do
+    let(:user) { build(:user) }
+    let(:file) { create(:file_set) }
+
+    before do
+      # Add the original_file (this service  creates a version after saving when you call it with versioning: true)
+      Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file, versioning: true)
+    end
+
+    describe 'latest_version_of' do
+      subject { described_class.latest_version_of(file.original_file).label }
+
+      context 'with one version' do
+        it { is_expected.to eq 'version1' }
+      end
+
+      context 'with two versions' do
+        before do
+          file.original_file.create_version
+        end
+        it { is_expected.to eq 'version2' }
+      end
+    end
+  end
+end

data/spec/services/hyrax/work_query_service_spec.rb

@@ -0,0 +1,56 @@
+module Hyrax
+  RSpec.describe WorkQueryService do
+    let(:user) { create(:user) }
+    let(:work_id) { 'abc' }
+    let(:work_relation) { double('Work Relation') }
+    let(:work_query_service) { described_class.new(id: work_id, work_relation: work_relation) }
+
+    describe '#default_work_relation' do
+      subject { work_query_service.send(:default_work_relation) }
+
+      it { is_expected.to respond_to(:find).with(1).arguments }
+      it { is_expected.to respond_to(:exists?).with(1).arguments }
+    end
+
+    describe '#deleted_work?' do
+      subject { work_query_service.deleted_work? }
+
+      context 'when not in SOLR' do
+        before { allow(work_relation).to receive(:exists?).with(work_id).and_return(false) }
+        it { is_expected.to be_truthy }
+      end
+      context 'when in SOLR' do
+        before { allow(work_relation).to receive(:exists?).with(work_id).and_return(true) }
+        it { is_expected.to be_falsey }
+      end
+    end
+    describe '#work' do
+      let(:expected_work) { double('Work') }
+
+      subject { work_query_service.work }
+
+      context 'when not in SOLR' do
+        before { allow(work_relation).to receive(:find).with(work_id).and_return(expected_work) }
+        it { is_expected.to eq(expected_work) }
+      end
+    end
+    describe '#to_s' do
+      subject { work_query_service.to_s }
+
+      context 'when the work is deleted' do
+        before { allow(work_relation).to receive(:exists?).with(work_id).and_return(false) }
+        it { is_expected.to eq('work not found') }
+      end
+
+      context 'when the work is not deleted' do
+        # NOTE: This is testing the full behavior of finding
+        let!(:work_query_service) { described_class.new(id: work.id) }
+        let!(:work) { create(:generic_work, title: ["Test work"]) }
+
+        it 'will retrieve the SOLR document and use the #to_s method of that' do
+          expect(subject).to eq(work.title.first)
+        end
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/action_taken_service_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe Hyrax::Workflow::ActionTakenService do
+  context 'class methods' do
+    subject { described_class }
+
+    it { is_expected.to respond_to(:handle_action_taken) }
+  end
+
+  let(:triggered_methods) { [instance_double(Sipity::Method, service_name: 'FooBar')] }
+  let(:triggered_methods_rel) do
+    double('Sipity::Method::ActiveRecord_Relation',
+           order: triggered_methods,
+           any?: true)
+  end
+  let(:work) { instance_double(GenericWork, id: '9999') }
+  let(:action) { instance_double(Sipity::WorkflowAction, triggered_methods: triggered_methods_rel) }
+  let(:user) { User.new }
+  let(:instance) do
+    described_class.new(target: work,
+                        action: action,
+                        comment: "A pleasant read",
+                        user: user)
+  end
+
+  describe "#call" do
+    subject { instance.call }
+
+    context "when the method exists" do
+      around do |example|
+        class FooBar
+          def self.call; end
+        end
+        example.run
+        Object.send(:remove_const, :FooBar)
+      end
+
+      context "and the method succeedes" do
+        it "calls the method and saves the object" do
+          expect(work).to receive(:save)
+          expect(FooBar).to receive(:call).with(target: work, user: user, comment: "A pleasant read").and_return(true)
+          subject
+        end
+      end
+      context "and the method fails" do
+        it "calls the method and saves the object" do
+          expect(work).not_to receive(:save)
+          expect(FooBar).to receive(:call).with(target: work, user: user, comment: "A pleasant read").and_return(false)
+          expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+          subject
+        end
+      end
+    end
+
+    context "when the notification class doesn't have the method" do
+      around do |example|
+        class FooBar; end
+        example.run
+        Object.send(:remove_const, :FooBar)
+      end
+      it "logs an error" do
+        expect(Rails.logger).to receive(:error).with("Expected 'FooBar' to respond to 'call', but it didn't, so not running workflow callback")
+        expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+        subject
+      end
+    end
+
+    context "when the notification doesn't exist" do
+      it "logs an error" do
+        expect(Rails.logger).to receive(:error).with("Unable to find 'FooBar', so not running workflow callback")
+        expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+        subject
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/activate_object_spec.rb

@@ -0,0 +1,26 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::ActivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like "a Hyrax workflow method"
+
+  describe ".call" do
+    it "makes it active" do
+      if RDF::VERSION.to_s < '2.0'
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(instance_of(ActiveTriples::Resource))
+      else
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#active'))
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/changes_required_notification_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Workflow::ChangesRequiredNotification do
+  let(:approver) { create(:user) }
+  let(:depositor) { create(:user) }
+  let(:to_user) { create(:user) }
+  let(:cc_user) { create(:user) }
+  let(:work) { create(:generic_work, user: depositor) }
+  let(:entity) { create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s) }
+  let(:comment) { double("comment", comment: 'A pleasant read') }
+  let(:recipients) { { 'to' => [to_user], 'cc' => [cc_user] } }
+
+  describe ".send_notification" do
+    it 'sends a message to all users' do
+      expect(approver).to receive(:send_message)
+        .with(anything,
+              "Test title (<a href=\"/concern/generic_works/#{work.id}\">#{work.id}</a>) " \
+              "requires additional changes before approval.\n\n 'A pleasant read'",
+              anything).exactly(3).times.and_call_original
+
+      expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+        .to change { depositor.mailbox.inbox.count }.by(1)
+                                                    .and change { to_user.mailbox.inbox.count }.by(1)
+                                                                                               .and change { cc_user.mailbox.inbox.count }.by(1)
+    end
+    context 'without carbon-copied users' do
+      let(:recipients) { { 'to' => [to_user] } }
+
+      it 'sends a message to the to user(s)' do
+        expect(approver).to receive(:send_message).exactly(2).times.and_call_original
+        expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+          .to change { depositor.mailbox.inbox.count }.by(1)
+                                                      .and change { to_user.mailbox.inbox.count }.by(1)
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/deactivate_object_spec.rb

@@ -0,0 +1,26 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::DeactivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like "a Hyrax workflow method"
+
+  describe ".call" do
+    it "makes it inactive" do
+      if RDF::VERSION.to_s < '2.0'
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(instance_of(ActiveTriples::Resource))
+      else
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#inactive'))
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/deposited_notification_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Workflow::DepositedNotification do
+  let(:approver) { create(:user) }
+  let(:depositor) { create(:user) }
+  let(:to_user) { create(:user) }
+  let(:cc_user) { create(:user) }
+  let(:work) { create(:generic_work, user: depositor) }
+  let(:entity) { create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s) }
+  let(:comment) { double("comment", comment: 'A pleasant read') }
+  let(:recipients) { { 'to' => [to_user], 'cc' => [cc_user] } }
+
+  describe ".send_notification" do
+    it 'sends a message to all users' do
+      expect(approver).to receive(:send_message)
+        .with(anything,
+              "Test title (<a href=\"/concern/generic_works/#{work.id}\">#{work.id}</a>) " \
+              "was approved by #{approver.user_key}. A pleasant read",
+              anything).exactly(3).times.and_call_original
+
+      expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+        .to change { depositor.mailbox.inbox.count }.by(1)
+                                                    .and change { to_user.mailbox.inbox.count }.by(1)
+                                                                                               .and change { cc_user.mailbox.inbox.count }.by(1)
+    end
+    context 'without carbon-copied users' do
+      let(:recipients) { { 'to' => [to_user] } }
+
+      it 'sends a message to the to user(s)' do
+        expect(approver).to receive(:send_message).exactly(2).times.and_call_original
+        expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+          .to change { depositor.mailbox.inbox.count }.by(1)
+                                                      .and change { to_user.mailbox.inbox.count }.by(1)
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/grant_edit_to_depositor_spec.rb

@@ -0,0 +1,53 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::GrantEditToDepositor do
+  let(:depositor) { create(:user) }
+  let(:user) { User.new }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like 'a Hyrax workflow method'
+
+  describe ".call" do
+    subject do
+      described_class.call(target: work,
+                           comment: "A pleasant read",
+                           user: user)
+    end
+
+    context "with no additional editors" do
+      let(:work) { create(:work_without_access, depositor: depositor.user_key) }
+
+      it "adds edit access" do
+        expect { subject }.to change { work.edit_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with an additional editor" do
+      let(:editor) { create(:user) }
+      let(:work) { create(:work_without_access, depositor: depositor.user_key, edit_users: [editor.user_key]) }
+
+      it "adds edit access" do
+        expect { subject }.to change { work.edit_users }.from([editor.user_key]).to([editor.user_key, depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with attached FileSets", :perform_enqueued do
+      let(:work) { create(:work_with_one_file, user: depositor) }
+      let(:file_set) do
+        work.members.first.tap do |file_set|
+          # Manually remove edit_users to satisfy the pre-condition
+          file_set.update(edit_users: [])
+        end
+      end
+
+      it "grants edit access" do
+        # We need to reload, because this work happens in a background job
+        expect { subject }.to change { file_set.reload.edit_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+  end
+end