solidus_core 4.1.6 → 4.5.1

data/app/models/spree/null_promotion_handler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Spree
+  class NullPromotionHandler
+    attr_reader :order, :coupon_code
+
+    def initialize(order)
+      @order = order
+      @coupon_code = order.coupon_code&.downcase
+    end
+
+    def activate
+      @order
+    end
+
+    def apply
+      self
+    end
+
+    def can_apply?
+      true
+    end
+
+    def error
+      nil
+    end
+
+    def success
+      true
+    end
+
+    def successful?
+      true
+    end
+
+    def status_code
+      :coupon_code_applied
+    end
+
+    def status
+      I18n.t(:coupon_code_applied, scope: [:spree, :null_promotion_handler])
+    end
+  end
+end

data/app/models/spree/option_value.rb

@@ -17,6 +17,7 @@ module Spree
     delegate :name, :presentation, to: :option_type, prefix: :option_type
 
     self.allowed_ransackable_attributes = %w[name presentation]
+    self.allowed_ransackable_associations = %w[variants]
 
     # Updates the updated_at column on all the variants associated with this
     # option value.

data/app/models/spree/order.rb

@@ -26,6 +26,7 @@ module Spree
     include ::Spree::Config.state_machines.order
 
     include Spree::Order::Payments
+    include Metadata
 
     class InsufficientStock < StandardError
       attr_reader :items
@@ -62,7 +63,7 @@ module Spree
       go_to_state :confirm
     end
 
-    self.allowed_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
+    self.allowed_ransackable_associations = %w[shipments user bill_address ship_address line_items]
     self.allowed_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
 
     attr_reader :coupon_code
@@ -72,11 +73,15 @@ module Spree
 
     # Customer info
     belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
+
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address', optional: true
-    alias_attribute :billing_address, :bill_address
+    alias_method :billing_address, :bill_address
+    alias_method :billing_address=, :bill_address=
 
     belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address', optional: true
-    alias_attribute :shipping_address, :ship_address
+    alias_method :shipping_address, :ship_address
+    alias_method :shipping_address=, :ship_address=
+
     alias_attribute :ship_total, :shipment_total
 
     belongs_to :store, class_name: 'Spree::Store', optional: true
@@ -104,8 +109,6 @@ module Spree
              foreign_key: :order_id,
              dependent: :destroy,
              inverse_of: :order
-    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
-    has_many :promotions, through: :order_promotions
 
     # Payments
     has_many :payments, dependent: :destroy, inverse_of: :order
@@ -135,7 +138,9 @@ module Spree
     before_validation :set_currency
     before_validation :generate_order_number, on: :create
     before_validation :assign_billing_to_shipping_address, if: :use_billing?
+    before_validation :assign_shipping_to_billing_address, if: :use_shipping?
     attr_accessor :use_billing
+    attr_accessor :use_shipping
 
     before_create :create_token
     before_create :link_by_email
@@ -159,8 +164,24 @@ module Spree
     delegate :name, to: :bill_address, prefix: true, allow_nil: true
     alias_method :billing_name, :bill_address_name
 
-    class_attribute :line_item_comparison_hooks
-    self.line_item_comparison_hooks = Set.new
+    delegate :line_item_comparison_hooks, to: :class
+    class << self
+      def line_item_comparison_hooks=(value)
+        Spree::Config.line_item_comparison_hooks = value.to_a
+      end
+      line_item_hooks_deprecation_msg = "Use Spree::Config.line_item_comparison_hooks instead."
+      deprecate :line_item_comparison_hooks= => line_item_hooks_deprecation_msg, :deprecator => Spree.deprecator
+
+      def line_item_comparison_hooks
+        Spree::Config.line_item_comparison_hooks
+      end
+      deprecate line_item_comparison_hooks: line_item_hooks_deprecation_msg, deprecator: Spree.deprecator
+
+      def register_line_item_comparison_hook(hook)
+        Spree::Config.line_item_comparison_hooks << hook
+      end
+      deprecate register_line_item_comparison_hook: line_item_hooks_deprecation_msg, deprecator: Spree.deprecator
+    end
 
     scope :created_between, ->(start_date, end_date) { where(created_at: start_date..end_date) }
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
@@ -175,7 +196,7 @@ module Spree
     end
 
     def self.by_state(state)
-      where(state: state)
+      where(state:)
     end
 
     def self.complete
@@ -194,12 +215,6 @@ module Spree
       where.not(state: 'canceled')
     end
 
-    # Use this method in other gems that wish to register their own custom logic
-    # that should be called when determining if two line items are equal.
-    def self.register_line_item_comparison_hook(hook)
-      line_item_comparison_hooks.add(hook)
-    end
-
     # For compatiblity with Calculator::PriceSack
     def amount
       line_items.sum(&:amount)
@@ -223,7 +238,7 @@ module Spree
     end
 
     def shipping_discount
-      shipment_adjustments.credit.eligible.sum(:amount) * - 1
+      shipment_adjustments.credit.sum(:amount) * - 1
     end
 
     def to_param
@@ -271,6 +286,11 @@ module Spree
       true
     end
 
+    def assign_shipping_to_billing_address
+      self.bill_address = ship_address if ship_address
+      true
+    end
+
     def allow_cancel?
       return false unless completed? && state != 'canceled'
       shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
@@ -305,7 +325,7 @@ module Spree
 
       if persisted?
         # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
-        self.class.unscoped.where(id: id).update_all(attrs_to_set)
+        self.class.unscoped.where(id:).update_all(attrs_to_set)
       end
 
       assign_attributes(attrs_to_set)
@@ -347,7 +367,7 @@ module Spree
     def line_item_options_match(line_item, options)
       return true unless options
 
-      line_item_comparison_hooks.all? { |hook|
+      Spree::Config.line_item_comparison_hooks.all? { |hook|
         send(hook, line_item, options)
       }
     end
@@ -439,7 +459,7 @@ module Spree
       line_items.destroy_all
       adjustments.destroy_all
       shipments.destroy_all
-      order_promotions.destroy_all
+      Spree::Bus.publish :order_emptied, order: self
 
       recalculate
     end
@@ -453,7 +473,7 @@ module Spree
     end
 
     def can_add_coupon?
-      Spree::Promotion.order_activatable?(self)
+      Spree::Config.promotions.coupon_code_handler_class.new(self).can_apply?
     end
 
     def shipped?
@@ -497,11 +517,6 @@ module Spree
       end
     end
 
-    def apply_shipping_promotions
-      Spree::PromotionHandler::Shipping.new(self).activate
-      recalculate
-    end
-
     # Clean shipments and make order back to address state (or to whatever state
     # is set by restart_checkout_flow in case of state machine modifications)
     def check_shipments_and_restart_checkout
@@ -566,7 +581,7 @@ module Spree
 
     def add_store_credit_payments
       return if user.nil?
-      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency: currency).zero?
+      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency:).zero?
 
       payments.store_credits.checkout.each(&:invalidate!)
 
@@ -577,7 +592,7 @@ module Spree
 
       remaining_total = outstanding_balance - authorized_total
 
-      matching_store_credits = user.store_credits.where(currency: currency)
+      matching_store_credits = user.store_credits.where(currency:)
 
       if matching_store_credits.any?
         payment_method = Spree::PaymentMethod::StoreCredit.first
@@ -589,7 +604,7 @@ module Spree
 
           amount_to_take = [credit.amount_remaining, remaining_total].min
           payments.create!(source: credit,
-                           payment_method: payment_method,
+                           payment_method:,
                            amount: amount_to_take,
                            state: 'checkout',
                            response_code: credit.generate_authorization_code)
@@ -613,13 +628,13 @@ module Spree
 
     def covered_by_store_credit?
       return false unless user
-      user.available_store_credit_total(currency: currency) >= total
+      user.available_store_credit_total(currency:) >= total
     end
     alias_method :covered_by_store_credit, :covered_by_store_credit?
 
     def total_available_store_credit
       return 0.0 unless user
-      user.available_store_credit_total(currency: currency)
+      user.available_store_credit_total(currency:)
     end
 
     def order_total_after_store_credit
@@ -630,16 +645,16 @@ module Spree
       if can_complete? || complete?
         valid_store_credit_payments.to_a.sum(&:amount)
       else
-        [total, user.try(:available_store_credit_total, currency: currency) || 0.0].min
+        [total, user.try(:available_store_credit_total, currency:) || 0.0].min
       end
     end
 
     def display_total_applicable_store_credit
-      Spree::Money.new(-total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(-total_applicable_store_credit, { currency: })
     end
 
     def display_store_credit_remaining_after_capture
-      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: })
     end
 
     def bill_address_attributes=(attributes)
@@ -788,10 +803,9 @@ module Spree
     end
 
     def ensure_promotions_eligible
-      adjustment_changed = all_adjustments.eligible.promotion.any? do |adjustment|
-        !adjustment.calculate_eligibility
-      end
-      if adjustment_changed
+      Spree::Config.promotions.order_adjuster_class.new(self).call
+
+      if promo_total_changed?
         restart_checkout_flow
         recalculate
         errors.add(:base, I18n.t('spree.promotion_total_changed_before_complete'))
@@ -860,6 +874,10 @@ module Spree
       use_billing.in?([true, 'true', '1'])
     end
 
+    def use_shipping?
+      use_shipping.in?([true, 'true', '1'])
+    end
+
     def set_currency
       self.currency = Spree::Config[:currency] if self[:currency].nil?
     end

data/app/models/spree/order_cancellations.rb

@@ -36,7 +36,7 @@ class Spree::OrderCancellations
     Spree::OrderMutex.with_lock!(@order) do
       Spree::InventoryUnit.transaction do
         inventory_units.each do |iu|
-          unit_cancels << short_ship_unit(iu, created_by: created_by)
+          unit_cancels << short_ship_unit(iu, created_by:)
         end
 
         update_shipped_shipments(inventory_units)
@@ -67,9 +67,9 @@ class Spree::OrderCancellations
 
     Spree::OrderMutex.with_lock!(@order) do
       unit_cancel = Spree::UnitCancel.create!(
-        inventory_unit: inventory_unit,
-        reason: reason,
-        created_by: created_by
+        inventory_unit:,
+        reason:,
+        created_by:
       )
 
       inventory_unit.cancel!
@@ -89,8 +89,8 @@ class Spree::OrderCancellations
 
     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(created_by: created_by)
+      reimbursement = Spree::Reimbursement.new(order: @order, return_items:)
+      reimbursement.return_all(created_by:)
     end
 
     reimbursement
@@ -100,9 +100,9 @@ class Spree::OrderCancellations
 
   def short_ship_unit(inventory_unit, created_by: nil)
     unit_cancel = Spree::UnitCancel.create!(
-      inventory_unit: inventory_unit,
+      inventory_unit:,
       reason: Spree::UnitCancel::SHORT_SHIP,
-      created_by: created_by
+      created_by:
     )
     unit_cancel.adjust!
     inventory_unit.cancel!

data/app/models/spree/order_inventory.rb

@@ -61,10 +61,12 @@ module Spree
 
       potential_shipments.detect do |shipment|
         shipment.include?(variant)
-      end || potential_shipments.detect do |shipment|
-        stock_item = variant.stock_items.detect { |stock_item| stock_item.stock_location == shipment.stock_location }
-        if stock_item
-          stock_item.backorderable? || stock_item.count_on_hand >= quantity
+      end || begin
+        stock_items = variant.stock_items.sort_by(&:id) # cache stock items to avoid N+1
+
+        potential_shipments.detect do |shipment|
+          stock_item = stock_items.detect { |stock_item| stock_item.stock_location == shipment.stock_location }
+          stock_item.backorderable? || stock_item.count_on_hand >= quantity if stock_item
         end
       end || potential_shipments.detect do |shipment|
         variant.stock_location_ids.include?(shipment.stock_location_id)

data/app/models/spree/order_merger.rb

@@ -78,7 +78,7 @@ module Spree
     def find_matching_line_item(other_order_line_item)
       order.line_items.detect do |my_li|
         my_li.variant == other_order_line_item.variant &&
-          order.line_item_comparison_hooks.all? do |hook|
+          Spree::Config.line_item_comparison_hooks.all? do |hook|
             order.send(hook, my_li, other_order_line_item.serializable_hash)
           end
       end

data/app/models/spree/order_mutex.rb

@@ -16,10 +16,10 @@ module Spree
         raise ArgumentError, "order must be supplied" if order.nil?
 
         # limit the maximum lock time just in case a lock is somehow left in place accidentally
-        expired.where(order: order).delete_all
+        expired.where(order:).delete_all
 
         begin
-          order_mutex = create!(order: order)
+          order_mutex = create!(order:)
         rescue ActiveRecord::RecordNotUnique
           error = LockFailed.new("Could not obtain lock on order #{order.id}")
           logger.error error.inspect

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
 
@@ -50,12 +50,12 @@ class Spree::OrderShipping
       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
@@ -79,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

@@ -28,6 +28,7 @@ module Spree
 
       @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
 

data/app/models/spree/order_updater.rb

@@ -26,7 +26,7 @@ module Spree
           update_shipments
           update_shipment_state
         end
-        Spree::Bus.publish :order_recalculated, order: order
+        Spree::Bus.publish(:order_recalculated, order:)
         persist_totals
       end
     end
@@ -113,8 +113,7 @@ module Spree
       # It also fits the criteria for sales tax as outlined here:
       # http://www.boe.ca.gov/formspubs/pub113/
       update_promotions
-      update_taxes
-      update_cancellations
+      update_tax_adjustments
       update_item_totals
     end
 
@@ -158,9 +157,9 @@ module Spree
       recalculate_adjustments
 
       all_items = line_items + shipments
-      order_tax_adjustments = adjustments.select(&:eligible?).select(&:tax?)
+      order_tax_adjustments = adjustments.select(&:tax?)
 
-      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).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)
 
@@ -189,57 +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_promotions
-      Spree::Config.promotion_adjuster_class.new(order).call
+      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)
-
-        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
+        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,
+          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

@@ -64,7 +64,7 @@ module Spree
           complete! if handle_response(response)
         end
 
-        capture_events.create!(amount: amount)
+        capture_events.create!(amount:)
       end
 
       # Takes the amount in cents to capture.
@@ -243,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
@@ -69,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
 
@@ -211,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,39 +29,44 @@ 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 = {})
+      message_detail = " - #{__method__}"
       if options[:originator].completed?
-        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
       else
-        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE + message_detail, {}, test: true, authorization: AUTHORIZATION_CODE)
       end
     end