spree_core 6.0.0.beta4 → 6.0.0.rc2

data/lib/spree/money.rb

@@ -1,10 +1,23 @@
 require 'money'
 
 Money.locale_backend = :i18n
+Money.default_currency = 'USD'
 Money.rounding_mode = BigDecimal::ROUND_HALF_UP
 
 module Spree
   class Money
+    # An amount that is not a canonical decimal string: a JSON number, a
+    # localized or padded string, or more decimals than the field allows.
+    class InvalidFormat < ArgumentError
+      # @return [Symbol, nil] the request field the amount came from
+      attr_reader :field
+
+      def initialize(message = nil, field: nil)
+        super(message)
+        @field = field
+      end
+    end
+
     # How Spree rounds an amount to a currency.
     #
     # Lives here beside the rounding mode above because "how much is this worth
@@ -14,42 +27,156 @@ module Spree
     module Rounding
       module_function
 
+      # ISO 4217 minor units, the one table Ruby and the TypeScript clients
+      # share. The Money gem disagrees for a few currencies (it writes HUF
+      # without decimals), so Spree reads its own copy.
+      EXPONENTS = JSON.parse(File.read(File.expand_path('../../config/currency_exponents.json', __dir__))).freeze
+
+      # Every currency Spree knows, the closed list the API types publish as
+      # `CurrencyCode`.
+      CURRENCY_CODES = EXPONENTS.keys.sort.freeze
+
+      # Unit prices may be quoted below the minor unit ("0.0125" USD); amounts
+      # that change hands never are.
+      UNIT_PRICE_DECIMALS = 4
+
+      CANONICAL_DECIMAL = /\A-?\d+(\.\d+)?\z/
+
+      ROUNDING_MODES = {
+        half_up: BigDecimal::ROUND_HALF_UP,
+        half_even: BigDecimal::ROUND_HALF_EVEN,
+        half_down: BigDecimal::ROUND_HALF_DOWN,
+        up: BigDecimal::ROUND_UP,
+        down: BigDecimal::ROUND_DOWN
+      }.freeze
+
       # The number of decimal places a currency is written in: 2 for most, 0
       # for yen, 3 for dinar. An unknown currency falls back to two places
       # rather than raising — a sale is not the moment to discover a typo in a
       # currency code.
       #
-      # Note that Spree's money columns are `decimal(_, 2)` throughout, so a
-      # three-decimal currency still loses its last place on the way into the
-      # database. Rounding here to the currency's own precision keeps the
-      # arithmetic honest and means widening those columns would be the only
-      # change needed; it does not by itself make Spree dinar-exact.
-      #
       # @param currency [String, ::Money::Currency, nil]
       # @return [Integer]
       def precision(currency)
-        (::Money::Currency.find(currency) || ::Money::Currency.find('USD')).exponent
+        code = currency.respond_to?(:iso_code) ? currency.iso_code : currency.to_s.upcase
+        EXPONENTS[code] || ::Money::Currency.find(code)&.exponent || EXPONENTS['USD']
       end
 
-      # Rounds to the currency's own minor unit, half-up, so amounts reconcile
-      # to the cent when they are summed.
+      # Rounds to the currency's own minor unit, so amounts reconcile to the
+      # cent when they are summed.
       #
       # @param amount [Numeric, String, nil]
       # @param currency [String, ::Money::Currency, nil]
+      # @param mode [Symbol] one of {ROUNDING_MODES}; tax providers pick their own
       # @return [BigDecimal]
-      def to_currency(amount, currency)
-        quantize(amount, precision(currency))
+      def to_currency(amount, currency, mode: :half_up)
+        quantize(amount, precision(currency), mode: mode)
       end
 
       # The same rounding against a precision already in hand.
       #
       # @param amount [Numeric, String, nil]
       # @param precision [Integer]
+      # @param mode [Symbol] one of {ROUNDING_MODES}
       # @return [BigDecimal]
-      def quantize(amount, precision)
-        BigDecimal(amount.to_s).round(precision, BigDecimal::ROUND_HALF_UP)
+      def quantize(amount, precision, mode: :half_up)
+        BigDecimal(amount.to_s).round(precision, ROUNDING_MODES.fetch(mode))
       end
 
+      # Reads a money amount from an API request. Only a canonical decimal
+      # string is accepted — never a JSON number, which may already have lost
+      # precision as a float, and never more decimals than the field holds.
+      #
+      # @param value [String, nil]
+      # @param currency [String, ::Money::Currency, nil] nil when unknown,
+      #   which allows up to {UNIT_PRICE_DECIMALS} decimals
+      # @param unit_price [Boolean] allows up to {UNIT_PRICE_DECIMALS} decimals
+      # @return [BigDecimal, nil]
+      # @raise [Spree::Money::InvalidFormat]
+      def parse_canonical(value, currency, unit_price: false)
+        amount = parse_canonical_decimal(value)
+        return if amount.nil?
+
+        allowed = if currency.nil? || unit_price
+                    [precision(currency), UNIT_PRICE_DECIMALS].max
+                  else
+                    precision(currency)
+                  end
+        raise InvalidFormat, "has more than #{allowed} decimal places" if decimal_places(value) > allowed
+
+        amount
+      end
+
+      # Reads a rate or percentage from an API request: a canonical decimal
+      # string with no limit on its decimals.
+      #
+      # @param value [String, nil]
+      # @return [BigDecimal, nil]
+      # @raise [Spree::Money::InvalidFormat]
+      def parse_canonical_decimal(value)
+        return if value.nil?
+        raise InvalidFormat, 'must be a decimal string like "19.99"' unless value.is_a?(String) && value.match?(CANONICAL_DECIMAL)
+
+        BigDecimal(value)
+      end
+
+      # Reads a decimal from a caller that may send a number or text: a blank
+      # is nil, a number passes, and text must be a plain decimal ("16.50"),
+      # never read as a wrong number the way `"1,599.99".to_d` reads 1.
+      #
+      # @param value [Numeric, String, nil]
+      # @return [BigDecimal, nil]
+      # @raise [Spree::Money::InvalidFormat]
+      def parse_decimal(value)
+        return if value.nil? || (value.is_a?(String) && value.strip.empty?)
+        return BigDecimal(value.to_s) if value.is_a?(Numeric)
+
+        parse_canonical_decimal(value.is_a?(String) ? value.strip : value)
+      end
+
+      # Writes an amount the way the API and exports carry it: exactly the
+      # currency's decimal places ("10.00", "1.500", "100"). A unit price keeps
+      # up to {UNIT_PRICE_DECIMALS}, with zeros beyond the currency's own
+      # places dropped ("0.0125", "19.99").
+      #
+      # @param amount [Numeric, String, nil]
+      # @param currency [String, ::Money::Currency, nil]
+      # @param unit_price [Boolean]
+      # @return [String, nil]
+      def format(amount, currency, unit_price: false)
+        return if amount.nil?
+
+        places = precision(currency)
+        kept = unit_price ? [places, UNIT_PRICE_DECIMALS].max : places
+        rounded = quantize(amount, kept)
+        whole, fraction = (rounded.zero? ? BigDecimal(0) : rounded).to_s('F').split('.')
+        fraction = without_trailing_zeros(fraction.to_s).ljust(places, '0')
+        fraction.empty? ? whole : "#{whole}.#{fraction}"
+      end
+
+      # Writes a rate or percentage with no trailing zeros ("0.23", "23").
+      #
+      # @param value [Numeric, String, nil]
+      # @return [String, nil]
+      def format_decimal(value)
+        return if value.nil?
+
+        without_trailing_zeros(BigDecimal(value.to_s).to_s('F')).delete_suffix('.')
+      end
+
+      # Trailing zeros carry no value, so "1000.0" is a whole yen.
+      def decimal_places(value)
+        value.include?('.') ? without_trailing_zeros(value.split('.').last).length : 0
+      end
+      private_class_method :decimal_places
+
+      # Scans back to the last other digit, in linear time on request input.
+      def without_trailing_zeros(text)
+        last = text.rindex(/[^0]/)
+        last ? text[0..last] : ''
+      end
+      private_class_method :without_trailing_zeros
+
       # An amount as a whole number of the currency's smallest unit — cents for
       # most currencies, whole yen for one written without decimals.
       #
@@ -67,14 +194,65 @@ module Spree
         (BigDecimal(amount.to_s) * (10**precision(currency))).round.to_i
       end
 
+      # An amount in hundredths of the currency, whatever its own minor unit:
+      # the unit payment gateways are called with until they take amounts with
+      # their currency.
+      #
+      # @param amount [Numeric, String]
+      # @return [Integer]
+      def to_hundredths(amount)
+        quantize(BigDecimal(amount.to_s) * 100, 0).to_i
+      end
+
+      # @param hundredths [Integer] as {#to_hundredths} returns
+      # @return [BigDecimal]
+      def from_hundredths(hundredths)
+        BigDecimal(hundredths) / 100
+      end
+
+      # Whether an amount is missing or zero. Text that is not a number is
+      # neither, so a malformed value is never mistaken for "nothing to pay".
+      #
+      # @param value [Numeric, String, nil]
+      # @return [Boolean]
+      def blank_or_zero?(value)
+        return true if value.blank?
+
+        BigDecimal(value.to_s, exception: false)&.zero? || false
+      end
+
       # @param units [Integer] whole minor units, as {#to_minor_units} returns
       # @param currency [String, ::Money::Currency, nil]
       # @return [BigDecimal]
       def from_minor_units(units, currency)
         BigDecimal(units) / (10**precision(currency))
       end
+
+      # Makes the Money gem agree with {EXPONENTS}, so formatting, `cents`
+      # and anything else built on it use ISO 4217 decimals too.
+      def register_with_money_gem!
+        EXPONENTS.each do |code, exponent|
+          subunit_to_unit = 10**exponent
+          currency = ::Money::Currency.find(code)
+
+          if currency.nil?
+            ::Money::Currency.register(
+              iso_code: code, name: code, symbol: code, subunit: nil, subunit_to_unit: subunit_to_unit,
+              priority: 100, symbol_first: false, thousands_separator: ',', decimal_mark: '.'
+            )
+          elsif currency.subunit_to_unit != subunit_to_unit
+            # The smallest cash amount is counted in subunits, so it scales
+            # with them: 5 forints stays 5 forints, not 0.05.
+            scaled = currency.smallest_denomination &&
+                     currency.smallest_denomination * subunit_to_unit / currency.subunit_to_unit
+            ::Money::Currency.inherit(code.downcase.to_sym, subunit_to_unit: subunit_to_unit, smallest_denomination: scaled)
+          end
+        end
+      end
     end
 
+    Rounding.register_with_money_gem!
+
     include Comparable
 
     class << self
@@ -97,13 +275,16 @@ module Spree
     delegate    :cents, :currency, :to_d, :positive?, :zero?, to: :money
 
     def initialize(amount, options = {})
-      ::Money.default_currency ||= Spree::Store.default.default_currency || 'USD'
       @money   = Monetize.parse(amount, (options[:currency] || Spree::Store.default.default_currency))
       @options = Spree::Money.default_formatting_rules.merge(options)
     end
 
+    # The amount in hundredths of the currency, whatever its own minor unit —
+    # the unit payment gateways have always been called with.
+    #
+    # @return [Integer]
     def amount_in_cents
-      (cents / currency.subunit_to_unit.to_f * 100).round
+      Rounding.to_hundredths(to_d)
     end
 
     def abs

data/lib/spree/reporting/adapters/base.rb

@@ -22,24 +22,25 @@ module Spree
 
         def cast_value(metric, raw)
           case metric.format
-          when :money, :decimal, :percent then raw.to_f.round(2)
+          when :money then BigDecimal((raw || 0).to_s)
+          when :decimal, :percent then BigDecimal((raw || 0).to_s).round(2)
           else raw.to_i
           end
         end
 
         def zero_for(metric)
-          metric.format == :integer ? 0 : 0.0
+          metric.format == :integer ? 0 : BigDecimal(0)
         end
 
         # Computes requested ratio metrics from their aggregated components.
         def apply_derived(metrics)
           query.metrics.select(&:derived?).each do |metric|
             numerator, denominator = metric.ratio.map { |name| metrics[name] || 0 }
-            ratio = denominator.to_f.zero? ? 0.0 : numerator / denominator.to_f
+            ratio = denominator.zero? ? BigDecimal(0) : BigDecimal(numerator.to_s) / BigDecimal(denominator.to_s)
             # A percent metric carries the number a merchant reads (42.5), not
             # the fraction, so clients never have to know to multiply.
             ratio *= 100 if metric.format == :percent
-            metrics[metric.name] = ratio.round(2)
+            metrics[metric.name] = metric.money? ? ratio : ratio.round(2)
           end
         end
 
@@ -58,12 +59,12 @@ module Spree
         def growth_rate(current, previous)
           return nil if previous.nil?
           if previous.zero?
-            return 0.0 if current.zero?
+            return BigDecimal(0) if current.zero?
 
             return nil
           end
 
-          (((current - previous) / previous.to_f) * 100).round(1)
+          ((BigDecimal(current.to_s) - BigDecimal(previous.to_s)) / BigDecimal(previous.to_s) * 100).round(1)
         end
       end
     end

data/lib/spree/reporting/adapters/live.rb

@@ -642,12 +642,12 @@ module Spree
           end.to_h
         end
 
-        # Both periods span the same number of days, so their bucket counts
-        # differ by at most one partial edge. Pairing runs from the start —
-        # the nth bucket of this period with the nth of the previous — because
-        # the ranges share a start offset: a range beginning mid-month pairs
-        # its partial first bucket with the previous period's partial first
-        # bucket. A bucket past the end of the previous list has no
+        # Both periods span the same number of days (or of whole months), so
+        # their bucket counts differ by at most one partial edge. Pairing runs
+        # from the start — the nth bucket of this period with the nth of the
+        # previous — because the ranges share a start offset: a range
+        # beginning mid-month pairs its partial first bucket with the previous
+        # period's partial first bucket. A bucket past the end of the previous list has no
         # counterpart and pairs with nothing rather than wrapping around.
         def bucket_pairs(grain)
           current = expected_buckets(query.time_range, grain)

data/lib/spree/reporting/default_vocabulary.rb

@@ -113,16 +113,27 @@ module Spree
         SUM(COALESCE((SELECT SUM(r.amount) FROM %{refunds} r WHERE r.order_id = %{orders}.id), 0))
       SQL
 
-      # A refund is issued against the order, not a line, so it is apportioned
-      # by the line's share of the order's pre-tax value. The denominator is
-      # summed over the order's own lines rather than read from item_total:
-      # item_total is priced before discounts, so on a discounted order the
-      # shares would not add up to one and part of the refund would vanish.
-      # The `* 1.0` forces real division: SQLite divides two integer-valued
-      # decimals as integers, which silently rounds every share to zero.
+      # A refund that gives tax back carries it in its own column, so the goods
+      # and the tax it returned are netted from goods and tax respectively.
+      REFUNDED_GOODS_SUBQUERY = <<~SQL.squish.freeze
+        SUM(COALESCE((SELECT SUM(r.amount - r.tax_amount) FROM %{refunds} r WHERE r.order_id = %{orders}.id), 0))
+      SQL
+
+      REFUNDED_TAX_SUBQUERY = <<~SQL.squish.freeze
+        SUM(COALESCE((SELECT SUM(r.tax_amount) FROM %{refunds} r WHERE r.order_id = %{orders}.id), 0))
+      SQL
+
+      # A refund is issued against the order, not a line, so its goods are
+      # apportioned by the line's share of the order's pre-tax value. The
+      # denominator is summed over the order's own lines rather than read from
+      # item_total: item_total is priced before discounts, so on a discounted
+      # order the shares would not add up to one and part of the refund would
+      # vanish. The `* 1.0` forces real division: SQLite divides two
+      # integer-valued decimals as integers, which silently rounds every share
+      # to zero.
       LINE_ITEM_REFUNDS_SUBQUERY = <<~SQL.squish.freeze
         SUM(
-          COALESCE((SELECT SUM(r.amount) FROM %{refunds} r WHERE r.order_id = %{orders}.id), 0)
+          COALESCE((SELECT SUM(r.amount - r.tax_amount) FROM %{refunds} r WHERE r.order_id = %{orders}.id), 0)
           * CASE
               WHEN COALESCE((SELECT SUM(sibling.pre_tax_amount) FROM %{line_items} sibling
                              WHERE sibling.order_id = %{orders}.id), 0) > 0
@@ -293,7 +304,7 @@ module Spree
           metric :gross_sales, sql: 'SUM(%{line_items}.price * %{line_items}.quantity)',
                                base: :line_items, format: :money
           metric :discounts, sql: 'SUM(%{line_items}.discount_total)', base: :line_items, format: :money
-          metric :returns, sql: REFUNDS_SUBQUERY, base: :orders, format: :money
+          metric :returns, sql: REFUNDED_GOODS_SUBQUERY, base: :orders, format: :money
           # Net of returns as well as discounts, so this is the figure a
           # merchant recognises as "what we actually sold".
           metric :net_sales, sql: "SUM(%{line_items}.pre_tax_amount) - #{LINE_ITEM_REFUNDS_SUBQUERY}",
@@ -303,7 +314,8 @@ module Spree
           # Every shopper-visible fee except duties, which the chain counts separately.
           metric :fees, sql: "SUM(COALESCE(%{orders}.fee_total, 0)) - #{DUTIES_SUBQUERY}",
                         base: :orders, format: :money, suggests: 'net_sales'
-          metric :taxes, sql: 'SUM(%{orders}.additional_tax_total + %{orders}.included_tax_total)',
+          # Net of the tax given back, as net_sales is net of the goods.
+          metric :taxes, sql: "SUM(%{orders}.additional_tax_total + %{orders}.included_tax_total) - #{REFUNDED_TAX_SUBQUERY}",
                          base: :orders, format: :money, suggests: 'net_sales'
           # The order grand total, net of what came back.
           metric :total_sales, sql: "SUM(%{orders}.total) - #{REFUNDS_SUBQUERY}",

data/lib/spree/reporting/hydration.rb

@@ -21,7 +21,7 @@ module Spree
         dimension = definition(name)
         # A row whose key is NULL is a real group — an order with no market or
         # channel — and needs a name a person can read, not a blank cell.
-        return { id: nil, label: Spree.t('reporting.unassigned'), meta: {} } if raw.nil? && !plain?(dimension)
+        return { id: nil, label: I18n.t('spree.reporting.unassigned'), meta: {} } if raw.nil? && !plain?(dimension)
         return { id: raw.to_s, label: Schema.value_label(dimension, raw), meta: {} } if dimension.enumerated_values
         return raw unless dimension.hydrate
 

data/lib/spree/reporting/query.rb

@@ -126,12 +126,20 @@ module Spree
       # year" means February to February, and an equal-day-count shift off a
       # 28-day February would land in January. ActiveSupport maps February 29
       # to February 28 in a non-leap year.
+      #
+      # A range of whole calendar months (a full quarter, `last_month`) shifts
+      # by the same number of months for the same reason: July – September is
+      # 92 days, and shifting it by days would start on March 31, putting a
+      # one-day March bucket at the front of the previous period.
       def previous_time_range
         first = time_range.first.in_time_zone(time_zone)
         last = time_range.last.in_time_zone(time_zone)
 
         if compare == 'previous_year'
           (first - 1.year)..(last - 1.year)
+        elsif first == first.beginning_of_month && last == last.end_of_month
+          months = (last.year * 12 + last.month) - (first.year * 12 + first.month) + 1
+          (first - months.months)..(last - months.months).end_of_month
         else
           days = (last.to_date - first.to_date).to_i + 1
           (first - days.days)..(last - days.days)

data/lib/spree/reporting/registry.rb

@@ -45,6 +45,19 @@ module Spree
       # total is suppressed rather than rendered as a headline.
       def per_group? = requires_grouping.present?
       def money? = format == :money
+
+      # A value as the API and exports write it: money to the currency's
+      # decimal places, other decimals without trailing zeros, counts as
+      # integers.
+      #
+      # @param value [Numeric, nil]
+      # @param currency [String, nil]
+      # @return [String, Integer, nil]
+      def format_value(value, currency)
+        return value if value.nil? || format == :integer
+
+        money? ? Spree::Money::Rounding.format(value, currency) : Spree::Money::Rounding.format_decimal(value)
+      end
     end
 
     # A dimension groups rows. The definition owns every behavior keyed off

data/lib/spree/reporting/schema.rb

@@ -32,7 +32,7 @@ module Spree
           metrics: metrics.map { |m| metric_entry(m) },
           dimensions: dimensions.map { |d| dimension_entry(d, metrics) },
           time_range: {
-            presets: (Query::PRESETS + Query::RELATIVE_PRESETS).map { |p| { name: p, label: translate('presets', p, :label) } },
+            presets: (Query::PRESETS + Query::RELATIVE_PRESETS).map { |p| { name: p, label: catalog_text('presets', p, :label) } },
             relative: %w[last_<n>_days last_<n>_weeks last_<n>_months],
             absolute: 'ISO 8601 dates or datetimes in `since` / `until`, resolved in the store timezone'
           },
@@ -50,7 +50,7 @@ module Spree
       # @param group [Symbol] :metrics | :dimensions
       # @return [String] localized label (humanized name when none registered)
       def label_for(group, name)
-        translate(group, name, :label)
+        catalog_text(group, name, :label)
       end
 
       private
@@ -61,7 +61,7 @@ module Spree
         metrics.group_by { |metric| @registry.family_of(metric) }.map do |family, family_metrics|
           {
             name: family,
-            label: translate('families', family, :label),
+            label: catalog_text('families', family, :label),
             metrics: family_metrics.map(&:name),
             dimensions: @registry.dimensions.values.
               select { |d| @allowed.call(d) && @registry.base!(d.base).family == family }.map(&:name)
@@ -73,8 +73,8 @@ module Spree
         {
           name: metric.name,
           family: @registry.family_of(metric),
-          label: translate('metrics', metric.name, :label),
-          description: translate('metrics', metric.name, :description),
+          label: catalog_text('metrics', metric.name, :label),
+          description: catalog_text('metrics', metric.name, :description),
           format: metric.format,
           currency: (metric.money? ? @store.default_currency : nil),
           derived: metric.derived?,
@@ -88,8 +88,8 @@ module Spree
       def dimension_entry(dimension, metrics)
         {
           name: dimension.name,
-          label: translate('dimensions', dimension.name, :label),
-          description: translate('dimensions', dimension.name, :description),
+          label: catalog_text('dimensions', dimension.name, :label),
+          description: catalog_text('dimensions', dimension.name, :description),
           type: dimension.type,
           grains: dimension.grains,
           lookup: dimension.lookup,
@@ -104,8 +104,8 @@ module Spree
         }.compact
       end
 
-      def translate(group, name, facet)
-        Spree.t("reporting.#{group}.#{name}.#{facet}", default: (facet == :label ? name.to_s.humanize : nil))
+      def catalog_text(group, name, facet)
+        I18n.t("spree.reporting.#{group}.#{name}.#{facet}", default: (facet == :label ? name.to_s.humanize : nil))
       end
 
 
@@ -117,7 +117,7 @@ module Spree
       # @param value [String]
       # @return [String]
       def self.value_label(dimension, value)
-        Spree.t("reporting.values.#{dimension.name}.#{value}", default: value.to_s.humanize)
+        I18n.t("spree.reporting.values.#{dimension.name}.#{value}", default: value.to_s.humanize)
       end
     end
   end

data/lib/spree/testing_support/editable_email_templates.rb

@@ -0,0 +1,61 @@
+# Registers core's staff password reset as an editable email for the length
+# of an example, with a fixed sample, so specs in any engine can exercise the
+# template editor without spree_emails' customer emails. Restores whatever was
+# registered under the key before.
+#
+#   RSpec.describe '...' do
+#     include_context 'with an editable email template'
+#   end
+module Spree
+  module TestingSupport
+    class EmailTemplateSample
+      def self.record_type
+        nil
+      end
+
+      def initialize(store:, record_id: nil)
+        @store = store
+      end
+
+      def currency
+        @store.default_currency
+      end
+
+      def recent_records(limit: 5)
+        @store.orders.order(created_at: :desc).limit(limit).map do |order|
+          Spree::EmailTemplates::SampleRecord.new(id: order.prefixed_id, label: order.number, created_at: order.created_at)
+        end
+      end
+
+      def variables
+        {
+          user: { 'first_name' => 'Ann', 'email' => 'ann@example.com' },
+          order: { 'number' => 'R123456789', 'customer_name' => 'Ann Lee' },
+          reset_url: "#{@store.storefront_url}/reset-password?token=preview"
+        }
+      end
+    end
+  end
+end
+
+RSpec.shared_context 'with an editable email template' do
+  let(:editable_key) { 'spree/admin_user_mailer/password_reset_email' }
+
+  # Templates have per-language versions only in the store's languages.
+  before { allow_any_instance_of(Spree::Store).to receive(:supported_locales_list).and_return(%w[de en fr]) }
+
+  around do |example|
+    registry = Spree.editable_email_templates
+    previous = registry[editable_key]
+    previous_layout = registry['layouts/spree/base_mailer']
+    registry.register(editable_key, kind: :email, sample: 'Spree::TestingSupport::EmailTemplateSample')
+    registry.register('layouts/spree/base_mailer', kind: :layout)
+
+    begin
+      example.run
+    ensure
+      previous ? registry.register(previous.key, kind: previous.kind, sample: previous.sample) : registry.delete(editable_key)
+      previous_layout ? registry.register(previous_layout.key, kind: :layout) : registry.delete('layouts/spree/base_mailer')
+    end
+  end
+end

data/lib/spree/testing_support/emails.rb

@@ -0,0 +1,22 @@
+module Spree
+  module TestingSupport
+    module Emails
+      # The decoded text of every part of an email, HTML and plain text
+      # together. Rendered emails are quoted-printable on the wire, so the raw
+      # encoded body splits long lines and turns "=" into "=3D".
+      #
+      # @param message [Mail::Message, ActionMailer::MessageDelivery]
+      # @return [String]
+      def email_body(message)
+        message = message.message if message.respond_to?(:message) && !message.is_a?(Mail::Message)
+        parts = message.multipart? ? message.parts : [message]
+
+        parts.map(&:decoded).join("\n")
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Spree::TestingSupport::Emails
+end

data/lib/spree/testing_support/factories/cart_factory.rb

@@ -31,7 +31,7 @@ FactoryBot.define do
           country = Spree::Country.by_iso('US')
 
           if Spree::DeliveryMethod.none?
-            create(:shipping_method).tap do |delivery_method|
+            create(:delivery_method).tap do |delivery_method|
               delivery_method.calculator.preferred_amount = evaluator.shipping_cost
               delivery_method.calculator.preferred_currency = cart.store.default_currency
               delivery_method.calculator.save!

data/lib/spree/testing_support/factories/email_template_factory.rb

@@ -0,0 +1,28 @@
+FactoryBot.define do
+  factory :email_template, class: Spree::EmailTemplate do
+    store { Spree::Store.default || create(:store) }
+    key { 'spree/admin_user_mailer/password_reset_email' }
+    locale { 'any' }
+    subject { 'Reset {{ store.name }}' }
+    body { '<mj-section><mj-column><mj-text>Hello</mj-text></mj-column></mj-section>' }
+    base_subject { 'Reset {{ store.name }}' }
+    base_body { '<mj-section><mj-column><mj-text>Default</mj-text></mj-column></mj-section>' }
+    published_at { Time.current }
+  end
+
+  factory :email_template_draft, class: Spree::EmailTemplateDraft do
+    store { Spree::Store.default || create(:store) }
+    key { 'spree/admin_user_mailer/password_reset_email' }
+    locale { 'any' }
+    subject { 'Reset {{ store.name }}' }
+    body { '<mj-section><mj-column><mj-text>Draft</mj-text></mj-column></mj-section>' }
+    base_subject { 'Reset {{ store.name }}' }
+    base_body { '<mj-section><mj-column><mj-text>Default</mj-text></mj-column></mj-section>' }
+  end
+
+  factory :email_template_revision, class: Spree::EmailTemplateRevision do
+    email_template
+    subject { 'Reset {{ store.name }}' }
+    body { '<mj-section><mj-column><mj-text>Hello</mj-text></mj-column></mj-section>' }
+  end
+end

data/lib/spree/testing_support/factories/order_factory.rb

@@ -39,7 +39,7 @@ FactoryBot.define do
         create(:line_item, order: order, price: evaluator.line_items_price)
         order.line_items.reload # to ensure order.line_items is accessible after
 
-        order.update_column(:item_count, order.line_items.count)
+        order.update_column(:total_quantity, order.line_items.count)
         order.reload
       end
     end
@@ -78,7 +78,7 @@ FactoryBot.define do
         end
 
         stock_location = order.line_items&.first&.variant&.stock_levels&.first&.stock_location || create(:stock_location)
-        create(:shipment, order: order, cost: evaluator.shipment_cost, stock_location: stock_location)
+        create(:fulfillment, order: order, cost: evaluator.shipment_cost, stock_location: stock_location)
         order.fulfillments.reload
 
         order.recalculate_totals!