Skip to content

armgit / spree

Public Imported from GitHub
0

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.

Add Spree::Workflow and the two-tier services doctrine

Damian Legawiecc6fd70713e47
diff --git a/CLAUDE.md b/CLAUDE.md
index 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 Organization
diff --git a/docs/plans/6.0-service-workflows.md b/docs/plans/6.0-service-workflows.md
new file mode 100644
index 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.md
index 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-carrier
gem for delivery rates (pick still pending; Integration + provider
pair). Stripe Tax remains buildable by third parties but is not the
reference — 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.rb
index 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 Spree
def recalculate
return if @cart.complete? || @cart.canceled?
- @cart.update_with_updater!
+ @cart.recalculate_totals!
rescue StandardError => e
Rails.error.report(e, context: { order_id: @cart.id }, source: 'spree.checkout')
ensure
diff --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.rb
index 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: :co
it 'removes the promotion and clears the stored code' do
order.update!(coupon_code: 'save5')
- order.update_with_updater!
+ order.recalculate_totals!
expect(order.reload.discounts.where(promotion_id: promotion.id)).to be_present
delete :destroy, params: { order_id: order.prefixed_id, id: 'save5' }, as: :json
diff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rb
index 40f1611adf..3a5a237729 100644
--- a/spree/core/app/models/spree/cart.rb
+++ b/spree/core/app/models/spree/cart.rb
@@ -134,7 +134,9 @@ module Spree
self.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 Spree
bill_address == ship_address
end
+ def use_shipping?
+ use_shipping.in?([true, 'true', '1'])
+ end
+
def quantity
line_items.sum(:quantity)
end
@@ -364,7 +379,7 @@ module Spree
line_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 Spree
private
+ # 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_store
return if currency.blank? || store.blank?
diff --git a/spree/core/app/models/spree/cart_updater.rb b/spree/core/app/models/spree/cart_updater.rb
index 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 Spree
class CartUpdater < OrderUpdater
alias 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_total
cart.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }
end
diff --git a/spree/core/app/models/spree/fulfillment.rb b/spree/core/app/models/spree/fulfillment.rb
index 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?
end
end
end
diff --git a/spree/core/app/models/spree/fulfillment_changer.rb b/spree/core/app/models/spree/fulfillment_changer.rb
index 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 Spree
desired_shipment.update_amounts
desired_shipment.order.reload
- desired_shipment.order.update_with_updater!
+ desired_shipment.order.recalculate_totals!
end
def new_on_hand_quantity
diff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rb
index 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)
end
def disassociate_user!
@@ -905,7 +914,7 @@ module Spree
def apply_free_shipping_promotions
Spree::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 Spree
payments.store_credits.pending.each(&:void!)
end
- update_with_updater!
+ recalculate_totals!
send_order_canceled_webhook
end
diff --git a/spree/core/app/models/spree/order/currency_updater.rb b/spree/core/app/models/spree/order/currency_updater.rb
index 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 Spree
included do
def homogenize_line_item_currencies
update_line_item_currencies!
- update_with_updater!
+ recalculate_totals!
end
end
diff --git a/spree/core/app/models/spree/order_merger.rb b/spree/core/app/models/spree/order_merger.rb
index 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 Spree
end
def persist_merge
- updater.update
+ Spree::Orders::RecalculateTotals.call(order: order)
end
def handle_gift_card(other_order)
diff --git a/spree/core/app/models/spree/order_updater.rb b/spree/core/app/models/spree/order_updater.rb
index 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 OrderUpdater
attr_reader :order
delegate :payments, :line_items, :fulfillments, :update_hooks, :quantity, to: :order
@@ -7,29 +12,14 @@ module Spree
@order = order
end
- # 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)
end
def run_hooks
diff --git a/spree/core/app/models/spree/promotion.rb b/spree/core/app/models/spree/promotion.rb
index f982c0f191..eec48e1f76 100644
--- a/spree/core/app/models/spree/promotion.rb
+++ b/spree/core/app/models/spree/promotion.rb
@@ -203,7 +203,7 @@ module Spree
action_taken
end
- # called anytime order.update_with_updater! happens
+ # called anytime order.recalculate_totals! happens
def 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.rb
index 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 Spree
remove_promotion_adjustments(promotion)
remove_promotion_line_items(promotion)
- order.update_with_updater!
+ order.recalculate_totals!
set_success_code :adjustments_deleted
else
@@ -208,7 +208,7 @@ module Spree
if discount || created_line_items
handle_coupon_code(discount, coupon_code) if discount
- order.update_with_updater!
+ order.recalculate_totals!
set_success_code :coupon_code_applied
elsif 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.rb
index 8bad961f41..e7764693ea 100644
--- a/spree/core/app/models/spree/refund.rb
+++ b/spree/core/app/models/spree/refund.rb
@@ -131,7 +131,7 @@ module Spree
end
def update_order
- payment.order.updater.update
+ payment.order.recalculate_totals!
end
end
end
diff --git a/spree/core/app/services/spree/carts/add_item.rb b/spree/core/app/services/spree/carts/add_item.rb
deleted file mode 100644
index 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
-end
diff --git a/spree/core/app/services/spree/carts/merge.rb b/spree/core/app/services/spree/carts/merge.rb
index 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 Spree
other_cart.reload.destroy! if other_cart.line_items.reload.empty?
end
- cart.update_with_updater!
+ cart.recalculate_totals!
success(cart)
end
end
diff --git a/spree/core/app/services/spree/carts/recalculate.rb b/spree/core/app/services/spree/carts/recalculate.rb
deleted file mode 100644
index 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
-end
diff --git a/spree/core/app/services/spree/carts/update.rb b/spree/core/app/services/spree/carts/update.rb
index 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 Spree
cart.create_proposed_fulfillments
cart.set_shipments_cost
end
- cart.update_with_updater!
+ cart.recalculate_totals!
end
else
- cart.update_with_updater!
+ cart.recalculate_totals!
end
rescue StandardError => e
Rails.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.rb
index 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 Spree
return failure(line_item) unless line_item.save
end
- cart.update_with_updater!
+ cart.recalculate_totals!
end
success(cart)
diff --git a/spree/core/app/services/spree/checkout/advance.rb b/spree/core/app/services/spree/checkout/advance.rb
index 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 Spree
return result if result.failure?
end
- cart.update_with_updater!
+ cart.recalculate_totals!
success(cart)
end
end
diff --git a/spree/core/app/services/spree/checkout/select_shipping_method.rb b/spree/core/app/services/spree/checkout/select_shipping_method.rb
index 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 Spree
end
# 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)
end
diff --git a/spree/core/app/services/spree/fulfillments/create.rb b/spree/core/app/services/spree/fulfillments/create.rb
index 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 Create
prepend Spree::ServiceModule::Base
@@ -77,7 +78,8 @@ module Spree
fulfillment.update!(order)
end
- order.reload.update_with_updater!
+ reprice_pending_fulfillments(order.reload)
+ order.recalculate_totals!
end
success(fulfillment.reload)
@@ -85,6 +87,19 @@ module Spree
private
+ # 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). Loaded
diff --git a/spree/core/app/services/spree/gift_cards/apply.rb b/spree/core/app/services/spree/gift_cards/apply.rb
index 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 Spree
state: 'checkout',
response_code: store_credit.generate_authorization_code
)
- order.update_with_updater!
+ order.recalculate_totals!
end
success(order.reload)
diff --git a/spree/core/app/services/spree/gift_cards/remove.rb b/spree/core/app/services/spree/gift_cards/remove.rb
index 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 Spree
end
order.update!(gift_card: nil)
- order.update_with_updater!
+ order.recalculate_totals!
end
success(true)
diff --git a/spree/core/app/services/spree/orders/add_item.rb b/spree/core/app/services/spree/orders/add_item.rb
deleted file mode 100644
index 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
-end
diff --git a/spree/core/app/services/spree/orders/create.rb b/spree/core/app/services/spree/orders/create.rb
index 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 Spree
add_items(order) if @params[:items].present?
build_fulfillments(order)
apply_coupon(order) if @params[:coupon_code].present?
- order.update_with_updater!
+ order.recalculate_totals!
end
success(order.reload)
diff --git a/spree/core/app/services/spree/orders/recalculate.rb b/spree/core/app/services/spree/orders/recalculate.rb
deleted file mode 100644
index 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
-end
diff --git a/spree/core/app/services/spree/orders/remove_item.rb b/spree/core/app/services/spree/orders/remove_item.rb
index 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 Spree
module 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)
end
end
end
diff --git a/spree/core/app/services/spree/orders/remove_line_item.rb b/spree/core/app/services/spree/orders/remove_line_item.rb
index 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 Spree
module 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)
end
end
end
diff --git a/spree/core/app/services/spree/orders/update.rb b/spree/core/app/services/spree/orders/update.rb
index 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 Spree
build_fulfillments
end
- @order.update_with_updater!
+ @order.recalculate_totals!
end
success(@order.reload)
diff --git a/spree/core/app/services/spree/orders/upsert_items.rb b/spree/core/app/services/spree/orders/upsert_items.rb
index 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 UpsertItems
prepend Spree::ServiceModule::Base
diff --git a/spree/core/app/workflows/spree/carts/add_item.rb b/spree/core/app/workflows/spree/carts/add_item.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/services/spree/carts/complete.rb b/spree/core/app/workflows/spree/carts/complete.rb
similarity index 60%
rename from spree/core/app/services/spree/carts/complete.rb
rename to spree/core/app/workflows/spree/carts/complete.rb
index 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 Spree
module 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::Workflow
COMPLETING_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 — FINALIZE
finalize!(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.ago
end
- 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_completion
finalize!(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.order
end
# P7 — the copy contract: the order receives copies (line items with
@@ -221,22 +287,6 @@ module Spree
order.payments.valid.where(state: %w[pending processing completed]).sum(:amount) >= order.total
end
- # 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 do
order.finalize! unless order.placed?
@@ -251,29 +301,6 @@ module Spree
def 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
- end
end
end
end
diff --git a/spree/core/app/workflows/spree/carts/recalculate.rb b/spree/core/app/workflows/spree/carts/recalculate.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/workflows/spree/carts/recalculate_totals.rb b/spree/core/app/workflows/spree/carts/recalculate_totals.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/workflows/spree/orders/add_item.rb b/spree/core/app/workflows/spree/orders/add_item.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/workflows/spree/orders/recalculate.rb b/spree/core/app/workflows/spree/orders/recalculate.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/workflows/spree/orders/recalculate_totals.rb b/spree/core/app/workflows/spree/orders/recalculate_totals.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/lib/spree/core.rb b/spree/core/lib/spree/core.rb
index 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.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/lib/spree/testing_support/factories/cart_factory.rb b/spree/core/lib/spree/testing_support/factories/cart_factory.rb
index 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 do
after(: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!
end
end
end
diff --git a/spree/core/lib/spree/testing_support/factories/order_factory.rb b/spree/core/lib/spree/testing_support/factories/order_factory.rb
index 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 do
create(:shipment, order: order, cost: evaluator.shipment_cost, stock_location: stock_location)
order.fulfillments.reload
- order.update_with_updater!
+ order.recalculate_totals!
end
factory :completed_order_with_totals do
diff --git a/spree/core/lib/spree/testing_support/factories/payment_factory.rb b/spree/core/lib/spree/testing_support/factories/payment_factory.rb
index 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 do
end
factory :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) }
end
end
diff --git a/spree/core/lib/spree/testing_support/order_walkthrough.rb b/spree/core/lib/spree/testing_support/order_walkthrough.rb
index 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 OrderWalkthrough
return complete_cart!(cart) if state.to_sym == :complete
- cart.update_with_updater!
+ cart.recalculate_totals!
cart
end
@@ -55,7 +55,7 @@ class OrderWalkthrough
def self.delivery(cart)
# Rates were proposed with the address; keep the selected defaults.
- cart.update_with_updater!
+ cart.recalculate_totals!
end
def self.payment(cart)
diff --git a/spree/core/lib/spree/workflow.rb b/spree/core/lib/spree/workflow.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/spec/lib/spree/workflow_spec.rb b/spree/core/spec/lib/spree/workflow_spec.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rb b/spree/core/spec/models/spree/adjusters/coupon_code_retry_spec.rb
index 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' do
it 'activates the pending code once the cart qualifies and deactivates below threshold' do
cart.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_present
expect(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_empty
expect(cart.read_attribute(:coupon_code)).to eq('save5')
@@ -37,7 +37,7 @@ describe 'coupon code retry on recalculation' do
it 'clears the persisted code when the promotion is removed' do
cart.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_present
handler = 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.rb
index 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 do
before do
create(:discount, order: order, line_item: line_item, amount: discount_amount, label: 'Discount', kind: 'manual')
- order.update_with_updater!
+ order.recalculate_totals!
line_item.reload
end
@@ -36,7 +36,7 @@ describe Spree::Calculator::Returns::DefaultRefundAmount, type: :model do
before do
create(:discount, order: order, fulfillment: shipment, amount: -50, label: 'Free shipping', kind: 'promotion')
- order.update_with_updater!
+ order.recalculate_totals!
end
it 'does not affect the line item refund' do
diff --git a/spree/core/spec/models/spree/line_item_spec.rb b/spree/core/spec/models/spree/line_item_spec.rb
index 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' do
line_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)
end
diff --git a/spree/core/spec/models/spree/order/adjustments_spec.rb b/spree/core/spec/models/spree/order/adjustments_spec.rb
index 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 do
persisted_order.create_proposed_fulfillments
persisted_order.set_shipments_cost
create(: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!
end
it 'still requires payment (shipping keeps the total above zero)' do
diff --git a/spree/core/spec/models/spree/order/checkout_spec.rb b/spree/core/spec/models/spree/order/checkout_spec.rb
index 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 do
let(: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)
end
diff --git a/spree/core/spec/models/spree/order/finalizing_spec.rb b/spree/core/spec/models/spree/order/finalizing_spec.rb
index 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 do
it 'freezes adjustment recalculation (order-level freeze)' do
order.finalize!
expect(Spree::Adjusters::Promotion).not_to receive(:adjust)
- order.update_with_updater!
+ order.recalculate_totals!
end
context 'order is considered risky' do
diff --git a/spree/core/spec/models/spree/order/payment_spec.rb b/spree/core/spec/models/spree/order/payment_spec.rb
index 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 Spree
order = 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 20
create :refund, amount: order.total,
@@ -278,7 +278,7 @@ module Spree
reimbursement: reimbursement
order = 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) = 0
expect(order.outstanding_balance).to eq 0
@@ -294,7 +294,7 @@ module Spree
order.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) = 0
expect(order.outstanding_balance).to eq 10
diff --git a/spree/core/spec/models/spree/order/updating_spec.rb b/spree/core/spec/models/spree/order/updating_spec.rb
index 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 do
let(:order) { create(:order) }
- context '#update_with_updater!' do
+ context '#recalculate_totals!' do
let(: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 }
end
end
end
diff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rb
index 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 do
end
end
- describe '#update_with_updater!' do
+ describe '#recalculate_totals!' do
let(:updater) { order.updater }
before do
@@ -202,10 +202,8 @@ describe Spree::Order, type: :model do
allow(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 }
end
end
@@ -360,8 +358,9 @@ describe Spree::Order, type: :model do
let(: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)
end
end
end
@@ -441,7 +440,7 @@ describe Spree::Order, type: :model do
it 'freezes adjustment recalculation (order-level freeze)' do
order.finalize!
expect(Spree::Adjusters::Promotion).not_to receive(:adjust)
- order.update_with_updater!
+ order.recalculate_totals!
end
context 'order is considered risky' do
@@ -551,43 +550,6 @@ describe Spree::Order, type: :model do
end
end
- 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' do
let(: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 do
Spree::Order.update_hooks = Set.new
end
- 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' do
order = create(:order)
expect(order).to receive(:add_awesome_sauce)
@@ -844,7 +800,7 @@ describe Spree::Order, type: :model do
it 'calls out to the FreeShipping promotion handler' do
expect(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_promotions
end
@@ -1073,8 +1029,9 @@ describe Spree::Order, type: :model do
context 'events', :events do
it '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)
end
end
end
@@ -1109,8 +1066,9 @@ describe Spree::Order, type: :model do
context 'events', :events do
it '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)
end
end
end
@@ -1888,7 +1846,7 @@ describe Spree::Order, type: :model do
free_shipping_promotion.activate(order: order)
line_item_promotion.activate(order: order)
order_promotion.activate(order: order)
- order.update_with_updater!
+ order.recalculate_totals!
end
it 'includes all promotions' do
@@ -2664,14 +2622,14 @@ describe Spree::Order, type: :model do
describe '#quick_checkout_available?' do
it 'returns true if the order is fully digital' do
digital_line_item
- order.update_with_updater!
+ order.recalculate_totals!
expect(order.quick_checkout_available?).to be true
end
it 'returns true if the order has no digital products at all' do
physical_line_item
- order.update_with_updater!
+ order.recalculate_totals!
expect(order.quick_checkout_available?).to be true
end
@@ -2679,7 +2637,7 @@ describe Spree::Order, type: :model do
it 'returns false if the order has physical products and some digital products' do
physical_line_item
digital_line_item
- order.update_with_updater!
+ order.recalculate_totals!
expect(order.quick_checkout_available?).to be false
end
@@ -2687,7 +2645,7 @@ describe Spree::Order, type: :model do
it 'returns false if order has many shipments' do
physical_line_item
digital_line_item
- order.update_with_updater!
+ order.recalculate_totals!
order.create_proposed_fulfillments
expect(order.shipments.count).to eq(2)
@@ -2697,7 +2655,7 @@ describe Spree::Order, type: :model do
it 'returns false if order does not require payment' do
physical_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 do
it 'returns false if the order is digital' do
digital_line_item
- order.update_with_updater!
+ order.recalculate_totals!
expect(order.quick_checkout_require_address?).to be false
end
diff --git a/spree/core/spec/models/spree/order_updater_spec.rb b/spree/core/spec/models/spree/order_updater_spec.rb
index 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 Spree
before do
create_list(:line_item, 2, order: order, price: 10)
order.reload
- order.update_with_updater!
+ order.recalculate_totals!
end
it 'updates payment totals' do
@@ -71,12 +71,12 @@ module Spree
end
end
- describe '#update_with_updater!' do
+ describe '#recalculate_totals!' do
it 'updates item count' do
create(: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 Spree
before { 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_original
updater.update
end
end
diff --git a/spree/core/spec/models/spree/promotion_handler/coupon_spec.rb b/spree/core/spec/models/spree/promotion_handler/coupon_spec.rb
index 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 Spree
expect(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.apply
end
diff --git a/spree/core/spec/models/spree/promotion_spec.rb b/spree/core/spec/models/spree/promotion_spec.rb
index 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 do
context 'when the user has used this promo' do
before do
promotion.activate(order: order)
- order.update_with_updater!
+ order.recalculate_totals!
order.completed_at = Time.current
order.save!
end
@@ -848,7 +848,7 @@ describe Spree::Promotion, type: :model do
expect(order.adjustment_total).to eq 0
promo.activate(order: order)
- order.update_with_updater!
+ order.recalculate_totals!
line_item.reload
expect(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.rb
index 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 do
line_item
# the order instance may hold a stale (empty) cached line_items association
order.reload
- order.update_with_updater!
+ order.recalculate_totals!
order.reload
end
@@ -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.reload
end
diff --git a/spree/core/spec/models/spree/refund_spec.rb b/spree/core/spec/models/spree/refund_spec.rb
index 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 do
subject
end
- 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 }
end
end
diff --git a/spree/core/spec/models/spree/shipment_spec.rb b/spree/core/spec/models/spree/shipment_spec.rb
index 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 do
let(:shipment) { create(:shipment, stock_location: create(:stock_location)) }
before do
- allow(order).to receive :update_with_updater!
+ allow(order).to receive :recalculate_totals!
end
it 'generates a number containing a letter + 11 numbers' do
@@ -431,7 +431,7 @@ describe Spree::Shipment, type: :model do
it 'returns true if order is digital and it does not have a ship address' do
order.ship_address = nil
order.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_truthy
end
@@ -653,7 +653,7 @@ describe Spree::Shipment, type: :model do
let(: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 do
let(: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 do
end
it '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 do
let(: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}" do
before 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 do
it 'leaves typed adjustment columns to the order recalculation' do
create(: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)
end
end
@@ -966,13 +966,13 @@ describe Spree::Shipment, type: :model do
end
it 'triggers the order recalculation' do
- expect(shipment.order).to receive(:update_with_updater!)
+ expect(shipment.order).to receive(:recalculate_totals!)
shipment.save
end
it 'does not trigger recalculation if shipment is fulfilled' do
shipment.status = 'fulfilled'
- expect(shipment.order).not_to receive(:update_with_updater!)
+ expect(shipment.order).not_to receive(:recalculate_totals!)
shipment.save
end
end
@@ -980,7 +980,7 @@ describe Spree::Shipment, type: :model do
context 'cost does not change' do
it 'does not trigger the order recalculation' do
shipment.save!
- expect(shipment.order).not_to receive(:update_with_updater!)
+ expect(shipment.order).not_to receive(:recalculate_totals!)
shipment.save
end
end
diff --git a/spree/core/spec/models/spree/tax_rate_spec.rb b/spree/core/spec/models/spree/tax_rate_spec.rb
index 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 do
end
it '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)
end
it 'to germany costs 100 euros including tax' do
allow(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 do
it 'to france costs more including tax' do
allow(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 do
it 'to somewhere else costs the net amount' do
allow(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 do
it 'to germany costs 100 euros including tax' do
allow(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 do
allow(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 do
allow(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))
end
diff --git a/spree/core/spec/services/spree/carts/update_spec.rb b/spree/core/spec/services/spree/carts/update_spec.rb
index 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 Spree
let!(: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' do
let(:params) { { email: '[email protected]' } }
- it 'updates the order email' do
+ it 'updates the cart email' do
expect(subject).to be_success
- expect(order.reload.email).to eq('[email protected]')
+ expect(cart.reload.email).to eq('[email protected]')
end
end
@@ -25,22 +25,22 @@ module Spree
it 'updates the customer note' do
expect(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')
end
context '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('')
end
it '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_nil
end
end
end
@@ -51,13 +51,13 @@ module Spree
it 'updates the currency' do
expect(subject).to be_success
- expect(order.reload.currency).to eq('EUR')
+ expect(cart.reload.currency).to eq('EUR')
end
it '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')
end
end
@@ -70,7 +70,7 @@ module Spree
it 'does not change the currency' do
subject
- expect(order.reload.currency).to eq('USD')
+ expect(cart.reload.currency).to eq('USD')
end
end
@@ -79,38 +79,38 @@ module Spree
let(: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)
end
it '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)
end
it '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)
end
it '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)
end
end
end
@@ -127,7 +127,7 @@ module Spree
it 'updates the market' do
expect(subject).to be_success
- expect(order.reload.market).to eq(eu_market)
+ expect(cart.reload.market).to eq(eu_market)
end
end
@@ -142,31 +142,31 @@ module Spree
context 'when shipping address country is not in the new market' do
let!(: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_present
expect(subject).to be_success
- expect(order.reload.ship_address).to be_nil
+ expect(cart.reload.ship_address).to be_nil
end
- 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_present
expect(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_empty
end
end
context 'when shipping address country is in the new market' do
let(: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' do
expect(subject).to be_success
- expect(order.reload.ship_address).to eq(de_address)
+ expect(cart.reload.ship_address).to eq(de_address)
end
end
end
@@ -197,7 +197,7 @@ module Spree
it 'creates a new address' do
expect(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 Spree
expect(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' do
before 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' do
expect(subject).to be_success
- steps = order.checkout_steps
- expect(order.reload.completed?).to be(false)
+ expect(cart.reload.completed?).to be(false)
end
end
end
@@ -251,7 +225,7 @@ module Spree
it 'uses the existing address' do
expect(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)
end
end
@@ -261,13 +235,42 @@ module Spree
it 'uses the existing address' do
expect(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)
end
end
end
describe 'shipping_address' do
include_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
+ end
end
describe 'billing_address' do
@@ -278,7 +281,7 @@ module Spree
describe 'billing address does not reset checkout state' do
let(: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_empty
expect(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)
end
end
@@ -328,39 +328,39 @@ module Spree
it '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')
end
it 'works when set alongside shipping address in the same request' do
params = { 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)
end
it '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)
end
end
@@ -373,10 +373,10 @@ module Spree
let(: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)
end
end
@@ -384,10 +384,10 @@ module Spree
let(: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)
end
end
end
@@ -395,14 +395,14 @@ module Spree
include_examples 'ignores other users address', :shipping_address
include_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_id
expect(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)
end
end
end
@@ -410,19 +410,19 @@ module Spree
describe 'updating metadata' do
let(:params) { { metadata: { 'erp_id' => '12345', 'source' => 'mobile' } } }
- it 'merges metadata into the order' do
+ it 'merges metadata into the cart' do
expect(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')
end
context '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' do
expect(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')
end
end
end
@@ -449,10 +449,10 @@ module Spree
it 'updates all fields in a single transaction' do
expect(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')
end
end
@@ -473,17 +473,17 @@ module Spree
}
end
- it 'adds line items to the order' do
+ it 'adds line items to the cart' do
expect(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_present
expect(line_item.quantity).to eq(2)
end
end
context '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 Spree
let(: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_id
expect(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)
end
end
- context 'when order save fails' do
+ context 'when the cart save fails' do
let(: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))
end
it 'returns failure with error message' do
@@ -551,7 +551,7 @@ module Spree
it 'handles string keys' do
expect(subject).to be_success
- expect(order.reload.email).to eq('[email protected]')
+ expect(cart.reload.email).to eq('[email protected]')
end
end
diff --git a/spree/core/spec/services/spree/carts/upsert_items_spec.rb b/spree/core/spec/services/spree/carts/upsert_items_spec.rb
index 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 Spree
RSpec.describe Carts::UpsertItems do
let(: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 Spree
end
context '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 Spree
end
context '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 Spree
end
context '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 Spree
end
context '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 Spree
end
context '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.rb
index 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 Spree
params[:delivery_method] = delivery_method
# Settle factory-persisted totals before measuring invariance.
- order.update_with_updater!
+ order.recalculate_totals!
original_total = order.reload.total
source_shipment_cost = source_shipment.reload.cost
diff --git a/spree/core/spec/services/spree/gift_cards/apply_spec.rb b/spree/core/spec/services/spree/gift_cards/apply_spec.rb
index 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 do
expect(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!)
subject
end
@@ -82,8 +82,8 @@ RSpec.describe Spree::GiftCards::Apply do
expect(subject).to be_success
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
end
end
diff --git a/spree/core/spec/services/spree/gift_cards/remove_spec.rb b/spree/core/spec/services/spree/gift_cards/remove_spec.rb
index 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 do
expect(store_credit_payment.source).to be_deleted
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
end
diff --git a/spree/core/spec/services/spree/orders/cancel_spec.rb b/spree/core/spec/services/spree/orders/cancel_spec.rb
index 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 Spree
it { 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)
end
end
@@ -27,9 +28,10 @@ module Spree
it { 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)
end
end
end
diff --git a/spree/core/spec/services/spree/carts/complete_spec.rb b/spree/core/spec/workflows/spree/carts/complete_spec.rb
similarity index 100%
rename from spree/core/spec/services/spree/carts/complete_spec.rb
rename to spree/core/spec/workflows/spree/carts/complete_spec.rb
diff --git a/spree/core/spec/services/spree/carts/legacy_add_item_spec.rb b/spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb
similarity index 100%
rename from spree/core/spec/services/spree/carts/legacy_add_item_spec.rb
rename to spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb