solidus_core 4.6.2 → 4.7.0

data/app/models/spree/order_shipping.rb

@@ -43,7 +43,7 @@ class Spree::OrderShipping
   # @param tracking_number An option tracking number.
   # @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)
+    shipped_at: Time.current, external_number: nil, tracking_number: nil, suppress_mailer: false)
     carton = nil
 
     Spree::InventoryUnit.transaction do

data/app/models/spree/order_updater.rb

@@ -18,13 +18,14 @@ module Spree
     # associations try to save and then in turn try to call +update!+ again.)
     def recalculate
       order.transaction do
-        update_item_count
+        recalculate_line_item_prices
+        recalculate_item_count
         update_shipment_amounts
         update_totals
         if order.completed?
-          update_payment_state
+          recalculate_payment_state
           update_shipments
-          update_shipment_state
+          recalculate_shipment_state
         end
         Spree::Bus.publish(:order_recalculated, order:)
         persist_totals
@@ -43,15 +44,17 @@ module Spree
     # pending   when all Shipments are in the "pending" state
     #
     # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
-    def update_shipment_state
-      log_state_change('shipment') do
+    def recalculate_shipment_state
+      log_state_change("shipment") do
         order.shipment_state = determine_shipment_state
       end
 
       order.shipment_state
     end
+    alias_method :update_shipment_state, :recalculate_shipment_state
+    deprecate update_shipment_state: :recalculate_shipment_state, deprecator: Spree.deprecator
 
-    # Updates the +payment_state+ attribute according to the following logic:
+    # Recalculates the +payment_state+ attribute according to the following logic:
     #
     # paid          when +payment_total+ is equal to +total+
     # balance_due   when +payment_total+ is less than +total+
@@ -60,40 +63,42 @@ module Spree
     # void          when the order has been canceled and the payment total is 0
     #
     # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
-    def update_payment_state
-      log_state_change('payment') do
+    def recalculate_payment_state
+      log_state_change("payment") do
         order.payment_state = determine_payment_state
       end
 
       order.payment_state
     end
+    alias_method :update_payment_state, :recalculate_payment_state
+    deprecate update_payment_state: :recalculate_payment_state, deprecator: Spree.deprecator
 
     private
 
     def determine_payment_state
       if payments.present? && payments.valid.empty? && order.outstanding_balance != 0
-        'failed'
-      elsif order.state == 'canceled' && order.payment_total.zero?
-        'void'
+        "failed"
+      elsif order.state == "canceled" && order.payment_total.zero?
+        "void"
       elsif order.outstanding_balance > 0
-        'balance_due'
+        "balance_due"
       elsif order.outstanding_balance < 0
-        'credit_owed'
+        "credit_owed"
       else
         # outstanding_balance == 0
-        'paid'
+        "paid"
       end
     end
 
     def determine_shipment_state
       if order.backordered?
-        'backorder'
+        "backorder"
       else
         # get all the shipment states for this order
         shipment_states = shipments.states
         if shipment_states.size > 1
           # multiple shiment states means it's most likely partially shipped
-          'partial'
+          "partial"
         else
           # will return nil if no shipments are found
           shipment_states.first
@@ -106,7 +111,7 @@ module Spree
     # fields (promo_total, included_tax_total, additional_tax_total, and
     # adjustment_total) on the item.
     # @return [void]
-    def recalculate_adjustments
+    def update_adjustments
       # Promotion adjustments must be applied first, then tax adjustments.
       # This fits the criteria for VAT tax as outlined here:
       # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
@@ -114,8 +119,10 @@ module Spree
       # http://www.boe.ca.gov/formspubs/pub113/
       update_promotions
       update_tax_adjustments
-      update_item_totals
+      recalculate_item_totals
     end
+    alias_method :recalculate_adjustments, :update_adjustments
+    deprecate recalculate_adjustments: :update_adjustments, deprecator: Spree.deprecator
 
     # Updates the following Order total values:
     #
@@ -125,9 +132,9 @@ module Spree
     # +promo_total+        The total value of all promotion adjustments
     # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
     def update_totals
-      update_payment_total
-      update_item_total
-      update_shipment_total
+      recalculate_payment_total
+      recalculate_item_total
+      recalculate_shipment_total
       update_adjustment_total
     end
 
@@ -140,23 +147,29 @@ module Spree
       shipments.each(&:update_state)
     end
 
-    def update_payment_total
+    def recalculate_payment_total
       order.payment_total = payments.completed.includes(:refunds).sum { |payment| payment.amount - payment.refunds.sum(:amount) }
     end
+    alias_method :update_payment_total, :recalculate_payment_total
+    deprecate update_payment_total: :recalculate_payment_total, deprecator: Spree.deprecator
 
-    def update_shipment_total
+    def recalculate_shipment_total
       order.shipment_total = shipments.to_a.sum(&:cost)
-      update_order_total
+      recalculate_order_total
     end
+    alias_method :update_shipment_total, :recalculate_shipment_total
+    deprecate update_shipment_total: :recalculate_shipment_total, deprecator: Spree.deprecator
 
-    def update_order_total
+    def recalculate_order_total
       order.total = order.item_total + order.shipment_total + order.adjustment_total
     end
+    alias_method :update_order_total, :recalculate_order_total
+    deprecate update_order_total: :recalculate_order_total, deprecator: Spree.deprecator
 
     def update_adjustment_total
-      recalculate_adjustments
+      update_adjustments
 
-      all_items = line_items + shipments
+      all_items = (line_items + shipments).reject(&:marked_for_destruction?)
       # Ignore any adjustments that have been marked for destruction in our
       # calculations. They'll get removed when/if we persist the order.
       valid_adjustments = adjustments.reject(&:marked_for_destruction?)
@@ -166,17 +179,21 @@ module Spree
       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
+      recalculate_order_total
     end
 
-    def update_item_count
+    def recalculate_item_count
       order.item_count = line_items.to_a.sum(&:quantity)
     end
+    alias_method :update_item_count, :recalculate_item_count
+    deprecate update_item_count: :recalculate_item_count, deprecator: Spree.deprecator
 
-    def update_item_total
+    def recalculate_item_total
       order.item_total = line_items.to_a.sum(&:amount)
-      update_order_total
+      recalculate_order_total
     end
+    alias_method :update_item_total, :recalculate_item_total
+    deprecate update_item_total: :recalculate_item_total, deprecator: Spree.deprecator
 
     def persist_totals
       order.save!
@@ -210,20 +227,25 @@ module Spree
     end
     deprecate :update_cancellations, deprecator: Spree.deprecator
 
-    def update_item_totals
+    def recalculate_item_totals
       [*line_items, *shipments].each do |item|
         Spree::Config.item_total_class.new(item).recalculate!
 
         next unless item.changed?
 
-        item.update_columns(
-          promo_total:          item.promo_total,
-          included_tax_total:   item.included_tax_total,
+        item.assign_attributes(
+          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,
+          adjustment_total: item.adjustment_total
         )
       end
     end
+
+    def recalculate_line_item_prices
+      if Spree::Config.recalculate_cart_prices
+        line_items.each(&:recalculate_price)
+      end
+    end
   end
 end

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

@@ -8,7 +8,7 @@ module Spree
     # creating a refund about the full amount instead.
     #
     class Cancellation
-      DEFAULT_REASON = 'Order canceled'.freeze
+      DEFAULT_REASON = "Order canceled"
 
       attr_reader :reason
 
@@ -26,7 +26,7 @@ module Spree
       # @param payment [Spree::Payment] - the payment that should be canceled
       #
       def cancel(payment)
-        if response = payment.payment_method.try_void(payment)
+        if (response = payment.payment_method.try_void(payment))
           payment.handle_void_response(response)
         else
           payment.refunds.create!(amount: payment.credit_allowed, reason: refund_reason).perform!

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

@@ -43,7 +43,7 @@ module Spree
           response = payment_method.authorize(
             money.money.cents,
             source,
-            gateway_options,
+            gateway_options
           )
           pend! if handle_response(response)
         end
@@ -59,7 +59,7 @@ module Spree
           response = payment_method.purchase(
             money.money.cents,
             source,
-            gateway_options,
+            gateway_options
           )
           complete! if handle_response(response)
         end
@@ -95,13 +95,13 @@ module Spree
         return false unless amount.positive?
 
         protect_from_connection_error do
-          if payment_method.payment_profiles_supported?
+          response = if payment_method.payment_profiles_supported?
             # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
             # so supply the authorization itself as well as the credit card, rather than just the authorization code
-            response = payment_method.void(response_code, source, gateway_options)
+            payment_method.void(response_code, source, gateway_options)
           else
             # Standard ActiveMerchant void usage
-            response = payment_method.void(response_code, gateway_options)
+            payment_method.void(response_code, gateway_options)
           end
 
           handle_void_response(response)
@@ -170,12 +170,12 @@ module Spree
         return unless payment_method.source_required?
 
         unless source
-          gateway_error(I18n.t('spree.payment_processing_failed'))
+          gateway_error(I18n.t("spree.payment_processing_failed"))
         end
 
         unless payment_method.supports?(source)
           invalidate!
-          gateway_error(I18n.t('spree.payment_method_not_supported'))
+          gateway_error(I18n.t("spree.payment_method_not_supported"))
         end
 
         true
@@ -194,11 +194,11 @@ module Spree
 
         unless response.authorization.nil?
           self.response_code = response.authorization
-          self.avs_response = response.avs_result['code']
+          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']
+            self.cvv_response_code = response.cvv_result["code"]
+            self.cvv_response_message = response.cvv_result["message"]
           end
         end
 
@@ -217,18 +217,18 @@ module Spree
 
       def gateway_error(error)
         message, log = case error
-                       when ActiveMerchant::Billing::Response
-                          [
-                            error.params['message'] || error.params['response_reason_text'] || error.message,
-                            basic_response_info(error)
-                          ]
-                        when ActiveMerchant::ConnectionError
-                          [I18n.t('spree.unable_to_connect_to_gateway')] * 2
-                        else
-                          [error.to_s, error]
-                        end
-
-        logger.error("#{I18n.t('spree.gateway_error')}: #{log}")
+        when ActiveMerchant::Billing::Response
+          [
+            error.params["message"] || error.params["response_reason_text"] || error.message,
+            basic_response_info(error)
+          ]
+        when ActiveMerchant::ConnectionError
+          [I18n.t("spree.unable_to_connect_to_gateway")] * 2
+        else
+          [error.to_s, error]
+        end
+
+        logger.error("#{I18n.t("spree.gateway_error")}: #{log}")
         raise Core::GatewayError.new(message)
       end
 

data/app/models/spree/payment.rb

@@ -9,17 +9,17 @@ module Spree
     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
-    RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
+    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
+    RISKY_AVS_CODES = ["A", "C", "E", "F", "G", "I", "K", "L", "N", "O", "P", "R", "S", "U", "W", "Z"].freeze
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments, optional: true
+    belongs_to :order, class_name: "Spree::Order", touch: true, inverse_of: :payments, optional: true
     belongs_to :source, polymorphic: true, optional: true
-    belongs_to :payment_method, -> { with_discarded }, class_name: 'Spree::PaymentMethod', inverse_of: :payments, optional: true
+    belongs_to :payment_method, -> { with_discarded }, class_name: "Spree::PaymentMethod", inverse_of: :payments, optional: true
 
     has_many :log_entries, as: :source
     has_many :state_changes, as: :stateful
-    has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
+    has_many :capture_events, class_name: "Spree::PaymentCaptureEvent"
     has_many :refunds, inverse_of: :payment
 
     before_validation :validate_source, unless: :invalid?
@@ -43,17 +43,17 @@ module Spree
 
     default_scope -> { order(:created_at) }
 
-    scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
+    scope :from_credit_card, -> { where(source_type: "Spree::CreditCard") }
     scope :with_state, ->(state) { where(state: state.to_s) }
 
-    scope :checkout, -> { with_state('checkout') }
-    scope :completed, -> { with_state('completed') }
-    scope :pending, -> { with_state('pending') }
-    scope :processing, -> { with_state('processing') }
-    scope :failed, -> { with_state('failed') }
+    scope :checkout, -> { with_state("checkout") }
+    scope :completed, -> { with_state("completed") }
+    scope :pending, -> { with_state("pending") }
+    scope :processing, -> { with_state("processing") }
+    scope :failed, -> { with_state("failed") }
 
-    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 :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) }
     scope :not_store_credits, -> { where(arel_table[:source_type].not_eq(Spree::StoreCredit.to_s).or(arel_table[:source_type].eq(nil))) }
@@ -70,9 +70,9 @@ module Spree
 
     # @return [Spree::Money] this amount of this payment as money object
     def money
-      Spree::Money.new(amount, { currency: })
+      Spree::Money.new(amount, {currency:})
     end
-    alias display_amount money
+    alias_method :display_amount, :money
 
     # Sets the amount, parsing it based on i18n settings if it is a string.
     #
@@ -81,8 +81,8 @@ module Spree
       self[:amount] =
         case amount
         when String
-          separator = I18n.t('number.currency.format.separator')
-          number    = amount.delete("^0-9-#{separator}\.").tr(separator, '.')
+          separator = I18n.t("number.currency.format.separator")
+          number = amount.delete("^0-9-#{separator}.").tr(separator, ".")
           number.presence&.to_d
         end || amount
     end
@@ -119,7 +119,7 @@ module Spree
 
     # @return [Boolean] true when this payment is risky
     def risky?
-      is_avs_risky? || is_cvv_risky? || state == 'failed'
+      is_avs_risky? || is_cvv_risky? || state == "failed"
     end
 
     # @return [Boolean] true when this payment is risky based on address
@@ -153,7 +153,7 @@ module Spree
     private
 
     def source_actions
-      return [] unless payment_source && payment_source.respond_to?(:actions)
+      return [] unless payment_source&.respond_to?(:actions)
       payment_source.actions.select { |action| !payment_source.respond_to?("can_#{action}?") || payment_source.send("can_#{action}?", self) }
     end
 
@@ -161,7 +161,7 @@ module Spree
       if source && !source.valid?
         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}")
+          errors.add(I18n.t(source.class.to_s.demodulize.underscore, scope: "spree"), "#{field_name} #{error.message}")
         end
       end
       if errors.any?
@@ -179,7 +179,7 @@ module Spree
 
     def create_payment_profile
       # Don't attempt to create on bad payments.
-      return if %w(invalid failed).include?(state)
+      return if %w[invalid failed].include?(state)
       # Payment profile cannot be created without source
       return unless source
       # Imported payments shouldn't create a payment profile.
@@ -191,9 +191,9 @@ module Spree
     end
 
     def invalidate_old_payments
-      if !store_credit? && !['invalid', 'failed'].include?(state)
+      if !store_credit? && !["invalid", "failed"].include?(state)
         order.payments.select { |payment|
-          payment.state == 'checkout' && !payment.store_credit? && payment.id != id
+          payment.state == "checkout" && !payment.store_credit? && payment.id != id
         }.each(&:invalidate!)
       end
     end
@@ -217,7 +217,7 @@ module Spree
     end
 
     def generate_identifier
-      Array.new(8){ IDENTIFIER_CHARS.sample }.join
+      Array.new(8) { IDENTIFIER_CHARS.sample }.join
     end
 
     def create_eligible_credit_event

data/app/models/spree/payment_capture_event.rb

@@ -2,10 +2,10 @@
 
 module Spree
   class PaymentCaptureEvent < Spree::Base
-    belongs_to :payment, class_name: 'Spree::Payment', optional: true
+    belongs_to :payment, class_name: "Spree::Payment", optional: true
 
     def display_amount
-      Spree::Money.new(amount, { currency: payment.currency })
+      Spree::Money.new(amount, {currency: payment.currency})
     end
   end
 end

data/app/models/spree/payment_create.rb

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

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

@@ -2,16 +2,16 @@
 
 module Spree
   class PaymentMethod::BogusCreditCard < PaymentMethod::CreditCard
-    TEST_VISA = ['4111111111111111', '4012888888881881', '4222222222222']
-    TEST_MC   = ['5500000000000004', '5555555555554444', '5105105105105100']
-    TEST_AMEX = ['378282246310005', '371449635398431', '378734493671000', '340000000000009']
-    TEST_DISC = ['6011000000000004', '6011111111111117', '6011000990139424']
+    TEST_VISA = ["4111111111111111", "4012888888881881", "4222222222222"]
+    TEST_MC = ["5500000000000004", "5555555555554444", "5105105105105100"]
+    TEST_AMEX = ["378282246310005", "371449635398431", "378734493671000", "340000000000009"]
+    TEST_DISC = ["6011000000000004", "6011111111111117", "6011000990139424"]
 
-    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
+    VALID_CCS = ["1", TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
 
-    AUTHORIZATION_CODE = '12345'
-    FAILURE_MESSAGE = 'Bogus Gateway: Forced failure'
-    SUCCESS_MESSAGE = 'Bogus Gateway: Forced success'
+    AUTHORIZATION_CODE = "12345"
+    FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
+    SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
 
     attr_accessor :test
 
@@ -22,7 +22,7 @@ module Spree
     def create_profile(payment)
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
-      if success = VALID_CCS.include?(payment.source.number)
+      if (success = VALID_CCS.include?(payment.source.number))
         payment.source.update(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
@@ -30,18 +30,18 @@ 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 + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'D' })
+      if VALID_CCS.include?(credit_card.number) || profile_id&.starts_with?("BGS-")
+        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_detail, { message: FAILURE_MESSAGE + message_detail }, 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 + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE, avs_result: { code: 'M' })
+      if VALID_CCS.include?(credit_card.number) || profile_id&.starts_with?("BGS-")
+        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_detail, message: FAILURE_MESSAGE + message_detail, test: true)
       end
@@ -54,7 +54,7 @@ module Spree
 
     def capture(_money, authorization, _gateway_options)
       message_detail = " - #{__method__}"
-      if authorization == '12345'
+      if authorization == "12345"
         ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true)
       else
         ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, error: FAILURE_MESSAGE + message_detail, test: true)
@@ -80,16 +80,16 @@ module Spree
     end
 
     def actions
-      %w(capture void credit)
+      %w[capture void credit]
     end
 
     private
 
     def generate_profile_id(success)
       record = true
-      prefix = success ? 'BGS' : 'FAIL'
+      prefix = success ? "BGS" : "FAIL"
       while record
-        random = "#{prefix}-#{Array.new(6){ rand(6) }.join}"
+        random = "#{prefix}-#{Array.new(6) { rand(6) }.join}"
         record = Spree::CreditCard.where(gateway_customer_profile_id: random).first
       end
       random

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

@@ -3,17 +3,17 @@
 module Spree
   class PaymentMethod::Check < PaymentMethod
     def actions
-      %w{capture void credit}
+      %w[capture void credit]
     end
 
     # Indicates whether its possible to capture the payment
     def can_capture?(payment)
-      ['checkout', 'pending'].include?(payment.state)
+      ["checkout", "pending"].include?(payment.state)
     end
 
     # Indicates whether its possible to void the payment.
     def can_void?(payment)
-      payment.state != 'void'
+      payment.state != "void"
     end
 
     def capture(*)

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

@@ -10,7 +10,7 @@ module Spree
     end
 
     def partial_name
-      'gateway'
+      "gateway"
     end
 
     def supports?(source)

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

@@ -11,9 +11,9 @@ module Spree
       message_detail = " - #{__method__}"
 
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, 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)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, {message: FAILURE_MESSAGE}, test: true)
       end
     end
 
@@ -21,7 +21,7 @@ module Spree
       message_detail = " - #{__method__}"
 
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, 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