spree_core 5.6.1 → 6.0.0.beta2

data/db/migrate/20260907000002_create_spree_price_adjustment_tiers.rb

@@ -0,0 +1,19 @@
+class CreateSpreePriceAdjustmentTiers < ActiveRecord::Migration[8.1]
+  def change
+    # The higher bands of a list's percentage adjustment. The list's own
+    # `price_adjustment_percentage` column stays its quantity-1 value, so a
+    # list with no tiers behaves exactly as it does today
+    # (docs/plans/6.0-volume-pricing.md).
+    create_table :spree_price_adjustment_tiers do |t|
+      t.references :price_list, null: false, index: false
+      t.integer :min_quantity, null: false, default: 1
+      t.decimal :percentage, precision: 6, scale: 3, null: false, default: 0
+
+      t.timestamps
+    end
+
+    add_index :spree_price_adjustment_tiers, [:price_list_id, :min_quantity],
+              name: 'index_spree_price_adjustment_tiers_on_list_and_quantity',
+              unique: true
+  end
+end

data/db/migrate/20260908000001_add_seller_to_spree_package_types.rb

@@ -0,0 +1,78 @@
+class AddSellerToSpreePackageTypes < ActiveRecord::Migration[8.1]
+  MARKETPLACE_NAME_INDEX = 'index_spree_package_types_marketplace_name'.freeze
+  SELLER_NAME_INDEX = 'index_spree_package_types_seller_name'.freeze
+  MARKETPLACE_DEFAULT_INDEX = 'index_spree_package_types_marketplace_default'.freeze
+  SELLER_DEFAULT_INDEX = 'index_spree_package_types_seller_default'.freeze
+  STORE_NAME_INDEX = 'index_spree_package_types_on_store_and_name'.freeze
+  DEFAULT_PER_STORE_INDEX = 'index_spree_package_types_default_per_store'.freeze
+
+  def change
+    # Whose packaging this is: a seller's own boxes and cartons, or (nil) the
+    # marketplace's — the shared vocabulary every seller may pack into.
+    add_reference :spree_package_types, :seller, null: true
+
+    # Two indexes where there was one, because a nullable column inside a
+    # unique index constrains nothing for the rows where it is null: the
+    # marketplace's rows all share a NULL seller_id, and NULLs compare
+    # distinct. MySQL has no partial indexes, so there the seller rows are
+    # covered (they carry no NULL) and the marketplace's fall back to the
+    # model validation — the arrangement the default flag already has.
+    #
+    # Spelled out per direction so the change rolls back: an index removed by
+    # name alone cannot be inferred in reverse.
+    reversible do |dir|
+      dir.up { split_indexes_by_owner }
+      dir.down { restore_store_wide_indexes }
+    end
+  end
+
+  private
+
+  def split_indexes_by_owner
+    remove_index :spree_package_types, name: STORE_NAME_INDEX
+
+    if supports_partial_index?
+      add_index :spree_package_types, [:store_id, :name], unique: true,
+                where: 'seller_id IS NULL', name: MARKETPLACE_NAME_INDEX
+      add_index :spree_package_types, [:store_id, :seller_id, :name], unique: true,
+                where: 'seller_id IS NOT NULL', name: SELLER_NAME_INDEX
+
+      remove_index :spree_package_types, name: DEFAULT_PER_STORE_INDEX
+      add_index :spree_package_types, :store_id, unique: true,
+                where: '"default" = TRUE AND seller_id IS NULL', name: MARKETPLACE_DEFAULT_INDEX
+      add_index :spree_package_types, [:store_id, :seller_id], unique: true,
+                where: '"default" = TRUE AND seller_id IS NOT NULL', name: SELLER_DEFAULT_INDEX
+    else
+      add_index :spree_package_types, [:store_id, :seller_id, :name], unique: true,
+                name: SELLER_NAME_INDEX
+    end
+  end
+
+  # Rolling back means going back to one default and one name per store, so a
+  # store holding a seller's packaging cannot satisfy either. Drop those rows
+  # first: they are unreachable without the column this migration adds.
+  def restore_store_wide_indexes
+    execute("DELETE FROM spree_package_types WHERE seller_id IS NOT NULL")
+
+    if supports_partial_index?
+      remove_index :spree_package_types, name: SELLER_DEFAULT_INDEX
+      remove_index :spree_package_types, name: MARKETPLACE_DEFAULT_INDEX
+      add_index :spree_package_types, :store_id, unique: true,
+                where: '"default" = TRUE', name: DEFAULT_PER_STORE_INDEX
+
+      remove_index :spree_package_types, name: SELLER_NAME_INDEX
+      remove_index :spree_package_types, name: MARKETPLACE_NAME_INDEX
+    else
+      remove_index :spree_package_types, name: SELLER_NAME_INDEX
+    end
+
+    add_index :spree_package_types, [:store_id, :name], unique: true, name: STORE_NAME_INDEX
+  end
+
+  # `Spree.mysql?` rather than a fresh adapter check: it matches Trilogy too,
+  # which Rails reports as "Trilogy", and a hand-rolled /mysql/i test would
+  # take the partial-index branch there and fail on a database that has none.
+  def supports_partial_index?
+    !Spree.mysql?
+  end
+end

data/db/migrate/20260910000001_add_stock_receipts.rb

@@ -0,0 +1,44 @@
+class AddStockReceipts < ActiveRecord::Migration[8.1]
+  def change
+    create_table :spree_stock_receipts do |t|
+      t.string :number, null: false
+      t.references :store, null: false
+      t.references :receivable, polymorphic: true, null: false
+      t.string :reference
+      t.datetime :received_at, null: false
+      t.bigint :received_by_id
+      t.text :notes
+      if t.respond_to?(:jsonb)
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      t.timestamps
+    end
+    add_index :spree_stock_receipts, :number, unique: true
+    add_index :spree_stock_receipts, :received_by_id
+
+    create_table :spree_stock_receipt_items do |t|
+      t.references :stock_receipt, null: false
+      t.references :line, polymorphic: true, null: false
+      t.integer :quantity_accepted, null: false, default: 0
+      t.integer :quantity_rejected, null: false, default: 0
+      t.string :rejection_reason
+      t.text :notes
+      t.timestamps
+    end
+
+    add_column :spree_purchase_order_items, :quantity_rejected, :integer, null: false, default: 0
+    add_column :spree_stock_transfer_items, :quantity_rejected, :integer, null: false, default: 0
+    remove_column :spree_stock_transfer_items, :discrepancy_reason, :string
+
+    add_column :spree_purchase_orders, :cancel_by, :date
+    add_column :spree_purchase_orders, :closed_short_at, :datetime
+    add_column :spree_purchase_orders, :close_reason, :text
+    add_column :spree_stock_transfers, :closed_short_at, :datetime
+    add_column :spree_stock_transfers, :close_reason, :text
+
+    add_column :spree_stock_movements, :stock_receipt_id, :bigint
+    add_index :spree_stock_movements, :stock_receipt_id
+  end
+end

data/db/migrate/20260910000002_add_counters_to_spree_stock_levels.rb

@@ -0,0 +1,6 @@
+class AddCountersToSpreeStockLevels < ActiveRecord::Migration[8.1]
+  def change
+    add_column :spree_stock_levels, :reserved_count, :integer, default: 0, null: false
+    add_column :spree_stock_levels, :incoming_count, :integer, default: 0, null: false
+  end
+end

data/db/migrate/20260910120000_index_reporting_time_columns.rb

@@ -0,0 +1,12 @@
+class IndexReportingTimeColumns < ActiveRecord::Migration[8.1]
+  # The payments and inventory reporting bases filter on these columns and
+  # nothing else (docs/plans/6.0-analytics-semantic-layer.md). Movements are
+  # the highest-volume table a mature store has and carry no store column, so
+  # tenancy is a join up to the product — the composite serves that nested loop
+  # and the date filter together, rather than leaving the planner to scan the
+  # whole ledger.
+  def change
+    add_index :spree_stock_movements, %i[stock_level_id created_at]
+    add_index :spree_payments, :created_at
+  end
+end

data/db/migrate/20260912120000_index_reporting_lifetime_and_promotion_columns.rb

@@ -0,0 +1,19 @@
+class IndexReportingLifetimeAndPromotionColumns < ActiveRecord::Migration[8.1]
+  # Customer lifetime value correlates a customer's whole order history on
+  # email, which `spree_orders` had no index for at all — so every customer
+  # group in a report drove a full scan of the orders table, and the metric
+  # became unusable well before a store got large. Store first, because every
+  # reporting query is store-scoped before it is anything else.
+  #
+  # The promotion breakdown probes discounts per line item, filtered to
+  # promotion rows; carrying `kind` in the index keeps those probes from
+  # visiting the row itself.
+  # Cart reporting anchors on when a basket was started, and `spree_carts` had
+  # no index pairing the store with that column — so every cart report scanned
+  # the store's whole cart history to find one period's rows.
+  def change
+    add_index :spree_orders, %i[store_id email]
+    add_index :spree_discounts, %i[line_item_id kind]
+    add_index :spree_carts, %i[store_id created_at]
+  end
+end

data/db/migrate/20260914000001_add_settlement_to_spree_seller_transfers.rb

@@ -0,0 +1,18 @@
+# What a seller actually received, when their account settles in a currency
+# other than the one the sale was priced in.
+#
+# This records a conversion the provider performed and reported. Spree still
+# holds no exchange rates and converts nothing itself.
+#
+# Required rather than nullable: every query that groups or sums by settlement
+# reads these columns directly, so a null row would fall out of balances and
+# out of payout selection without saying so.
+class AddSettlementToSpreeSellerTransfers < ActiveRecord::Migration[8.1]
+  def change
+    add_column :spree_seller_transfers, :settled_amount, :decimal, precision: 10, scale: 2, null: false
+    add_column :spree_seller_transfers, :settled_currency, :string, null: false
+
+    add_index :spree_seller_transfers, [:seller_id, :settled_currency, :status],
+              name: 'index_seller_transfers_on_seller_and_settled_currency'
+  end
+end

data/db/migrate/20260914230000_add_store_to_spree_option_types.rb

@@ -0,0 +1,46 @@
+class AddStoreToSpreeOptionTypes < ActiveRecord::Migration[8.1]
+  def up
+    add_reference :spree_option_types, :store, null: true, index: true
+
+    # Existing option types were installation-wide, so they belong to the
+    # store that has been using them. Left nullable: a fresh install has no
+    # store yet, and the association enforces presence from the model side.
+    default_store = Spree::Store.where(default: true).first || Spree::Store.first
+    Spree::OptionType.update_all(store_id: default_store.id) if default_store
+
+    # Names are unique within a store now, so two stores may each define `size`.
+    remove_index :spree_option_types, :name, unique: true, if_exists: true
+    add_index :spree_option_types, %i[store_id name], unique: true
+  end
+
+  def down
+    remove_index :spree_option_types, %i[store_id name]
+
+    # Two stores may each hold a `size` by now, which the global index would
+    # refuse. Rolling back means going back to installation-wide option
+    # types, so the duplicates are suffixed rather than dropped: no row is
+    # lost, and the operator can see what to reconcile. Written in SQL
+    # because a migration must not depend on model scopes or callbacks.
+    execute(<<~SQL.squish)
+      UPDATE spree_option_types
+      SET name = #{concat_sql}
+      WHERE id NOT IN (
+        SELECT MIN(id) FROM spree_option_types GROUP BY name
+      )
+    SQL
+
+    add_index :spree_option_types, :name, unique: true
+    remove_reference :spree_option_types, :store
+  end
+
+  private
+
+  # MySQL has no `||` string operator under its default SQL mode.
+  def concat_sql
+    if connection.adapter_name.downcase.include?('mysql')
+      "CONCAT(name, '-', id)"
+    else
+      "name || '-' || id"
+    end
+  end
+end

data/db/migrate/20260916000001_order_operation_actors_polymorphic.rb

@@ -0,0 +1,30 @@
+# Makes the order-operation "who did this" associations polymorphic, so a
+# write made with a secret API key records the key rather than nobody.
+# See docs/plans/6.0-action-actors.md.
+class OrderOperationActorsPolymorphic < ActiveRecord::Migration[8.1]
+  ACTORS = {
+    spree_orders: %i[created_by approver canceler],
+    spree_refunds: %i[refunder],
+    spree_returns: %i[created_by],
+    spree_exchanges: %i[created_by],
+    spree_claims: %i[created_by],
+    spree_stock_receipts: %i[received_by]
+  }.freeze
+
+  def change
+    ACTORS.each do |table, names|
+      names.each do |name|
+        # Nullable with no default: the type is data, filled by
+        # `rake spree:upgrade:backfill_actor_types`. Until it runs, the
+        # transitional reader resolves these rows through the admin user
+        # class — the only thing they could ever have pointed at.
+        add_column table, :"#{name}_type", :string
+
+        # Named for the pair so it reads apart from the `_id` index that
+        # already exists on most of these columns.
+        add_index table, [:"#{name}_type", :"#{name}_id"],
+                  name: "index_#{table}_on_#{name}_actor"
+      end
+    end
+  end
+end

data/db/sample_data/collections.rb

@@ -0,0 +1,58 @@
+# Three collections that between them exercise both membership models: two
+# rule-based (they regenerate themselves) and one hand-curated with a dynamic
+# sort. Runs after the product import so there is a catalog to draw from.
+store = Spree::Store.default
+
+# Each automatic collection is defined by the single rule that materializes it.
+automatic_collections = [
+  {
+    permalink: 'new-arrivals',
+    name: 'New Arrivals',
+    sort_order: 'available_on desc',
+    rule_type: 'Spree::CollectionRules::AvailableOn',
+    # Days back the window reaches.
+    rule_value: '30'
+  },
+  {
+    permalink: 'on-sale',
+    name: 'On Sale',
+    sort_order: 'price asc',
+    rule_type: 'Spree::CollectionRules::Sale',
+    rule_value: 'true'
+  }
+]
+
+automatic_collections.each do |attributes|
+  collection = store.collections.find_or_initialize_by(permalink: attributes[:permalink])
+  collection.name = attributes[:name]
+  collection.automatic = true
+  collection.rules_match_policy = 'all'
+  collection.sort_order = attributes[:sort_order]
+  collection.save!
+
+  unless collection.rules.exists?(type: attributes[:rule_type])
+    collection.rules.create!(
+      type: attributes[:rule_type],
+      value: attributes[:rule_value],
+      match_policy: 'is_equal_to'
+    )
+  end
+
+  collection.regenerate_products
+end
+
+# Manual: "best selling" is a sort, not a membership rule, so this is a curated
+# shelf the merchant controls, ordered by actual sales. Seeded with a slice of
+# the catalog to demonstrate curation.
+best_sellers = store.collections.find_or_initialize_by(permalink: 'best-sellers')
+best_sellers.name = 'Best Sellers'
+best_sellers.automatic = false
+best_sellers.sort_order = 'best_selling'
+best_sellers.save!
+
+if best_sellers.products.empty?
+  Spree::Collections::AddProducts.call(
+    collections: [best_sellers],
+    products: store.products.order(:id).limit(12)
+  )
+end

data/db/sample_data/custom_field_definitions.rb

@@ -0,0 +1,9 @@
+store = Spree::Store.default
+
+%w[warranty capacity voltage wattage runtime room_coverage noise_level connectivity].each do |key|
+  store.custom_field_definitions.find_or_create_by!(
+    namespace: 'custom',
+    key: key,
+    resource_type: 'Spree::Product'
+  )
+end

data/db/sample_data/digital_products.rb

@@ -0,0 +1,26 @@
+# The digital product itself is a normal row in products.csv (product_type
+# "Digital"), so the import gives it the digital delivery profile — the product
+# type stamps it at creation. The one thing a CSV row cannot carry is the file
+# buyers download, so that is all this step does: attach a PDF to the imported
+# product's default variant.
+store = Spree::Store.default
+
+product = Spree::Product.find_by(store: store, slug: 'the-spree-commerce-handbook')
+
+if product && !product.default_variant.digital_assets.exists?
+  # A minimal valid PDF, built in memory so seeding stays offline. The customer
+  # receives this file through their download link.
+  pdf = +"%PDF-1.4\n"
+  pdf << "1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n"
+  pdf << "2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n"
+  pdf << "3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 612 792]>>endobj\n"
+  pdf << "trailer<</Root 1 0 R>>\n%%EOF\n"
+
+  asset = Spree::DigitalAsset.new(variant: product.default_variant)
+  asset.attachment.attach(
+    io: StringIO.new(pdf),
+    filename: 'the-spree-commerce-handbook.pdf',
+    content_type: 'application/pdf'
+  )
+  asset.save!
+end

data/db/sample_data/fulfillment.rb

@@ -0,0 +1,88 @@
+# The whole demo fulfillment setup in one place: a realistic parcel and
+# Shopify-style delivery methods on the Domestic and International zones.
+# The free international method showcases delivery-method rules — free
+# above a spend threshold, hidden below it.
+store = Spree::Store.default
+
+# The zones are created from the store's country at first-run setup, so an
+# install that has not been set up yet has none. Provision them here from
+# whatever country the store already names rather than abort — sample data
+# should be loadable on a bare seed.
+if store.delivery_zones.where(name: %w[Domestic International]).count < 2
+  Spree::Stores::ProvisionDefaults.call(
+    store: store,
+    country: store.default_country || Spree::Country.by_iso('US'),
+    locale: store.default_locale
+  )
+  store.reload
+end
+
+# A realistic shipping box (imperial units — the demo store is US): its weight
+# rides on every parcel and its dimensions feed dimensional-weight pricing,
+# without which carrier quotes under-price bulky-but-light items. Created only
+# when the store has no default box, so a merchant's own is never replaced.
+if store.default_package_type.nil?
+  store.package_types.create!(
+    name: 'Standard box',
+    kind: 'box',
+    default: true,
+    weight: 0.5,
+    length: 12,
+    width: 9,
+    height: 4,
+    dimensions_unit: 'in',
+    weight_unit: 'lb'
+  )
+end
+
+# Wholesale packaging: the carton products are packed into, and the pallet
+# those cartons stack onto. A merchant configuring freight starts from rows
+# like these.
+[
+  { name: 'Master carton', kind: 'carton', length: 40, width: 30, height: 25, weight: 0.4, max_weight: 20 },
+  { name: 'Euro pallet', kind: 'pallet', length: 120, width: 80, height: 15, weight: 25, max_weight: 1_500 }
+].each do |attributes|
+  # `first_party`, because on a marketplace the store's packaging includes
+  # every seller's: a seller who named a carton the same way would make this
+  # seeder skip the marketplace's own, leaving the demo freight setup reading
+  # that seller's measurements.
+  store.package_types.first_party.where(name: attributes[:name]).first_or_create! do |package_type|
+    package_type.assign_attributes(attributes.merge(dimensions_unit: 'cm', weight_unit: 'kg'))
+  end
+end
+
+domestic = store.delivery_zones.find_by(name: 'Domestic')
+international = store.delivery_zones.find_by(name: 'International')
+
+if domestic.nil? || international.nil?
+  # abort, not exit: exit reports success and would silently skip the payment
+  # methods and promotions the loader still has to seed.
+  abort "Couldn't provision the Domestic/International delivery zones for this store."
+end
+
+currency = store.default_currency
+
+delivery_methods = [
+  { name: 'Standard', zone: domestic, amount: 5 },
+  { name: 'Express', zone: domestic, amount: 15 },
+  { name: 'International Shipping', zone: international, amount: 20 },
+  { name: 'Free International Shipping', zone: international, amount: 0, minimum_item_total: 100 }
+]
+
+delivery_methods.each do |attributes|
+  delivery_method = Spree::DeliveryMethod.where(name: attributes[:name], store: store).first_or_create! do |record|
+    record.calculator = Spree::Calculator::Shipping::FlatRate.create!(
+      preferences: { amount: attributes[:amount], currency: currency }
+    )
+    record.delivery_profile = attributes[:zone].delivery_profile
+    record.delivery_zone = attributes[:zone]
+    record.storefront_visible = true
+  end
+
+  next if attributes[:minimum_item_total].blank?
+
+  Spree::DeliveryMethodRules::ItemTotalRule.where(delivery_method: delivery_method).first_or_create! do |rule|
+    rule.active = true
+    rule.preferred_minimum_amount = attributes[:minimum_item_total]
+  end
+end

data/db/sample_data/options.rb

@@ -1,4 +1,28 @@
 color = Spree::OptionType.find_or_initialize_by(name: 'color')
-color.presentation = 'Color'
+color.label = 'Color'
 color.kind = 'color_swatch'
 color.save!
+
+# Condition — new / refurbished / used. An option type rather than a column
+# because that is exactly what it is: an axis that splits a product into
+# variants, which hands it the whole option machinery for free (label
+# kinds, positions, storefront pickers and facets) and gives a marketplace a
+# new buy box and a used buy box on the same listing at no extra cost
+# (docs/plans/6.0-multi-vendor-marketplace.md, Decision 11).
+#
+# Sample data, not a seed: nothing in core keys on the word "condition" — the
+# buy box groups by whatever option values it is given — so a store that
+# sells only new goods should not find this on a fresh install. A marketplace
+# that wants its sellers to describe condition the same way loads it, or
+# creates its own.
+condition = Spree::OptionType.find_or_initialize_by(name: 'condition')
+condition.label = 'Condition'
+condition.kind = 'buttons'
+condition.filterable = true
+condition.save!
+
+%w[new refurbished used].each_with_index do |value, index|
+  next if condition.option_values.exists?(name: value)
+
+  condition.option_values.create!(name: value, label: value.capitalize, position: index + 1)
+end

data/db/sample_data/orders.rb

@@ -10,36 +10,39 @@ unless product_1 && product_2
 end
 
 # Build addresses for orders
-us = Spree::Country.find_by!(iso: 'US')
-ny = us.states.find_by(abbr: 'NY')
+us_iso = 'US'
+ny_abbr = 'NY'
 
 billing_address = Spree::Address.find_or_create_by!(
-  firstname: 'John',
-  lastname: 'Doe',
+  first_name: 'John',
+  last_name: 'Doe',
   address1: '7735 Old Georgetown Rd',
   city: 'Bethesda',
-  state: ny,
-  zipcode: '20814',
-  country: us,
+  state_abbr: ny_abbr,
+  postal_code: '20814',
+  country_code: us_iso,
   phone: '555-0199'
 )
 
 shipping_address = Spree::Address.find_or_create_by!(
-  firstname: 'John',
-  lastname: 'Doe',
+  first_name: 'John',
+  last_name: 'Doe',
   address1: '1600 Pennsylvania Ave NW',
   city: 'Washington',
-  state: ny,
-  zipcode: '20500',
-  country: us,
+  state_abbr: ny_abbr,
+  postal_code: '20500',
+  country_code: us_iso,
   phone: '555-0199'
 )
 
-# Create orders
+# Create orders. Numbers are fixed rather than generated — the number is the
+# `first_or_create!` key that makes a re-run idempotent — and match the 6.0
+# sequential default so a sample store looks like a real one. Real orders
+# created afterwards skip past taken values on their own.
 orders = []
 
 orders << store.orders.where(
-  number: 'R123456789',
+  number: 'R1001',
   email: 'spree@example.com',
   currency: 'USD'
 ).first_or_create! do |order|
@@ -49,7 +52,7 @@ orders << store.orders.where(
 end
 
 orders << store.orders.where(
-  number: 'R987654321',
+  number: 'R1002',
   email: 'spree@example.com',
   currency: 'USD'
 ).first_or_create! do |order|
@@ -76,23 +79,27 @@ unless orders[1].line_items.any?
   ).save!
 end
 
-orders.each(&:create_proposed_shipments)
+orders.each(&:rebuild_fulfillments!)
 
-Spree::Order.where(id: orders.map(&:id)).update_all(state: :complete, status: 'placed', completed_at: Time.current - 1.day)
+Spree::Order.where(id: orders.map(&:id)).update_all(status: 'placed', completed_at: Time.current - 1.day)
 
-# Adjustments (tax)
+# Tax lines (zero-amount sample rows against the California rate)
 tax_rate = Spree::TaxRate.find_by(name: 'California')
 
 if tax_rate
   orders.each do |order|
-    order.all_adjustments.where(
-      adjustable: order,
-      source: tax_rate,
-      label: 'Tax',
-      state: 'open',
-      mandatory: true
-    ).first_or_create! do |adj|
-      adj.amount = 0
+    line_item = order.line_items.first
+    next if line_item.nil?
+
+    order.tax_lines.where(
+      line_item: line_item,
+      tax_rate: tax_rate,
+      label: 'Tax'
+    ).first_or_create! do |tax_line|
+      tax_line.amount = 0
+      tax_line.rate = tax_rate.amount
+      tax_line.included = tax_rate.included_in_price
+      tax_line.provider_id = 'internal'
     end
   end
 end
@@ -108,6 +115,7 @@ if method
   end
 
   credit_card = Spree::CreditCard.find_or_initialize_by(gateway_customer_profile_id: 'BGS-1234')
+  credit_card.payment_method = method
   credit_card.cc_type = 'visa'
   credit_card.month = 12
   credit_card.year = 2.years.from_now.year
@@ -116,16 +124,31 @@ if method
   credit_card.save!
 
   orders.each do |order|
-    order.update_with_updater!
+    order.recalculate_totals!
     payment = order.payments.where(
       amount: BigDecimal(order.total, 4),
       source: credit_card.clone,
       payment_method: method
     ).first_or_create!
-    payment.update_columns(state: 'pending', response_code: "BGS-#{SecureRandom.hex(6)}")
+    payment.update_columns(status: 'pending', response_code: "BGS-#{SecureRandom.hex(6)}")
   end
 end
 
-# Reimbursement
+# Statuses are derive-then-persist; the direct writes above bypass the
+# event subscribers, so recompute explicitly.
+orders.each { |order| order.reload.update_statuses! }
+
+# A return in progress, so the admin has something to look at. Built through
+# the workflows rather than by direct writes — they own every transition.
 first_complete_order = Spree::Order.complete.first
-Spree::Reimbursement.create(order: first_complete_order) if first_complete_order
+if first_complete_order && first_complete_order.fulfillment_items.any?
+  fulfillment_item = first_complete_order.fulfillment_items.first
+
+  Spree::Returns::Create.call(
+    order: first_complete_order,
+    items: [{ fulfillment_item: fulfillment_item, quantity: 1 }],
+    stock_location: fulfillment_item.fulfillment&.stock_location || Spree::StockLocation.first,
+    reason: Spree::ReturnReason.first,
+    memo: 'Sample return'
+  )
+end

data/db/sample_data/payment_methods.rb

@@ -5,7 +5,7 @@ Spree::Store.all.find_each do |store|
     description: 'Bogus payment gateway.',
     active: true
   )
-  cc_payment_method.display_on = 'back_end'
+  cc_payment_method.storefront_visible = false
   cc_payment_method.save!
 
   check_payment_method = store.payment_methods.find_or_initialize_by(
@@ -14,6 +14,6 @@ Spree::Store.all.find_each do |store|
     description: 'Pay by check.',
     active: true
   )
-  check_payment_method.display_on = 'back_end'
+  check_payment_method.storefront_visible = false
   check_payment_method.save!
 end