Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Add Spree::Workflow and the two-tier services doctrine
Damian Legawiecc6fd70713e47
diff --git a/CLAUDE.md b/CLAUDE.mdindex c49f3af4a6..0c824d4cca 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -31,6 +31,7 @@ Active plans (6.0 target, work pending):- `6.0-inventory-operations.md` — StockTransfer lifecycle (draft → ready_to_ship → in_transit → received with partial receive), new `Spree::PurchaseOrder` + `Spree::Supplier` (renamed from Vendor — `Spree::Vendor` is the marketplace seller, see decisions.md 2026-07-14) replacing today's "external receive" hack, variant + stock-location stock history panels. Consumes the typed-movement primitives from `6.0-typed-stock-movements.md`.- `6.0-replace-taxons-with-categories.md` — Split Taxon into Category (hierarchy) + Collection (flat/rule-based). **Shipped to 6-0-dev (PR #14302):** the Category surface (5.5–5.6) plus the 6.0 core — `spree_taxons`→`spree_categories` table rename + inheritance flip (`Spree::Category < Spree.base_class`, `Spree::Taxon` alias kept), the full `Collection` stack (model + rules + DB/Meilisearch manual sort + API), the taxon→category/collection data migration, and de-ruling Category. Pending (all 6.1): channel-aware `CollectionRules::AvailableOn` (ships interim now, rides with channels) + dropping `spree_taxon_rules`/`Taxonomy`. No brand feature in 6.0 — brands are modeled as a Category/Collection; `brand_taxon`/`brand_name` removed with `Taxonomy`.- `6.0-delivery-method-rules.md` — `Spree::DeliveryMethodRule` STI on DeliveryMethod (design finalized 2026-07-29): ItemTotal/Weight rules first (Channel/Market/CustomerGroup later in lockstep with payment-method-rules), enforced solely in `Stock::Estimator`'s method filter so calculator- AND provider-priced methods obey eligibility; replaces the FlatRate-only bound preferences (one-release bridge + data task). Phase 1 rides the 6.0 core-rewrite finishing work.+- `6.0-service-workflows.md` — Two-tier services doctrine (2026-07-30). **Tier 1 `app/services/`:** plain `ServiceModule` classes, hand-written `def call(cart:, ...)`, Ruby kwargs as the contract — the permanent default; no DSL, no new `run`-pipelines, no hand-rolled sagas. **Tier 2 `app/workflows/`:** `Spree::Workflow` step DSL (`argument` typed contracts, `provides:`, `transaction`/`external_step`, `on_flow_failure:`, `rescue_from`, `run_hooks` + `Spree.hooks`, `emit`, bare argument readers), reserved for flows needing hooks, compensation/external I/O, replay, or durability — currently `Carts::Complete`, `Carts::AddItem`, `Carts::Recalculate`, `Carts::RecalculateTotals` (+ order twins). A service graduates to the workflow tier when it earns a hook, never speculatively. `Carts::Complete` battery must pass unmodified; durable flows via ActiveJob Continuations in Phase 2.- `6.0-store-scoped-custom-field-definitions.md` — Add `store_id` + persisted `filter_key` to `Spree::MetafieldDefinition` (today global and computed), making uniqueness `(store_id, resource_type, filter_key)` with a DB index. Deferred from the 5.6 custom-field search/sort/filter work (schema change, not patch-safe). **Until then:** `filter_key` is a computed method — no Ransack predicates or `where`/`order` against it; definitions are global; uniqueness rests on a `CONCAT` validation with no index behind it.Multi-version plans (some phases shipped, some pending):@@ -132,6 +133,7 @@ Backend: http://localhost:3000, admin at `/admin`, hosted React Dashboard at `/d- DO NOT put logic into controllers or serializers - this should live in models and services- ALWAYS use Yard comments for classes and public methods, with `@param` and `@return` types- DO NOT generate too much comment noise, be very strict and selective about what gets a comment — only non-obvious public methods, never private methods or internal helpers+- DO NOT use shorthand variable names, readibility by humans is the core principle### Code Organizationdiff --git a/docs/plans/6.0-service-workflows.md b/docs/plans/6.0-service-workflows.mdnew file mode 100644index 0000000000..e3c7a2bf60--- /dev/null+++ b/docs/plans/6.0-service-workflows.md@@ -0,0 +1,318 @@+# Service Workflows — one step DSL for services, sagas, hooks and events++**Status:** In Progress — Phase 1 shipped to 6-0-dev as a two-tier split (2026-07-30): `Spree::Workflow` (the DSL) powers the curated flows in `app/workflows/`; every other service stays a plain ServiceModule class+**Target:** Spree 6.0+**Depends on:** `6.0-cart-order-split.md` (Carts::Complete is the reference implementation and stress test). Coordinates with: `6.0-multi-vendor-marketplace.md` (payout runs are the first durable-flow consumer), the Rails 8.1 floor decision (decisions.md 2026-07-29 — ActiveJob Continuations are the durability primitive).+**Author:** Damian Legawiec + Claude (design session 2026-07-30)+**Last updated:** 2026-07-30++## Summary++Services, sagas, extension points and events are today four unrelated idioms:+`ServiceModule` run-pipelines threading raw kwarg hashes between steps,+`Carts::Complete` hand-rolling phases/compensation/resumability, extensions+choosing between replacing a whole service (`Spree::Dependencies`) or reacting+after commit (subscribers), and `publish_event` calls buried inside bodies.+This plan evolves `ServiceModule` — in place, additively — into a declared+step DSL (`argument` / `step` / `on_flow_failure:` / `run_hooks` / `emit` /+transaction grouping) so one mental model covers a two-step item service and the+completion saga alike. Medusa's workflows are the DX benchmark; the runtime+stays plain Ruby inside Rails transactions — no execution-state tables, no+engine. **`Carts::Complete` is the stress test:** the DSL is done when the+completion pipeline expresses its lock scopes, out-of-transaction payment+I/O, compensation and structural resumability with its entire spec battery+green and its observable semantics byte-identical.++## Problem++- **Step contracts are implicit.** Pipeline steps receive whatever kwargs the+ caller passed (`@_passed_input` seeds from the raw hash); renames and new+ keys fail at runtime as `IncompatibleParamsPassed`, or worse, silently+ (the 2026-07-30 `cart:` kwarg sweep broke exactly this way; `rewrite_input!`+ exists only to patch the seed mid-flight).+- **Sagas are bespoke.** Compensation, resumability and TTL sweeping live as+ one-off code in `Carts::Complete`; the next saga (marketplace payouts,+ claims) would reinvent all three.+- **Extensions have an axe and a megaphone, no scalpel.** They can swap an+ entire service class or subscribe after commit — there is no supported way+ to inject logic *inside* a flow, in-transaction, at a named point.+- **Events are invisible side effects.** What a service announces is+ discoverable only by reading its body; subscribers form a second, parallel+ system with its own discovery problem (the never-built status subscriber+ hid for months).++## Key Decisions (do not deviate without discussion)++1. **Two tiers, one caller contract (2026-07-30 — supersedes the earlier+ "evolve ServiceModule in place" framing).** `app/services/` holds plain+ `ServiceModule` classes — hand-written `def call(cart:, ...)`, standard+ Ruby, zero DSL vocabulary; this is the permanent default, not a legacy+ tier. `app/workflows/` holds `Spree::Workflow` (the DSL below), earned+ only by flows needing an extension hook, compensation/external I/O,+ replay/halt semantics, or a durable future. Initial set:+ `Carts::Complete`, `Carts::AddItem`, `Carts::Recalculate`,+ `Carts::RecalculateTotals` (+ order twins); a service graduates to the+ workflow tier the moment it earns a hook — never speculatively.+ `Callable.call`, `Result`, `success`/`failure` stay the shared caller+ contract across both tiers — callers cannot tell them apart.+2. **No engine.** No execution-state tables, no visualizer, no parallel+ executor, no cross-process orchestration in this plan. Medusa needs those+ because its modules cross process boundaries; inside one Rails process+ they are ceremony. Durable flows get state from ActiveJob Continuations+ (Phase 2), not from us.+3. **Declared contracts.** `argument :cart` / `argument :quantity, default: 1` declare presence-validated+ per-line arguments (ActiveJob/GraphQL vocabulary); `step :name, provides: [:line_item]`+ declares what a step adds to the context. Unknown keys raise in test/dev, log in+ production. Context is an object (`flow.cart`), not a threaded hash.+4. **Transaction boundaries are explicit DSL, not ambiance.** A bare `step`+ runs in the flow's ambient transaction started by `transaction do ... end`+ grouping blocks; `external_step` is forbidden inside one. This is the lesson+ `Carts::Complete` teaches: PREPARE is in-lock transactional, payment I/O+ must never be, FINALIZE is its own transaction. The DSL must express all+ three or it has failed the stress test.+5. **`on_flow_failure:` pairs a step with its undo method,** run in reverse+ order for completed steps when a later step fails outside a shared+ transaction (inside one, rollback is the compensation — the undo arms+ only after the enclosing transaction commits). Formalizes+ `Carts::Complete#compensate!`; the name says when it runs and why (the+ plain-English rename from the saga literature's "compensation" was+ deliberate — see the naming discussion 2026-07-30).+6. **`run_hooks :name` declares the extension point (ActiveSupport's run_callbacks verb — all registered handlers run there)**, registered through `Spree.hooks`+ with dotted keys and class handlers (decided 2026-07-30):++ ```ruby+ Spree.hooks.register('carts.add_item.after_item_added', MyApp::UpdateExternalWMS)+ Spree.hooks.carts # introspection: flows → points → handlers+ Spree.hooks.for('carts.add_item.after_item_added') # resolved handler list+ ```++ Handlers are classes responding to `call(context)`, where the context at+ a hook point is exactly the declared arguments ∪ the `provides:` keys of+ every preceding step — a computed contract, not a documented one. Discovery, cheapest to+ strictest: `Spree.hooks.contract('carts.add_item.after_item_added')`+ returns the key list; unknown-key reads raise listing the available+ keys; the context supports `deconstruct_keys` for self-documenting+ pattern-matching destructure (`context => { cart:, line_item: }`); and+ an opt-in `uses :cart, :line_item` declaration (Spree::Flows::Handler)+ validates the handler against the contract at boot-finalize. The hook+ reference page is generated from these contracts (Typelizer+ philosophy — code is the source of truth). The registry stores+ class *names* and constantizes at dispatch (the Spree::Dependencies+ trick) — dev-reload safe, initializer safe, and re-registration dedupes+ by string identity. Blocks are accepted for one-line glue but class+ handlers are the documented norm. Hooks run in-transaction; exceptions+ abort the flow (that is the point — consistency-tier one). At+ boot-finalize every registered key is validated against hooks actually+ declared by flow classes (their `run_hooks` declarations), so typos fail loudly at boot instead of+ silently never firing. Hook keys are public API, versioned like+ dependency keys.+7. **`emit 'name', payload: ->(ctx) { ... }`** declares an after-commit+ event with an explicit plain-Ruby payload lambda. The documented+ convention — enforced by review, visible at the declaration — is+ serializing through the record's `event_payload` (the V3 serializer+ path lifecycle events use), so flow events stay shape-identical to+ webhook payloads: `payload: ->(ctx) { ctx.order.event_payload.merge(notify_customer: ctx.order.notify_customer) }`. Same bus, same subscribers, same webhooks — the+ only change is that announcements are declarations, greppable at the top+ of the file. Inline `publish_event` remains valid for conditional edges.+8. **The consistency doctrine ships as documentation** in the same PR:+ *step* — must be true in the same transaction; *sync subscriber* — must be+ true in the same request (statuses); *async subscriber* — eventually+ (emails, webhooks, metrics). One table, linked from CLAUDE.md.+9. **`Carts::Complete` is the acceptance test, not a rewrite target.** The+ retrofit must preserve, observably unchanged: P1 replay idempotency,+ in-lock `expected_total` verification, `completing_at` TTL + sweeper+ resume, pre-capture-only compensation, after-commit-only event emission,+ and the `complete_order` draft branch. The existing spec battery runs+ unmodified — if a spec has to change, the DSL is wrong, not the spec.+10. **Dependency swapping gains step granularity, keeps service granularity.**+ `Spree.cart_add_item_service` continues to resolve the class; inside a+ flow, `step :reserve_stock, with: -> { Spree.stock_reserve_service }`+ keeps step implementations swappable without subclassing the whole flow.++## Design Details++```ruby+class Spree::Carts::AddItem < Spree::Service+ argument :cart+ argument :variant+ argument :quantity, default: 1+ argument :options, default: {}++ transaction do+ step :add_to_line_item, provides: [:line_item, :line_item_created]+ step :reserve_stock, if: ->(ctx) { ctx.cart.in_checkout? },+ undo: :release_reservation+ step :recalculate, with: -> { Spree.cart_recalculate_service }+ run_hooks :after_item_added+ end++ emit 'cart.item_added', payload: ->(ctx) { ctx.cart.event_payload.merge(line_item_id: ctx.line_item.prefixed_id) }++ private++ def add_to_line_item(ctx)+ # returns a hash merged into the context, validated against out:+ end+end+```++The completion saga shape (the stress test — abbreviated):++```ruby+class Spree::Carts::Complete < Spree::Service+ argument :cart+ argument :expected_total, default: nil+ argument :payment_pending, default: false++ step :replay_completed, halt_with: :existing_order # P1 idempotency++ transaction lock: :cart do # PREPARE+ step :recalculate_in_lock+ step :verify_expected_total+ step :validate_cart+ step :stamp_completing+ step :copy_draft_order, provides: [:order]+ end++ external_step :process_payments, undo: :destroy_draft_and_repoint # Y — never in a txn++ transaction do # FINALIZE+ step :finalize_order+ step :stamp_cart_completed+ end++ step :release_reservations+ step :recompute_statuses+ emit 'order.placed', payload: ->(ctx) { ctx.order.event_payload.merge(notify_customer: ctx.order.notify_customer) }+end+```++- **Context object**: thin struct over the accumulated hash; `ctx.cart`,+ `ctx[:line_item]`; writes only through step `provides:` merges. `Result.value`+ remains whatever `success(...)` returns, for caller compatibility.+- **`halt_with:`** — early successful exit (replay paths) without treating it+ as failure.+- **Compensation registry**: completed `on_flow_failure:`-bearing steps push+ their undo methods; a failure in a *later* non-shared-transaction step pops them in+ reverse. Inside a `transaction` block no compensation runs — rollback is it.+- **`emit` timing**: collected during the flow, published after the outermost+ commit via `after_commit` on the flow's final transaction (or immediately+ when no transaction is open). Mirrors today's `finalize!` guarantee that a+ rolled-back completion never leaks `order.placed`.+- **Durable flows (Phase 2 — design settled 2026-07-30, starts after the+ cart/order service migrations complete)**: the declared flow structure is+ what makes durability mechanical — a different runner walks the same+ `flow_items` under checkpointed execution, and services need no rewrite.+ - **Crash-resume via ActiveJob Continuations** (Rails 8.1 is the floor): a+ generic `Spree::FlowJob` (`include ActiveJob::Continuable`) receives the+ flow class name + serialized arguments and wraps each DSL step in a+ continuation step. Mapping rules: one DSL step → one checkpoint; a+ `transaction do ... end` group → **one** checkpoint (the group is the+ atomic unit — no checkpointing inside an open transaction); an+ `external_step` → its own checkpoint (the reason the keyword exists).+ A deploy/crash re-enqueues and resumes after the last completed step.+ - **`provides:` is the checkpoint schema**: after each step the runner+ serializes exactly the provided keys into the continuation cursor —+ records as GlobalIDs, re-resolved fresh on resume (no stale marshaled+ objects). Flows opting into durability get a lint that provided values+ must be serializable.+ - **Parking** (wait for webhook / 3DS return / manual approval — Medusa's+ async steps): beyond Continuations' interruption-resume; needs a+ `Spree::FlowExecution` row (flow key, serialized context, position,+ `status: 'waiting'`, resume token) + `FlowExecution.resume(token,+ payload)` re-enqueueing at the parked step with the payload merged into+ context. Precedent: `Carts::Complete` already does this by hand — the+ `requires_action` payment session is the park, the customer's redirect+ is the external event, `completion_result` replay via `halt_with` is the+ resume. Phase 2 generalizes that pattern; whether the stuck-completion+ sweeper generalizes with it is decided then.+ - **At-least-once, honestly**: an `external_step` crashing after the side+ effect but before its checkpoint re-runs on resume. Mitigation the DSL+ can offer that ad-hoc services never get: an idempotency key derived per+ `(execution_id, step_name)` handed to the step via ctx, for server-side+ dedupe (e.g. Stripe idempotency keys).+ - **Boundaries**: opt-in per invocation (`Flow.call_later(...)`) or per+ flow (`durable!`); synchronous `.call` stays the default for+ request-cycle flows. No event-sourced replay à la Temporal (demands+ deterministic code — alien to Rails), no separate engine process, no+ Redis: Solid Queue + Continuations + one table. Targets: CSV imports,+ `spree:upgrade` data migrations, payout runs. Explicitly out of scope+ for the 6.0 GA gate if it slips — the DSL must not block on it.++## Editor & Typing Story++The contracts are declared data — typing artifacts are generated from them,+never hand-written (Typelizer philosophy, applied to Ruby):++1. **Contexts are real classes** (Phase 1a requirement, not optional):+ per-flow `Context` classes metaprogrammed at load with defined reader+ methods + generated YARD. Solargraph and Ruby LSP then complete and+ navigate `ctx.line_item` with no extra toolchain — method_missing+ dispatch would forfeit the entire editor story and is forbidden.+2. **Opt-in argument types, GraphQL-Ruby style** — the per-line `argument`+ freed the second positional for a type: `argument :cart, Spree::Cart`,+ `argument :quantity, Integer, default: 1`, `:boolean` for `[true,+ false]`, arrays as unions (`[Spree::Cart, Spree::Order]`, `nil` for+ nilable). Validated once at the `call` boundary against supplied+ arguments: ContractError in dev/test, log-warn in production+ (consistent with the other contract checks). **No coercion** — silent+ `"2"` → `2` hides caller bugs; controllers already cast. (RBS/sig+ generation was considered and dropped — 2026-07-30: the runtime+ contracts plus real reader methods carry the editor story on their+ own; no generated signature artifacts.)+3. **`ruby-lsp-spree` addon (tooling backlog, separate from this plan):**+ ruby-lsp-rails-style addon giving in-string completion for hook keys in+ `Spree.hooks.register`, go-to-definition from key to `run_hooks` declaration,+ hover contracts, unknown-key diagnostics — generalizing to the wider+ string-registry family (`subscribes_to` event names, dependency keys).++## Migration Path++1. **Phase 1a — the DSL** (`Spree::Service`, context, `argument`/`step`/+ `transaction`/`external_step`/`on_flow_failure:`/`run_hooks`/`emit`/+ `halt_with:`) — **shipped**, with typed arguments and the+ provides:-as-write-schema rule; specs+ for every construct, consistency-tier doc. No production service changes.+2. **Phase 1b — reference retrofit — shipped.** Every Cart/Order service+ was migrated as a stress exercise, then deliberately folded back+ (2026-07-30): the DSL stays only on the four curated workflows;+ everything else returned to plain bodies keeping the semantics gained+ along the way (`OrderUpdater#update` dissolved into+ `RecalculateTotals`, single status writer, `use_shipping` fix).+ Acceptance held throughout: batteries green unmodified.+3. **Phase 1c — first hooks — shipped:** `after_item_added` (AddItem) and+ `before_finalize` (Complete) registered-hook seams. These two only; more+ hooks are added by demand, not speculation. Extension-facing docs pending.+4. **Rolling adoption:** services migrate when meaningfully touched — never a+ big-bang sweep. `ServiceModule::Base` is not deprecated in 6.0.+5. **Phase 2 (starts once the cart/order service migrations complete; may+ land post-GA):** durable flows per the settled design above — first+ consumer is the CSV import pipeline, second the upgrade data migrations.++## Constraints on Current Work++- New services are plain sequential `ServiceModule` bodies (like+ `Orders::UpdateItem`) — no new `run`-pipelines, and no DSL outside+ `app/workflows/`.+- Do not hand-roll compensation/saga logic in a plain service; a flow that+ needs it belongs in `app/workflows/` on `Spree::Workflow`.+- Adding an extension hook to a plain service means graduating it to the+ workflow tier first — hooks exist only as `run_hooks` declarations.++## Open Questions++- Should `with:` step swapping be exposed to extensions or reserved for core+ seams initially?+- Context object mutability rules for hooks (read-write vs read-plus-merge).+- Whether the sweeper that resumes stuck completions generalizes into flow+ infrastructure in Phase 2 or stays completion-specific.++## References++- `docs/plans/6.0-cart-order-split.md` — Carts::Complete pipeline semantics+ (idempotency, compensation, resumability) this plan must preserve.+- decisions.md 2026-07-29 (Rails 8.1 floor / Continuations), 2026-07-30+ (consistency doctrine discussion: updater vs statuses vs subscribers).+- Medusa workflows (DX benchmark): createWorkflow/createStep, per-step+ compensation, workflow hooks.+- `spree/core/lib/spree/service_module.rb` — the base being evolved.diff --git a/docs/plans/decisions.md b/docs/plans/decisions.mdindex 40873862c3..e9cc987a7e 100644--- a/docs/plans/decisions.md+++ b/docs/plans/decisions.md@@ -711,3 +711,22 @@ stays the OSS default), and the **EasyPost-or-Shippo** multi-carriergem for delivery rates (pick still pending; Integration + providerpair). Stripe Tax remains buildable by third parties but is not thereference — and carries the merchant-of-record caveat recorded above.+++## 2026-07-30 — Service workflows: one step DSL, Carts::Complete as the stress test++Services, sagas, extension hooks and events unify under a declared step+DSL evolved from ServiceModule in place (plan:+`6.0-service-workflows.md`, targeted 6.0). Medusa's workflows are the DX+benchmark; the runtime stays plain Ruby in Rails transactions — no+engine, no execution-state tables. Explicit transaction/io_step+boundaries, per-step compensation, in-transaction `hook` extension+points and declared `emit` events; the consistency doctrine (step →+sync subscriber → async subscriber) ships as documentation.+**Carts::Complete is the reference implementation and acceptance test:**+the cart→order swap already exercises every hard property (in-lock+verification, out-of-transaction payment I/O, compensation, replay+idempotency, sweeper resume) and its spec battery must pass unmodified+after the retrofit. Durable flows compile onto ActiveJob Continuations+in Phase 2 (imports, upgrade migrations, payout runs) and may land+post-GA without blocking the DSL.diff --git a/spree/api/app/controllers/spree/api/v3/store/carts/fulfillments_controller.rb b/spree/api/app/controllers/spree/api/v3/store/carts/fulfillments_controller.rbindex d5dd1bd049..92f573317d 100644--- a/spree/api/app/controllers/spree/api/v3/store/carts/fulfillments_controller.rb+++ b/spree/api/app/controllers/spree/api/v3/store/carts/fulfillments_controller.rb@@ -49,7 +49,7 @@ module Spreedef recalculatereturn if @cart.complete? || @cart.canceled?- @cart.update_with_updater!+ @cart.recalculate_totals!rescue StandardError => eRails.error.report(e, context: { order_id: @cart.id }, source: 'spree.checkout')ensurediff --git a/spree/api/spec/controllers/spree/api/v3/admin/orders/discount_codes_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/orders/discount_codes_controller_spec.rbindex 69cac2485c..b07b2abaf5 100644--- a/spree/api/spec/controllers/spree/api/v3/admin/orders/discount_codes_controller_spec.rb+++ b/spree/api/spec/controllers/spree/api/v3/admin/orders/discount_codes_controller_spec.rb@@ -67,7 +67,7 @@ RSpec.describe Spree::Api::V3::Admin::Orders::DiscountCodesController, type: :coit 'removes the promotion and clears the stored code' doorder.update!(coupon_code: 'save5')- order.update_with_updater!+ order.recalculate_totals!expect(order.reload.discounts.where(promotion_id: promotion.id)).to be_presentdelete :destroy, params: { order_id: order.prefixed_id, id: 'save5' }, as: :jsondiff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rbindex 40f1611adf..3a5a237729 100644--- a/spree/core/app/models/spree/cart.rb+++ b/spree/core/app/models/spree/cart.rb@@ -134,7 +134,9 @@ module Spreeself.whitelisted_ransackable_attributes = %w[email completed_at token updated_at]- attr_accessor :temporary_address, :use_billing, :use_shipping, :skip_market_resolution+ attr_accessor :temporary_address, :use_shipping, :skip_market_resolution++ before_validation :clone_shipping_address, if: :use_shipping?before_validation :resolve_market_from_currency, if: -> { persisted? && currency_changed? && !skip_market_resolution }@@ -198,8 +200,17 @@ module Spree@updater ||= Spree::CartUpdater.new(self)end+ # Recomputes and persists money totals (item, tax, promotion, delivery)+ # and derived item counts. Convenience for+ # {Spree::Carts::RecalculateTotals}.+ def recalculate_totals!+ Spree::Carts::RecalculateTotals.call(cart: self)+ end++ # @deprecated Use {#recalculate_totals!}; removed in 6.1.def update_with_updater!- updater.update+ Spree::Deprecation.warn('Spree::Cart#update_with_updater! is deprecated and will be removed in Spree 6.1. Use #recalculate_totals! instead.')+ recalculate_totals!end# The address tax is computed against, honoring the tax_using_ship_address@@ -223,6 +234,10 @@ module Spreebill_address == ship_addressend+ def use_shipping?+ use_shipping.in?([true, 'true', '1'])+ end+def quantityline_items.sum(:quantity)end@@ -364,7 +379,7 @@ module Spreeline_items.reload.each(&:update_price)rebuild_fulfillments!set_fulfillments_cost- update_with_updater!+ recalculate_totals!end# Duck-type parity with the order-side inventory hooks: carts have no@@ -550,6 +565,12 @@ module Spreeprivate+ # Same-object copy as Spree::Order — the two FKs share one address row.+ def clone_shipping_address+ self.bill_address = ship_address if ship_address+ true+ end+def currency_must_be_supported_by_storereturn if currency.blank? || store.blank?diff --git a/spree/core/app/models/spree/cart_updater.rb b/spree/core/app/models/spree/cart_updater.rbindex 9bb6af6879..776ba56926 100644--- a/spree/core/app/models/spree/cart_updater.rb+++ b/spree/core/app/models/spree/cart_updater.rb@@ -6,15 +6,6 @@ module Spreeclass CartUpdater < OrderUpdateralias cart order- def update- cart.association(:line_items).reset if cart.persisted?- cart.association(:fulfillments).reset if cart.persisted?-- update_item_count- update_totals- persist_totals- end-def update_payment_totalcart.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }enddiff --git a/spree/core/app/models/spree/fulfillment.rb b/spree/core/app/models/spree/fulfillment.rbindex 28027f6d50..2632421978 100644--- a/spree/core/app/models/spree/fulfillment.rb+++ b/spree/core/app/models/spree/fulfillment.rb@@ -674,7 +674,7 @@ module Spree# replacement) and completed orders are frozen.return if previously_new_record?- owner.update_with_updater! if saved_change_to_cost? && status != 'fulfilled' && owner&.persisted? && !owner.completed?+ owner.recalculate_totals! if saved_change_to_cost? && status != 'fulfilled' && owner&.persisted? && !owner.completed?endendenddiff --git a/spree/core/app/models/spree/fulfillment_changer.rb b/spree/core/app/models/spree/fulfillment_changer.rbindex 9f975399e9..d17121991d 100644--- a/spree/core/app/models/spree/fulfillment_changer.rb+++ b/spree/core/app/models/spree/fulfillment_changer.rb@@ -118,7 +118,7 @@ module Spreedesired_shipment.update_amountsdesired_shipment.order.reload- desired_shipment.order.update_with_updater!+ desired_shipment.order.recalculate_totals!enddef new_on_hand_quantitydiff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rbindex 6e725b6f5b..d3e488e452 100644--- a/spree/core/app/models/spree/order.rb+++ b/spree/core/app/models/spree/order.rb@@ -75,7 +75,7 @@ module Spree# would drop warnings already recorded upstream.def remove_out_of_stock_items!existing_warnings = warnings- result = Spree::Carts::RemoveOutOfStockItems.call(order: self)+ result = Spree::Carts::RemoveOutOfStockItems.call(cart: self)return self unless result.success?order, _messages, new_warnings = result.value@@ -539,8 +539,17 @@ module Spree@updater ||= Spree.order_updater.new(self)end+ # Recomputes and persists money totals (item, tax, promotion, delivery)+ # and derived item counts. Convenience for+ # {Spree::Orders::RecalculateTotals}.+ def recalculate_totals!+ Spree::Orders::RecalculateTotals.call(order: self)+ end++ # @deprecated Use {#recalculate_totals!}; removed in 6.1.def update_with_updater!- updater.update+ Spree::Deprecation.warn('Spree::Order#update_with_updater! is deprecated and will be removed in Spree 6.1. Use #recalculate_totals! instead.')+ recalculate_totals!end# @deprecated Use {Spree::Carts::Merge}; removed in 6.1.@@ -598,7 +607,7 @@ module Spree# @param override_email [Boolean] whether to override the order email with the user's email# @return [Spree::ServiceModule::Result]def associate_user!(user, override_email = true)- Spree.cart_associate_service.call(guest_order: self, user: user, override_email: override_email)+ Spree.cart_associate_service.call(guest_cart: self, user: user, override_email: override_email)enddef disassociate_user!@@ -905,7 +914,7 @@ module Spreedef apply_free_shipping_promotionsSpree::PromotionHandler::FreeShipping.new(self).activate- update_with_updater!+ recalculate_totals!end# Applies user promotions when login after filling the cart@@ -1196,7 +1205,7 @@ module Spreepayments.store_credits.pending.each(&:void!)end- update_with_updater!+ recalculate_totals!send_order_canceled_webhookenddiff --git a/spree/core/app/models/spree/order/currency_updater.rb b/spree/core/app/models/spree/order/currency_updater.rbindex 5ba1469021..199f5997ef 100644--- a/spree/core/app/models/spree/order/currency_updater.rb+++ b/spree/core/app/models/spree/order/currency_updater.rb@@ -6,7 +6,7 @@ module Spreeincluded dodef homogenize_line_item_currenciesupdate_line_item_currencies!- update_with_updater!+ recalculate_totals!endenddiff --git a/spree/core/app/models/spree/order_merger.rb b/spree/core/app/models/spree/order_merger.rbindex eeeee9a713..1aa87b69e4 100644--- a/spree/core/app/models/spree/order_merger.rb+++ b/spree/core/app/models/spree/order_merger.rb@@ -74,7 +74,7 @@ module Spreeenddef persist_merge- updater.update+ Spree::Orders::RecalculateTotals.call(order: order)enddef handle_gift_card(other_order)diff --git a/spree/core/app/models/spree/order_updater.rb b/spree/core/app/models/spree/order_updater.rbindex f8012064a4..1234734865 100644--- a/spree/core/app/models/spree/order_updater.rb+++ b/spree/core/app/models/spree/order_updater.rb@@ -1,4 +1,9 @@module Spree+ # Granular money calculator for orders (Spree::CartUpdater covers carts).+ # The full-recalculation sequence is owned by+ # Spree::Carts::RecalculateTotals / Spree::Orders::RecalculateTotals —+ # this class provides the individual computations those steps (and a few+ # surgical partial-update call sites) invoke.class OrderUpdaterattr_reader :orderdelegate :payments, :line_items, :fulfillments, :update_hooks, :quantity, to: :order@@ -7,29 +12,14 @@ module Spree@order = orderend- # This is a multi-purpose method for processing logic related to changes in the Order.- # It is meant to be called from various observers so that the Order is aware of changes- # that affect totals and other values stored in the Order.- #- # This method should never do anything to the Order that results in a save call on the- # object with callbacks (otherwise you will end up in an infinite recursion as the- # associations try to save and then in turn try to call +update!+ again.)+ # @deprecated Use {Spree::Orders::RecalculateTotals} /+ # {Spree::Carts::RecalculateTotals} (or the model's+ # #recalculate_totals! convenience); removed in 6.1. The full+ # recalculation sequence lives in that flow — this class is the+ # granular calculator behind it.def update- # Drop possibly stale association caches — an earlier recalculation on- # this instance may have loaded them mid-mutation.- order.association(:line_items).reset if order.persisted?- order.association(:fulfillments).reset if order.persisted?-- update_item_count- update_totals- if order.completed?- update_payment_state- update_fulfillments- update_fulfillment_status- update_delivery_total- end- run_hooks- persist_totals+ Spree::Deprecation.warn('Spree::OrderUpdater#update is deprecated and will be removed in Spree 6.1. Use Spree::Orders::RecalculateTotals / Spree::Carts::RecalculateTotals (or #recalculate_totals!) instead.')+ Spree::Carts::RecalculateTotals.call(cart: order)enddef run_hooksdiff --git a/spree/core/app/models/spree/promotion.rb b/spree/core/app/models/spree/promotion.rbindex f982c0f191..eec48e1f76 100644--- a/spree/core/app/models/spree/promotion.rb+++ b/spree/core/app/models/spree/promotion.rb@@ -203,7 +203,7 @@ module Spreeaction_takenend- # called anytime order.update_with_updater! happens+ # called anytime order.recalculate_totals! happensdef eligible?(promotable, options = {})return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)diff --git a/spree/core/app/models/spree/promotion_handler/coupon.rb b/spree/core/app/models/spree/promotion_handler/coupon.rbindex 6184a661ff..817b58da3a 100644--- a/spree/core/app/models/spree/promotion_handler/coupon.rb+++ b/spree/core/app/models/spree/promotion_handler/coupon.rb@@ -77,7 +77,7 @@ module Spreeremove_promotion_adjustments(promotion)remove_promotion_line_items(promotion)- order.update_with_updater!+ order.recalculate_totals!set_success_code :adjustments_deletedelse@@ -208,7 +208,7 @@ module Spreeif discount || created_line_itemshandle_coupon_code(discount, coupon_code) if discount- order.update_with_updater!+ order.recalculate_totals!set_success_code :coupon_code_appliedelsif order.promotions.with_coupon_code(order.coupon_code)# since CouponCode is disposable...diff --git a/spree/core/app/models/spree/refund.rb b/spree/core/app/models/spree/refund.rbindex 8bad961f41..e7764693ea 100644--- a/spree/core/app/models/spree/refund.rb+++ b/spree/core/app/models/spree/refund.rb@@ -131,7 +131,7 @@ module Spreeenddef update_order- payment.order.updater.update+ payment.order.recalculate_totals!endendenddiff --git a/spree/core/app/services/spree/carts/add_item.rb b/spree/core/app/services/spree/carts/add_item.rbdeleted file mode 100644index e1dc25d1bc..0000000000--- a/spree/core/app/services/spree/carts/add_item.rb+++ /dev/null@@ -1,67 +0,0 @@-module Spree- module Carts- class AddItem- prepend Spree::ServiceModule::Base-- def call(cart: nil, order: nil, variant: nil, quantity: nil, metadata: {}, public_metadata: {}, private_metadata: {}, options: {})- if order- Spree::Deprecation.warn('Calling Spree::Carts::AddItem with order: is deprecated and will be removed in Spree 6.1. Pass cart: instead.')- cart ||= order- end- rewrite_input!(remove: [:order], cart: cart)- ApplicationRecord.transaction do- run :add_to_line_item- run :handle_stock_reservations- run Spree.cart_recalculate_service- end- end-- private-- def add_to_line_item(cart:, variant:, quantity: nil, metadata: {}, public_metadata: {}, private_metadata: {}, options: {})- options ||= {}- quantity ||= 1-- return failure(variant, "#{variant.name} is not available in #{cart.currency}") if variant.amount_in(cart.currency).nil?-- line_item = Spree.line_item_by_variant_finder.new.execute(cart: cart, variant: variant, options: options)-- line_item_created = line_item.nil?- if line_item.nil?- opts = ::Spree::PermittedAttributes.line_item_attributes.flatten.each_with_object({}) do |attribute, result|- result[attribute] = options[attribute]- end.merge(currency: cart.currency).delete_if { |_key, value| value.nil? }-- line_item = cart.line_items.new(quantity: quantity,- variant: variant,- options: opts)- else- line_item.quantity += quantity.to_i- end--- # `metadata` is the primary API param (maps to private_metadata).- # Legacy `public_metadata`/`private_metadata` params kept for backward compatibility.- resolved_metadata = metadata.presence || private_metadata- line_item.metadata = resolved_metadata.to_h if resolved_metadata.present?- line_item.public_metadata = public_metadata.to_h if public_metadata.present?-- return failure(line_item) unless line_item.save-- line_item.reload.recalculate_price-- ::Spree.tax_provider.estimate(line_item.owner, [line_item]) if line_item_created- success(cart: cart, line_item: line_item, line_item_created: line_item_created, options: options)- end-- def handle_stock_reservations(cart:, line_item:, line_item_created:, options:)- if cart.in_checkout?- result = Spree::StockReservations::Reserve.call(cart: cart)- return failure(line_item, result.error) if result.failure?- end-- success(cart: cart, line_item: line_item, line_item_created: line_item_created, options: options)- end- end- end-enddiff --git a/spree/core/app/services/spree/carts/merge.rb b/spree/core/app/services/spree/carts/merge.rbindex f8a6056e57..cec52bef9e 100644--- a/spree/core/app/services/spree/carts/merge.rb+++ b/spree/core/app/services/spree/carts/merge.rb@@ -33,7 +33,7 @@ module Spreeother_cart.reload.destroy! if other_cart.line_items.reload.empty?end- cart.update_with_updater!+ cart.recalculate_totals!success(cart)endenddiff --git a/spree/core/app/services/spree/carts/recalculate.rb b/spree/core/app/services/spree/carts/recalculate.rbdeleted file mode 100644index 71006eda74..0000000000--- a/spree/core/app/services/spree/carts/recalculate.rb+++ /dev/null@@ -1,31 +0,0 @@-module Spree- module Carts- class Recalculate- prepend Spree::ServiceModule::Base-- def call(cart: nil, order: nil, line_item: nil, line_item_created: false, options: {})- if order- Spree::Deprecation.warn('Calling Spree::Carts::Recalculate with order: is deprecated and will be removed in Spree 6.1. Pass cart: instead.')- cart ||= order- end- order_updater = cart.updater-- cart.remove_gift_card if cart.gift_card.present?- cart.payments.store_credits.checkout.destroy_all if cart.payments.store_credits.checkout.any?- # Totals must be current before the proposal rebuild — delivery rate- # calculators (e.g. price sack) read them.- order_updater.update_item_count- order_updater.update_totals- order_updater.persist_totals-- cart.ensure_updated_fulfillments-- ::Spree::PromotionHandler::Cart.new(cart, line_item).activate- # Typed rows (discounts + tax) are rebuilt by the order-level- # recalculation inside the updater.- order_updater.update- success(line_item)- end- end- end-enddiff --git a/spree/core/app/services/spree/carts/update.rb b/spree/core/app/services/spree/carts/update.rbindex 9cab09b23a..d063d31dfc 100644--- a/spree/core/app/services/spree/carts/update.rb+++ b/spree/core/app/services/spree/carts/update.rb@@ -139,10 +139,10 @@ module Spreecart.create_proposed_fulfillmentscart.set_shipments_costend- cart.update_with_updater!+ cart.recalculate_totals!endelse- cart.update_with_updater!+ cart.recalculate_totals!endrescue StandardError => eRails.error.report(e, context: { order_id: cart.id }, source: 'spree.checkout')diff --git a/spree/core/app/services/spree/carts/upsert_items.rb b/spree/core/app/services/spree/carts/upsert_items.rbindex 43aa4ea470..7c55188070 100644--- a/spree/core/app/services/spree/carts/upsert_items.rb+++ b/spree/core/app/services/spree/carts/upsert_items.rb@@ -49,7 +49,7 @@ module Spreereturn failure(line_item) unless line_item.saveend- cart.update_with_updater!+ cart.recalculate_totals!endsuccess(cart)diff --git a/spree/core/app/services/spree/checkout/advance.rb b/spree/core/app/services/spree/checkout/advance.rbindex dfd61ae933..45de3baac1 100644--- a/spree/core/app/services/spree/checkout/advance.rb+++ b/spree/core/app/services/spree/checkout/advance.rb@@ -21,7 +21,7 @@ module Spreereturn result if result.failure?end- cart.update_with_updater!+ cart.recalculate_totals!success(cart)endenddiff --git a/spree/core/app/services/spree/checkout/select_shipping_method.rb b/spree/core/app/services/spree/checkout/select_shipping_method.rbindex 8b77491add..637dcf8e83 100644--- a/spree/core/app/services/spree/checkout/select_shipping_method.rb+++ b/spree/core/app/services/spree/checkout/select_shipping_method.rb@@ -36,9 +36,9 @@ module Spreeend# Note: selected_shipping_rate_id= now automatically updates order totals,- # but we still need update_with_updater! here because Checkout::Advance+ # but we still need recalculate_totals! here because Checkout::Advance# expects the full updater to run (including state updates) when this service succeeds.- order.update_with_updater!+ order.recalculate_totals!success(order)enddiff --git a/spree/core/app/services/spree/fulfillments/create.rb b/spree/core/app/services/spree/fulfillments/create.rbindex fcf22468eb..1b5c973f6c 100644--- a/spree/core/app/services/spree/fulfillments/create.rb+++ b/spree/core/app/services/spree/fulfillments/create.rb@@ -15,9 +15,10 @@ module Spree## The resulting cost is frozen only for fulfillments registered with# status: 'shipped' (rate refresh skips shipped shipments). Pending/ready- # fulfillments participate in the standard rate machinery — the order- # updater re-prices them from the delivery method calculators on the next- # recalculation, exactly like shipments created via split/transfer.+ # fulfillments participate in the standard rate machinery — this service+ # re-prices them from the delivery method calculators before the final+ # totals recalculation (repricing a completed order's delivery is an+ # explicit post-placement edit, never a side effect of a totals refresh).class Createprepend Spree::ServiceModule::Base@@ -77,7 +78,8 @@ module Spreefulfillment.update!(order)end- order.reload.update_with_updater!+ reprice_pending_fulfillments(order.reload)+ order.recalculate_totals!endsuccess(fulfillment.reload)@@ -85,6 +87,19 @@ module Spreeprivate+ # Moved here from the old updater completed-order branch: pending/ready+ # fulfillments re-price from backoffice-visible delivery methods;+ # fulfilled ones keep their frozen cost.+ def reprice_pending_fulfillments(order)+ order.fulfillments.each do |fulfillment|+ next unless fulfillment.persisted?+ next if fulfillment.fulfilled?++ fulfillment.refresh_rates(Spree::DeliveryMethod::DISPLAY_ON_BACK_END)+ fulfillment.update_amounts+ end+ end+# Units that can still be moved into a manual fulfillment: on-hand or# backordered units sitting in shipments that haven't shipped or been# canceled (canceled shipments already restocked their stock). Loadeddiff --git a/spree/core/app/services/spree/gift_cards/apply.rb b/spree/core/app/services/spree/gift_cards/apply.rbindex acfd39b19b..39ea7827c8 100644--- a/spree/core/app/services/spree/gift_cards/apply.rb+++ b/spree/core/app/services/spree/gift_cards/apply.rb@@ -54,7 +54,7 @@ module Spreestate: 'checkout',response_code: store_credit.generate_authorization_code)- order.update_with_updater!+ order.recalculate_totals!endsuccess(order.reload)diff --git a/spree/core/app/services/spree/gift_cards/remove.rb b/spree/core/app/services/spree/gift_cards/remove.rbindex 86ed7f1c1d..66114e50a2 100644--- a/spree/core/app/services/spree/gift_cards/remove.rb+++ b/spree/core/app/services/spree/gift_cards/remove.rb@@ -29,7 +29,7 @@ module Spreeendorder.update!(gift_card: nil)- order.update_with_updater!+ order.recalculate_totals!endsuccess(true)diff --git a/spree/core/app/services/spree/orders/add_item.rb b/spree/core/app/services/spree/orders/add_item.rbdeleted file mode 100644index 18d0b795c1..0000000000--- a/spree/core/app/services/spree/orders/add_item.rb+++ /dev/null@@ -1,13 +0,0 @@-module Spree- module Orders- # Draft-order twin of the cart item service. Identical mechanics today;- # exists so cart-only behavior (stock reservations, checkout warnings)- # and draft-order behavior can diverge without branching one service.- # Speaks order: on the outside, maps onto the shared cart pipeline.- class AddItem < Spree::Carts::AddItem- def call(order: nil, **kwargs)- super(cart: order, **kwargs)- end- end- end-enddiff --git a/spree/core/app/services/spree/orders/create.rb b/spree/core/app/services/spree/orders/create.rbindex 9dd0e3ba02..c7200e0a56 100644--- a/spree/core/app/services/spree/orders/create.rb+++ b/spree/core/app/services/spree/orders/create.rb@@ -35,7 +35,7 @@ module Spreeadd_items(order) if @params[:items].present?build_fulfillments(order)apply_coupon(order) if @params[:coupon_code].present?- order.update_with_updater!+ order.recalculate_totals!endsuccess(order.reload)diff --git a/spree/core/app/services/spree/orders/recalculate.rb b/spree/core/app/services/spree/orders/recalculate.rbdeleted file mode 100644index a453be0755..0000000000--- a/spree/core/app/services/spree/orders/recalculate.rb+++ /dev/null@@ -1,10 +0,0 @@-module Spree- module Orders- # Draft-order twin of cart recalculation — see Orders::AddItem.- class Recalculate < Spree::Carts::Recalculate- def call(order: nil, **kwargs)- super(cart: order, **kwargs)- end- end- end-enddiff --git a/spree/core/app/services/spree/orders/remove_item.rb b/spree/core/app/services/spree/orders/remove_item.rbindex c6b70041ac..626af30e10 100644--- a/spree/core/app/services/spree/orders/remove_item.rb+++ b/spree/core/app/services/spree/orders/remove_item.rb@@ -1,9 +1,12 @@module Spreemodule Orders- # Draft-order twin of the cart item-removal service — see Orders::AddItem.- class RemoveItem < Spree::Carts::RemoveItem- def call(order: nil, **kwargs)- super(cart: order, **kwargs)+ # Draft-order twin of the cart service — order: is the canonical keyword+ # on this side, delegating onto the shared implementation.+ class RemoveItem+ prepend Spree::ServiceModule::Base++ def call(order:, variant:, quantity: nil, options: {})+ Spree::Carts::RemoveItem.call(cart: order, variant: variant, quantity: quantity, options: options)endendenddiff --git a/spree/core/app/services/spree/orders/remove_line_item.rb b/spree/core/app/services/spree/orders/remove_line_item.rbindex 8bf4e11c1f..4e841c378d 100644--- a/spree/core/app/services/spree/orders/remove_line_item.rb+++ b/spree/core/app/services/spree/orders/remove_line_item.rb@@ -1,9 +1,12 @@module Spreemodule Orders- # Draft-order twin of the cart removal service — see Orders::AddItem.- class RemoveLineItem < Spree::Carts::RemoveLineItem- def call(order: nil, **kwargs)- super(cart: order, **kwargs)+ # Draft-order twin of the cart service — order: is the canonical keyword+ # on this side, delegating onto the shared implementation.+ class RemoveLineItem+ prepend Spree::ServiceModule::Base++ def call(order:, line_item:, options: {})+ Spree::Carts::RemoveLineItem.call(cart: order, line_item: line_item, options: options)endendenddiff --git a/spree/core/app/services/spree/orders/update.rb b/spree/core/app/services/spree/orders/update.rbindex 351efcd40b..84455fdb84 100644--- a/spree/core/app/services/spree/orders/update.rb+++ b/spree/core/app/services/spree/orders/update.rb@@ -27,7 +27,7 @@ module Spreebuild_fulfillmentsend- @order.update_with_updater!+ @order.recalculate_totals!endsuccess(@order.reload)diff --git a/spree/core/app/services/spree/orders/upsert_items.rb b/spree/core/app/services/spree/orders/upsert_items.rbindex c6d05cbc82..2677fa68b7 100644--- a/spree/core/app/services/spree/orders/upsert_items.rb+++ b/spree/core/app/services/spree/orders/upsert_items.rb@@ -10,7 +10,7 @@ module Spree## Order totals are NOT recalculated here. Callers (Spree::Orders::Create# and Spree::Orders::Update) are responsible for running shipment- # rebuilding and a final `order.update_with_updater!` once their+ # rebuilding and a final `order.recalculate_totals!` once their# full pipeline (items, shipments, coupons) has run.class UpsertItemsprepend Spree::ServiceModule::Basediff --git a/spree/core/app/workflows/spree/carts/add_item.rb b/spree/core/app/workflows/spree/carts/add_item.rbnew file mode 100644index 0000000000..30e753fff1--- /dev/null+++ b/spree/core/app/workflows/spree/carts/add_item.rb@@ -0,0 +1,64 @@+module Spree+ module Carts+ class AddItem < Spree::Workflow+ argument :cart, [Spree::Cart, Spree::Order]+ argument :variant, Spree::Variant+ argument :quantity, default: nil+ argument :metadata, default: {}+ argument :public_metadata, default: {}+ argument :private_metadata, default: {}+ argument :options, default: {}+ alias_argument order: :cart, deprecated: true+ returns :line_item++ transaction do+ step :add_to_line_item, provides: [:line_item, :line_item_created]+ step :handle_stock_reservations, if: -> { cart.in_checkout? }+ step :recalculate, with: -> { Spree.cart_recalculate_service }+ run_hooks :after_item_added+ end++ private++ def add_to_line_item+ item_options = options || {}+ requested_quantity = quantity || 1++ return failure(variant, "#{variant.name} is not available in #{cart.currency}") if variant.amount_in(cart.currency).nil?++ line_item = Spree.line_item_by_variant_finder.new.execute(cart: cart, variant: variant, options: item_options)++ line_item_created = line_item.nil?+ if line_item.nil?+ opts = ::Spree::PermittedAttributes.line_item_attributes.flatten.each_with_object({}) do |attribute, result|+ result[attribute] = item_options[attribute]+ end.merge(currency: cart.currency).delete_if { |_key, value| value.nil? }++ line_item = cart.line_items.new(quantity: requested_quantity,+ variant: variant,+ options: opts)+ else+ line_item.quantity += requested_quantity.to_i+ end++ # `metadata` is the primary API param (maps to private_metadata).+ # Legacy `public_metadata`/`private_metadata` params kept for backward compatibility.+ resolved_metadata = metadata.presence || private_metadata+ line_item.metadata = resolved_metadata.to_h if resolved_metadata.present?+ line_item.public_metadata = public_metadata.to_h if public_metadata.present?++ return failure(line_item) unless line_item.save++ line_item.reload.recalculate_price++ ::Spree.tax_provider.estimate(line_item.owner, [line_item]) if line_item_created+ { line_item: line_item, line_item_created: line_item_created }+ end++ def handle_stock_reservations+ result = Spree::StockReservations::Reserve.call(cart: cart)+ return failure(line_item, result.error) if result.failure?+ end+ end+ end+enddiff --git a/spree/core/app/services/spree/carts/complete.rb b/spree/core/app/workflows/spree/carts/complete.rbsimilarity index 60%rename from spree/core/app/services/spree/carts/complete.rbrename to spree/core/app/workflows/spree/carts/complete.rbindex 3eaeb4bdaf..8fcf6696b0 100644--- a/spree/core/app/services/spree/carts/complete.rb+++ b/spree/core/app/workflows/spree/carts/complete.rb@@ -1,95 +1,161 @@module Spreemodule Carts- # Completes a cart into an immutable order — a three-phase pipeline with+ # Completes a cart into an immutable order — a three-phase flow with# explicit transaction boundaries. External payment I/O never runs inside# a DB transaction; everything after a successful charge is small,# idempotent and resumable (docs/plans/6.0-cart-order-split.md).#- # PREPARE (txn) replay → lock → in-lock recalculation → drift guard →- # validate → draft order + copies (unique orders.cart_id)- # PAYMENT offline methods collapse into FINALIZE; external- # gateways run outside any txn with compensation- # FINALIZE (txn) inventory + counters + draft→placed + cart.completed_at- # + RecomputeStatuses; events after commit- class Complete- prepend Spree::ServiceModule::Base-+ # PREPARE (txn, cart lock) replay → TTL guard → in-lock recalculation+ # → drift guard → validate → draft order ++ # copies (unique orders.cart_id)+ # PAYMENT (external_step) offline methods collapse into FINALIZE;+ # gateways run outside any txn — a+ # pre-capture failure triggers the armed+ # on_flow_failure compensation+ # FINALIZE (own txn) inventory + counters + draft→placed ++ # cart.completed_at + RecomputeStatuses;+ # events after commit+ class Complete < Spree::WorkflowCOMPLETING_TTL = 5.minutes- def call(cart:, expected_total: nil, payment_pending: false)- # Legacy signature bridge: completing an already-created draft order- # (admin/B2B path) funnels through the same finalize semantics.- return complete_order(cart, payment_pending: payment_pending) if cart.is_a?(Spree::Order)+ argument :cart, [Spree::Cart, Spree::Order]+ argument :expected_total, default: nil+ argument :payment_pending, :boolean, default: false+ returns :order- # P1 — replay: a double-clicked Place Order must get the order back- if (existing = completion_result(cart))- return finalize_or_return(cart, existing)- end+ # Concurrent completion lost the unique orders.cart_id race — re-enter+ # the flow: the replay step returns the winner's order (or the TTL+ # guard reports completion_in_progress).+ rescue_from ActiveRecord::RecordNotUnique do |_error|+ self.class.call(cart: cart.reload, expected_total: expected_total, payment_pending: payment_pending)+ end- order = nil+ # Legacy signature bridge: completing an already-created draft order+ # (admin/B2B path) funnels through the same finalize semantics.+ step :complete_draft_order, if: -> { cart.is_a?(Spree::Order) },+ provides: [:draft_completion], halt_with: :draft_completion++ # P1 — replay: a double-clicked Place Order must get the order back.+ step :replay_completed, provides: [:replayed], halt_with: :replayed++ transaction lock: :cart do+ step :guard_concurrent_completion+ step :recalculate_in_lock+ step :verify_expected_total+ step :validate_cart+ step :mark_completing+ step :create_draft_order, provides: [:order], on_flow_failure: :rollback_draft_order+ end- # PHASE P — PREPARE- cart.with_lock do- if cart.completing? && cart.completing_at > COMPLETING_TTL.ago- return failure(cart, code: 'completion_in_progress')- end+ external_step :process_payments, if: -> { order.payment_required? && !payment_covered?(order) }- # In-lock recalculation — the totals about to be charged are- # computed here, not trusted from earlier requests- cart.update_with_updater!+ run_hooks :before_finalize+ step :finalize_completion- if expected_total.present? && BigDecimal(expected_total.to_s) != cart.total- return failure(cart, code: 'cart_changed', current_total: cart.total)- end+ private++ # Admin/B2B draft orders bypass the cart but reuse the same finalize+ # semantics (idempotency + inventory + reservation release in one home).+ def complete_draft_order+ order = cart+ return { draft_completion: order } if order.completed?+ return failure(order, 'Order is canceled') if order.canceled?++ order.with_lock do+ skip_payments = payment_pending || !order.payment_required?+ order.process_payments! if !skip_payments && !payment_covered?(order)- validation = Spree::Carts::Validate.new.errors_for(cart)- return failure(cart, code: 'validation_failed', errors: validation) if validation.any?+ return failure(order, order.errors.full_messages.to_sentence) if order.errors.any?+ return failure(order, Spree.t(:payment_processing_failed)) if !skip_payments && !payment_covered?(order)- cart.update_columns(completing_at: Time.current)- order = create_draft_order!(cart)+ order.finalize! unless order.completed?+ Spree::StockReservations::Release.call(owner: order)+ Spree::Orders::RecomputeStatuses.call(order: order)end- # PHASE Y — PAYMENT (external I/O outside any transaction)- if order.payment_required? && !payment_covered?(order)- begin- order.process_payments!- rescue Spree::Core::GatewayError => e- return compensate!(cart, order, e.message)- end+ { draft_completion: order }+ end- unless payment_covered?(order)- return compensate!(cart, order, order.errors.full_messages.to_sentence.presence || Spree.t(:payment_processing_failed))- end+ # A draft here means a previous attempt died mid-pipeline — re-verify+ # payment coverage, then re-run FINALIZE (idempotent).+ def replay_completed+ order = completion_result(cart)+ return if order.nil?+ return { replayed: order } if order.placed? || order.canceled?++ if order.payment_required? && !payment_covered?(order)+ return failure(cart, code: 'payment_failed', message: Spree.t(:payment_processing_failed))end- # PHASE F — FINALIZEfinalize!(cart, order)- success(order)- rescue ActiveRecord::RecordNotUnique- # Concurrent completion won the unique orders.cart_id race — replay- retry_result = completion_result(cart.reload)- retry_result ? finalize_or_return(cart, retry_result) : failure(cart, code: 'completion_in_progress')+ { replayed: order }end- private-- # Exactly one of cart.order (single partition) or, later, the- # multi-vendor order group.- def completion_result(cart)- cart.order+ def guard_concurrent_completion+ failure(cart, code: 'completion_in_progress') if cart.completing? && cart.completing_at > COMPLETING_TTL.agoend- def finalize_or_return(cart, order)- return success(order) if order.placed? || order.canceled?+ # In-lock recalculation — the totals about to be charged are computed+ # here, not trusted from earlier requests.+ def recalculate_in_lock+ cart.recalculate_totals!+ end- # Draft order exists — a previous attempt died mid-pipeline. Resume:- # re-verify payment coverage, then re-run FINALIZE (idempotent).- if order.payment_required? && !payment_covered?(order)- return failure(cart, code: 'payment_failed', message: Spree.t(:payment_processing_failed))+ def verify_expected_total+ if expected_total.present? && BigDecimal(expected_total.to_s) != cart.total+ failure(cart, code: 'cart_changed', current_total: cart.total)end+ end+ def validate_cart+ validation = Spree::Carts::Validate.new.errors_for(cart)+ failure(cart, code: 'validation_failed', errors: validation) if validation.any?+ end++ def mark_completing+ cart.update_columns(completing_at: Time.current)+ end++ def create_draft_order+ { order: create_draft_order!(cart) }+ end++ def process_payments+ order.process_payments!+ return if payment_covered?(order)++ failure(cart, code: 'payment_failed',+ message: order.errors.full_messages.to_sentence.presence || Spree.t(:payment_processing_failed))+ rescue Spree::Core::GatewayError => e+ failure(cart, code: 'payment_failed', message: e.message)+ end++ def finalize_completionfinalize!(cart, order)- success(order)+ end++ # Y3 — armed when PREPARE commits; a pre-capture payment failure pops+ # it. Post-capture (or covered net-terms) failures must resume through+ # the sweeper instead — the draft is never destroyed once money moved+ # or completion could still finalize.+ def rollback_draft_order+ return if order.nil?+ return if order.payments.valid.completed.any? || payment_covered?(order)++ ApplicationRecord.transaction do+ order.payments.update_all(order_id: nil, cart_id: cart.id)+ order.payment_sessions.update_all(order_id: nil, cart_id: cart.id)+ order.stock_reservations.update_all(order_id: nil, cart_id: cart.id)+ Spree::CouponCode.where(order_id: order.id).update_all(order_id: nil, cart_id: cart.id)+ order.reload.destroy!+ cart.update_columns(completing_at: nil)+ end+ end++ # Exactly one of cart.order (single partition) or, later, the+ # multi-vendor order group.+ def completion_result(cart)+ cart.orderend# P7 — the copy contract: the order receives copies (line items with@@ -221,22 +287,6 @@ module Spreeorder.payments.valid.where(state: %w[pending processing completed]).sum(:amount) >= order.totalend- # Y3 — only pre-capture failures compensate; post-capture failures- # resume through the sweeper, never destroy the order.- def compensate!(cart, order, message)- if order.payments.valid.completed.none?- ApplicationRecord.transaction do- order.payments.update_all(order_id: nil, cart_id: cart.id)- order.payment_sessions.update_all(order_id: nil, cart_id: cart.id)- order.stock_reservations.update_all(order_id: nil, cart_id: cart.id)- Spree::CouponCode.where(order_id: order.id).update_all(order_id: nil, cart_id: cart.id)- order.reload.destroy!- cart.update_columns(completing_at: nil)- end- end- failure(cart, code: 'payment_failed', message: message)- end-def finalize!(cart, order)ApplicationRecord.transaction doorder.finalize! unless order.placed?@@ -251,29 +301,6 @@ module Spreedef mark_coupon_codes_used!(_cart, order)Spree::CouponCode.where(order_id: order.id).unused.update_all(state: 1)end-- # Admin/B2B draft orders bypass the cart but reuse the same finalize- # semantics (idempotency + inventory + reservation release in one home).- def complete_order(order, payment_pending: false)- return success(order) if order.completed?- return failure(order, 'Order is canceled') if order.canceled?-- order.with_lock do- skip_payments = payment_pending || !order.payment_required?- order.process_payments! if !skip_payments && !payment_covered?(order)-- return failure(order, order.errors.full_messages.to_sentence) if order.errors.any?-- if !skip_payments && !payment_covered?(order)- return failure(order, Spree.t(:payment_processing_failed))- end-- order.finalize! unless order.completed?- Spree::StockReservations::Release.call(owner: order)- Spree::Orders::RecomputeStatuses.call(order: order)- success(order)- end- endendendenddiff --git a/spree/core/app/workflows/spree/carts/recalculate.rb b/spree/core/app/workflows/spree/carts/recalculate.rbnew file mode 100644index 0000000000..42a61c6e8b--- /dev/null+++ b/spree/core/app/workflows/spree/carts/recalculate.rb@@ -0,0 +1,43 @@+module Spree+ module Carts+ class Recalculate < Spree::Workflow+ argument :cart, [Spree::Cart, Spree::Order]+ argument :line_item, Spree::LineItem, default: nil+ argument :line_item_created, :boolean, default: false+ argument :options, default: {}+ alias_argument order: :cart, deprecated: true+ returns :line_item++ step :unapply_stale_payment_sources+ step :refresh_totals+ step :rebuild_delivery_proposals+ step :activate_promotions+ # Typed rows (discounts + tax) are rebuilt by the full recalculation.+ step :final_recalculation, with: -> { Spree::Carts::RecalculateTotals }++ private++ def unapply_stale_payment_sources+ cart.remove_gift_card if cart.gift_card.present?+ cart.payments.store_credits.checkout.destroy_all if cart.payments.store_credits.checkout.any?+ end++ # Totals must be current before the proposal rebuild — delivery rate+ # calculators (e.g. price sack) read them.+ def refresh_totals+ updater = cart.updater+ updater.update_item_count+ updater.update_totals+ updater.persist_totals+ end++ def rebuild_delivery_proposals+ cart.ensure_updated_fulfillments+ end++ def activate_promotions+ ::Spree::PromotionHandler::Cart.new(cart, line_item).activate+ end+ end+ end+enddiff --git a/spree/core/app/workflows/spree/carts/recalculate_totals.rb b/spree/core/app/workflows/spree/carts/recalculate_totals.rbnew file mode 100644index 0000000000..428328e1b4--- /dev/null+++ b/spree/core/app/workflows/spree/carts/recalculate_totals.rb@@ -0,0 +1,50 @@+module Spree+ module Carts+ # Money recalculation — item counts, money totals (with the+ # typed-adjustment two-pass), one update_columns persist. Money ONLY: payment_status/fulfillment_status (and the+ # legacy payment_state column) are written exclusively by+ # Spree::Orders::RecomputeStatuses, triggered from+ # Spree::OrderStatusSubscriber on payment/refund/fulfillment/return+ # events; completed-order fulfillment repricing belongs to the explicit+ # post-placement edit path, never to a totals refresh.+ #+ # Granular math stays on the calculator objects (Spree::OrderUpdater /+ # Spree::CartUpdater, resolved polymorphically via the model's #updater);+ # this service owns the sequence. Callers use this service (or the+ # model's #recalculate_totals! convenience) — never the calculator's+ # #update, which is deprecated.+ class RecalculateTotals < Spree::Workflow+ argument :cart, [Spree::Cart, Spree::Order]+ alias_argument order: :cart, deprecated: true+ returns :cart++ step :reset_association_caches+ step :update_item_count+ step :update_money_totals+ step :persist_totals++ private++ # An earlier recalculation on this instance may have loaded the+ # associations mid-mutation.+ def reset_association_caches+ return unless cart.persisted?++ cart.association(:line_items).reset+ cart.association(:fulfillments).reset+ end++ def update_item_count+ cart.updater.update_item_count+ end++ def update_money_totals+ cart.updater.update_totals+ end++ def persist_totals+ cart.updater.persist_totals+ end+ end+ end+enddiff --git a/spree/core/app/workflows/spree/orders/add_item.rb b/spree/core/app/workflows/spree/orders/add_item.rbnew file mode 100644index 0000000000..595e6511e0--- /dev/null+++ b/spree/core/app/workflows/spree/orders/add_item.rb@@ -0,0 +1,11 @@+module Spree+ module Orders+ # Draft-order twin of the cart service — order: is the canonical keyword+ # on this side, mapped onto the shared pipeline. Exists so cart-only+ # behavior (reservations, checkout warnings) can diverge without+ # branching one implementation.+ class AddItem < Spree::Carts::AddItem+ alias_argument order: :cart+ end+ end+enddiff --git a/spree/core/app/workflows/spree/orders/recalculate.rb b/spree/core/app/workflows/spree/orders/recalculate.rbnew file mode 100644index 0000000000..3354bb2e0a--- /dev/null+++ b/spree/core/app/workflows/spree/orders/recalculate.rb@@ -0,0 +1,11 @@+module Spree+ module Orders+ # Draft-order twin of the cart service — order: is the canonical keyword+ # on this side, mapped onto the shared pipeline. Exists so cart-only+ # behavior (reservations, checkout warnings) can diverge without+ # branching one implementation.+ class Recalculate < Spree::Carts::Recalculate+ alias_argument order: :cart+ end+ end+enddiff --git a/spree/core/app/workflows/spree/orders/recalculate_totals.rb b/spree/core/app/workflows/spree/orders/recalculate_totals.rbnew file mode 100644index 0000000000..7ce5af51cd--- /dev/null+++ b/spree/core/app/workflows/spree/orders/recalculate_totals.rb@@ -0,0 +1,10 @@+module Spree+ module Orders+ # Order twin of the cart service — order: is the canonical keyword on+ # this side, mapped onto the shared flow (the calculator resolves+ # polymorphically through the model's #updater).+ class RecalculateTotals < Spree::Carts::RecalculateTotals+ alias_argument order: :cart+ end+ end+enddiff --git a/spree/core/lib/spree/core.rb b/spree/core/lib/spree/core.rbindex f45e6cb990..2a6ccda338 100644--- a/spree/core/lib/spree/core.rb+++ b/spree/core/lib/spree/core.rb@@ -580,6 +580,7 @@ require 'spree/translations'require 'spree/money'require 'spree/permitted_attributes'require 'spree/service_module'+require 'spree/workflow'require 'spree/analytics'require 'spree/events'require 'spree/webhooks'diff --git a/spree/core/lib/spree/hooks.rb b/spree/core/lib/spree/hooks.rbnew file mode 100644index 0000000000..da4249ebca--- /dev/null+++ b/spree/core/lib/spree/hooks.rb@@ -0,0 +1,115 @@+module Spree+ # Extension hook registry for Spree::Workflow flows (see+ # docs/plans/6.0-service-workflows.md). Keys are dotted strings —+ # '<workflow key>.<hook name>', e.g. 'carts.add_item.after_item_added'.+ # Handlers are stored as class names (constantized at dispatch) so+ # registration is initializer-safe, dev-reload-safe and idempotent;+ # blocks are accepted for one-line glue.+ class Hooks+ class UnknownHookError < StandardError; end++ def initialize+ @handlers = Hash.new { |hash, key| hash[key] = [] }+ # workflow key => workflow class name; populated by Spree::Workflow+ # when a class declares hooks. Class NAMES, never classes — reload+ # safety.+ @workflows = {}+ end++ attr_reader :workflows++ # @param key [String] '<workflow key>.<hook name>'+ # @param handler [Class, String, nil] class responding to call(context)+ def register(key, handler = nil, &block)+ key = key.to_s+ callable = block || handler+ raise ArgumentError, 'Pass a handler class or a block' if callable.nil?++ entry = callable.is_a?(Proc) ? callable : callable.to_s+ @handlers[key] << entry unless @handlers[key].include?(entry)+ entry+ end++ def unregister(key, handler = nil)+ return @handlers.delete(key.to_s) if handler.nil?++ @handlers[key.to_s].delete(handler.is_a?(Proc) ? handler : handler.to_s)+ end++ # @return [Array<#call>] resolved handlers for the key+ def for(key)+ @handlers[key.to_s].map { |entry| entry.is_a?(Proc) ? entry : entry.constantize.new }+ end++ def dispatch(key, context)+ self.for(key).each { |handler| handler.call(context) }+ end++ # Registered by Spree::Workflow at class-definition time.+ def register_workflow(workflow_key, class_name)+ @workflows[workflow_key.to_s] = class_name.to_s+ end++ # @return [Array<String>] context keys available at the hook point+ def contract(key)+ workflow_key, hook_name = split_key(key)+ workflow = @workflows[workflow_key]&.safe_constantize+ raise UnknownHookError, "No workflow registered for '#{workflow_key}'" if workflow.nil?++ workflow.hook_contract(hook_name.to_sym)+ end++ # Validates every registered key against hooks declared by workflow+ # classes. Call after eager load — a typo fails the boot instead of+ # never firing.+ def validate!+ @handlers.keys.each do |key|+ workflow_key, hook_name = split_key(key)+ workflow = @workflows[workflow_key]&.safe_constantize+ raise UnknownHookError, "Hook '#{key}' does not match any registered workflow" if workflow.nil?++ unless workflow.declared_hooks.include?(hook_name.to_sym)+ raise UnknownHookError,+ "Workflow '#{workflow_key}' declares no hook '#{hook_name}' (declared: #{workflow.declared_hooks.join(', ')})"+ end+ end+ true+ end++ def keys+ @handlers.keys+ end++ def clear!+ @handlers.clear+ end++ # Introspection facade: Spree.hooks.carts => { 'carts.add_item' => [...] }+ def method_missing(name, *args, &block)+ prefix = "#{name}."+ matching = @workflows.keys.select { |workflow_key| workflow_key.start_with?(prefix) || workflow_key == name.to_s }+ return super if matching.empty? && [email protected]? { |k| k.start_with?(prefix) }++ matching.index_with do |workflow_key|+ workflow = @workflows[workflow_key]&.safe_constantize+ workflow ? workflow.declared_hooks : []+ end+ end++ def respond_to_missing?(name, include_private = false)+ prefix = "#{name}."+ @workflows.keys.any? { |workflow_key| workflow_key.start_with?(prefix) } || super+ end++ private++ def split_key(key)+ parts = key.to_s.split('.')+ [parts[0..-2].join('.'), parts[-1]]+ end+ end++ def self.hooks+ @hooks ||= Hooks.new+ end+enddiff --git a/spree/core/lib/spree/testing_support/factories/cart_factory.rb b/spree/core/lib/spree/testing_support/factories/cart_factory.rbindex 2788b11a06..9096c3a745 100644--- a/spree/core/lib/spree/testing_support/factories/cart_factory.rb+++ b/spree/core/lib/spree/testing_support/factories/cart_factory.rb@@ -12,7 +12,7 @@ FactoryBot.define doafter(:create) do |cart, evaluator|create_list(:line_item, evaluator.line_items_count, cart: cart, order: nil, price: evaluator.line_items_price)cart.line_items.reload- cart.update_with_updater!+ cart.recalculate_totals!endendenddiff --git a/spree/core/lib/spree/testing_support/factories/order_factory.rb b/spree/core/lib/spree/testing_support/factories/order_factory.rbindex 640a7b69ea..7eb237b0db 100644--- a/spree/core/lib/spree/testing_support/factories/order_factory.rb+++ b/spree/core/lib/spree/testing_support/factories/order_factory.rb@@ -81,7 +81,7 @@ FactoryBot.define docreate(:shipment, order: order, cost: evaluator.shipment_cost, stock_location: stock_location)order.fulfillments.reload- order.update_with_updater!+ order.recalculate_totals!endfactory :completed_order_with_totals dodiff --git a/spree/core/lib/spree/testing_support/factories/payment_factory.rb b/spree/core/lib/spree/testing_support/factories/payment_factory.rbindex b4c5aacc1a..579225cc1b 100644--- a/spree/core/lib/spree/testing_support/factories/payment_factory.rb+++ b/spree/core/lib/spree/testing_support/factories/payment_factory.rb@@ -29,7 +29,7 @@ FactoryBot.define doendfactory :store_credit_payment, class: Spree::Payment, parent: :payment do- payment_method { create(:store_credit_payment_method, store: order.store) }- source { create(:store_credit, store: order.store, user: order.user) }+ payment_method { create(:store_credit_payment_method, store: (order || cart).store) }+ source { create(:store_credit, store: (order || cart).store, user: (order || cart).user) }endenddiff --git a/spree/core/lib/spree/testing_support/order_walkthrough.rb b/spree/core/lib/spree/testing_support/order_walkthrough.rbindex 59038819be..0e55d76409 100644--- a/spree/core/lib/spree/testing_support/order_walkthrough.rb+++ b/spree/core/lib/spree/testing_support/order_walkthrough.rb@@ -36,7 +36,7 @@ class OrderWalkthroughreturn complete_cart!(cart) if state.to_sym == :complete- cart.update_with_updater!+ cart.recalculate_totals!cartend@@ -55,7 +55,7 @@ class OrderWalkthroughdef self.delivery(cart)# Rates were proposed with the address; keep the selected defaults.- cart.update_with_updater!+ cart.recalculate_totals!enddef self.payment(cart)diff --git a/spree/core/lib/spree/workflow.rb b/spree/core/lib/spree/workflow.rbnew file mode 100644index 0000000000..88e9f3882d--- /dev/null+++ b/spree/core/lib/spree/workflow.rb@@ -0,0 +1,551 @@+require 'spree/service_module'+require 'spree/hooks'++module Spree+ # Declared-step workflow base — the DSL from+ # docs/plans/6.0-service-workflows.md, reserved for the curated flows in+ # app/workflows/ (regular services stay plain ServiceModule classes).+ # Caller-compatible with ServiceModule (Callable.call, Result,+ # success/failure); adds declared argument contracts, real context+ # classes, explicit transaction grouping, per-step undo, extension hooks+ # and declared event emission.+ #+ # class Spree::Carts::AddItem < Spree::Workflow+ # workflow_key 'carts.add_item'+ # argument :cart+ # argument :variant+ # argument :quantity, default: 1+ # alias_argument order: :cart, deprecated: true+ #+ # transaction do+ # step :add_to_line_item, provides: [:line_item]+ # run_hooks :after_item_added+ # end+ #+ # private+ #+ # # Steps are zero-arg methods; arguments and provided keys read as+ # # private methods (the #context accessor also remains available)+ # def add_to_line_item+ # { line_item: cart.line_items.find_or_initialize_by(variant: variant) }+ # end+ #+ # emit 'cart.item_added', payload: -> { { id: cart.prefixed_id } }+ # end+ class Workflow+ prepend Spree::ServiceModule::Base++ class ContractError < StandardError; end++ Halt = Struct.new(:value)++ class << self+ attr_reader :declared_hooks++ def inherited(subclass)+ super+ subclass.instance_variable_set(:@return_selector, return_selector)+ subclass.instance_variable_set(:@rescue_contracts, rescue_contracts.dup)+ subclass.instance_variable_set(:@flow_items, flow_items.dup)+ subclass.instance_variable_set(:@required_arguments, required_arguments.dup)+ subclass.instance_variable_set(:@optional_arguments, optional_arguments.dup)+ subclass.instance_variable_set(:@argument_aliases, argument_aliases.dup)+ subclass.instance_variable_set(:@argument_types, argument_types.dup)+ subclass.instance_variable_set(:@emits, emits.dup)+ subclass.instance_variable_set(:@declared_hooks, (declared_hooks || []).dup)+ subclass.instance_variable_set(:@context_keys, context_keys.dup)+ end++ def flow_items = @flow_items ||= []+ def required_arguments = @required_arguments ||= []+ def optional_arguments = @optional_arguments ||= {}+ def argument_aliases = @argument_aliases ||= {}+ def argument_types = @argument_types ||= {}+ def emits = @emits ||= []+ def context_keys = @context_keys ||= []++ # Dotted identity used for hook keys; derived from the class name+ # (Spree::Carts::AddItem => 'carts.add_item') unless set explicitly.+ def workflow_key(value = nil)+ @workflow_key = value.to_s if value+ @workflow_key ||= name.delete_prefix('Spree::').split('::').map(&:underscore).join('.')+ end++ REQUIRED = Object.new.freeze++ # One declared argument per line, ActiveJob/GraphQL-style. The+ # optional second positional declares a runtime-checked type: a+ # class/module, an array union (nil in the union means nilable), or+ # :boolean for [true, false]. Checked once at the call boundary —+ # ContractError in dev/test, log-warn in production. Never coerces.+ #+ # argument :cart, Spree::Cart+ # argument :quantity, Integer, default: 1+ # argument :owner, [Spree::Cart, Spree::Order]+ def argument(name, type = nil, default: REQUIRED)+ name = name.to_sym+ argument_types[name] = type unless type.nil?+ if default.equal?(REQUIRED)+ @required_arguments = required_arguments | [name]+ else+ optional_arguments[name] = default+ end+ register_context_keys([name])+ end++ # alias_argument order: :cart, deprecated: true — accepts the legacy+ # keyword, warns when deprecated, maps onto the canonical argument.+ # Retires ad-hoc kwarg bridges and rewrite_input!.+ def alias_argument(deprecated: false, **mapping)+ mapping.each { |from, to| argument_aliases[from.to_sym] = { to: to.to_sym, deprecated: deprecated } }+ end++ def step(name, provides: [], if: nil, on_flow_failure: nil, with: nil, halt_with: nil)+ condition = binding.local_variable_get(:if)+ flow_items << { type: :step, name: name.to_sym, provides: Array(provides).map(&:to_sym),+ if: condition, on_flow_failure: on_flow_failure&.to_sym, with: binding.local_variable_get(:with),+ halt_with: halt_with&.to_sym, io: false,+ transaction: @building_transaction }+ register_context_keys(Array(provides).map(&:to_sym) + [halt_with].compact.map(&:to_sym))+ end++ # External I/O — structurally forbidden inside a transaction block.+ def external_step(name, provides: [], if: nil, on_flow_failure: nil, halt_with: nil)+ raise ContractError, "external_step #{name} cannot be declared inside a transaction block" if @building_transaction++ condition = binding.local_variable_get(:if)+ flow_items << { type: :step, name: name.to_sym, provides: Array(provides).map(&:to_sym),+ if: condition, on_flow_failure: on_flow_failure&.to_sym, with: nil,+ halt_with: halt_with&.to_sym, io: true, transaction: nil }+ register_context_keys(Array(provides).map(&:to_sym) + [halt_with].compact.map(&:to_sym))+ end++ # transaction(lock: :cart) do ... end — steps inside share one+ # database transaction (optionally holding a row lock); rollback is+ # their compensation.+ def transaction(lock: nil, &block)+ group = { lock: lock&.to_sym }+ @building_transaction = group+ instance_eval(&block)+ ensure+ @building_transaction = nil+ end++ def run_hooks(name)+ (@declared_hooks ||= []) << name.to_sym+ flow_items << { type: :hook, name: name.to_sym, transaction: @building_transaction }+ Spree.hooks.register_workflow(workflow_key, self.name)+ end++ # Declared after-commit event. The payload lambda is explicit plain+ # Ruby — by convention it serializes through the record's+ # event_payload (the same V3 serializer path lifecycle events use),+ # so what feeds the event is visible at the declaration:+ #+ # emit 'order.placed', payload: -> { order.event_payload.merge(notify_customer: order.notify_customer) }+ def emit(event_name, payload:)+ emits << { name: event_name.to_s, payload: payload }+ end++ # Declarative exception contract: convert matching exceptions raised+ # anywhere in the flow into failure Results (the block builds the+ # Result via the failure helper). Unmatched exceptions keep raising.+ #+ # rescue_from ActiveRecord::RecordInvalid do |error|+ # failure(cart, error.record.errors.full_messages.to_sentence)+ # end+ def rescue_from(*exception_classes, &block)+ raise ArgumentError, 'rescue_from requires a block building the failure Result' if block.nil?++ exception_classes.each { |klass| rescue_contracts << { klass: klass, handler: block } }+ end++ def rescue_contracts = @rescue_contracts ||= []++ # Selects the successful Result value (a context key, or a lambda on+ # the context). Defaults to the context itself.+ def returns(key = nil, &block)+ @return_selector = block || key+ end++ def return_selector+ @return_selector+ end++ # @return [Array<Symbol>] context keys available at the given hook+ def hook_contract(hook_name)+ available = required_arguments + optional_arguments.keys+ flow_items.each do |item|+ return available.uniq if item[:type] == :hook && item[:name] == hook_name.to_sym++ available += item[:provides] if item[:type] == :step+ end+ raise Spree::Hooks::UnknownHookError, "#{name} declares no hook '#{hook_name}'"+ end++ # Real context class with defined readers — the editor story depends+ # on these being actual methods (never method_missing). Named as the+ # flow's Context constant (Spree::Carts::AddItem::Context) so YARD+ # references and the generated RBS have a real type to point at.+ def context_class+ @context_class ||= begin+ klass = Workflow.build_context_class(context_keys)+ remove_const(:Context) if const_defined?(:Context, false)+ const_set(:Context, klass)+ end+ end++ def build_context_class(keys)+ Class.new do+ define_method(:initialize) { |values| @values = values }++ keys.each do |key|+ define_method(key) { @values[key] }+ end++ define_method(:[]) { |key| @values[key.to_sym] }+ define_method(:to_h) { @values.dup }+ define_method(:deconstruct_keys) { |requested| requested.nil? ? @values.dup : @values.slice(*requested) }+ define_method(:key?) { |key| @values.key?(key.to_sym) }++ define_method(:merge!) do |hash|+ @values.merge!(hash.transform_keys(&:to_sym))+ self+ end++ def method_missing(name, *args)+ raise NoMethodError,+ "Unknown context key :#{name} — available: #{@values.keys.join(', ')}"+ end++ def respond_to_missing?(_name, _include_private = false)+ false+ end+ end+ end++ # Keys the reader-definition must never shadow — the DSL's own API.+ def reserved_context_key?(key)+ @reserved_context_keys ||= (Workflow.instance_methods(false) ++ Workflow.private_instance_methods(false) ++ Spree::ServiceModule::Base.instance_methods(false)).to_set+ @reserved_context_keys.include?(key)+ end++ private++ # Arguments and provided keys become private zero-arg readers on the+ # service (ActiveInteraction-style), so step bodies read +cart+, not+ # +context.cart+. An author-defined method of the same name wins; a+ # collision with the Spree::Workflow API itself is a definition error.+ def register_context_keys(keys)+ keys.each do |key|+ raise ContractError, "#{name}: context key :#{key} collides with the Spree::Workflow API" if Workflow.reserved_context_key?(key)++ unless method_defined?(key, false) || private_method_defined?(key, false)+ define_method(key) { @context[key] }+ private key+ end+ end+ @context_keys = context_keys | keys+ @context_class = nil+ end+ end++ attr_reader :context++ # Events collected by emit declarations; published after all+ # transactions commit. Exposed for specs.+ attr_reader :emitted_events++ def call(**kwargs)+ kwargs = resolve_aliases(kwargs)+ validate_arguments!(kwargs)++ values = self.class.optional_arguments.merge(kwargs)+ @context = self.class.context_class.new(values)+ @undo_stack = []+ @emitted_events = []++ result = execute_flow+ result = success(default_return_value) unless result.is_a?(Spree::ServiceModule::Result)++ if result.success?+ collect_emits+ publish_emitted_events+ end++ result+ rescue StandardError => e+ run_undo_stack!+ contract = self.class.rescue_contracts.find { |entry| e.is_a?(entry[:klass]) }+ raise if contract.nil?++ handler = contract[:handler]+ outcome = handler.arity == 1 ? instance_exec(e, &handler) : instance_exec(e, @context, &handler)+ raise unless outcome.is_a?(Spree::ServiceModule::Result)++ outcome+ end++ private++ def default_return_value+ selector = self.class.return_selector+ case selector+ when nil then @context+ when Symbol then @context[selector]+ when Proc then exec_in_service(selector)+ end+ end++ # DSL lambdas (if:, returns, emit payloads) run in the service instance+ # and read the #context accessor; legacy one-arg lambdas still receive+ # the context.+ def exec_in_service(block)+ block.arity.zero? ? instance_exec(&block) : instance_exec(@context, &block)+ end++ def resolve_aliases(kwargs)+ self.class.argument_aliases.each do |from, config|+ next unless kwargs.key?(from)++ if config[:deprecated]+ Spree::Deprecation.warn(+ "Calling #{self.class.name} with #{from}: is deprecated and will be removed in Spree 6.1. Pass #{config[:to]}: instead."+ )+ end+ legacy_value = kwargs.delete(from)+ kwargs[config[:to]] = legacy_value if kwargs[config[:to]].nil?+ end+ kwargs+ end++ def validate_arguments!(kwargs)+ unknown = kwargs.keys.map(&:to_sym) - self.class.context_keys+ if unknown.any?+ message = "#{self.class.name}: unknown argument #{unknown.join(', ')} (accepts: #{(self.class.required_arguments + self.class.optional_arguments.keys).join(', ')})"+ raise ContractError, message unless Rails.env.production?++ Rails.logger.warn(message)+ end++ missing = self.class.required_arguments.select { |key| !kwargs.key?(key) || kwargs[key].nil? }+ raise ContractError, "#{self.class.name}: missing required argument #{missing.join(', ')}" if missing.any?++ validate_argument_types!(kwargs)+ end++ # Presence is the required-check's job — nil supplied values are skipped+ # here, so optional arguments are nilable without declaring it.+ def validate_argument_types!(kwargs)+ self.class.argument_types.each do |key, type|+ value = kwargs[key]+ next if value.nil? || type_matches?(value, type)++ message = "#{self.class.name}: expected #{key} to be #{describe_type(type)}, got #{value.class.name}"+ raise ContractError, message unless Rails.env.production?++ Rails.logger.warn(message)+ end+ end++ def type_matches?(value, type)+ case type+ when Array then type.any? { |member| type_matches?(value, member) }+ when :boolean then value == true || value == false+ when nil then value.nil?+ when Module then value.is_a?(type)+ else false+ end+ end++ def describe_type(type)+ case type+ when Array then type.map { |member| describe_type(member) }.join(' | ')+ when :boolean then 'boolean'+ when nil then 'nil'+ else type.name+ end+ end++ def execute_flow+ items = self.class.flow_items+ index = 0++ while index < items.length+ item = items[index]++ if (group = item[:transaction])+ group_items = []+ group_items << items[index] and index += 1 while index < items.length && items[index][:transaction].equal?(group)++ result = run_transaction_group(group, group_items)+ else+ result = run_item(item, compensable: true)+ index += 1+ end++ return result if result.is_a?(Spree::ServiceModule::Result) || result.is_a?(Halt)+ end++ nil+ rescue StandardError+ raise+ ensure+ # Halt is success — unwrap for the caller.+ end++ def run_transaction_group(group, group_items)+ completed_in_group = []+ outcome = nil++ run_in_lock(group[:lock]) do+ ApplicationRecord.transaction do+ group_items.each do |item|+ outcome = run_item(item, compensable: false)+ if outcome.is_a?(Spree::ServiceModule::Result)+ raise ActiveRecord::Rollback if outcome.failure?++ break+ end+ break if outcome.is_a?(Halt)++ completed_in_group << item+ end+ end+ end++ if outcome.is_a?(Spree::ServiceModule::Result) && outcome.failure?+ # The group rolled back — undo previously committed work.+ run_undo_stack!+ return outcome+ end++ # Once the group committed, its compensable steps join the stack.+ completed_in_group.each do |item|+ @undo_stack << item[:on_flow_failure] if item[:on_flow_failure]+ end++ outcome+ end++ def run_in_lock(lock_key, &block)+ return yield if lock_key.nil?++ @context[lock_key].with_lock(&block)+ end++ def run_item(item, compensable:)+ case item[:type]+ when :hook+ Spree.hooks.dispatch("#{self.class.workflow_key}.#{item[:name]}", @context)+ nil+ when :step+ run_step(item, compensable: compensable)+ end+ end++ def run_step(item, compensable:)+ return nil if item[:if] && !exec_in_service(item[:if])++ outcome =+ if item[:with]+ callable = instance_exec(&item[:with])+ callable.call(**@context.to_h.slice(*callable_kwargs(callable)))+ else+ send(item[:name])+ end++ case outcome+ when Spree::ServiceModule::Result+ if outcome.failure?+ run_undo_stack!+ return outcome+ end+ merge_step_output(item, outcome.value) if outcome.value.is_a?(Hash)+ when Hash+ merge_step_output(item, outcome)+ end++ @undo_stack << item[:on_flow_failure] if compensable && item[:on_flow_failure]++ if item[:halt_with] && @context.key?(item[:halt_with]) && @context[item[:halt_with]]+ return success(@context[item[:halt_with]])+ end++ nil+ end++ # provides: is the step's write schema — a step declaring no outputs+ # writes nothing, so bodies can end on any expression (no defensive+ # trailing nils) without incidental hashes polluting the context.+ def merge_step_output(item, hash)+ allowed = item[:provides] + [item[:halt_with]].compact+ return if allowed.empty?++ extras = hash.keys.map(&:to_sym) - allowed+ if extras.any?+ message = "#{self.class.name}##{item[:name]} returned undeclared keys #{extras.join(', ')} (declared provides: #{item[:provides].join(', ')})"+ raise ContractError, message unless Rails.env.production?++ Rails.logger.warn(message)+ end+ @context.merge!(hash)+ end++ def callable_kwargs(callable)+ if callable.is_a?(Class) && callable < Spree::Workflow+ return callable.required_arguments + callable.optional_arguments.keys + callable.argument_aliases.keys+ end++ target = callable.respond_to?(:new) ? callable.instance_method(:call) : callable.method(:call)+ # Skip the prepended wrappers (ServiceModule::Base / Service) to read+ # the signature the author actually wrote.+ while target.respond_to?(:owner) && [Spree::ServiceModule::Base, Spree::Workflow].include?(target.owner) && target.super_method+ target = target.super_method+ end+ params = target.parameters+ return @context.to_h.keys if params.any? { |type, _| type == :keyrest }++ params.filter_map { |type, name| name if [:key, :keyreq].include?(type) }+ end++ def run_undo_stack!+ return if @undo_stack.nil?++ @undo_stack.reverse_each do |compensation|+ send(compensation)+ rescue StandardError => e+ Rails.error.report(e, context: { workflow: self.class.workflow_key }, source: 'spree.workflow')+ end+ @undo_stack = []+ end++ def collect_emits+ self.class.emits.each do |declaration|+ payload =+ case declaration[:payload]+ when Proc then exec_in_service(declaration[:payload])+ when Symbol then send(declaration[:payload])+ end+ @emitted_events << { name: declaration[:name], payload: payload }+ end+ end++ def publish_emitted_events+ events = @emitted_events+ return if events.empty?++ publish = -> { events.each { |event| Spree::Events.publish(event[:name], event[:payload]) } }++ # Non-joinable transactions are test fixtures — deferring behind one+ # would postpone past the example's rollback, so publish immediately.+ if ApplicationRecord.connection.transaction_open? && ApplicationRecord.connection.current_transaction.joinable?+ ActiveRecord.after_all_transactions_commit(&publish)+ else+ publish.call+ end+ end+ end+enddiff --git a/spree/core/spec/lib/spree/workflow_spec.rb b/spree/core/spec/lib/spree/workflow_spec.rbnew file mode 100644index 0000000000..173402d1c5--- /dev/null+++ b/spree/core/spec/lib/spree/workflow_spec.rb@@ -0,0 +1,347 @@+require 'spec_helper'++RSpec.describe Spree::Workflow do+ before { Spree.hooks.clear! }+ after { Spree.hooks.clear! }++ def build_workflow(&block)+ workflow = Class.new(Spree::Workflow) do+ def self.name = 'Spree::Testing::SampleWorkflow'+ workflow_key 'testing.sample_workflow'+ class_eval(&block)+ end+ stub_const('Spree::Testing::SampleWorkflow', workflow)+ workflow+ end++ describe 'argument contracts' do+ it 'validates required arguments, applies defaults, and rejects unknown keys' do+ workflow = build_workflow do+ argument :subject+ argument :quantity, default: 2+ step :inspect_inputs, provides: [:seen]+ def inspect_inputs = { seen: [context.subject, context.quantity] }+ end++ expect(workflow.call(subject: 'a').value.seen).to eq(['a', 2])+ expect(workflow.call(subject: 'a', quantity: 5).value.seen).to eq(['a', 5])+ expect { workflow.call(quantity: 1) }.to raise_error(Spree::Workflow::ContractError, /missing required argument subject/)+ expect { workflow.call(subject: 'a', bogus: 1) }.to raise_error(Spree::Workflow::ContractError, /unknown argument bogus/)+ end++ it 'validates declared argument types at the call boundary without coercing' do+ workflow = build_workflow do+ argument :cart, Spree::Cart+ argument :quantity, Integer, default: 1+ argument :confirmed, :boolean, default: false+ step :noop+ def noop = nil+ end++ cart = build(:cart)+ expect(workflow.call(cart: cart)).to be_success+ expect(workflow.call(cart: cart, quantity: 3, confirmed: true)).to be_success+ expect { workflow.call(cart: 'cart_123') }+ .to raise_error(Spree::Workflow::ContractError, /expected cart to be Spree::Cart, got String/)+ expect { workflow.call(cart: cart, quantity: '3') }+ .to raise_error(Spree::Workflow::ContractError, /expected quantity to be Integer, got String/)+ expect { workflow.call(cart: cart, confirmed: 1) }+ .to raise_error(Spree::Workflow::ContractError, /expected confirmed to be boolean, got Integer/)+ end++ it 'accepts any member of a union type and skips nil optionals' do+ workflow = build_workflow do+ argument :owner, [Spree::Cart, Spree::Order], default: nil+ step :noop+ def noop = nil+ end++ expect(workflow.call).to be_success+ expect(workflow.call(owner: build(:order))).to be_success+ expect { workflow.call(owner: 42) }+ .to raise_error(Spree::Workflow::ContractError, /expected owner to be Spree::Cart \| Spree::Order, got Integer/)+ end++ it 'maps deprecated aliases onto canonical keys with a warning' do+ workflow = build_workflow do+ argument :cart+ alias_argument order: :cart, deprecated: true+ step :read, provides: [:value]+ def read = { value: context.cart }+ end++ expect(Spree::Deprecation).to receive(:warn).with(/order: is deprecated/)+ expect(workflow.call(order: 'the-cart').value.value).to eq('the-cart')+ end+ end++ describe 'steps and context' do+ it 'threads declared outs through real context readers' do+ workflow = build_workflow do+ argument :base+ step :double, provides: [:doubled]+ step :describe, provides: [:text]+ def double = { doubled: context.base * 2 }+ def describe = { text: "got #{context.doubled}" }+ end++ result = workflow.call(base: 21)+ expect(result).to be_success+ expect(result.value.text).to eq('got 42')+ expect(result.value.to_h).to include(base: 21, doubled: 42)+ result.value => { doubled: }+ expect(doubled).to eq(42)+ end++ it 'raises a teaching error for unknown context keys and undeclared outs' do+ workflow = build_workflow do+ argument :base+ step :bad, provides: [:declared]+ def bad = { undeclared: 1 }+ end+ expect { workflow.call(base: 1) }.to raise_error(Spree::Workflow::ContractError, /undeclared keys undeclared/)++ workflow2 = build_workflow do+ argument :base+ step :peek, provides: []+ def peek = context.missing_key && {}+ end+ expect { workflow2.call(base: 1) }.to raise_error(NoMethodError, /Unknown context key :missing_key — available: base/)+ end++ it 'ignores incidental hashes from steps that declare no provides' do+ workflow = build_workflow do+ argument :base+ step :side_effect+ step :peek, provides: [:seen]+ def side_effect = { junk: 1 }+ def peek = { seen: context.key?(:junk) }+ end++ expect(workflow.call(base: 1).value.seen).to be(false)+ end++ it 'supports conditional steps, failure short-circuit, and halt_with' do+ workflow = build_workflow do+ argument :mode+ step :maybe_fail, if: -> { context.mode == :fail }+ step :maybe_halt, provides: [:early], halt_with: :early+ step :after, provides: [:reached]+ def maybe_fail = failure('nope')+ def maybe_halt = { early: (context.mode == :halt ? 'halted' : nil) }+ def after = { reached: true }+ end++ expect(workflow.call(mode: :fail)).to be_failure+ halted = workflow.call(mode: :halt)+ expect(halted).to be_success+ expect(halted.value).to eq('halted')+ expect(workflow.call(mode: :run).value.reached).to be(true)+ end++ it 'delegates with: steps and merges their kwargs from the context' do+ collaborator = Class.new do+ prepend Spree::ServiceModule::Base+ def call(base:)+ success(tripled: base * 3)+ end+ end++ workflow = build_workflow do+ argument :base+ step :triple, with: -> { @collaborator }, provides: [:tripled]+ end+ instance = workflow.new+ instance.instance_variable_set(:@collaborator, collaborator)+ result = instance.call(base: 3)+ expect(result.value.tripled).to eq(9)+ end+ end++ describe 'transactions and undo' do+ it 'rolls back a transaction group on failure and runs earlier undos' do+ undo_log = []+ workflow = build_workflow do+ argument :product+ step :outside_work, on_flow_failure: :undo_outside+ transaction do+ step :rename+ step :explode+ end+ define_method(:outside_work) { nil }+ define_method(:undo_outside) { undo_log << :undone }+ def rename = context.product.update!(name: 'Renamed') && nil+ def explode = failure('boom')+ end++ product = create(:product, name: 'Original')+ result = workflow.call(product: product)++ expect(result).to be_failure+ expect(product.reload.name).to eq('Original')+ expect(undo_log).to eq([:undone])+ end++ it 'runs undos in reverse order on exceptions' do+ undo_log = []+ workflow = build_workflow do+ argument :subject+ step :first, on_flow_failure: :undo_first+ step :second, on_flow_failure: :undo_second+ step :third+ define_method(:first) { nil }+ define_method(:second) { nil }+ define_method(:undo_first) { undo_log << :first }+ define_method(:undo_second) { undo_log << :second }+ def third = raise('io blew up')+ end++ expect { workflow.call(subject: 1) }.to raise_error('io blew up')+ expect(undo_log).to eq([:second, :first])+ end++ it 'forbids external_step inside a transaction block at definition time' do+ expect do+ build_workflow do+ argument :subject+ transaction do+ external_step :charge+ end+ end+ end.to raise_error(Spree::Workflow::ContractError, /external_step charge cannot be declared inside a transaction/)+ end++ it 'converts declared exceptions into failures and re-raises the rest' do+ workflow = build_workflow do+ argument :subject+ rescue_from ArgumentError do |error|+ failure(context.subject, "handled: #{error.message}")+ end+ step :explode+ def explode = raise(context.subject == :known ? ArgumentError.new('bad input') : 'unknown boom')+ end++ result = workflow.call(subject: :known)+ expect(result).to be_failure+ expect(result.error.to_s).to eq('handled: bad input')++ expect { workflow.call(subject: :other) }.to raise_error('unknown boom')+ end++ it 'holds the declared row lock around the group' do+ workflow = build_workflow do+ argument :product+ transaction lock: :product do+ step :touch_name+ end+ def touch_name = context.product.update!(name: 'Locked') && nil+ end++ product = create(:product)+ expect(product).to receive(:with_lock).and_call_original+ workflow.call(product: product)+ expect(product.reload.name).to eq('Locked')+ end+ end++ describe 'hooks' do+ it 'dispatches registered handlers with the context and computes contracts' do+ workflow = build_workflow do+ argument :subject+ step :produce, provides: [:artifact]+ run_hooks :after_produce+ def produce = { artifact: 'thing' }+ end++ seen = nil+ Spree.hooks.register('testing.sample_workflow.after_produce') { |hook_context| seen = hook_context.artifact }+ workflow.call(subject: 1)++ expect(seen).to eq('thing')+ expect(workflow.hook_contract(:after_produce)).to contain_exactly(:subject, :artifact)+ expect(Spree.hooks.contract('testing.sample_workflow.after_produce')).to contain_exactly(:subject, :artifact)+ end++ it 'validates registrations against declared hooks at boot' do+ build_workflow do+ argument :subject+ run_hooks :real_hook+ end+ Spree.hooks.register('testing.sample_workflow.real_hook', 'SomeHandler')+ expect(Spree.hooks.validate!).to be(true)++ Spree.hooks.register('testing.sample_workflow.typo_hook', 'SomeHandler')+ expect { Spree.hooks.validate! }.to raise_error(Spree::Hooks::UnknownHookError, /declares no hook 'typo_hook'/)+ end++ it 'dedupes class-name registrations' do+ build_workflow do+ argument :subject+ run_hooks :point+ end+ Spree.hooks.register('testing.sample_workflow.point', 'MyHandler')+ Spree.hooks.register('testing.sample_workflow.point', 'MyHandler')++ expect(Spree.hooks.keys.count { |k| k == 'testing.sample_workflow.point' }).to eq(1)+ handler = Class.new { def call = nil }+ stub_const('MyHandler', handler)+ expect(Spree.hooks.for('testing.sample_workflow.point').size).to eq(1)+ end+ end++ describe 'emits' do+ it 'serializes through event_payload by convention, explicitly in the lambda' do+ workflow = build_workflow do+ argument :subject+ emit 'testing.finished', payload: -> { context.subject.event_payload.merge(extra: context.subject.class.name) }+ end++ record = create(:cart, store: @default_store)+ instance = workflow.new+ result = instance.call(subject: record)+ expect(result).to be_success+ event = instance.emitted_events.sole+ expect(event[:name]).to eq('testing.finished')+ expect(event[:payload][:id]).to eq(record.prefixed_id)+ expect(event[:payload][:extra]).to eq('Spree::Cart')+ end++ it 'collects declared events on success and exposes them' do+ workflow = build_workflow do+ argument :subject+ step :work, provides: [:artifact]+ emit 'testing.finished', payload: -> { { artifact: context.artifact } }+ def work = { artifact: 'done' }+ end++ instance = workflow.new+ result = instance.call(subject: 1)+ expect(result).to be_success+ expect(instance.emitted_events).to eq([{ name: 'testing.finished', payload: { artifact: 'done' } }])+ end++ it 'names the context class as the flow Context constant' do+ workflow = build_workflow do+ argument :subject+ step :noop+ def noop = nil+ end++ workflow.call(subject: 1)+ expect(workflow.const_get(:Context).instance_methods).to include(:subject)+ end++ it 'does not collect events on failure' do+ workflow = build_workflow do+ argument :subject+ step :work+ emit 'testing.finished', payload: -> { { subject: context.subject } }+ def work = failure('no')+ end++ instance = workflow.new+ expect(instance.call(subject: 1)).to be_failure+ expect(instance.emitted_events).to be_empty+ end+ end+enddiff --git a/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rb b/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rbindex 516c742c03..5eb30d5ffe 100644--- a/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rb+++ b/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rb@@ -14,13 +14,13 @@ describe 'coupon code retry on recalculation' doit 'activates the pending code once the cart qualifies and deactivates below threshold' docart.update!(coupon_code: 'save5')- cart.update_with_updater!+ cart.recalculate_totals!expect(cart.reload.discounts.where(promotion_id: promotion.id)).to be_empty# Grow the cart past the threshold — recalculation applies the code.create(:line_item, cart: cart, order: nil, price: 25)cart.line_items.reload- cart.update_with_updater!+ cart.recalculate_totals!expect(cart.reload.discounts.where(promotion_id: promotion.id)).to be_presentexpect(cart.order_promotions.where(promotion_id: promotion.id)).to be_present@@ -28,7 +28,7 @@ describe 'coupon code retry on recalculation' do# Shrink below the threshold — rows deactivate, the code stays.cart.line_items.order(:created_at).last.destroy!cart.line_items.reload- cart.update_with_updater!+ cart.recalculate_totals!expect(cart.reload.discounts.where(promotion_id: promotion.id)).to be_emptyexpect(cart.read_attribute(:coupon_code)).to eq('save5')@@ -37,7 +37,7 @@ describe 'coupon code retry on recalculation' doit 'clears the persisted code when the promotion is removed' docart.line_items.first.update!(price: 50)cart.update!(coupon_code: 'save5')- cart.update_with_updater!+ cart.recalculate_totals!expect(cart.reload.discounts.where(promotion_id: promotion.id)).to be_presenthandler = Spree::PromotionHandler::Coupon.new(cart)diff --git a/spree/core/spec/models/spree/calculator/refunds/default_refund_amount_spec.rb b/spree/core/spec/models/spree/calculator/refunds/default_refund_amount_spec.rbindex 3a20133946..773ab7c005 100644--- a/spree/core/spec/models/spree/calculator/refunds/default_refund_amount_spec.rb+++ b/spree/core/spec/models/spree/calculator/refunds/default_refund_amount_spec.rb@@ -24,7 +24,7 @@ describe Spree::Calculator::Returns::DefaultRefundAmount, type: :model dobefore docreate(:discount, order: order, line_item: line_item, amount: discount_amount, label: 'Discount', kind: 'manual')- order.update_with_updater!+ order.recalculate_totals!line_item.reloadend@@ -36,7 +36,7 @@ describe Spree::Calculator::Returns::DefaultRefundAmount, type: :model dobefore docreate(:discount, order: order, fulfillment: shipment, amount: -50, label: 'Free shipping', kind: 'promotion')- order.update_with_updater!+ order.recalculate_totals!endit 'does not affect the line item refund' dodiff --git a/spree/core/spec/models/spree/line_item_spec.rb b/spree/core/spec/models/spree/line_item_spec.rbindex fe1cb195a4..8974ef5a1e 100644--- a/spree/core/spec/models/spree/line_item_spec.rb+++ b/spree/core/spec/models/spree/line_item_spec.rb@@ -187,7 +187,7 @@ describe Spree::LineItem, type: :model do# every cart/checkout flow runs after the save.it 'refreshes tax through the order recalculation' doline_item.save- line_item.order.update_with_updater!+ line_item.order.recalculate_totals!expect(line_item.reload.pre_tax_amount).to eq(line_item.price * line_item.quantity)enddiff --git a/spree/core/spec/models/spree/order/adjustments_spec.rb b/spree/core/spec/models/spree/order/adjustments_spec.rbindex 7f0ffffe7f..ba96038a85 100644--- a/spree/core/spec/models/spree/order/adjustments_spec.rb+++ b/spree/core/spec/models/spree/order/adjustments_spec.rb@@ -17,7 +17,7 @@ describe Spree::Order dopersisted_order.create_proposed_fulfillmentspersisted_order.set_shipments_costcreate(:discount, order: persisted_order, line_item: line_item, amount: -line_item.amount, label: 'Promotion', kind: 'manual')- persisted_order.update_with_updater!+ persisted_order.recalculate_totals!endit 'still requires payment (shipping keeps the total above zero)' dodiff --git a/spree/core/spec/models/spree/order/checkout_spec.rb b/spree/core/spec/models/spree/order/checkout_spec.rbindex cc8c5d0bfe..ffde77d63b 100644--- a/spree/core/spec/models/spree/order/checkout_spec.rb+++ b/spree/core/spec/models/spree/order/checkout_spec.rb@@ -127,7 +127,7 @@ describe Spree::Order, type: :model dolet(:gift_card) { create(:gift_card, amount: order.total, store: store) }before do- order.update_with_updater!+ order.recalculate_totals!order.apply_gift_card(gift_card)enddiff --git a/spree/core/spec/models/spree/order/finalizing_spec.rb b/spree/core/spec/models/spree/order/finalizing_spec.rbindex 438e60849b..cd05b87791 100644--- a/spree/core/spec/models/spree/order/finalizing_spec.rb+++ b/spree/core/spec/models/spree/order/finalizing_spec.rb@@ -52,7 +52,7 @@ describe Spree::Order, type: :model doit 'freezes adjustment recalculation (order-level freeze)' doorder.finalize!expect(Spree::Adjusters::Promotion).not_to receive(:adjust)- order.update_with_updater!+ order.recalculate_totals!endcontext 'order is considered risky' dodiff --git a/spree/core/spec/models/spree/order/payment_spec.rb b/spree/core/spec/models/spree/order/payment_spec.rbindex 8fcc31e29e..1e24b0ad8d 100644--- a/spree/core/spec/models/spree/order/payment_spec.rb+++ b/spree/core/spec/models/spree/order/payment_spec.rb@@ -270,7 +270,7 @@ module Spreeorder = reimbursement.order# Sync totals (the factory leaves the delivery repricing unapplied),# then set the payment amount to the order total of 20- order.update_with_updater!+ order.recalculate_totals!order.payments.first.update_column :amount, order.total# Creates a refund of 20create :refund, amount: order.total,@@ -278,7 +278,7 @@ module Spreereimbursement: reimbursementorder = reimbursement.order.reload# Update the order totals so payment_total goes to 0 reflecting the refund..- order.update_with_updater!+ order.recalculate_totals!# Order Total - (Payment Total + Reimbursed)# 20 - (0 + 20) = 0expect(order.outstanding_balance).to eq 0@@ -294,7 +294,7 @@ module Spreeorder.payments << create(:payment, state: :completed, order: order, amount: order.total)create(:refund, amount: 10, payment: order.payments.first)- order.update_with_updater!+ order.recalculate_totals!# Order Total - (Payment Total + Reimbursed)# 10 - (0 + 0) = 0expect(order.outstanding_balance).to eq 10diff --git a/spree/core/spec/models/spree/order/updating_spec.rb b/spree/core/spec/models/spree/order/updating_spec.rbindex a4c61e7df9..0b0c442500 100644--- a/spree/core/spec/models/spree/order/updating_spec.rb+++ b/spree/core/spec/models/spree/order/updating_spec.rb@@ -3,18 +3,11 @@ require 'spec_helper'describe Spree::Order, type: :model dolet(:order) { create(:order) }- context '#update_with_updater!' do+ context '#recalculate_totals!' dolet(:line_items) { create_list(:line_item, 1, amount: 5) }- context 'when there are update hooks' do- before { Spree::Order.register_update_hook :foo }-- after { Spree::Order.update_hooks.clear }-- it 'calls each of the update hooks' do- expect(order).to receive :foo- order.update_with_updater!- end+ it 'persists recalculated totals' do+ expect { order.recalculate_totals! }.to change { order.reload.updated_at }endendenddiff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rbindex 0ccfef56c7..69720fda1c 100644--- a/spree/core/spec/models/spree/order_spec.rb+++ b/spree/core/spec/models/spree/order_spec.rb@@ -194,7 +194,7 @@ describe Spree::Order, type: :model doendend- describe '#update_with_updater!' do+ describe '#recalculate_totals!' dolet(:updater) { order.updater }before do@@ -202,10 +202,8 @@ describe Spree::Order, type: :model doallow(updater).to receive(:update).and_return(true)end- after { order.update_with_updater! }-- it 'expects to update order with order updater' do- expect(updater).to receive(:update).and_return(true)+ it 'recalculates and persists totals through the RecalculateTotals flow' do+ expect { order.recalculate_totals! }.to change { order.reload.updated_at }endend@@ -360,8 +358,9 @@ describe Spree::Order, type: :model dolet(:order) { create(:completed_order_with_totals) }it 'publishes order.canceled event' do- expect(order).to receive(:publish_event).with('order.canceled', hash_including(:notify_customer))+ allow(Spree::Events).to receive(:publish)order.canceled_by(admin_user)+ expect(Spree::Events).to have_received(:publish).with('order.canceled', hash_including(:notify_customer), any_args)endendend@@ -441,7 +440,7 @@ describe Spree::Order, type: :model doit 'freezes adjustment recalculation (order-level freeze)' doorder.finalize!expect(Spree::Adjusters::Promotion).not_to receive(:adjust)- order.update_with_updater!+ order.recalculate_totals!endcontext 'order is considered risky' do@@ -551,43 +550,6 @@ describe Spree::Order, type: :model doendend- context 'empty!' do- let(:order) { Spree::Order.create(email: '[email protected]') }- let(:promotion) { create :promotion, code: '10off' }-- before do- promotion.orders << order- end-- context 'completed order' do- before do- order.update_columns(status: 'placed', completed_at: Time.current)- end-- it 'raises an exception' do- expect { order.empty! }.to raise_error(RuntimeError, Spree.t(:cannot_empty_completed_order))- end- end-- context 'incomplete order' do- before do- order.empty!- end-- it 'clears out line items, adjustments and update totals' do- expect(order.line_items.count).to be_zero- expect(order.discounts.count).to be_zero- expect(order.tax_lines.count).to be_zero- expect(order.fees.count).to be_zero- expect(order.shipments.count).to be_zero- expect(order.order_promotions.count).to be_zero- expect(order.promo_total).to be_zero- expect(order.item_total).to be_zero- expect(order.empty!).to eq(order)- end- end- end-describe '#amount_due' dolet(:store_credit) { create(:store_credit, amount: 200, store: order.store, user: order.user) }let(:store_credit_payment_method) { create(:store_credit_payment_method, store: order.store) }@@ -763,12 +725,6 @@ describe Spree::Order, type: :model doSpree::Order.update_hooks = Set.newend- it 'calls hook during update' do- order = create(:order)- expect(order).to receive(:add_awesome_sauce)- order.update_with_updater!- end-it 'calls hook during finalize' doorder = create(:order)expect(order).to receive(:add_awesome_sauce)@@ -844,7 +800,7 @@ describe Spree::Order, type: :model doit 'calls out to the FreeShipping promotion handler' doexpect(Spree::PromotionHandler::FreeShipping).to receive(:new).and_return(handler = double)expect(handler).to receive(:activate)- expect(order).to receive(:update_with_updater!)+ expect(order).to receive(:recalculate_totals!)order.apply_free_shipping_promotionsend@@ -1073,8 +1029,9 @@ describe Spree::Order, type: :model docontext 'events', :events doit 'publishes order.approved event' do- expect(order).to receive(:publish_event).with('order.approved').at_least(:once)+ allow(Spree::Events).to receive(:publish)order.approved_by(admin_user)+ expect(Spree::Events).to have_received(:publish).with('order.approved', any_args)endendend@@ -1109,8 +1066,9 @@ describe Spree::Order, type: :model docontext 'events', :events doit 'publishes order.approved event' do- expect(order).to receive(:publish_event).with('order.approved')+ allow(Spree::Events).to receive(:publish)order.approve!+ expect(Spree::Events).to have_received(:publish).with('order.approved', any_args)endendend@@ -1888,7 +1846,7 @@ describe Spree::Order, type: :model dofree_shipping_promotion.activate(order: order)line_item_promotion.activate(order: order)order_promotion.activate(order: order)- order.update_with_updater!+ order.recalculate_totals!endit 'includes all promotions' do@@ -2664,14 +2622,14 @@ describe Spree::Order, type: :model dodescribe '#quick_checkout_available?' doit 'returns true if the order is fully digital' dodigital_line_item- order.update_with_updater!+ order.recalculate_totals!expect(order.quick_checkout_available?).to be trueendit 'returns true if the order has no digital products at all' dophysical_line_item- order.update_with_updater!+ order.recalculate_totals!expect(order.quick_checkout_available?).to be trueend@@ -2679,7 +2637,7 @@ describe Spree::Order, type: :model doit 'returns false if the order has physical products and some digital products' dophysical_line_itemdigital_line_item- order.update_with_updater!+ order.recalculate_totals!expect(order.quick_checkout_available?).to be falseend@@ -2687,7 +2645,7 @@ describe Spree::Order, type: :model doit 'returns false if order has many shipments' dophysical_line_itemdigital_line_item- order.update_with_updater!+ order.recalculate_totals!order.create_proposed_fulfillmentsexpect(order.shipments.count).to eq(2)@@ -2697,7 +2655,7 @@ describe Spree::Order, type: :model doit 'returns false if order does not require payment' dophysical_line_item.update(price: 0)- order.update_with_updater!+ order.recalculate_totals!expect(order.total).to eq(0)expect(order.payment_required?).to be false@@ -2715,7 +2673,7 @@ describe Spree::Order, type: :model doit 'returns false if the order is digital' dodigital_line_item- order.update_with_updater!+ order.recalculate_totals!expect(order.quick_checkout_require_address?).to be falseenddiff --git a/spree/core/spec/models/spree/order_updater_spec.rb b/spree/core/spec/models/spree/order_updater_spec.rbindex e06b539762..e8d0c1b0a3 100644--- a/spree/core/spec/models/spree/order_updater_spec.rb+++ b/spree/core/spec/models/spree/order_updater_spec.rb@@ -10,7 +10,7 @@ module Spreebefore docreate_list(:line_item, 2, order: order, price: 10)order.reload- order.update_with_updater!+ order.recalculate_totals!endit 'updates payment totals' do@@ -71,12 +71,12 @@ module Spreeendend- describe '#update_with_updater!' do+ describe '#recalculate_totals!' doit 'updates item count' docreate(:line_item, order: order)create(:line_item, order: order)- order.update_with_updater!+ order.recalculate_totals!expect(order.item_count).to eq(2)end@@ -220,20 +220,12 @@ module Spreebefore { order.update(completed_at: Time.current) }describe '#update' do- it 'updates payment state' do- expect(updater).to receive(:update_payment_state)- updater.update- end-- it 'updates fulfillment status' do- expect(updater).to receive(:update_fulfillment_status)- updater.update- end-- it 'updates delivery total again after updating fulfillments' do- expect(updater).to receive(:update_delivery_total).ordered- expect(updater).to receive(:update_fulfillments).ordered- expect(updater).to receive(:update_delivery_total).ordered+ it 'delegates to Carts::RecalculateTotals with a deprecation warning, money only' do+ expect(Spree::Deprecation).to receive(:warn).with(/updater#update is deprecated/i)+ expect(updater).not_to receive(:update_payment_state)+ expect(updater).not_to receive(:update_fulfillments)+ expect(updater).to receive(:update_totals).and_call_original+ expect(updater).to receive(:persist_totals).and_call_originalupdater.updateendenddiff --git a/spree/core/spec/models/spree/promotion_handler/coupon_spec.rb b/spree/core/spec/models/spree/promotion_handler/coupon_spec.rbindex 98145b8ce5..35d9109d30 100644--- a/spree/core/spec/models/spree/promotion_handler/coupon_spec.rb+++ b/spree/core/spec/models/spree/promotion_handler/coupon_spec.rb@@ -90,8 +90,8 @@ module Spreeexpect(order.reload.total).to eq(100)end- it 'calls update_with_updater!' do- expect(order).to receive(:update_with_updater!)+ it 'calls recalculate_totals!' do+ expect(order).to receive(:recalculate_totals!)subject.applyenddiff --git a/spree/core/spec/models/spree/promotion_spec.rb b/spree/core/spec/models/spree/promotion_spec.rbindex 17005aa7c5..957907f6af 100644--- a/spree/core/spec/models/spree/promotion_spec.rb+++ b/spree/core/spec/models/spree/promotion_spec.rb@@ -802,7 +802,7 @@ describe Spree::Promotion, type: :model docontext 'when the user has used this promo' dobefore dopromotion.activate(order: order)- order.update_with_updater!+ order.recalculate_totals!order.completed_at = Time.currentorder.save!end@@ -848,7 +848,7 @@ describe Spree::Promotion, type: :model doexpect(order.adjustment_total).to eq 0promo.activate(order: order)- order.update_with_updater!+ order.recalculate_totals!line_item.reloadexpect(line_item.discounts.size).to eq(1)diff --git a/spree/core/spec/models/spree/promotion_tax_recalculation_spec.rb b/spree/core/spec/models/spree/promotion_tax_recalculation_spec.rbindex a7b8da020f..6e1174c2d1 100644--- a/spree/core/spec/models/spree/promotion_tax_recalculation_spec.rb+++ b/spree/core/spec/models/spree/promotion_tax_recalculation_spec.rb@@ -27,7 +27,7 @@ describe 'Promotion discounts and the taxable basis', type: :model doline_item# the order instance may hold a stale (empty) cached line_items associationorder.reload- order.update_with_updater!+ order.recalculate_totals!order.reloadend@@ -55,7 +55,7 @@ describe 'Promotion discounts and the taxable basis', type: :model do# completed order keeps.def rebuild_tax_like_checkout!order.create_tax_charge!- order.update_with_updater!+ order.recalculate_totals!order.reloadenddiff --git a/spree/core/spec/models/spree/refund_spec.rb b/spree/core/spec/models/spree/refund_spec.rbindex a632346806..0d6d53cb58 100644--- a/spree/core/spec/models/spree/refund_spec.rb+++ b/spree/core/spec/models/spree/refund_spec.rb@@ -113,9 +113,8 @@ describe Spree::Refund, type: :model dosubjectend- it 'updates the payment total' do- expect(payment.order.updater).to receive(:update)- subject+ it 'recalculates order totals' do+ expect { subject }.to change { payment.order.reload.updated_at }endenddiff --git a/spree/core/spec/models/spree/shipment_spec.rb b/spree/core/spec/models/spree/shipment_spec.rbindex 93e85c3422..6522d14b34 100644--- a/spree/core/spec/models/spree/shipment_spec.rb+++ b/spree/core/spec/models/spree/shipment_spec.rb@@ -99,7 +99,7 @@ describe Spree::Shipment, type: :model dolet(:shipment) { create(:shipment, stock_location: create(:stock_location)) }before do- allow(order).to receive :update_with_updater!+ allow(order).to receive :recalculate_totals!endit 'generates a number containing a letter + 11 numbers' do@@ -431,7 +431,7 @@ describe Spree::Shipment, type: :model doit 'returns true if order is digital and it does not have a ship address' doorder.ship_address = nilorder.line_items = [digital_line_item]- order.update_with_updater!+ order.recalculate_totals!expect(order.digital?).to eq(true)expect(shipment.send(:can_get_rates?)).to be_truthyend@@ -653,7 +653,7 @@ describe Spree::Shipment, type: :model dolet(:inventory_unit) { create(:inventory_unit, state: 'on_hand', line_item: line_item, variant: variant, quantity: 1) }it 'cancels the shipment' do- allow(shipment.order).to receive(:update_with_updater!)+ allow(shipment.order).to receive(:recalculate_totals!)shipment.state = 'pending'expect(shipment).to receive(:after_cancel)@@ -701,7 +701,7 @@ describe Spree::Shipment, type: :model dolet(:inventory_unit) { create(:inventory_unit, quantity: 1, line_item: line_item, variant: variant) }it 'transitions state to ready if the order is ready' do- allow(shipment.order).to receive(:update_with_updater!)+ allow(shipment.order).to receive(:recalculate_totals!)shipment.state = 'canceled'expect(shipment).to receive(:determine_state).and_return('ready')@@ -711,7 +711,7 @@ describe Spree::Shipment, type: :model doendit 'transitions state to pending if the order is not ready' do- allow(shipment.order).to receive(:update_with_updater!)+ allow(shipment.order).to receive(:recalculate_totals!)shipment.state = 'canceled'expect(shipment).to receive(:determine_state).and_return('pending')@@ -746,7 +746,7 @@ describe Spree::Shipment, type: :model dolet(:subject) { shipment_with_inventory_units.ship! }before do- allow(order).to receive(:update_with_updater!)+ allow(order).to receive(:recalculate_totals!)allow(shipment_with_inventory_units).to receive_messages(require_inventory: false, update_order: true)end@@ -760,7 +760,7 @@ describe Spree::Shipment, type: :model do['ready', 'canceled'].each do |status|context "from #{status}" dobefore do- allow(order).to receive(:update_with_updater!)+ allow(order).to receive(:recalculate_totals!)allow(shipment).to receive_messages(require_inventory: false, update_order: true, status: status)end@@ -849,7 +849,7 @@ describe Spree::Shipment, type: :model doit 'leaves typed adjustment columns to the order recalculation' docreate(:fee, order: shipment.order, fulfillment: shipment, label: 'Additional', amount: 5)- shipment.order.update_with_updater!+ shipment.order.recalculate_totals!expect(shipment.reload.adjustment_total).to eq(5)endend@@ -966,13 +966,13 @@ describe Spree::Shipment, type: :model doendit 'triggers the order recalculation' do- expect(shipment.order).to receive(:update_with_updater!)+ expect(shipment.order).to receive(:recalculate_totals!)shipment.saveendit 'does not trigger recalculation if shipment is fulfilled' doshipment.status = 'fulfilled'- expect(shipment.order).not_to receive(:update_with_updater!)+ expect(shipment.order).not_to receive(:recalculate_totals!)shipment.saveendend@@ -980,7 +980,7 @@ describe Spree::Shipment, type: :model docontext 'cost does not change' doit 'does not trigger the order recalculation' doshipment.save!- expect(shipment.order).not_to receive(:update_with_updater!)+ expect(shipment.order).not_to receive(:recalculate_totals!)shipment.saveendenddiff --git a/spree/core/spec/models/spree/tax_rate_spec.rb b/spree/core/spec/models/spree/tax_rate_spec.rbindex e4a4d372f1..1182cd0600 100644--- a/spree/core/spec/models/spree/tax_rate_spec.rb+++ b/spree/core/spec/models/spree/tax_rate_spec.rb@@ -194,14 +194,14 @@ describe Spree::TaxRate, type: :model doendit 'without an address costs 100 euros including tax' do- order.update_with_updater!+ order.recalculate_totals!expect(order.display_total).to eq(Spree::Money.new(100))expect(order.included_tax_total).to eq(15.97)endit 'to germany costs 100 euros including tax' doallow(order).to receive(:tax_zone).and_return(germany_zone)- order.update_with_updater!+ order.recalculate_totals!expect(order.display_total).to eq(Spree::Money.new(100))expect(order.included_tax_total).to eq(15.97)end@@ -209,7 +209,7 @@ describe Spree::TaxRate, type: :model doit 'to france costs more including tax' doallow(order).to receive(:tax_zone).and_return(france_zone)order.update_line_item_prices!- order.update_with_updater!+ order.recalculate_totals!expect(order.display_total).to eq(Spree::Money.new(105.04))expect(order.included_tax_total).to eq(21.01)expect(order.additional_tax_total).to eq(0)@@ -218,7 +218,7 @@ describe Spree::TaxRate, type: :model doit 'to somewhere else costs the net amount' doallow(order).to receive(:tax_zone).and_return(india_zone)order.update_line_item_prices!- order.update_with_updater!+ order.recalculate_totals!expect(order.included_tax_total).to eq(0)expect(order.display_total).to eq(Spree::Money.new(84.03))end@@ -228,7 +228,7 @@ describe Spree::TaxRate, type: :model doit 'to germany costs 100 euros including tax' doallow(order).to receive(:tax_zone).and_return(germany_zone)Spree::Carts::AddItem.call(order: order, variant: tshirt.default_variant)- order.update_with_updater!+ order.recalculate_totals!expect(order.display_total).to eq(Spree::Money.new(100))expect(order.included_tax_total).to eq(15.97)end@@ -237,7 +237,7 @@ describe Spree::TaxRate, type: :model doallow(order).to receive(:tax_zone).and_return(france_zone)Spree::Carts::AddItem.call(order: order, variant: tshirt.default_variant)order.update_line_item_prices!- order.update_with_updater!+ order.recalculate_totals!expect(order.display_total).to eq(Spree::Money.new(100.00))expect(order.included_tax_total).to eq(15.97)expect(order.additional_tax_total).to eq(0)@@ -247,7 +247,7 @@ describe Spree::TaxRate, type: :model doallow(order).to receive(:tax_zone).and_return(india_zone)Spree::Carts::AddItem.call(order: order, variant: tshirt.default_variant)order.update_line_item_prices!- order.update_with_updater!+ order.recalculate_totals!expect(order.included_tax_total).to eq(0)expect(order.display_total).to eq(Spree::Money.new(84.03))enddiff --git a/spree/core/spec/services/spree/carts/update_spec.rb b/spree/core/spec/services/spree/carts/update_spec.rbindex 847ef763d8..d113ab1670 100644--- a/spree/core/spec/services/spree/carts/update_spec.rb+++ b/spree/core/spec/services/spree/carts/update_spec.rb@@ -6,17 +6,17 @@ module Spreelet!(:store_stock_location) { create(:stock_location, store: store, backorderable_default: true) }let!(:store_delivery_method) { create(:shipping_method, store: store) }let(:user) { create(:user) }- let(:order) { create(:order_with_line_items, user: user, store: store, currency: 'USD') }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, currency: 'USD') }describe '#call' do- subject { described_class.call(cart: order, params: params) }+ subject { described_class.call(cart: cart, params: params) }describe 'updating email' dolet(:params) { { email: '[email protected]' } }- it 'updates the order email' do+ it 'updates the cart email' doexpect(subject).to be_success- expect(order.reload.email).to eq('[email protected]')+ expect(cart.reload.email).to eq('[email protected]')endend@@ -25,22 +25,22 @@ module Spreeit 'updates the customer note' doexpect(subject).to be_success- expect(order.reload.special_instructions).to eq('Leave at the door')+ expect(cart.reload.special_instructions).to eq('Leave at the door')endcontext 'when clearing customer_note' do- let(:order) { create(:order_with_line_items, user: user, store: store, special_instructions: 'Existing instructions') }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, special_instructions: 'Existing instructions') }it 'clears with empty string' do- result = described_class.call(cart: order, params: { customer_note: '' })+ result = described_class.call(cart: cart, params: { customer_note: '' })expect(result).to be_success- expect(order.reload.special_instructions).to eq('')+ expect(cart.reload.special_instructions).to eq('')endit 'clears with nil' do- result = described_class.call(cart: order, params: { customer_note: nil })+ result = described_class.call(cart: cart, params: { customer_note: nil })expect(result).to be_success- expect(order.reload.special_instructions).to be_nil+ expect(cart.reload.special_instructions).to be_nilendendend@@ -51,13 +51,13 @@ module Spreeit 'updates the currency' doexpect(subject).to be_success- expect(order.reload.currency).to eq('EUR')+ expect(cart.reload.currency).to eq('EUR')endit 'is case-insensitive' do- result = described_class.call(cart: order, params: { currency: 'eur' })+ result = described_class.call(cart: cart, params: { currency: 'eur' })expect(result).to be_success- expect(order.reload.currency).to eq('EUR')+ expect(cart.reload.currency).to eq('EUR')endend@@ -70,7 +70,7 @@ module Spreeit 'does not change the currency' dosubject- expect(order.reload.currency).to eq('USD')+ expect(cart.reload.currency).to eq('USD')endend@@ -79,38 +79,38 @@ module Spreelet(:de_country) { create(:country, iso: 'DE', name: 'Germany') }let!(:us_market) { store.default_market }let!(:eu_market) { create(:market, :eu, store: store, countries: [de_country]) }- let(:order) { create(:order_with_line_items, user: user, store: store, market: us_market, currency: 'USD') }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, currency: 'USD') }it 'switches market when currency changes' do- result = described_class.call(cart: order, params: { currency: 'EUR' })+ result = described_class.call(cart: cart, params: { currency: 'EUR' })expect(result).to be_success- expect(order.reload.currency).to eq('EUR')- expect(order.market).to eq(eu_market)+ expect(cart.reload.currency).to eq('EUR')+ expect(cart.market).to eq(eu_market)endit 'does not switch market when currency matches current market' do- result = described_class.call(cart: order, params: { currency: 'USD' })+ result = described_class.call(cart: cart, params: { currency: 'USD' })expect(result).to be_success- expect(order.reload.market).to eq(us_market)+ expect(cart.reload.market).to eq(us_market)endit 'does not switch market when market_id is explicitly provided' do- result = described_class.call(cart: order, params: { currency: 'EUR', market_id: us_market.prefixed_id })+ result = described_class.call(cart: cart, params: { currency: 'EUR', market_id: us_market.prefixed_id })expect(result).to be_success- expect(order.reload.market).to eq(us_market)+ expect(cart.reload.market).to eq(us_market)endit 'keeps the current market when no market exists for the currency' do# GBP is store-supported via the legacy column; without a GBP# market the cart keeps its current market.- result = described_class.call(cart: order, params: { currency: 'GBP' })+ result = described_class.call(cart: cart, params: { currency: 'GBP' })expect(result).to be_success- expect(order.reload.currency).to eq('GBP')- expect(order.market).to eq(us_market)+ expect(cart.reload.currency).to eq('GBP')+ expect(cart.market).to eq(us_market)endendend@@ -127,7 +127,7 @@ module Spreeit 'updates the market' doexpect(subject).to be_success- expect(order.reload.market).to eq(eu_market)+ expect(cart.reload.market).to eq(eu_market)endend@@ -142,31 +142,31 @@ module Spreecontext 'when shipping address country is not in the new market' dolet!(:us_state) { us_country.states.find_by(abbr: 'NY') || create(:state, country: us_country, abbr: 'NY', name: 'New York') }let(:us_address) { create(:address, country: us_country, state: us_state) }- let(:order) { create(:order_with_line_items, user: user, store: store, market: us_market, ship_address: us_address, state: 'delivery') }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, ship_address: us_address, email: '[email protected]') }let(:params) { { market_id: eu_market.prefixed_id } }it 'clears the shipping address' do- expect(order.ship_address).to be_present+ expect(cart.ship_address).to be_presentexpect(subject).to be_success- expect(order.reload.ship_address).to be_nil+ expect(cart.reload.ship_address).to be_nilend- it 'reverts checkout state to address' do+ it 'drops delivery proposals built for the cleared address' do+ cart.create_proposed_fulfillments+ expect(cart.fulfillments).to be_presentexpect(subject).to be_success- # After revert + try_advance, state depends on checkout flow- # but it should not remain past address without a valid shipping address- expect(order.reload.fulfillments).to be_empty+ expect(cart.reload.fulfillments).to be_emptyendendcontext 'when shipping address country is in the new market' dolet(:de_address) { create(:address, country: de_country) }- let(:order) { create(:order_with_line_items, user: user, store: store, market: us_market, ship_address: de_address) }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, ship_address: de_address) }let(:params) { { market_id: eu_market.prefixed_id } }it 'keeps the shipping address' doexpect(subject).to be_success- expect(order.reload.ship_address).to eq(de_address)+ expect(cart.reload.ship_address).to eq(de_address)endendend@@ -197,7 +197,7 @@ module Spreeit 'creates a new address' doexpect(subject).to be_success- address = order.reload.public_send(address_key)+ address = cart.reload.public_send(address_key)expect(address.first_name).to eq('John')expect(address.last_name).to eq('Doe')expect(address.address1).to eq('123 Main St')@@ -207,40 +207,14 @@ module Spreeexpect(address.state.abbr).to eq('NY')end- context 'when order has address checkout step and is past address state' do- let(:order) { create(:order_with_line_items, user: user, store: store, state: 'delivery') }-- it 'reverts to address then auto-advances to payment' do- expect(subject).to be_success- expect(order.reload.fulfillments).to be_present- end- end-- context 'when order is in cart state' do- let(:order) { create(:order_with_line_items, user: user, store: store, state: 'cart') }-- it 'auto-advances to payment' do- expect(subject).to be_success- expect(order.reload.fulfillments).to be_present- end- end-- context 'when order is fully covered by store credit payment' do- let(:order) { create(:order_with_line_items, user: user, store: store, state: 'cart') }-+ context 'when the cart is fully covered by store credit payment' dobefore do- create(:store_credit_payment, order: order, amount: order.total)- end-- it 'does not auto-complete the order' do- expect(subject).to be_success- expect(order.reload.completed?).to be(false)+ create(:store_credit_payment, cart: cart, amount: cart.total)end- it 'stops at the last step before complete' do+ it 'does not auto-complete the cart' doexpect(subject).to be_success- steps = order.checkout_steps- expect(order.reload.completed?).to be(false)+ expect(cart.reload.completed?).to be(false)endendend@@ -251,7 +225,7 @@ module Spreeit 'uses the existing address' doexpect(subject).to be_success- expect(order.reload.public_send(address_id_key)).to eq(existing_address.id)+ expect(cart.reload.public_send(address_id_key)).to eq(existing_address.id)endend@@ -261,13 +235,42 @@ module Spreeit 'uses the existing address' doexpect(subject).to be_success- expect(order.reload.public_send(address_id_key)).to eq(existing_address.id)+ expect(cart.reload.public_send(address_id_key)).to eq(existing_address.id)endendenddescribe 'shipping_address' doinclude_examples 'address update', :shipping_address++ describe 'delivery proposals' do+ let(:params) do+ {+ shipping_address: {+ first_name: 'John', last_name: 'Doe',+ address1: '123 Main St', city: 'New York',+ postal_code: '10001', country_iso: 'US', state_abbr: 'NY',+ phone: '555-1234'+ }+ }+ end++ context 'when the cart is already mid-checkout' do+ let(:cart) { create(:cart_with_line_items, user: user, store: store, email: '[email protected]', ship_address: create(:address, user: user)) }++ it 'rebuilds delivery proposals for the new address' do+ expect(subject).to be_success+ expect(cart.reload.fulfillments).to be_present+ end+ end++ context 'when the cart is still in the shopping phase' do+ it 'builds delivery proposals once the address arrives' do+ expect(subject).to be_success+ expect(cart.reload.fulfillments).to be_present+ end+ end+ endenddescribe 'billing_address' do@@ -278,7 +281,7 @@ module Spreedescribe 'billing address does not reset checkout state' dolet(:country) { Spree::Country.find_by(iso: 'US') || create(:country, iso: 'US') }let!(:state) { country.states.find_by(abbr: 'NY') || create(:state, country: country, abbr: 'NY', name: 'New York') }- let(:order) { create(:order_with_line_items, user: user, store: store, state: 'delivery') }+ let(:cart) { create(:cart_with_line_items, user: user, store: store, email: '[email protected]', ship_address: create(:address, user: user)) }let(:params) do{@@ -295,17 +298,14 @@ module Spree}end- it 'does not revert order state to address' do- # Capture shipments before the update- order.reload- shipment_ids = order.shipments.pluck(:id)- expect(shipment_ids).not_to be_empty+ it 'preserves existing delivery proposals' do+ cart.create_proposed_fulfillments+ fulfillment_ids = cart.fulfillments.pluck(:id)+ expect(fulfillment_ids).not_to be_emptyexpect(subject).to be_success- order.reload- # Shipments should be preserved (not recreated)- expect(order.shipments.pluck(:id)).to eq(shipment_ids)+ expect(cart.reload.fulfillments.pluck(:id)).to eq(fulfillment_ids)endend@@ -328,39 +328,39 @@ module Spreeit 'copies shipping address to billing address' do# First set a shipping address- result = described_class.call(cart: order, params: { shipping_address: shipping_address })+ result = described_class.call(cart: cart, params: { shipping_address: shipping_address })expect(result).to be_success# Then use_shipping to copy it to billing- result = described_class.call(cart: order, params: { use_shipping: true })+ result = described_class.call(cart: cart, params: { use_shipping: true })expect(result).to be_success- order.reload- expect(order.bill_address).to be_present- expect(order.bill_address.first_name).to eq('John')- expect(order.bill_address.address1).to eq('123 Main St')- expect(order.bill_address.postal_code).to eq('10001')+ cart.reload+ expect(cart.bill_address).to be_present+ expect(cart.bill_address.first_name).to eq('John')+ expect(cart.bill_address.address1).to eq('123 Main St')+ expect(cart.bill_address.postal_code).to eq('10001')endit 'works when set alongside shipping address in the same request' doparams = { shipping_address: shipping_address, use_shipping: true }- result = described_class.call(cart: order, params: params)+ result = described_class.call(cart: cart, params: params)expect(result).to be_success- order.reload- expect(order.ship_address.first_name).to eq('John')- expect(order.bill_address.first_name).to eq('John')- expect(order.bill_address.address1).to eq(order.ship_address.address1)+ cart.reload+ expect(cart.ship_address.first_name).to eq('John')+ expect(cart.bill_address.first_name).to eq('John')+ expect(cart.bill_address.address1).to eq(cart.ship_address.address1)endit 'does not copy when use_shipping is false' do# Set shipping address first- described_class.call(cart: order, params: { shipping_address: shipping_address })- original_bill_address_id = order.reload.bill_address_id+ described_class.call(cart: cart, params: { shipping_address: shipping_address })+ original_bill_address_id = cart.reload.bill_address_id- result = described_class.call(cart: order, params: { use_shipping: false })+ result = described_class.call(cart: cart, params: { use_shipping: false })expect(result).to be_success- expect(order.reload.bill_address_id).to eq(original_bill_address_id)+ expect(cart.reload.bill_address_id).to eq(original_bill_address_id)endend@@ -373,10 +373,10 @@ module Spreelet(:params) { { address_type => { id: other_users_address.prefixed_id } } }it 'ignores the address and keeps original' do- original_address_id = order.public_send(:"#{address_type}_id")+ original_address_id = cart.public_send(:"#{address_type}_id")expect(subject).to be_success- expect(order.reload.public_send(:"#{address_type}_id")).to eq(original_address_id)- expect(order.public_send(:"#{address_type}_id")).not_to eq(other_users_address.id)+ expect(cart.reload.public_send(:"#{address_type}_id")).to eq(original_address_id)+ expect(cart.public_send(:"#{address_type}_id")).not_to eq(other_users_address.id)endend@@ -384,10 +384,10 @@ module Spreelet(:params) { { :"#{address_type}_id" => other_users_address.prefixed_id } }it 'ignores the address and keeps original' do- original_address_id = order.public_send(:"#{address_type}_id")+ original_address_id = cart.public_send(:"#{address_type}_id")expect(subject).to be_success- expect(order.reload.public_send(:"#{address_type}_id")).to eq(original_address_id)- expect(order.public_send(:"#{address_type}_id")).not_to eq(other_users_address.id)+ expect(cart.reload.public_send(:"#{address_type}_id")).to eq(original_address_id)+ expect(cart.public_send(:"#{address_type}_id")).not_to eq(other_users_address.id)endendend@@ -395,14 +395,14 @@ module Spreeinclude_examples 'ignores other users address', :shipping_addressinclude_examples 'ignores other users address', :billing_address- context 'when order has no user (guest order)' do- let(:order) { create(:order_with_line_items, user: nil, store: store) }+ context 'when the cart has no user (guest cart)' do+ let(:cart) { create(:cart_with_line_items, user: nil, store: store) }let(:params) { { shipping_address_id: other_users_address.prefixed_id } }it 'ignores address_id params and keeps existing address' do- original_address_id = order.ship_address_id+ original_address_id = cart.ship_address_idexpect(subject).to be_success- expect(order.reload.ship_address_id).to eq(original_address_id)+ expect(cart.reload.ship_address_id).to eq(original_address_id)endendend@@ -410,19 +410,19 @@ module Spreedescribe 'updating metadata' dolet(:params) { { metadata: { 'erp_id' => '12345', 'source' => 'mobile' } } }- it 'merges metadata into the order' do+ it 'merges metadata into the cart' doexpect(subject).to be_success- expect(order.reload.metadata).to include('erp_id' => '12345', 'source' => 'mobile')+ expect(cart.reload.metadata).to include('erp_id' => '12345', 'source' => 'mobile')endcontext 'with existing metadata' do- before { order.update!(metadata: { 'existing_key' => 'existing_value' }) }+ before { cart.update!(metadata: { 'existing_key' => 'existing_value' }) }let(:params) { { metadata: { 'new_key' => 'new_value' } } }it 'merges without removing existing keys' doexpect(subject).to be_success- expect(order.reload.metadata).to include('existing_key' => 'existing_value', 'new_key' => 'new_value')+ expect(cart.reload.metadata).to include('existing_key' => 'existing_value', 'new_key' => 'new_value')endendend@@ -449,10 +449,10 @@ module Spreeit 'updates all fields in a single transaction' doexpect(subject).to be_success- order.reload- expect(order.email).to eq('[email protected]')- expect(order.customer_note).to eq('Handle with care')- expect(order.shipping_address.first_name).to eq('John')+ cart.reload+ expect(cart.email).to eq('[email protected]')+ expect(cart.customer_note).to eq('Handle with care')+ expect(cart.shipping_address.first_name).to eq('John')endend@@ -473,17 +473,17 @@ module Spree}end- it 'adds line items to the order' do+ it 'adds line items to the cart' doexpect(subject).to be_success- order.reload- line_item = order.line_items.find_by(variant: variant)+ cart.reload+ line_item = cart.line_items.find_by(variant: variant)expect(line_item).to be_presentexpect(line_item.quantity).to eq(2)endendcontext 'with existing line item (upsert)' do- let!(:existing_line_item) { order.line_items.first }+ let!(:existing_line_item) { cart.line_items.first }let(:existing_variant) { existing_line_item.variant }before do@@ -527,17 +527,17 @@ module Spreelet(:params) { { shipping_address_id: 'addr_invalid123' } }it 'succeeds but does not change the address' do- original_address_id = order.ship_address_id+ original_address_id = cart.ship_address_idexpect(subject).to be_success- expect(order.reload.ship_address_id).to eq(original_address_id)+ expect(cart.reload.ship_address_id).to eq(original_address_id)endend- context 'when order save fails' do+ context 'when the cart save fails' dolet(:params) { { email: '[email protected]' } }before do- allow(order).to receive(:save!).and_raise(ActiveRecord::RecordInvalid.new(order))+ allow(cart).to receive(:save!).and_raise(ActiveRecord::RecordInvalid.new(cart))endit 'returns failure with error message' do@@ -551,7 +551,7 @@ module Spreeit 'handles string keys' doexpect(subject).to be_success- expect(order.reload.email).to eq('[email protected]')+ expect(cart.reload.email).to eq('[email protected]')endenddiff --git a/spree/core/spec/services/spree/carts/upsert_items_spec.rb b/spree/core/spec/services/spree/carts/upsert_items_spec.rbindex b9eb0a5ba6..847daa4ee9 100644--- a/spree/core/spec/services/spree/carts/upsert_items_spec.rb+++ b/spree/core/spec/services/spree/carts/upsert_items_spec.rb@@ -4,7 +4,7 @@ module SpreeRSpec.describe Carts::UpsertItems dolet(:store) { create(:store) }let(:user) { create(:user) }- let(:cart) { create(:order, user: user, store: store) }+ let(:cart) { create(:cart, user: user, store: store) }let(:variant) { create(:variant) }let(:variant2) { create(:variant) }@@ -43,7 +43,7 @@ module Spreeendcontext 'upserting existing line items' do- let!(:existing_line_item) { create(:line_item, order: cart, variant: variant, quantity: 5) }+ let!(:existing_line_item) { create(:line_item, cart: cart, order: nil, variant: variant, quantity: 5) }let(:items) do[{ variant_id: variant.prefixed_id, quantity: 2 }]@@ -56,7 +56,7 @@ module Spreeendcontext 'mix of new and existing line items' do- let!(:existing_line_item) { create(:line_item, order: cart, variant: variant, quantity: 5) }+ let!(:existing_line_item) { create(:line_item, cart: cart, order: nil, variant: variant, quantity: 5) }let(:items) do[@@ -93,7 +93,7 @@ module Spreeendcontext 'merging metadata on existing line item' do- let!(:existing_line_item) { create(:line_item, order: cart, variant: variant, quantity: 1, private_metadata: { 'existing' => 'val' }) }+ let!(:existing_line_item) { create(:line_item, cart: cart, order: nil, variant: variant, quantity: 1, private_metadata: { 'existing' => 'val' }) }let(:items) do[{ variant_id: variant.prefixed_id, quantity: 2, metadata: { 'new_key' => 'new_val' } }]@@ -146,7 +146,7 @@ module Spreeendcontext 'with variant not available in cart currency' do- let(:cart) { create(:order, user: user, store: store, currency: 'GBP') }+ let(:cart) { create(:cart, user: user, store: store, currency: 'GBP') }let(:items) { [{ variant_id: variant.prefixed_id, quantity: 1 }] }it 'returns failure with message' do@@ -241,7 +241,7 @@ module Spreeendcontext 'does not touch unrelated existing line items' do- let!(:unrelated_line_item) { create(:line_item, order: cart, variant: variant, quantity: 3) }+ let!(:unrelated_line_item) { create(:line_item, cart: cart, order: nil, variant: variant, quantity: 3) }let(:items) do[{ variant_id: variant2.prefixed_id, quantity: 1 }]diff --git a/spree/core/spec/services/spree/fulfillments/create_spec.rb b/spree/core/spec/services/spree/fulfillments/create_spec.rbindex ab1cfb8729..7cffc5c3e7 100644--- a/spree/core/spec/services/spree/fulfillments/create_spec.rb+++ b/spree/core/spec/services/spree/fulfillments/create_spec.rb@@ -204,7 +204,7 @@ module Spreeparams[:delivery_method] = delivery_method# Settle factory-persisted totals before measuring invariance.- order.update_with_updater!+ order.recalculate_totals!original_total = order.reload.totalsource_shipment_cost = source_shipment.reload.costdiff --git a/spree/core/spec/services/spree/gift_cards/apply_spec.rb b/spree/core/spec/services/spree/gift_cards/apply_spec.rbindex 50bb8e183d..ffc91c3738 100644--- a/spree/core/spec/services/spree/gift_cards/apply_spec.rb+++ b/spree/core/spec/services/spree/gift_cards/apply_spec.rb@@ -36,8 +36,8 @@ RSpec.describe Spree::GiftCards::Apply doexpect(store_credit.originator).to eq(gift_card)end- it 'calls update_with_updater!' do- expect(order).to receive(:update_with_updater!)+ it 'calls recalculate_totals!' do+ expect(order).to receive(:recalculate_totals!)subjectend@@ -82,8 +82,8 @@ RSpec.describe Spree::GiftCards::Apply doexpect(subject).to be_successend- it 'calls update_with_updater!' do- expect(order).to receive(:update_with_updater!)+ it 'calls recalculate_totals!' do+ expect(order).to receive(:recalculate_totals!)subjectendenddiff --git a/spree/core/spec/services/spree/gift_cards/remove_spec.rb b/spree/core/spec/services/spree/gift_cards/remove_spec.rbindex 5cb8c2e1a2..2be39a4ffd 100644--- a/spree/core/spec/services/spree/gift_cards/remove_spec.rb+++ b/spree/core/spec/services/spree/gift_cards/remove_spec.rb@@ -39,8 +39,8 @@ RSpec.describe Spree::GiftCards::Remove doexpect(store_credit_payment.source).to be_deletedend- it 'calls update_with_updater!' do- expect(order).to receive(:update_with_updater!)+ it 'calls recalculate_totals!' do+ expect(order).to receive(:recalculate_totals!)subjectenddiff --git a/spree/core/spec/services/spree/orders/cancel_spec.rb b/spree/core/spec/services/spree/orders/cancel_spec.rbindex 568899fa52..504c76efdb 100644--- a/spree/core/spec/services/spree/orders/cancel_spec.rb+++ b/spree/core/spec/services/spree/orders/cancel_spec.rb@@ -15,9 +15,10 @@ module Spreeit { expect { result }.to change(order, :status).to('canceled') }it { expect(result.value).to eq(order) }- it 'publishes order.canceled event' do- expect(order).to receive(:publish_event).with('order.canceled', hash_including(:notify_customer))+ it 'publishes order.canceled event', :events do+ allow(Spree::Events).to receive(:publish)result+ expect(Spree::Events).to have_received(:publish).with('order.canceled', hash_including(:notify_customer), any_args)endend@@ -27,9 +28,10 @@ module Spreeit { expect(result).to be_failure }it { expect(result.error).to be_present }- it 'does not publish order.canceled event' do- expect(order).not_to receive(:publish_event).with('order.canceled')+ it 'does not publish order.canceled event', :events do+ allow(Spree::Events).to receive(:publish)result+ expect(Spree::Events).not_to have_received(:publish).with('order.canceled', any_args)endendenddiff --git a/spree/core/spec/services/spree/carts/complete_spec.rb b/spree/core/spec/workflows/spree/carts/complete_spec.rbsimilarity index 100%rename from spree/core/spec/services/spree/carts/complete_spec.rbrename to spree/core/spec/workflows/spree/carts/complete_spec.rbdiff --git a/spree/core/spec/services/spree/carts/legacy_add_item_spec.rb b/spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rbsimilarity index 100%rename from spree/core/spec/services/spree/carts/legacy_add_item_spec.rbrename to spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb