solidus_core 3.0.0 → 4.5.1

data/app/models/spree/order_shipping.rb

@@ -22,11 +22,11 @@ class Spree::OrderShipping
       address: shipment.order.ship_address,
       shipping_method: shipment.shipping_method,
       shipped_at: Time.current,
-      external_number: external_number,
+      external_number:,
       # TODO: Remove the `|| shipment.tracking` once Shipment#ship! is called by
       # OrderShipping#ship rather than vice versa
       tracking_number: tracking_number || shipment.tracking,
-      suppress_mailer: suppress_mailer
+      suppress_mailer:
     )
   end
 
@@ -44,36 +44,32 @@ class Spree::OrderShipping
   # @return The carton created.
   def ship(inventory_units:, stock_location:, address:, shipping_method:,
            shipped_at: Time.current, external_number: nil, tracking_number: nil, suppress_mailer: false)
-
     carton = nil
 
     Spree::InventoryUnit.transaction do
       inventory_units.each(&:ship!)
 
       carton = Spree::Carton.create!(
-        stock_location: stock_location,
-        address: address,
-        shipping_method: shipping_method,
-        inventory_units: inventory_units,
-        shipped_at: shipped_at,
-        external_number: external_number,
+        stock_location:,
+        address:,
+        shipping_method:,
+        inventory_units:,
+        shipped_at:,
+        external_number:,
         tracking: tracking_number
       )
     end
 
     inventory_units.map(&:shipment).uniq.each do |shipment|
-      # Temporarily propagate the tracking number to the shipment as well
-      # TODO: Remove tracking numbers from shipments.
-      shipment.update!(tracking: tracking_number)
-
-      next unless shipment.inventory_units.reload.all? { |iu| iu.shipped? || iu.canceled? }
-      # TODO: make OrderShipping#ship_shipment call Shipment#ship! rather than
-      # having Shipment#ship! call OrderShipping#ship_shipment. We only really
-      # need this `update_columns` for the specs, until we make that change.
-      shipment.update_columns(state: 'shipped', shipped_at: Time.current)
+      if shipment.inventory_units.reload.all? { |iu| iu.shipped? || iu.canceled? }
+        shipment.update!(state: "shipped", shipped_at: Time.current, tracking: tracking_number)
+      else
+        shipment.update!(tracking: tracking_number)
+      end
     end
 
     send_shipment_emails(carton) if stock_location.fulfillable? && !suppress_mailer # e.g. digital gift cards that aren't actually shipped
+    @order.shipments.reload
     @order.recalculate
 
     carton
@@ -83,7 +79,7 @@ class Spree::OrderShipping
 
   def send_shipment_emails(carton)
     carton.orders.each do |order|
-      Spree::Config.carton_shipped_email_class.shipped_email(order: order, carton: carton).deliver_later
+      Spree::Config.carton_shipped_email_class.shipped_email(order:, carton:).deliver_later
     end
   end
 end

data/app/models/spree/order_taxation.rb

@@ -17,15 +17,18 @@ module Spree
 
     # Apply taxes to the order.
     #
-    # This method will create or update adjustments on all line items and
-    # shipments in the order to reflect the appropriate taxes passed in. It
-    # will also remove any now inapplicable tax adjustments.
+    # This method will create or update adjustments on the order and all line
+    # items and shipments in the order to reflect the appropriate taxes passed
+    # in. It will also remove any now inapplicable tax adjustments.
     #
     # @param [Spree::Tax::OrderTax] taxes the taxes to apply to the order
     # @return [void]
     def apply(taxes)
+      update_adjustments(@order, taxes.order_taxes) if taxes.order_taxes
+
       @order.line_items.each do |item|
         taxed_items = taxes.line_item_taxes.select { |element| element.item_id == item.id }
+        item.tax_category_id = item.variant_tax_category_id
         update_adjustments(item, taxed_items)
       end
 
@@ -70,7 +73,7 @@ module Spree
 
       tax_adjustment ||= item.adjustments.new(
         source: tax_item.tax_rate,
-        order_id: item.order_id,
+        order_id: item.is_a?(Spree::Order) ? item.id : item.order_id,
         label: tax_item.label,
         included: tax_item.included_in_price
       )

data/app/models/spree/order_update_attributes.rb

@@ -15,7 +15,7 @@ module Spree
 
     # Assign the attributes to the order and save the order
     # @return true if saved, otherwise false and errors will be set on the order
-    def apply
+    def call
       order.validate_payments_attributes(@payments_attributes)
 
       assign_order_attributes
@@ -24,6 +24,8 @@ module Spree
       order.save
     end
 
+    alias_method :apply, :call
+
     private
 
     attr_reader :attributes, :payments_attributes, :order

data/app/models/spree/order_updater.rb

@@ -16,7 +16,7 @@ module Spree
     # This method should never do anything to the Order that results in a save call on the
     # object with callbacks (otherwise you will end up in an infinite recursion as the
     # associations try to save and then in turn try to call +update!+ again.)
-    def update
+    def recalculate
       order.transaction do
         update_item_count
         update_shipment_amounts
@@ -26,10 +26,12 @@ module Spree
           update_shipments
           update_shipment_state
         end
-        Spree::Event.fire 'order_recalculated', order: order
+        Spree::Bus.publish(:order_recalculated, order:)
         persist_totals
       end
     end
+    alias_method :update, :recalculate
+    deprecate update: :recalculate, deprecator: Spree.deprecator
 
     # Updates the +shipment_state+ attribute according to the following logic:
     #
@@ -110,10 +112,8 @@ module Spree
       # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
       # It also fits the criteria for sales tax as outlined here:
       # http://www.boe.ca.gov/formspubs/pub113/
-      update_item_promotions
-      update_order_promotions
-      update_taxes
-      update_cancellations
+      update_promotions
+      update_tax_adjustments
       update_item_totals
     end
 
@@ -157,12 +157,11 @@ module Spree
       recalculate_adjustments
 
       all_items = line_items + shipments
+      order_tax_adjustments = adjustments.select(&:tax?)
 
-      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).sum(&:amount)
-      order.included_tax_total = all_items.sum(&:included_tax_total)
-      order.additional_tax_total = all_items.sum(&:additional_tax_total)
-
-      order.promo_total = all_items.sum(&:promo_total) + adjustments.select(&:eligible?).select(&:promotion?).sum(&:amount)
+      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.sum(&:amount)
+      order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
 
       update_order_total
     end
@@ -189,74 +188,37 @@ module Spree
         order.state_changes.new(
           previous_state: old_state,
           next_state:     new_state,
-          name:           name,
+          name:,
           user_id:        order.user_id
         )
       end
     end
 
-    def update_item_promotions
-      [*line_items, *shipments].each do |item|
-        promotion_adjustments = item.adjustments.select(&:promotion?)
-
-        promotion_adjustments.each(&:recalculate)
-        Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
-
-        item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
-      end
-    end
-
-    # Update and select the best promotion adjustment for the order.
-    # We don't update the order.promo_total yet. Order totals are updated later
-    # in #update_adjustment_total since they include the totals from the order's
-    # line items and/or shipments.
-    def update_order_promotions
-      promotion_adjustments = order.adjustments.select(&:promotion?)
-      promotion_adjustments.each(&:recalculate)
-      Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+    def update_promotions
+      Spree::Config.promotions.order_adjuster_class.new(order).call
     end
 
-    def update_taxes
+    def update_tax_adjustments
       Spree::Config.tax_adjuster_class.new(order).adjust!
-
-      [*line_items, *shipments].each do |item|
-        tax_adjustments = item.adjustments.select(&:tax?)
-        # Tax adjustments come in not one but *two* exciting flavours:
-        # Included & additional
-
-        # Included tax adjustments are those which are included in the price.
-        # These ones should not affect the eventual total price.
-        #
-        # Additional tax adjustments are the opposite, affecting the final total.
-        item.included_tax_total   = tax_adjustments.select(&:included?).sum(&:amount)
-        item.additional_tax_total = tax_adjustments.reject(&:included?).sum(&:amount)
-      end
     end
 
     def update_cancellations
-      line_items.each do |line_item|
-        line_item.adjustments.select(&:cancellation?).each(&:recalculate)
-      end
     end
+    deprecate :update_cancellations, deprecator: Spree.deprecator
 
     def update_item_totals
       [*line_items, *shipments].each do |item|
-        # The cancellation_total isn't persisted anywhere but is included in
-        # the adjustment_total
-        item.adjustment_total = item.adjustments.
-          select(&:eligible?).
-          reject(&:included?).
-          sum(&:amount)
+        Spree::Config.item_total_class.new(item).recalculate!
 
-        if item.changed?
-          item.update_columns(
-            promo_total:          item.promo_total,
-            included_tax_total:   item.included_tax_total,
-            additional_tax_total: item.additional_tax_total,
-            adjustment_total:     item.adjustment_total,
-            updated_at:           Time.current,
-          )
-        end
+        next unless item.changed?
+
+        item.update_columns(
+          promo_total:          item.promo_total,
+          included_tax_total:   item.included_tax_total,
+          additional_tax_total: item.additional_tax_total,
+          adjustment_total:     item.adjustment_total,
+          updated_at:           Time.current,
+        )
       end
     end
   end

data/app/models/spree/payment/processing.rb

@@ -35,12 +35,36 @@ module Spree
       end
 
       def authorize!
-        handle_payment_preconditions { process_authorization }
+        return unless check_payment_preconditions!
+
+        started_processing!
+
+        protect_from_connection_error do
+          response = payment_method.authorize(
+            money.money.cents,
+            source,
+            gateway_options,
+          )
+          pend! if handle_response(response)
+        end
       end
 
       # Captures the entire amount of a payment.
       def purchase!
-        handle_payment_preconditions { process_purchase }
+        return unless check_payment_preconditions!
+
+        started_processing!
+
+        protect_from_connection_error do
+          response = payment_method.purchase(
+            money.money.cents,
+            source,
+            gateway_options,
+          )
+          complete! if handle_response(response)
+        end
+
+        capture_events.create!(amount:)
       end
 
       # Takes the amount in cents to capture.
@@ -62,7 +86,7 @@ module Spree
           money = ::Money.new(capture_amount, currency)
           capture_events.create!(amount: money.to_d)
           update!(amount: captured_amount)
-          handle_response(response, :complete, :failure)
+          complete! if handle_response(response)
         end
       end
 
@@ -139,77 +163,56 @@ module Spree
 
       private
 
-      def process_authorization
-        started_processing!
-        gateway_action(source, :authorize, :pend)
-      end
+      # @raises Spree::Core::GatewayError
+      def check_payment_preconditions!
+        return if processing?
+        return unless payment_method
+        return unless payment_method.source_required?
 
-      def process_purchase
-        started_processing!
-        gateway_action(source, :purchase, :complete)
-        # This won't be called if gateway_action raises a GatewayError
-        capture_events.create!(amount: amount)
-      end
-
-      def handle_payment_preconditions(&_block)
-        unless block_given?
-          raise ArgumentError.new("handle_payment_preconditions must be called with a block")
+        unless source
+          gateway_error(I18n.t('spree.payment_processing_failed'))
         end
 
-        return if payment_method.nil?
-        return if !payment_method.source_required?
-
-        if source
-          if !processing?
-            if payment_method.supports?(source)
-              yield
-            else
-              invalidate!
-              raise Core::GatewayError.new(I18n.t('spree.payment_method_not_supported'))
-            end
-          end
-        else
-          raise Core::GatewayError.new(I18n.t('spree.payment_processing_failed'))
+        unless payment_method.supports?(source)
+          invalidate!
+          gateway_error(I18n.t('spree.payment_method_not_supported'))
         end
-      end
 
-      def gateway_action(source, action, success_state)
-        protect_from_connection_error do
-          response = payment_method.send(action, money.money.cents,
-                                         source,
-                                         gateway_options)
-          handle_response(response, success_state, :failure)
-        end
+        true
       end
 
-      def handle_response(response, success_state, failure_state)
+      # @returns true if the response is successful
+      # @returns false (and calls #failure) if the response is not successful
+      def handle_response(response)
         record_response(response)
 
-        if response.success?
-          unless response.authorization.nil?
-            self.response_code = response.authorization
-            self.avs_response = response.avs_result['code']
-
-            if response.cvv_result
-              self.cvv_response_code = response.cvv_result['code']
-              self.cvv_response_message = response.cvv_result['message']
-            end
-          end
-          send("#{success_state}!")
-        else
-          send(failure_state)
+        unless response.success?
+          failure
           gateway_error(response)
+          return false
+        end
+
+        unless response.authorization.nil?
+          self.response_code = response.authorization
+          self.avs_response = response.avs_result['code']
+
+          if response.cvv_result
+            self.cvv_response_code = response.cvv_result['code']
+            self.cvv_response_message = response.cvv_result['message']
+          end
         end
+
+        true
       end
 
       def record_response(response)
-        log_entries.create!(details: response.to_yaml)
+        log_entries.create!(parsed_payment_response_details_with_fallback: response)
       end
 
       def protect_from_connection_error
-          yield
+        yield
       rescue ActiveMerchant::ConnectionError => error
-          gateway_error(error)
+        gateway_error(error)
       end
 
       def gateway_error(error)
@@ -240,7 +243,7 @@ module Spree
           cvv_result: response.cvv_result,
           error_code: response.error_code,
           emv_authorization: response.emv_authorization,
-          gateway_order_id: gateway_order_id,
+          gateway_order_id:,
           order_number: order.number
         }
       end

data/app/models/spree/payment.rb

@@ -7,6 +7,7 @@ module Spree
   #
   class Payment < Spree::Base
     include Spree::Payment::Processing
+    include Metadata
 
     IDENTIFIER_CHARS    = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
@@ -16,7 +17,6 @@ module Spree
     belongs_to :source, polymorphic: true, optional: true
     belongs_to :payment_method, -> { with_discarded }, class_name: 'Spree::PaymentMethod', inverse_of: :payments, optional: true
 
-    has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
     has_many :state_changes, as: :stateful
     has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
@@ -45,8 +45,6 @@ module Spree
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(state) { where(state: state.to_s) }
-    # "offset" is reserved by activerecord
-    scope :offset_payment, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") }
 
     scope :checkout, -> { with_state('checkout') }
     scope :completed, -> { with_state('completed') }
@@ -54,7 +52,7 @@ module Spree
     scope :processing, -> { with_state('processing') }
     scope :failed, -> { with_state('failed') }
 
-    scope :risky, -> { where("avs_response IN (?) OR (cvv_response_code IS NOT NULL and cvv_response_code != 'M') OR state = 'failed'", RISKY_AVS_CODES) }
+    scope :risky, -> { failed.or(where(avs_response: RISKY_AVS_CODES)).or(where.not(cvv_response_code: [nil, '', 'M'])) }
     scope :valid, -> { where.not(state: %w(failed invalid void)) }
 
     scope :store_credits, -> { where(source_type: Spree::StoreCredit.to_s) }
@@ -72,7 +70,7 @@ module Spree
 
     # @return [Spree::Money] this amount of this payment as money object
     def money
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, { currency: })
     end
     alias display_amount money
 
@@ -89,19 +87,11 @@ module Spree
         end || amount
     end
 
-    # The total amount of the offsets (for old-style refunds) for this payment.
-    #
-    # @return [BigDecimal] the total amount of this payment's offsets
-    def offsets_total
-      offsets.pluck(:amount).sum
-    end
-
     # The total amount this payment can be credited.
     #
-    # @return [BigDecimal] the amount of this payment minus the offsets
-    #   (old-style refunds) and refunds
+    # @return [BigDecimal] the amount of this payment minus refunds
     def credit_allowed
-      amount - (offsets_total.abs + refunds.sum(:amount))
+      amount - refunds.sum(:amount)
     end
 
     # @return [Boolean] true when this payment can be credited
@@ -127,6 +117,11 @@ module Spree
       res || payment_method
     end
 
+    # @return [Boolean] true when this payment is risky
+    def risky?
+      is_avs_risky? || is_cvv_risky? || state == 'failed'
+    end
+
     # @return [Boolean] true when this payment is risky based on address
     def is_avs_risky?
       return false if avs_response.blank? || NON_RISKY_AVS_CODES.include?(avs_response)
@@ -137,7 +132,6 @@ module Spree
     def is_cvv_risky?
       return false if cvv_response_code == "M"
       return false if cvv_response_code.nil?
-      return false if cvv_response_message.present?
       true
     end
 
@@ -165,16 +159,9 @@ module Spree
 
     def validate_source
       if source && !source.valid?
-        if Gem::Requirement.new(">= 6.1").satisfied_by?(Rails.gem_version)
-          source.errors.each do |error|
-            field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{error.attribute}")
-            errors.add(I18n.t(source.class.to_s.demodulize.underscore, scope: 'spree'), "#{field_name} #{error.message}")
-          end
-        else
-          source.errors.each do |field, error|
-            field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-            errors.add(I18n.t(source.class.to_s.demodulize.underscore, scope: 'spree'), "#{field_name} #{error}")
-          end
+        source.errors.each do |error|
+          field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{error.attribute}")
+          errors.add(I18n.t(source.class.to_s.demodulize.underscore, scope: 'spree'), "#{field_name} #{error.message}")
         end
       end
       if errors.any?
@@ -225,7 +212,7 @@ module Spree
     def set_unique_identifier
       loop do
         self.number = generate_identifier
-        break unless self.class.exists?(number: number)
+        break unless self.class.exists?(number:)
       end
     end
 

data/app/models/spree/payment_create.rb

@@ -72,7 +72,7 @@ module Spree
 
     def available_cards
       if user_id = order.user_id
-        Spree::CreditCard.where(user_id: user_id)
+        Spree::CreditCard.where(user_id:)
       else
         Spree::CreditCard.none
       end

data/app/models/spree/payment_method/bogus_credit_card.rb

@@ -29,41 +29,45 @@ module Spree
 
     def authorize(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
+      message_detail = " - #{__method__}"
       if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'D' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'D' })
       else
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, { message: FAILURE_MESSAGE }, test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, { message: FAILURE_MESSAGE + message_detail }, test: true)
       end
     end
 
     def purchase(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
+      message_detail = " - #{__method__}"
       if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'M' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'M' })
       else
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, message: FAILURE_MESSAGE, test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, message: FAILURE_MESSAGE + message_detail, test: true)
       end
     end
 
     def credit(_money, _credit_card, _response_code, _options = {})
-      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+      message_detail = " - #{__method__}"
+      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
     end
 
     def capture(_money, authorization, _gateway_options)
+      message_detail = " - #{__method__}"
       if authorization == '12345'
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true)
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true)
       else
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, error: FAILURE_MESSAGE, test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, error: FAILURE_MESSAGE + message_detail, test: true)
       end
     end
 
-    def void(_response_code, _credit_card, _options = {})
-      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
-    end
-
-    # @see Spree::PaymentMethod#try_void
-    def try_void(_payment)
-      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+    def void(_response_code, _credit_card, options = {})
+      message_detail = " - #{__method__}"
+      if options[:originator].completed?
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
+      else
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
+      end
     end
 
     def test?

data/app/models/spree/payment_method/credit_card.rb

@@ -4,10 +4,6 @@ module Spree
   # An implementation of a `Spree::PaymentMethod` for credit card payments.
   #
   # It's a good candidate as base class for other credit card based payment methods.
-  #
-  # See https://github.com/solidusio/solidus_gateway/ for
-  # officially supported payment method implementations.
-  #
   class PaymentMethod::CreditCard < PaymentMethod
     def payment_source_class
       Spree::CreditCard

data/app/models/spree/payment_method/simple_bogus_credit_card.rb

@@ -8,18 +8,32 @@ module Spree
     end
 
     def authorize(_money, credit_card, _options = {})
+      message_detail = " - #{__method__}"
+
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, { message: FAILURE_MESSAGE }, test: true)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, { message: FAILURE_MESSAGE }, test: true)
       end
     end
 
     def purchase(_money, credit_card, _options = {})
+      message_detail = " - #{__method__}"
+
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, message: FAILURE_MESSAGE, test: true)
+      end
+    end
+
+    def void(_response_code, options = {})
+      message_detail = " - #{__method__}"
+
+      if options[:originator].completed?
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
       else
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, message: FAILURE_MESSAGE, test: true)
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
       end
     end
   end

data/app/models/spree/payment_method/store_credit.rb

@@ -107,7 +107,7 @@ module Spree
       store_credit = Spree::StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
 
       if store_credit.nil?
-        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code: auth_code, action: action_name), {}, {})
+        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code:, action: action_name), {}, {})
       else
         handle_action_call(store_credit, action, action_name, auth_code)
       end