diff --git a/backend/app/controllers/spree/admin/cancellations_controller.rb b/backend/app/controllers/spree/admin/cancellations_controller.rb
index 976f2a85d0b..3e7ac13e19b 100644
--- a/backend/app/controllers/spree/admin/cancellations_controller.rb
+++ b/backend/app/controllers/spree/admin/cancellations_controller.rb
@@ -20,7 +20,7 @@ def short_ship
           flash[:error] = t('spree.no_inventory_selected')
           redirect_to admin_order_cancellations_path(@order)
         else
-          @order.cancellations.short_ship(inventory_units, whodunnit: whodunnit)
+          @order.cancellations.short_ship(inventory_units, created_by: created_by)
 
           flash[:success] = t('spree.inventory_canceled')
           redirect_to edit_admin_order_url(@order)
@@ -29,7 +29,7 @@ def short_ship
 
       private
 
-      def whodunnit
+      def created_by
         try_spree_current_user.try(:email)
       end
 
diff --git a/backend/app/controllers/spree/admin/reimbursements_controller.rb b/backend/app/controllers/spree/admin/reimbursements_controller.rb
index 95b2577aa37..613cc8cfd3a 100644
--- a/backend/app/controllers/spree/admin/reimbursements_controller.rb
+++ b/backend/app/controllers/spree/admin/reimbursements_controller.rb
@@ -13,7 +13,7 @@ class ReimbursementsController < ResourceController
       rescue_from Spree::Core::GatewayError, with: :spree_core_gateway_error
 
       def perform
-        @reimbursement.perform!
+        @reimbursement.perform!(created_by: try_spree_current_user)
         redirect_to location_after_save
       end
 
@@ -57,7 +57,7 @@ def load_stock_locations
       end
 
       def load_simulated_refunds
-        @reimbursement_objects = @reimbursement.simulate
+        @reimbursement_objects = @reimbursement.simulate(created_by: try_spree_current_user)
       end
 
       def spree_core_gateway_error(error)
diff --git a/backend/spec/controllers/spree/admin/reimbursements_controller_spec.rb b/backend/spec/controllers/spree/admin/reimbursements_controller_spec.rb
index a36b095ee3d..3266d9b3aaa 100644
--- a/backend/spec/controllers/spree/admin/reimbursements_controller_spec.rb
+++ b/backend/spec/controllers/spree/admin/reimbursements_controller_spec.rb
@@ -9,6 +9,13 @@
     Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
   end
 
+  let(:user) { stub_model(Spree::LegacyUser, has_spree_role?: true, id: 1) }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:try_spree_current_user).
+      and_return(user)
+  end
+
   describe '#edit' do
     let(:reimbursement) { create(:reimbursement) }
     let(:order) { reimbursement.order }
diff --git a/backend/spec/features/admin/orders/return_payment_state_spec.rb b/backend/spec/features/admin/orders/return_payment_state_spec.rb
index b0a42f45580..4fe9ffb8726 100644
--- a/backend/spec/features/admin/orders/return_payment_state_spec.rb
+++ b/backend/spec/features/admin/orders/return_payment_state_spec.rb
@@ -7,9 +7,12 @@
 
   before do
     Spree::RefundReason.create!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
+    allow_any_instance_of(Spree::Admin::ReimbursementsController).to receive(:try_spree_current_user).
+      and_return(user)
   end
 
   let!(:order) { create(:shipped_order) }
+  let(:user) { create(:admin_user) }
 
   # Regression test for https://github.com/spree/spree/issues/6229
   it "refunds and has outstanding_balance of zero", js: true do
diff --git a/core/app/models/spree/order_cancellations.rb b/core/app/models/spree/order_cancellations.rb
index 471400b4f5f..05272a8c4a6 100644
--- a/core/app/models/spree/order_cancellations.rb
+++ b/core/app/models/spree/order_cancellations.rb
@@ -23,10 +23,16 @@ def initialize(order)
   # @api public
   #
   # @param [Array<InventoryUnit>] inventory_units the inventory units to be short shipped
-  # @param [String] whodunnit the system or person that is short shipping the inventory units
+  # @param (deprecated) [String] whodunnit the system or person that is short shipping the inventory unit
+  # @param [String] created_by the system or person that is short shipping the inventory unit
   #
   # @return [Array<UnitCancel>] the units that have been canceled due to short shipping
-  def short_ship(inventory_units, whodunnit: nil)
+  def short_ship(inventory_units, whodunnit: nil, created_by: nil)
+    if whodunnit
+      created_by ||= whodunnit
+      Spree::Deprecation.warn("Calling #short_ship on #{self} with whodunnit is deprecated, use created_by instead")
+    end
+
     if inventory_units.map(&:order_id).uniq != [@order.id]
       raise ArgumentError, "Not all inventory units belong to this order"
     end
@@ -36,7 +42,7 @@ def short_ship(inventory_units, whodunnit: nil)
     Spree::OrderMutex.with_lock!(@order) do
       Spree::InventoryUnit.transaction do
         inventory_units.each do |iu|
-          unit_cancels << short_ship_unit(iu, whodunnit: whodunnit)
+          unit_cancels << short_ship_unit(iu, created_by: created_by)
         end
 
         update_shipped_shipments(inventory_units)
@@ -59,17 +65,23 @@ def short_ship(inventory_units, whodunnit: nil)
   #
   # @param [InventoryUnit] inventory_unit the inventory unit to be canceled
   # @param [String] reason the reason that you are canceling the inventory unit
-  # @param [String] whodunnit the system or person that is canceling the inventory unit
+  # @param (deprecated) [String] whodunnit the system or person that is canceling the inventory unit
+  # @param [String] created_by the system or person that is canceling the inventory unit
   #
   # @return [UnitCancel] the unit that has been canceled
-  def cancel_unit(inventory_unit, reason: Spree::UnitCancel::DEFAULT_REASON, whodunnit: nil)
+  def cancel_unit(inventory_unit, reason: Spree::UnitCancel::DEFAULT_REASON, whodunnit: nil, created_by: nil)
+    if whodunnit
+      created_by ||= whodunnit
+      Spree::Deprecation.warn("Calling #cancel_unit on #{self} with whodunnit is deprecated, use created_by instead")
+    end
+
     unit_cancel = nil
 
     Spree::OrderMutex.with_lock!(@order) do
       unit_cancel = Spree::UnitCancel.create!(
         inventory_unit: inventory_unit,
         reason: reason,
-        created_by: whodunnit
+        created_by: created_by
       )
 
       inventory_unit.cancel!
@@ -82,14 +94,18 @@ def cancel_unit(inventory_unit, reason: Spree::UnitCancel::DEFAULT_REASON, whodu
   #
   # @api public
   # @param [Array<InventoryUnit>] inventory_units the inventory units to be reimbursed
+  # @param [Spree.user_class] created_by the user that is performing this action
   # @return [Reimbursement] the reimbursement for inventory being canceled
-  def reimburse_units(inventory_units)
+  def reimburse_units(inventory_units, created_by: nil)
+    unless created_by
+      Spree::Deprecation.warn("Calling #reimburse_units on #{self} without created_by is deprecated")
+    end
     reimbursement = nil
 
     Spree::OrderMutex.with_lock!(@order) do
       return_items = inventory_units.map(&:current_or_new_return_item)
       reimbursement = Spree::Reimbursement.new(order: @order, return_items: return_items)
-      reimbursement.return_all
+      reimbursement.return_all(created_by: created_by)
     end
 
     reimbursement
@@ -97,11 +113,16 @@ def reimburse_units(inventory_units)
 
   private
 
-  def short_ship_unit(inventory_unit, whodunnit: nil)
+  def short_ship_unit(inventory_unit, whodunnit: nil, created_by: nil)
+    if whodunnit
+      created_by ||= whodunnit
+      Spree::Deprecation.warn("Calling #short_ship_unit on #{self} with whodunnit is deprecated, use created_by instead")
+    end
+
     unit_cancel = Spree::UnitCancel.create!(
       inventory_unit: inventory_unit,
       reason: Spree::UnitCancel::SHORT_SHIP,
-      created_by: whodunnit
+      created_by: created_by
     )
     unit_cancel.adjust!
     inventory_unit.cancel!
diff --git a/core/app/models/spree/reimbursement.rb b/core/app/models/spree/reimbursement.rb
index 3485039997b..0c76a54b865 100644
--- a/core/app/models/spree/reimbursement.rb
+++ b/core/app/models/spree/reimbursement.rb
@@ -98,12 +98,15 @@ def unpaid_amount
       total - paid_amount
     end
 
-    def perform!
+    def perform!(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #perform on #{self} without created_by is deprecated")
+      end
       reimbursement_tax_calculator.call(self)
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.perform(self)
+      reimbursement_performer.perform(self, created_by: created_by)
 
       if unpaid_amount_within_tolerance?
         reimbursed!
@@ -116,12 +119,15 @@ def perform!
       end
     end
 
-    def simulate
+    def simulate(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #simulate on #{self} without created_by is deprecated")
+      end
       reimbursement_simulator_tax_calculator.call(self)
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.simulate(self)
+      reimbursement_performer.simulate(self, created_by: created_by)
     end
 
     def return_items_requiring_exchange
@@ -139,11 +145,15 @@ def all_exchanges?
     # Accepts all return items, saves the reimbursement, and performs the reimbursement
     #
     # @api public
+    # @param [Spree.user_class] created_by the user that is performing this action
     # @return [void]
-    def return_all
+    def return_all(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #return_all on #{self} without created_by is deprecated")
+      end
       return_items.each(&:accept!)
       save!
-      perform!
+      perform!(created_by: created_by)
     end
 
     private
diff --git a/core/app/models/spree/reimbursement_performer.rb b/core/app/models/spree/reimbursement_performer.rb
index e1b79e046f2..9be991ea626 100644
--- a/core/app/models/spree/reimbursement_performer.rb
+++ b/core/app/models/spree/reimbursement_performer.rb
@@ -11,22 +11,28 @@ class << self
       # - #description
       # - #display_amount
       # so they can be displayed in the Admin UI appropriately.
-      def simulate(reimbursement)
-        execute(reimbursement, true)
+      def simulate(reimbursement, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #simulate on #{self} without created_by is deprecated")
+        end
+        execute(reimbursement, true, created_by: created_by)
       end
 
       # Actually perform the reimbursement
-      def perform(reimbursement)
-        execute(reimbursement, false)
+      def perform(reimbursement, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #perform on #{self} without created_by is deprecated")
+        end
+        execute(reimbursement, false, created_by: created_by)
       end
 
       private
 
-      def execute(reimbursement, simulate)
+      def execute(reimbursement, simulate, created_by:)
         reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
 
         reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
-          reimbursement_type.reimburse(reimbursement, return_items, simulate)
+          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by: created_by)
         end
       end
 
diff --git a/core/app/models/spree/reimbursement_type.rb b/core/app/models/spree/reimbursement_type.rb
index fb2db58da1a..a669b9a37ba 100644
--- a/core/app/models/spree/reimbursement_type.rb
+++ b/core/app/models/spree/reimbursement_type.rb
@@ -11,7 +11,7 @@ class ReimbursementType < Spree::Base
     # This method will reimburse the return items based on however it child implements it
     # By default it takes a reimbursement, the return items it needs to reimburse, and if
     # it is a simulation or a real reimbursement. This should return an array
-    def self.reimburse(_reimbursement, _return_items, _simulate)
+    def self.reimburse(_reimbursement, _return_items, _simulate, *_optional_args)
       raise "Implement me"
     end
   end
diff --git a/core/app/models/spree/reimbursement_type/credit.rb b/core/app/models/spree/reimbursement_type/credit.rb
index 16e35a07814..f2a75bada69 100644
--- a/core/app/models/spree/reimbursement_type/credit.rb
+++ b/core/app/models/spree/reimbursement_type/credit.rb
@@ -5,9 +5,12 @@ class ReimbursementType::Credit < Spree::ReimbursementType
     extend Spree::ReimbursementType::ReimbursementHelpers
 
     class << self
-      def reimburse(reimbursement, return_items, simulate)
+      def reimburse(reimbursement, return_items, simulate, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #reimburse on #{self} without created_by is deprecated")
+        end
         unpaid_amount = return_items.sum(&:total).round(2, :down)
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by: created_by)
         reimbursement_list
       end
     end
diff --git a/core/app/models/spree/reimbursement_type/exchange.rb b/core/app/models/spree/reimbursement_type/exchange.rb
index 7c4867f96e5..ff2dd0a9aee 100644
--- a/core/app/models/spree/reimbursement_type/exchange.rb
+++ b/core/app/models/spree/reimbursement_type/exchange.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Spree::ReimbursementType::Exchange < Spree::ReimbursementType
-  def self.reimburse(reimbursement, return_items, simulate)
+  def self.reimburse(reimbursement, return_items, simulate, *_optional_args)
     return [] unless return_items.present?
 
     exchange = Spree::Exchange.new(reimbursement.order, return_items)
diff --git a/core/app/models/spree/reimbursement_type/original_payment.rb b/core/app/models/spree/reimbursement_type/original_payment.rb
index 72acae86dd2..dbe885d74b4 100644
--- a/core/app/models/spree/reimbursement_type/original_payment.rb
+++ b/core/app/models/spree/reimbursement_type/original_payment.rb
@@ -4,7 +4,7 @@ class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
   extend Spree::ReimbursementType::ReimbursementHelpers
 
   class << self
-    def reimburse(reimbursement, return_items, simulate)
+    def reimburse(reimbursement, return_items, simulate, _created_by)
       unpaid_amount = return_items.sum(&:total).round(2, :down)
       payments = reimbursement.order.payments.completed
 
diff --git a/core/app/models/spree/reimbursement_type/reimbursement_helpers.rb b/core/app/models/spree/reimbursement_type/reimbursement_helpers.rb
index b2d6a0b59f4..64f30a9c3d1 100644
--- a/core/app/models/spree/reimbursement_type/reimbursement_helpers.rb
+++ b/core/app/models/spree/reimbursement_type/reimbursement_helpers.rb
@@ -20,8 +20,8 @@ def create_refunds(reimbursement, payments, unpaid_amount, simulate, reimburseme
       [reimbursement_list, unpaid_amount]
     end
 
-    def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [])
-      credits = [create_credit(reimbursement, unpaid_amount, simulate)]
+    def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [], created_by:)
+      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by: created_by)]
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
@@ -43,19 +43,19 @@ def create_refund(reimbursement, payment, amount, simulate)
 
     # If you have multiple methods of crediting a customer, overwrite this method
     # Must return an array of objects the respond to #description, #display_amount
-    def create_credit(reimbursement, unpaid_amount, simulate)
-      creditable = create_creditable(reimbursement, unpaid_amount)
+    def create_credit(reimbursement, unpaid_amount, simulate, created_by:)
+      creditable = create_creditable(reimbursement, unpaid_amount, created_by: created_by)
       credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
       simulate ? credit.readonly! : credit.save!
       credit
     end
 
-    def create_creditable(reimbursement, unpaid_amount)
+    def create_creditable(reimbursement, unpaid_amount, created_by:)
       Spree::Reimbursement::Credit.default_creditable_class.new(
         user: reimbursement.order.user,
         amount: unpaid_amount,
         category: Spree::StoreCreditCategory.reimbursement_category(reimbursement),
-        created_by: Spree::StoreCredit.default_created_by,
+        created_by: created_by,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency
       )
diff --git a/core/app/models/spree/reimbursement_type/store_credit.rb b/core/app/models/spree/reimbursement_type/store_credit.rb
index 5c2aff0b7cb..1fc476f2d83 100644
--- a/core/app/models/spree/reimbursement_type/store_credit.rb
+++ b/core/app/models/spree/reimbursement_type/store_credit.rb
@@ -4,17 +4,32 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
   extend Spree::ReimbursementType::ReimbursementHelpers
 
   class << self
-    def reimburse(reimbursement, return_items, simulate)
+    def reimburse(reimbursement, return_items, simulate, created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #reimburse on #{self} without created_by is deprecated")
+      end
       unpaid_amount = return_items.sum(&:total).to_d.round(2, :down)
       payments = store_credit_payments(reimbursement)
       reimbursement_list = []
 
       # Credit each store credit that was used on the order
-      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list)
+      reimbursement_list, unpaid_amount = create_refunds(
+        reimbursement,
+        payments,
+        unpaid_amount,
+        simulate,
+        reimbursement_list
+      )
 
       # If there is any amount left to pay out to the customer, then create credit with that amount
       if unpaid_amount > 0.0
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
+        reimbursement_list, _unpaid_amount = create_credits(
+          reimbursement,
+          unpaid_amount,
+          simulate,
+          reimbursement_list,
+          created_by: created_by
+        )
       end
 
       reimbursement_list
diff --git a/core/app/models/spree/store_credit.rb b/core/app/models/spree/store_credit.rb
index 9eaafc5530b..69a21eef2d5 100644
--- a/core/app/models/spree/store_credit.rb
+++ b/core/app/models/spree/store_credit.rb
@@ -18,8 +18,6 @@ class Spree::StoreCredit < Spree::PaymentSource
   ADJUSTMENT_ACTION = 'adjustment'
   INVALIDATE_ACTION = 'invalidate'
 
-  DEFAULT_CREATED_BY_EMAIL = "spree@example.com"
-
   belongs_to :user, class_name: Spree::UserClassHandle.new
   belongs_to :created_by, class_name: Spree::UserClassHandle.new
   belongs_to :category, class_name: "Spree::StoreCreditCategory"
@@ -196,12 +194,6 @@ def invalidate(reason, user_performing_invalidation)
     end
   end
 
-  class << self
-    def default_created_by
-      Spree.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
-    end
-  end
-
   private
 
   def create_credit_record(amount, action_attributes = {})
diff --git a/core/spec/models/spree/customer_return_spec.rb b/core/spec/models/spree/customer_return_spec.rb
index f98a0cdccac..a6454e51baa 100644
--- a/core/spec/models/spree/customer_return_spec.rb
+++ b/core/spec/models/spree/customer_return_spec.rb
@@ -282,7 +282,8 @@
           end
 
           context 'when all reimbursements are reimbursed' do
-            before { reimbursement.perform! }
+            let(:created_by_user) { create(:user, email: 'user@email.com') }
+            before { reimbursement.perform!(created_by: created_by_user) }
 
             it { is_expected.to be true }
           end
diff --git a/core/spec/models/spree/order/outstanding_balance_integration_spec.rb b/core/spec/models/spree/order/outstanding_balance_integration_spec.rb
index 08206556c5e..b239d25c6b7 100644
--- a/core/spec/models/spree/order/outstanding_balance_integration_spec.rb
+++ b/core/spec/models/spree/order/outstanding_balance_integration_spec.rb
@@ -83,13 +83,14 @@
     context 'with a cancelled item' do
       let(:cancelations) { Spree::OrderCancellations.new(order) }
       let(:cancelled_item) { item_1 }
+      let(:created_by_user) { create(:user, email: 'user@email.com') }
 
       before do
         # Required to refund
         Spree::RefundReason.create!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
 
         cancelations.cancel_unit(cancelled_item.inventory_units.first)
-        cancelations.reimburse_units(cancelled_item.inventory_units)
+        cancelations.reimburse_units(cancelled_item.inventory_units, created_by: created_by_user)
 
         order.reload
       end
diff --git a/core/spec/models/spree/order_cancellations_spec.rb b/core/spec/models/spree/order_cancellations_spec.rb
index ad801ea6140..0af231b2e93 100644
--- a/core/spec/models/spree/order_cancellations_spec.rb
+++ b/core/spec/models/spree/order_cancellations_spec.rb
@@ -34,7 +34,8 @@
     context "when a whodunnit is specified" do
       subject { order.cancellations.cancel_unit(inventory_unit, whodunnit: "some automated system") }
 
-      it "sets the user on the UnitCancel" do
+      it "sets the user on the UnitCancel and print a deprecation" do
+        expect(Spree::Deprecation).to receive(:warn)
         expect(subject.created_by).to eq("some automated system")
       end
     end
@@ -44,13 +45,28 @@
         expect(subject.created_by).to be_nil
       end
     end
+
+    context "when a created_by is specified" do
+      subject { order.cancellations.cancel_unit(inventory_unit, created_by: "some automated system") }
+
+      it "sets the user on the UnitCancel" do
+        expect(subject.created_by).to eq("some automated system")
+      end
+    end
+
+    context "when a created_by is not specified" do
+      it "does not set created_by on the UnitCancel" do
+        expect(subject.created_by).to be_nil
+      end
+    end
   end
 
   describe "#reimburse_units" do
-    subject { Spree::OrderCancellations.new(order).reimburse_units(inventory_units) }
+    subject { Spree::OrderCancellations.new(order).reimburse_units(inventory_units, created_by: created_by_user) }
     let(:order) { create(:shipped_order, line_items_count: 2) }
     let(:inventory_units) { order.inventory_units }
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     it "creates and performs a reimbursement" do
       expect { subject }.to change { Spree::Reimbursement.count }.by(1)
@@ -120,8 +136,8 @@
       end
     end
 
-    context "with a who" do
-      subject { order.cancellations.short_ship([inventory_unit], whodunnit: 'some automated system') }
+    context "when a created_by is specified" do
+      subject { order.cancellations.short_ship([inventory_unit], created_by: 'some automated system') }
 
       let(:user) { order.user }
 
@@ -131,6 +147,19 @@
       end
     end
 
+    context "when a whodunnit is specified" do
+      subject { order.cancellations.short_ship([inventory_unit], whodunnit: 'some automated system') }
+
+      let(:user) { order.user }
+
+      it "sets the user on the UnitCancel and raises a deprecation # WARNING: " do
+        expect(Spree::Deprecation).to receive(:warn)
+
+        expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+        expect(Spree::UnitCancel.last.created_by).to eq("some automated system")
+      end
+    end
+
     context "when rounding is required" do
       let(:order) { create(:order_ready_to_ship, line_items_count: 1, line_items_price: 0.83) }
       let(:line_item) { order.line_items.to_a.first }
diff --git a/core/spec/models/spree/refund_spec.rb b/core/spec/models/spree/refund_spec.rb
index 249e89e4c49..08d8ed3e8cf 100644
--- a/core/spec/models/spree/refund_spec.rb
+++ b/core/spec/models/spree/refund_spec.rb
@@ -176,11 +176,12 @@
     let(:customer_return) { reimbursement.customer_return }
     let(:reimbursement) { create(:reimbursement) }
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     subject { Spree::Refund.total_amount_reimbursed_for(reimbursement) }
 
     context 'with reimbursements performed' do
-      before { reimbursement.perform! }
+      before { reimbursement.perform!(created_by: created_by_user) }
 
       it 'returns the total amount' do
         amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)
diff --git a/core/spec/models/spree/reimbursement_performer_spec.rb b/core/spec/models/spree/reimbursement_performer_spec.rb
index 5f870e52450..71e7cc9b9db 100644
--- a/core/spec/models/spree/reimbursement_performer_spec.rb
+++ b/core/spec/models/spree/reimbursement_performer_spec.rb
@@ -7,25 +7,26 @@
   let(:return_item)             { reimbursement.return_items.first }
   let(:reimbursement_type)      { double("ReimbursementType") }
   let(:reimbursement_type_hash) { { reimbursement_type => [return_item] } }
+  let(:created_by_user) { create(:user, email: 'user@email.com') }
 
   before do
     expect(Spree::ReimbursementPerformer).to receive(:calculate_reimbursement_types).and_return(reimbursement_type_hash)
   end
 
   describe ".simulate" do
-    subject { Spree::ReimbursementPerformer.simulate(reimbursement) }
+    subject { Spree::ReimbursementPerformer.simulate(reimbursement, created_by: created_by_user) }
 
     it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
-      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], true)
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], true, created_by: created_by_user)
       subject
     end
   end
 
   describe '.perform' do
-    subject { Spree::ReimbursementPerformer.perform(reimbursement) }
+    subject { Spree::ReimbursementPerformer.perform(reimbursement, created_by: created_by_user) }
 
     it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
-      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], false)
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], false, created_by: created_by_user)
       subject
     end
   end
diff --git a/core/spec/models/spree/reimbursement_spec.rb b/core/spec/models/spree/reimbursement_spec.rb
index 9815bb96dd8..0bdd1578908 100644
--- a/core/spec/models/spree/reimbursement_spec.rb
+++ b/core/spec/models/spree/reimbursement_spec.rb
@@ -66,8 +66,9 @@
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 
     let(:reimbursement) { create(:reimbursement, customer_return: customer_return, order: order, return_items: [return_item]) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-    subject { reimbursement.perform! }
+    subject { reimbursement.perform!(created_by: created_by_user) }
 
     before do
       order.shipments.each do |shipment|
@@ -230,13 +231,14 @@
   end
 
   describe "#return_all" do
-    subject { reimbursement.return_all }
+    subject { reimbursement.return_all(created_by: created_by_user) }
 
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
     let(:order)                  { create(:shipped_order, line_items_count: 1) }
     let(:inventory_unit)         { order.inventory_units.first }
     let(:return_item)            { build(:return_item, inventory_unit: inventory_unit) }
     let(:reimbursement)          { build(:reimbursement, order: order, return_items: [return_item]) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     it "accepts all the return items" do
       expect { subject }.to change { return_item.acceptance_status }.to "accepted"
diff --git a/core/spec/models/spree/reimbursement_type/credit_spec.rb b/core/spec/models/spree/reimbursement_type/credit_spec.rb
index 18100d74110..8188c714596 100644
--- a/core/spec/models/spree/reimbursement_type/credit_spec.rb
+++ b/core/spec/models/spree/reimbursement_type/credit_spec.rb
@@ -10,13 +10,14 @@ module Spree
     let(:simulate)                { false }
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
     let(:creditable)              { DummyCreditable.new(amount: 99.99) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
     class DummyCreditable < Spree::Base
       attr_accessor :amount
       self.table_name = 'spree_payments' # Your creditable class should not use this table
     end
 
-    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate) }
+    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate, created_by: created_by_user) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)
diff --git a/core/spec/models/spree/reimbursement_type/exchange_spec.rb b/core/spec/models/spree/reimbursement_type/exchange_spec.rb
index 3a699391869..b24bc522379 100644
--- a/core/spec/models/spree/reimbursement_type/exchange_spec.rb
+++ b/core/spec/models/spree/reimbursement_type/exchange_spec.rb
@@ -9,8 +9,9 @@ module Spree
       let(:return_items)  { reimbursement.return_items }
       let(:new_exchange)  { double("Exchange") }
       let(:simulate)      { true }
+      let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate) }
+      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate, created_by: created_by_user) }
 
       context 'return items are supplied' do
         before do
diff --git a/core/spec/models/spree/reimbursement_type/original_payment_spec.rb b/core/spec/models/spree/reimbursement_type/original_payment_spec.rb
index 85cddeaeca9..1b4a24b7036 100644
--- a/core/spec/models/spree/reimbursement_type/original_payment_spec.rb
+++ b/core/spec/models/spree/reimbursement_type/original_payment_spec.rb
@@ -9,8 +9,9 @@ module Spree
     let(:payment)                 { reimbursement.order.payments.first }
     let(:simulate)                { false }
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
 
-    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate) }
+    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate, created_by: created_by_user) }
 
     before { reimbursement.update!(total: reimbursement.calculated_total) }
 
diff --git a/core/spec/models/spree/reimbursement_type/store_credit_spec.rb b/core/spec/models/spree/reimbursement_type/store_credit_spec.rb
index c93402cab77..74b229d0a20 100644
--- a/core/spec/models/spree/reimbursement_type/store_credit_spec.rb
+++ b/core/spec/models/spree/reimbursement_type/store_credit_spec.rb
@@ -12,10 +12,10 @@ module Spree
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 
     let!(:primary_credit_type)    { create(:primary_credit_type) }
-    let!(:created_by_user)        { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
+    let(:created_by_user) { create(:user, email: 'user@email.com') }
     let!(:default_reimbursement_category) { create(:store_credit_category) }
 
-    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate) }
+    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate, created_by: created_by_user) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)
@@ -92,6 +92,18 @@ module Spree
             expect { subject }.to change { Spree::StoreCredit.count }.by(1)
             expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
           end
+
+          context 'without a user with email address "spree@example.com" in the database' do
+            before do
+              default_user = Spree::LegacyUser.find_by(email: "spree@example.com")
+              default_user.destroy if default_user
+            end
+
+            it "creates a store credit with the same currency as the reimbursement's order" do
+              expect { subject }.to change { Spree::StoreCredit.count }.by(1)
+              expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
+            end
+          end
         end
       end
     end