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.

Added services and worklofs tests plus fixed a lot of bugs

Damian Legawiec2f1e90b02c16
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/orders/discounts_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/orders/discounts_controller_spec.rb
index 2858ecef0f..b3bcffda8e 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/orders/discounts_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/orders/discounts_controller_spec.rb
@@ -105,7 +105,7 @@ RSpec.describe Spree::Api::V3::Admin::Orders::DiscountsController, type: :contro
end
it 'removes the row and re-sums totals' do
- order.updater.resum_typed_totals!
+ order.recalculate_totals!
with_discount_total = order.reload.total
delete :destroy, params: { order_id: order.prefixed_id, id: manual_discount.prefixed_id }, as: :json
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/orders/fees_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/orders/fees_controller_spec.rb
index 5e718e4f95..7b422d1fef 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/orders/fees_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/orders/fees_controller_spec.rb
@@ -57,7 +57,7 @@ RSpec.describe Spree::Api::V3::Admin::Orders::FeesController, type: :controller
let!(:fee) { create(:fee, order: order, amount: 5, label: 'Handling', kind: 'handling') }
it 'updates the fee and re-sums totals' do
- order.updater.resum_typed_totals!
+ order.recalculate_totals!
with_fee_total = order.reload.total
patch :update, params: { order_id: order.prefixed_id, id: fee.prefixed_id, amount: 8 }, as: :json
@@ -72,7 +72,7 @@ RSpec.describe Spree::Api::V3::Admin::Orders::FeesController, type: :controller
let!(:fee) { create(:fee, order: order, amount: 5, label: 'Handling', kind: 'handling') }
it 'removes the fee and re-sums totals' do
- order.updater.resum_typed_totals!
+ order.recalculate_totals!
with_fee_total = order.reload.total
delete :destroy, params: { order_id: order.prefixed_id, id: fee.prefixed_id }, as: :json
diff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rb
index 773d25fd2b..7386eedaf5 100644
--- a/spree/core/app/models/spree/cart.rb
+++ b/spree/core/app/models/spree/cart.rb
@@ -50,6 +50,11 @@ module Spree
alias_attribute :ship_total, :delivery_total
belongs_to :customer, class_name: "::#{Spree.user_class}", optional: true
+ # Order-parity aliases — shared Cart/Order code (services, Purchase
+ # concerns) reads #user; the cart column is customer_id.
+ alias_method :user, :customer
+ alias_method :user=, :customer=
+ alias_attribute :user_id, :customer_id
belongs_to :ship_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
belongs_to :bill_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
# Normalizes like the legacy Order writer so lookups stay case-insensitive.
@@ -155,6 +160,12 @@ module Spree
completing_at.present?
end
+ # Mirrors Order#can_be_deleted? — a completed cart is an immutable audit
+ # record, and settled money must never be deleted.
+ def can_be_deleted?
+ !completed? && payments.completed.empty?
+ end
+
# Checkout begins once any checkout-only data is present (email or a
# shipping address). Drives stock-reservation dispatch.
def in_checkout?
@@ -184,6 +195,11 @@ module Spree
total - payment_total
end
+ # Total fulfillment discount applied by promotions, as a positive amount.
+ def fulfillment_discount
+ discounts.for_fulfillments.sum(:amount) * -1
+ end
+
def outstanding_balance?
outstanding_balance != 0
end
diff --git a/spree/core/app/models/spree/fulfillment.rb b/spree/core/app/models/spree/fulfillment.rb
index 6d495d2441..81fcccd076 100644
--- a/spree/core/app/models/spree/fulfillment.rb
+++ b/spree/core/app/models/spree/fulfillment.rb
@@ -268,13 +268,16 @@ module Spree
# pending unless order is complete and +order.payment_state+ is +paid+
# shipped if already shipped (ie. does not change the state)
# ready all other cases
- def determine_state(order)
- return 'canceled' if canceled? || order.canceled?
- return 'pending' unless order.can_ship?
+ # @param [Spree::Cart, Spree::Order]
+ def determine_state(order_or_cart)
+ return 'pending' if order_or_cart.is_a?(Spree::Cart)
+
+ return 'canceled' if canceled? || order_or_cart.canceled?
+ return 'pending' unless order_or_cart.can_ship?
return 'pending' if fulfillment_items.any?(&:backordered?)
return 'fulfilled' if fulfilled?
- order.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
+ order_or_cart.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
end
def discounted_cost
diff --git a/spree/core/app/models/spree/line_item.rb b/spree/core/app/models/spree/line_item.rb
index 96965a5a7b..6a1ffc5c8a 100644
--- a/spree/core/app/models/spree/line_item.rb
+++ b/spree/core/app/models/spree/line_item.rb
@@ -213,13 +213,13 @@ module Spree
# Returns true if the line item has sufficient stock
#
- # The order's own active stock reservations are excluded from the
+ # The owner's own active stock reservations are excluded from the
# availability check — a customer's own checkout hold must not make
# their own line item look out of stock.
#
# @return [Boolean]
def sufficient_stock?
- Spree::Stock::Quantifier.new(variant, excluded_order: order).can_supply?(quantity)
+ Spree::Stock::Quantifier.new(variant, excluded_order: owner).can_supply?(quantity)
end
# Returns true if the line item has insufficient stock
diff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rb
index 2528ef0a9a..feae653627 100644
--- a/spree/core/app/models/spree/order.rb
+++ b/spree/core/app/models/spree/order.rb
@@ -259,6 +259,8 @@ module Spree
validates :discount_total, NEGATIVE_MONEY_VALIDATION
validates :total, MONEY_VALIDATION
+ # @deprecated Both warn and run the full recalculation; use
+ # {#recalculate_totals!}. Removed in 6.1.
delegate :update_totals, :persist_totals, to: :updater
delegate :merge!, to: :merger
delegate :firstname, :lastname, to: :bill_address, prefix: true, allow_nil: true
@@ -379,10 +381,17 @@ module Spree
(item_total + line_items.sum(:promo_total)).to_f
end
- def shipping_discount
+ # Total fulfillment discount applied by promotions, as a positive amount.
+ def fulfillment_discount
discounts.for_fulfillments.sum(:amount) * -1
end
+ # @deprecated Use {#fulfillment_discount}; removed in 6.1.
+ def shipping_discount
+ Spree::Deprecation.warn('Spree::Order#shipping_discount is deprecated and will be removed in Spree 6.1. Use #fulfillment_discount instead.')
+ fulfillment_discount
+ end
+
def completed?
completed_at.present?
end
@@ -484,8 +493,8 @@ module Spree
!digital? && delivery_required?
end
- # Returns the relevant zone (if any) to be used for taxation purposes.
- # Uses default tax zone unless there is a specific match
+ # @deprecated Use {#recalculate_totals!} for money and {#update_statuses!}
+ # for payment/fulfillment statuses; removed in 6.1.
def updater
@updater ||= Spree.order_updater.new(self)
end
diff --git a/spree/core/app/models/spree/order_updater.rb b/spree/core/app/models/spree/order_updater.rb
index 2ca506ad6a..d1696af8db 100644
--- a/spree/core/app/models/spree/order_updater.rb
+++ b/spree/core/app/models/spree/order_updater.rb
@@ -1,9 +1,16 @@
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.
+ # @deprecated Removed in Spree 6.1. Every method is a thin shim over the
+ # flows that own the work:
+ #
+ # * money — {Spree::Carts::RecalculateTotals} /
+ # {Spree::Orders::RecalculateTotals} (or the model's
+ # +#recalculate_totals!+)
+ # * statuses — {Spree::Orders::UpdateStatuses} (or +#update_statuses!+),
+ # the sole writer of +payment_status+/+fulfillment_status+
+ #
+ # The granular partial updates no longer exist as separate computations:
+ # the totals workflow is the single money seam, so each money shim runs
+ # the full recalculation.
class OrderUpdater
attr_reader :order
delegate :payments, :line_items, :fulfillments, :update_hooks, :quantity, to: :order
@@ -12,284 +19,154 @@ module Spree
@order = order
end
- # @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.
+ # @deprecated Use {Spree::Carts::RecalculateTotals} /
+ # {Spree::Orders::RecalculateTotals} (or +#recalculate_totals!+);
+ # removed in 6.1.
def update
- 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)
+ deprecate_totals(__method__)
+ recalculate_totals
+ update_statuses if order.completed?
end
- def run_hooks
- update_hooks.each { |hook| order.send hook }
- end
-
- # Rebuilds the typed adjustment rows (Discount/Fee via Spree.adjusters,
- # TaxLine via Spree.tax_provider) and refreshes the denormalized columns
- # on line items and fulfillments. Two-pass: adjusters persist the
- # discounted taxable base first, then tax is estimated on it.
- #
- # Completed orders are frozen — recalculation refuses to touch them.
- # Post-placement changes go through explicit admin actions that write
- # typed rows directly and recompute totals via {#update}.
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1. The
+ # totals workflow rebuilds the typed adjustment rows as part of its
+ # money pass.
def recalculate_adjustments
- return if order.completed?
-
- Spree.adjusters.each { |adjuster| adjuster.adjust(order) }
- refresh_discount_and_fee_columns
- Spree.tax_provider.estimate(order)
- refresh_tax_columns
+ deprecate_totals(__method__)
+ recalculate_totals
end
- # Updates the following Order total values:
- #
- # +payment_total+ The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
- # +item_total+ The total value of all LineItems
- # +adjustment_total+ The total value of all typed adjustment rows (discounts, fees, additional tax)
- # +discount_total+ The total value of all promotion discounts
- # +fee_total+ The total value of all fees
- # +total+ The so-called "order total." Equivalent to +item_total+ plus +delivery_total+ plus +adjustment_total+.
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
def update_totals
- update_payment_total
- update_item_total
- update_delivery_total
- update_adjustment_total
- end
-
- # give each of the fulfillments a chance to update themselves.
- # Completed orders only recompute statuses — repricing a completed
- # order's delivery would break the money freeze.
- def update_fulfillments
- shipping_method_filter = order.completed? ? DeliveryMethod::DISPLAY_ON_BACK_END : DeliveryMethod::DISPLAY_ON_FRONT_END
-
- fulfillments.each do |fulfillment|
- next unless fulfillment.persisted?
-
- fulfillment.update!(order)
- next if order.completed? && fulfillment.fulfilled?
-
- fulfillment.refresh_rates(shipping_method_filter)
- fulfillment.update_amounts
- end
+ deprecate_totals(__method__)
+ recalculate_totals
end
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
def update_payment_total
- order.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }
+ deprecate_totals(__method__)
+ recalculate_totals
+ order.payment_total
end
- def update_delivery_total
- order.delivery_total = fulfillments.to_a.sum(&:cost)
- update_order_total
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
+ def update_item_total
+ deprecate_totals(__method__)
+ recalculate_totals
+ order.item_total
end
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
def update_order_total
- order.total = order.item_total + order.delivery_total + order.adjustment_total
+ deprecate_totals(__method__)
+ recalculate_totals
+ order.total
end
- # Aggregates order totals from the typed tables. On completed orders the
- # stored sums are left untouched (the recalculation freeze) — only the
- # roll-up total is refreshed from its parts.
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
def update_adjustment_total
- if order.completed?
- update_order_total
- return
- end
-
- recalculate_adjustments
- sum_typed_rows_into_order
- update_order_total
- end
-
- # Money only — payment_status/fulfillment_status are written exclusively
- # by Spree::Orders::UpdateStatuses, triggered from
- # Spree::OrderStatusSubscriber on payment/refund/fulfillment/return
- # events (never inline here: those records change without any money
- # recalculation running, and most recalculations change no status
- # inputs).
- # The sanctioned post-placement edit path: re-sums typed rows into order
- # and per-adjustable totals WITHOUT re-running promotion competition or
- # tax estimation (both stay frozen once completed). Called by the admin
- # tax_lines/discounts/fees endpoints after writing rows directly.
- def resum_typed_totals!
- refresh_discount_and_fee_columns
- refresh_tax_columns
- sum_typed_rows_into_order
- update_order_total
- persist_totals
+ deprecate_totals(__method__)
+ recalculate_totals
+ order.adjustment_total
end
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
def update_item_count
- order.total_quantity = quantity
+ deprecate_totals(__method__)
+ recalculate_totals
+ order.total_quantity
end
- def sum_typed_rows_into_order
- discounts_sum = order.discounts.reload.sum(&:amount)
- fees = order.fees.reload.to_a
- tax_sums = order.tax_lines.reload.group_by(&:included?).transform_values { |lines| lines.sum(&:amount) }
-
- order.discount_total = order.discounts.select(&:promotion?).sum(&:amount)
- order.fee_total = fees.sum(&:amount)
- order.included_tax_total = tax_sums.fetch(true, 0)
- order.additional_tax_total = tax_sums.fetch(false, 0)
- order.adjustment_total = discounts_sum + order.fee_total + order.additional_tax_total
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
+ def persist_totals
+ deprecate_totals(__method__)
+ recalculate_totals
+ end
- # The order's own adjustable columns cover order-level rows only:
- # discounts distribute to line items, so fees are the only residents.
- order.taxable_adjustment_total = 0
- order.non_taxable_adjustment_total = fees.select(&:order_level?).sum(&:amount)
+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.
+ def update_shipment_total
+ Spree::Deprecation.warn('Spree::OrderUpdater#update_shipment_total is deprecated and will be removed in Spree 6.1. Use Spree::Carts::RecalculateTotals / Spree::Orders::RecalculateTotals (or #recalculate_totals!) instead.')
+ recalculate_totals
+ order.delivery_total
end
- def update_item_total
- order.item_total = line_items.to_a.sum(&:amount)
- update_order_total
+ # @deprecated Use {Spree::Orders::UpdateStatuses} (or
+ # +#update_statuses!+); removed in 6.1. UpdateStatuses writes the 6.0
+ # vocabulary (none/authorized/partially_paid/paid/partially_refunded/
+ # refunded/overcharged/voided), not the legacy balance_due/credit_owed/
+ # failed/void names.
+ def update_payment_state
+ deprecate_statuses(__method__)
+ update_statuses
+ order.payment_status
end
- def persist_totals
- order.update_columns(
- payment_status: order.payment_status,
- fulfillment_status: order.fulfillment_status,
- item_total: order.item_total,
- total_quantity: order.total_quantity,
- adjustment_total: order.adjustment_total,
- included_tax_total: order.included_tax_total,
- additional_tax_total: order.additional_tax_total,
- taxable_adjustment_total: order.taxable_adjustment_total,
- non_taxable_adjustment_total: order.non_taxable_adjustment_total,
- payment_total: order.payment_total,
- delivery_total: order.delivery_total,
- discount_total: order.discount_total,
- fee_total: order.fee_total,
- total: order.total,
- updated_at: Time.current
- )
+ # @deprecated Use {Spree::Orders::UpdateStatuses} (or
+ # +#update_statuses!+); removed in 6.1.
+ def update_shipment_state
+ deprecate_statuses(__method__)
+ update_statuses
+ order.fulfillment_status
end
- # Updates the +fulfillment_status+ attribute according to the following logic:
- #
- # fulfilled when all Fulfillments are in the "fulfilled" status
- # partial when at least one Fulfillment is "fulfilled" and there is another
- # Fulfillment with a status other than "fulfilled"
- # ready when all Fulfillments are "ready" (ready_for_pickup rolls up as ready)
- # backorder when there is backordered inventory associated with an order
- # pending when all Fulfillments are "pending"
- #
- # The +fulfillment_status+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
- def update_fulfillment_status
- if order.backordered?
- order.fulfillment_status = 'backorder'
- else
- # ready_for_pickup is customer-actionable on the fulfillment itself but
- # rolls up as ready at the order level
- statuses = fulfillments.states.uniq.map { |status| status == 'ready_for_pickup' ? 'ready' : status }.uniq
+ # @deprecated Use {Spree::Orders::UpdateStatuses} for the state roll-up
+ # and {Spree::Carts::Recalculate} for the delivery proposal rebuild;
+ # removed in 6.1.
+ def update_shipments
+ Spree::Deprecation.warn('Spree::OrderUpdater#update_shipments is deprecated and will be removed in Spree 6.1. Use Spree::Orders::UpdateStatuses (fulfillment states) and Spree::Carts::Recalculate (delivery proposals) instead.')
- order.fulfillment_status = if statuses.size > 1
- if statuses.include?('fulfilled')
- 'partial'
- elsif statuses.include?('pending')
- 'pending'
- else
- 'ready'
- end
- else
- # will return nil if no fulfillments are found
- statuses.first
- end
- end
+ shipping_method_filter = order.completed? ? DeliveryMethod::DISPLAY_ON_BACK_END : DeliveryMethod::DISPLAY_ON_FRONT_END
- order.fulfillment_status
- end
- # @deprecated Use {#update_fulfillment_status}; removed in 6.1.
- def update_shipment_state
- Spree::Deprecation.warn('Spree::OrderUpdater#update_shipment_state is deprecated and will be removed in Spree 6.1. Use #update_fulfillment_status instead.')
- update_fulfillment_status
- end
+ fulfillments.each do |fulfillment|
+ next unless fulfillment.persisted?
- # @deprecated Use {#update_delivery_total}; removed in 6.1.
- def update_shipment_total
- Spree::Deprecation.warn('Spree::OrderUpdater#update_shipment_total is deprecated and will be removed in Spree 6.1. Use #update_delivery_total instead.')
- update_delivery_total
- end
+ fulfillment.update!(order)
+ next if order.completed? && fulfillment.fulfilled?
- # @deprecated Use {#update_fulfillments}; removed in 6.1.
- def update_shipments
- Spree::Deprecation.warn('Spree::OrderUpdater#update_shipments is deprecated and will be removed in Spree 6.1. Use #update_fulfillments instead.')
- update_fulfillments
+ fulfillment.refresh_rates(shipping_method_filter)
+ fulfillment.update_amounts
+ end
end
- # Updates the +payment_state+ attribute according to the following logic:
- #
- # paid when +payment_total+ is equal to +total+
- # balance_due when +payment_total+ is less than +total+
- # credit_owed when +payment_total+ is greater than +total+
- # failed when most recent payment is in the failed state
- # void when order is canceled and +payment_total+ is equal to zero
- #
- # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
- def update_payment_state
- if payments.present? && payments.valid.empty?
- order.payment_state = 'failed'
- elsif order.canceled? && order.payment_total == 0
- order.payment_state = 'void'
- else
- order.payment_state = 'balance_due' if order.outstanding_balance > 0
- order.payment_state = 'credit_owed' if order.outstanding_balance < 0
- order.payment_state = 'paid' unless order.outstanding_balance?
- end
- order.payment_state
+ # @deprecated Order update hooks are removed in 6.1 — subscribe to the
+ # +order.updated+ event instead.
+ def run_hooks
+ Spree::Deprecation.warn('Spree::OrderUpdater#run_hooks is deprecated and will be removed in Spree 6.1. Subscribe to the order.updated event instead.')
+ update_hooks.each { |hook| order.send hook }
end
private
- # Pass one of the two-pass recalculation: persist per-adjustable discount
- # and fee sums so the tax provider estimates on the discounted base.
- def refresh_discount_and_fee_columns
- discounts = order.discounts.reload.to_a
- fees = order.fees.reload.to_a
-
- each_adjustable do |adjustable, key|
- rows = discounts.select { |row| row.public_send(key) == adjustable.id }
- fee_rows = fees.select { |row| row.public_send(key) == adjustable.id }
-
- update_adjustable_columns(
- adjustable,
- taxable_adjustment_total: rows.sum(&:amount),
- non_taxable_adjustment_total: fee_rows.sum(&:amount),
- promo_total: rows.select(&:promotion?).sum(&:amount)
- )
- end
+ def recalculate_totals
+ Spree.cart_recalculate_totals_workflow.call(cart: order)
end
- # Pass two: fold the freshly estimated tax into the per-adjustable columns.
- def refresh_tax_columns
- tax_lines = order.tax_lines.reload.to_a
+ # UpdateStatuses persists via update_columns, which leaves the in-memory
+ # record stale — re-read just the two status columns it wrote. The
+ # fulfillments cache is reset first: the roll-up reads that association,
+ # and callers routinely hold one loaded before their own mutations.
+ def update_statuses
+ order.association(:fulfillments).reset if order.persisted?
- each_adjustable do |adjustable, key|
- rows = tax_lines.select { |row| row.public_send(key) == adjustable.id }
- included, additional = rows.partition(&:included?)
+ Spree.order_update_statuses_service.call(order: order)
+ return unless order.persisted?
- update_adjustable_columns(
- adjustable,
- included_tax_total: included.sum(&:amount),
- additional_tax_total: additional.sum(&:amount),
- adjustment_total: adjustable.taxable_adjustment_total +
- adjustable.non_taxable_adjustment_total +
- additional.sum(&:amount)
- )
- end
- end
+ statuses = order.class.where(id: order.id).pick(:payment_status, :fulfillment_status)
+ return if statuses.nil?
- def each_adjustable
- line_items.each { |line_item| yield line_item, :line_item_id }
- fulfillments.each { |fulfillment| yield fulfillment, :fulfillment_id }
+ # write_attribute, not the setters — these columns are already
+ # persisted, so they must not show up as unsaved changes.
+ order.send(:write_attribute, :payment_status, statuses.first)
+ order.send(:write_attribute, :fulfillment_status, statuses.last)
+ order.send(:clear_attribute_changes, [:payment_status, :fulfillment_status])
end
- def update_adjustable_columns(adjustable, attributes)
- return unless adjustable.persisted?
- return if attributes.all? { |key, value| adjustable.public_send(key) == value }
+ def deprecate_totals(method_name)
+ Spree::Deprecation.warn("Spree::OrderUpdater##{method_name} is deprecated and will be removed in Spree 6.1. Use Spree::Carts::RecalculateTotals / Spree::Orders::RecalculateTotals (or #recalculate_totals!) instead.")
+ end
- adjustable.update_columns(attributes.merge(updated_at: Time.current))
+ def deprecate_statuses(method_name)
+ Spree::Deprecation.warn("Spree::OrderUpdater##{method_name} is deprecated and will be removed in Spree 6.1. Use Spree::Orders::UpdateStatuses (or #update_statuses!) instead.")
end
end
end
diff --git a/spree/core/app/models/spree/promotion.rb b/spree/core/app/models/spree/promotion.rb
index 2368615447..42ffa53ab7 100644
--- a/spree/core/app/models/spree/promotion.rb
+++ b/spree/core/app/models/spree/promotion.rb
@@ -107,7 +107,8 @@ module Spree
end
def self.order_activatable?(promotable)
- promotable && !promotable.completed? && !promotable.canceled?
+ # Carts have no cancellation concept — only placed orders can be canceled.
+ promotable && !promotable.completed? && !(promotable.is_a?(Spree::Order) && promotable.canceled?)
end
def generate_code=(generating_code)
diff --git a/spree/core/app/models/spree/promotion/actions/create_adjustment.rb b/spree/core/app/models/spree/promotion/actions/create_adjustment.rb
index ef34136117..3b9d0064cd 100644
--- a/spree/core/app/models/spree/promotion/actions/create_adjustment.rb
+++ b/spree/core/app/models/spree/promotion/actions/create_adjustment.rb
@@ -26,7 +26,7 @@ module Spree
end
def order_total(order)
- order.item_total + order.ship_total - order.shipping_discount
+ order.item_total + order.delivery_total - order.fulfillment_discount
end
end
end
diff --git a/spree/core/app/models/spree/stock/quantifier.rb b/spree/core/app/models/spree/stock/quantifier.rb
index 8f5f1d090e..c06a9d5c6c 100644
--- a/spree/core/app/models/spree/stock/quantifier.rb
+++ b/spree/core/app/models/spree/stock/quantifier.rb
@@ -3,10 +3,11 @@ module Spree
class Quantifier
attr_reader :variant, :stock_location, :excluded_order
- # @param excluded_order [Spree::Order, nil] when given, reservations
- # belonging to this order are not counted against availability. Used
- # when checking an order's own line items so the customer's own
- # checkout hold doesn't make their item look out of stock.
+ # @param excluded_order [Spree::Cart, Spree::Order, nil] when given,
+ # reservations belonging to this cart/order are not counted against
+ # availability. Used when checking a cart's own line items so the
+ # customer's own checkout hold doesn't make their item look out of
+ # stock.
def initialize(variant, stock_location = nil, excluded_order: nil)
@variant = variant
@stock_location = stock_location
@@ -68,17 +69,18 @@ module Spree
return @reserved_quantity = 0 unless Spree::Config[:stock_reservations_enabled]
return @reserved_quantity = 0 if stock_items.blank?
- excluded_order_id = excluded_order&.id
+ excluded_owner_key = excluded_order.is_a?(Spree::Cart) ? :cart_id : :order_id
+ excluded_owner_id = excluded_order&.id
@reserved_quantity = if reservations_preloaded?
stock_items.sum do |si|
reservations = si.active_stock_reservations
- reservations = reservations.reject { |r| r.order_id == excluded_order_id } if excluded_order_id
+ reservations = reservations.reject { |r| r.public_send(excluded_owner_key) == excluded_owner_id } if excluded_owner_id
reservations.sum(&:quantity)
end
else
reservations = Spree::StockReservation.active.where(stock_item_id: stock_items.map(&:id))
- reservations = reservations.where.not(order_id: excluded_order_id) if excluded_order_id
+ reservations = reservations.where.not(excluded_owner_key => excluded_owner_id) if excluded_owner_id
reservations.sum(:quantity)
end
end
diff --git a/spree/core/app/services/spree/carts/empty.rb b/spree/core/app/services/spree/carts/empty.rb
index 538c94d07c..a0902bb1e9 100644
--- a/spree/core/app/services/spree/carts/empty.rb
+++ b/spree/core/app/services/spree/carts/empty.rb
@@ -29,10 +29,11 @@ module Spree
cart.discounts.destroy_all
cart.fees.destroy_all
cart.fulfillments.destroy_all
- cart.state_changes.destroy_all
+ # Carts have no state machine — only legacy Order records carry
+ # state-change rows.
+ cart.state_changes.destroy_all if cart.respond_to?(:state_changes)
cart.order_promotions.destroy_all
- cart.update_totals
- cart.persist_totals
+ cart.recalculate_totals!
Spree::StockReservations::Release.call(cart: cart)
diff --git a/spree/core/app/services/spree/carts/update.rb b/spree/core/app/services/spree/carts/update.rb
index 463309a495..d433da3754 100644
--- a/spree/core/app/services/spree/carts/update.rb
+++ b/spree/core/app/services/spree/carts/update.rb
@@ -6,7 +6,7 @@ module Spree
def call(cart:, params:)
@cart = cart
@params = params.to_h.deep_symbolize_keys
- was_in_cart = cart.cart?
+ was_in_checkout = cart.in_checkout?
ApplicationRecord.transaction do
assign_cart_attributes
@@ -18,7 +18,7 @@ module Spree
process_items
try_advance
- sync_stock_reservations(was_in_cart: was_in_cart)
+ sync_stock_reservations(was_in_checkout: was_in_checkout)
end
success(cart)
@@ -112,14 +112,14 @@ module Spree
# entering checkout → Reserve, mid-checkout mutation → Extend, reverting to cart → Release.
# A failed Reserve raises so the enclosing transaction rolls back and the
# outer rescue surfaces the error to the API caller.
- def sync_stock_reservations(was_in_cart:)
- if cart.cart?
- Spree::StockReservations::Release.call(cart: cart) unless was_in_cart
- elsif was_in_cart
+ def sync_stock_reservations(was_in_checkout:)
+ if !cart.in_checkout?
+ Spree::StockReservations::Release.call(cart: cart) if was_in_checkout
+ elsif was_in_checkout
+ Spree::StockReservations::Extend.call(cart: cart)
+ else
result = Spree::StockReservations::Reserve.call(cart: cart)
raise Spree::StockReservations::InsufficientStockError.new(nil, result.error.to_s) if result.failure?
- else
- Spree::StockReservations::Extend.call(order: cart)
end
end
@@ -128,7 +128,7 @@ module Spree
# /carts/:id/complete endpoint (a fully-covered cart must never
# auto-complete during address updates).
def try_advance
- return if cart.complete? || cart.canceled?
+ return if cart.complete?
if @address_invalidated || address_changed?
if cart.respond_to?(:recalculate_for_address_change!)
diff --git a/spree/core/app/workflows/spree/carts/complete.rb b/spree/core/app/workflows/spree/carts/complete.rb
index 6b07af2c42..360156889e 100644
--- a/spree/core/app/workflows/spree/carts/complete.rb
+++ b/spree/core/app/workflows/spree/carts/complete.rb
@@ -187,7 +187,7 @@ module Spree
accept_marketing: cart.accept_marketing,
coupon_code: cart.read_attribute(:coupon_code),
preferred_stock_location_id: cart.preferred_stock_location_id,
- special_instructions: cart.special_instructions,
+ customer_note: cart.customer_note,
last_ip_address: cart.last_ip_address,
ship_address: cart.ship_address&.dup,
bill_address: cart.bill_address&.dup
diff --git a/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rb b/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rb
index f0d0154c8f..74a9f2f506 100644
--- a/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rb
+++ b/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rb
@@ -3,12 +3,12 @@ FactoryBot.define do
tracking { 'U10000' }
cost { 100.00 }
status { 'pending' }
- order
+ order { cart.present? ? nil : association(:order) }
stock_location
after(:create) do |fulfillment, _evalulator|
fulfillment.add_delivery_method(create(:delivery_method), true)
- fulfillment.order.line_items.map do |line_item|
+ (fulfillment.order || fulfillment.cart).line_items.map do |line_item|
fulfillment.fulfillment_items.create(
order_id: fulfillment.order_id,
variant_id: line_item.variant_id,
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 579225cc1b..744727e571 100644
--- a/spree/core/lib/spree/testing_support/factories/payment_factory.rb
+++ b/spree/core/lib/spree/testing_support/factories/payment_factory.rb
@@ -30,6 +30,6 @@ FactoryBot.define do
factory :store_credit_payment, class: Spree::Payment, parent: :payment do
payment_method { create(:store_credit_payment_method, store: (order || cart).store) }
- source { create(:store_credit, store: (order || cart).store, user: (order || cart).user) }
+ source { create(:store_credit, store: (order || cart).store, user: (order || cart).customer) }
end
end
diff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rb
index 8d862f199f..cb025d2641 100644
--- a/spree/core/spec/models/spree/order_spec.rb
+++ b/spree/core/spec/models/spree/order_spec.rb
@@ -380,8 +380,7 @@ describe Spree::Order, type: :model do
it 'update and persist totals' do
expect(shipment).to receive :update_amounts
- expect(order.updater).to receive :update_delivery_total
- expect(order.updater).to receive :persist_totals
+ expect(order).to receive :recalculate_totals!
order.set_fulfillments_cost
end
diff --git a/spree/core/spec/models/spree/order_updater_spec.rb b/spree/core/spec/models/spree/order_updater_spec.rb
index e1d4afa755..4d65f58d3e 100644
--- a/spree/core/spec/models/spree/order_updater_spec.rb
+++ b/spree/core/spec/models/spree/order_updater_spec.rb
@@ -82,128 +82,132 @@ module Spree
end
end
+ # The status shims delegate to Spree::Orders::UpdateStatuses, the sole
+ # writer of fulfillment_status — so these run against real fulfillments.
context 'updating shipment state' do
- before do
- allow(order).to receive_messages backordered?: false
- allow(order).to receive_message_chain(:fulfillments, :shipped, :count).and_return(0)
- allow(order).to receive_message_chain(:fulfillments, :ready, :count).and_return(0)
- allow(order).to receive_message_chain(:fulfillments, :pending, :count).and_return(0)
- end
+ # Fulfillment#determine_state re-derives each state from the order, so
+ # these need a placed order for the factory statuses to survive.
+ let(:order) { create(:completed_order_with_totals, line_items_count: 1) }
+
+ before { order.fulfillments.destroy_all }
it 'is backordered' do
- allow(order).to receive_messages backordered?: true
- updater.update_fulfillment_status
+ create(:fulfillment, order: order, status: 'pending')
+ allow(order).to receive(:backordered?).and_return(true)
+
+ updater.update_shipment_state
expect(order.fulfillment_status).to eq('backorder')
end
it 'is nil' do
- allow(order).to receive_message_chain(:fulfillments, :states).and_return([])
- allow(order).to receive_message_chain(:fulfillments, :count).and_return(0)
+ updater.update_shipment_state
- updater.update_fulfillment_status
expect(order.fulfillment_status).to be_nil
end
- ['fulfilled', 'ready', 'pending'].each do |status|
+ ['fulfilled', 'pending'].each do |status|
it "is #{status}" do
- allow(order).to receive_message_chain(:fulfillments, :states).and_return([status])
- updater.update_fulfillment_status
- expect(order.fulfillment_status).to eq(status.to_s)
+ create(:fulfillment, order: order, status: status)
+
+ updater.update_shipment_state
+
+ expect(order.fulfillment_status).to eq(status)
end
end
- it 'rolls ready_for_pickup up as ready' do
- allow(order).to receive_message_chain(:fulfillments, :states).and_return(['ready_for_pickup'])
- updater.update_fulfillment_status
- expect(order.fulfillment_status).to eq('ready')
+ # Fulfillment#determine_state only yields 'ready' once the order is paid.
+ context 'when the order is paid' do
+ before { allow(order).to receive(:paid?).and_return(true) }
+
+ it 'is ready' do
+ create(:fulfillment, order: order, status: 'ready')
+
+ updater.update_shipment_state
+
+ expect(order.fulfillment_status).to eq('ready')
+ end
+
+ it 'rolls ready_for_pickup up as ready' do
+ create(:fulfillment, order: order, status: 'ready_for_pickup')
+
+ updater.update_shipment_state
+
+ expect(order.fulfillment_status).to eq('ready')
+ end
end
it 'is partial' do
- allow(order).to receive_message_chain(:fulfillments, :states).and_return(['pending', 'fulfilled'])
- updater.update_fulfillment_status
+ create(:fulfillment, order: order, status: 'pending')
+ create(:fulfillment, order: order, status: 'fulfilled')
+
+ updater.update_shipment_state
+
expect(order.fulfillment_status).to eq('partial')
end
end
+ # The status shims delegate to Spree::Orders::UpdateStatuses, the sole
+ # writer of payment_status — so these run against real payments and use
+ # its vocabulary (none/authorized/partially_paid/paid/refunded/voided),
+ # not the legacy balance_due/credit_owed/void names.
context 'updating payment state' do
- let(:order) { Order.new }
- let(:updater) { order.updater }
-
- it 'is failed if no valid payments' do
- allow(order).to receive_message_chain(:payments, :valid, :empty?).and_return(true)
+ let(:order) { create(:order_with_line_items, line_items_count: 1) }
+ let(:order_total) { order.total }
+ it 'is none when there are no payments' do
updater.update_payment_state
- expect(order.payment_state).to eq('failed')
+
+ expect(order.payment_state).to eq('none')
end
- context 'payment total is greater than order total' do
- it 'is credit_owed' do
- order.payment_total = 2
- order.total = 1
+ it 'is authorized when a payment is only pending' do
+ create(:payment, order: order, amount: order_total, state: 'pending')
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'credit_owed'
- end
+ updater.update_payment_state
+
+ expect(order.payment_state).to eq('authorized')
end
context 'order total is greater than payment total' do
- it 'is balance_due' do
- order.payment_total = 1
- order.total = 2
+ it 'is partially_paid' do
+ create(:payment, order: order, amount: order_total - 1, state: 'completed')
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'balance_due'
+ updater.update_payment_state
+
+ expect(order.payment_state).to eq('partially_paid')
end
end
context 'order total equals payment total' do
it 'is paid' do
- order.payment_total = 30
- order.total = 30
+ create(:payment, order: order, amount: order_total, state: 'completed')
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'paid'
+ updater.update_payment_state
+
+ expect(order.payment_state).to eq('paid')
end
end
context 'order is canceled' do
- before do
- order.status = 'canceled'
- end
+ before { order.update_columns(status: 'canceled') }
context 'and is still unpaid' do
- it 'is void' do
- order.payment_total = 0
- order.total = 30
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'void'
- end
- end
+ it 'is none' do
+ updater.update_payment_state
- context 'and is paid' do
- it 'is credit_owed' do
- order.payment_total = 30
- order.total = 30
- allow(order).to receive_message_chain(:payments, :valid, :empty?).and_return(false)
- allow(order).to receive_message_chain(:payments, :completed, :size).and_return(1)
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'credit_owed'
+ expect(order.payment_state).to eq('none')
end
end
context 'and payment is refunded' do
- it 'is void' do
- order.payment_total = 0
- order.total = 30
- expect do
- updater.update_payment_state
- end.to change(order, :payment_state).to 'void'
+ it 'is voided' do
+ payment = create(:payment, order: order, amount: order_total, state: 'completed')
+ create(:refund, payment: payment, amount: order_total)
+
+ updater.update_payment_state
+
+ expect(order.payment_state).to eq('voided')
end
end
end
@@ -239,21 +243,21 @@ module Spree
allow(shipments).to receive_messages shipped: []
expect(shipment).to receive(:update!).with(order)
- updater.update_fulfillments
+ updater.update_shipments
end
it 'refreshes shipment rates' do
allow(order).to receive_messages fulfillments: shipments
expect(shipment).to receive(:refresh_rates)
- updater.update_fulfillments
+ updater.update_shipments
end
it 'updates the shipment amount' do
allow(order).to receive_messages fulfillments: shipments
expect(shipment).to receive(:update_amounts)
- updater.update_fulfillments
+ updater.update_shipments
end
context 'refresh rates' do
@@ -298,7 +302,7 @@ module Spree
let(:order) { ::OrderWalkthrough.up_to(:delivery) }
it 'resets shipping method to frontend-available' do
- Spree::CartUpdater.new(order).update_shipments
+ Spree::OrderUpdater.new(order).update_shipments
expect(order.fulfillments.first.delivery_method).to eq Spree::ShippingMethod.find_by(display_on: 'both')
end
end
diff --git a/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rb b/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rb
index f7df1b216b..09440d5ea7 100644
--- a/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rb
+++ b/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
describe Spree::Promotion::Actions::CreateAdjustment, type: :model do
let(:order) { create(:order_with_line_items, line_items_count: 2) }
- let(:promotion) { create(:promotion, kind: :automatic, code: nil, stores: [order.store]) }
+ let(:promotion) { create(:promotion, kind: :automatic, code: nil, store: order.store) }
let(:action) do
described_class.create!(promotion: promotion, calculator: Spree::Calculator::FlatRate.new(preferred_amount: 4))
end
diff --git a/spree/core/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb b/spree/core/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb
index 56c454256b..373690df1c 100644
--- a/spree/core/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb
+++ b/spree/core/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
describe Spree::Promotion::Actions::CreateItemAdjustments, type: :model do
let(:order) { create(:order_with_line_items, line_items_count: 2) }
- let(:promotion) { create(:promotion, kind: :automatic, code: nil, stores: [order.store]) }
+ let(:promotion) { create(:promotion, kind: :automatic, code: nil, store: order.store) }
let(:action) do
described_class.create!(promotion: promotion, calculator: Spree::Calculator::FlatRate.new(preferred_amount: 3))
end
diff --git a/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rb b/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rb
index 3206b9bbbe..2192512e40 100644
--- a/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rb
+++ b/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
describe Spree::Promotion::Actions::FreeShipping, type: :model do
let(:order) { create(:order_with_line_items, line_items_count: 1) }
- let(:promotion) { create(:promotion, kind: :automatic, code: nil, stores: [order.store]) }
+ let(:promotion) { create(:promotion, kind: :automatic, code: nil, store: order.store) }
let(:action) { described_class.create!(promotion: promotion) }
describe '#perform' do
diff --git a/spree/core/spec/services/spree/carts/associate_spec.rb b/spree/core/spec/services/spree/carts/associate_spec.rb
new file mode 100644
index 0000000000..2eb511c942
--- /dev/null
+++ b/spree/core/spec/services/spree/carts/associate_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Spree
+ describe Carts::Associate do
+ subject { described_class.call(guest_cart: cart, user: user) }
+
+ let(:user) { create(:user) }
+
+ context 'when a guest cart is given' do
+ let(:cart) { create(:cart, customer: nil) }
+
+ it 'assigns the cart to the user and takes over the email' do
+ expect(subject).to be_success
+ expect(cart.reload.customer).to eq(user)
+ expect(cart.email).to eq(user.email)
+ end
+ end
+
+ context 'when an already assigned cart is given' do
+ let(:assigned_user) { create(:user) }
+ let(:cart) { create(:cart, customer: assigned_user) }
+
+ it 'reassigns the cart to the new user' do
+ expect(subject).to be_success
+ expect(cart.reload.customer).to eq(user)
+ end
+
+ context 'with guest_only: true' do
+ subject { described_class.call(guest_cart: cart, user: user, guest_only: true) }
+
+ it 'returns failure' do
+ expect(subject).to be_failure
+ expect(cart.reload.customer).to eq(assigned_user)
+ end
+ end
+ end
+ end
+end
diff --git a/spree/core/spec/services/spree/carts/destroy_spec.rb b/spree/core/spec/services/spree/carts/destroy_spec.rb
new file mode 100644
index 0000000000..13f15e0b30
--- /dev/null
+++ b/spree/core/spec/services/spree/carts/destroy_spec.rb
@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+module Spree
+ describe Carts::Destroy do
+ subject { described_class.call cart: cart }
+
+ context 'when a cart is given' do
+ context 'when it can be destroyed' do
+ let(:cart) do
+ create(:cart_with_line_items, line_items_count: 2, ship_address: ship_address, bill_address: bill_address)
+ end
+ let!(:fulfillment) { create(:fulfillment, cart: cart, order: nil) }
+ let!(:payment) { create(:payment, amount: cart.total, cart: cart, order: nil) }
+ let!(:line_item_ids) { cart.line_item_ids }
+ let!(:fulfillment_ids) { cart.fulfillment_ids }
+ let!(:payment_ids) { cart.payment_ids }
+
+ let(:ship_address) { create(:address) }
+ let(:bill_address) { create(:address) }
+ let(:address_ids) { [ship_address.id, bill_address.id] }
+
+ # The factory's recalculate_totals! caches empty association sets on
+ # the cart instance before the let! rows above exist.
+ before { cart.reload }
+
+ it 'returns success' do
+ expect(subject.success?).to be true
+ end
+
+ it 'voids pending payments' do
+ expect_any_instance_of(Spree::Payment).to receive(:void).exactly(cart.payments.count).times
+
+ subject
+ end
+
+ it 'cancels unfulfilled fulfillments' do
+ expect_any_instance_of(Spree::Fulfillment).to receive(:cancel).exactly(cart.fulfillments.count).times
+
+ subject
+ end
+
+ it 'destroys the cart' do
+ expect(cart.destroyed?).not_to be true
+
+ subject
+
+ expect(cart.destroyed?).to be true
+ end
+
+ it 'destroys line_items, addresses, fulfillments and payments' do
+ subject
+
+ expect(Spree::LineItem.where(id: line_item_ids)).to be_empty
+ expect(Spree::Fulfillment.where(id: fulfillment_ids)).to be_empty
+ expect(Spree::Payment.where(id: payment_ids)).to be_empty
+ expect(Spree::Address.where(id: address_ids)).to be_empty
+ end
+
+ context 'with stock reservations' do
+ let(:line_item) { cart.line_items.first }
+ let!(:reservation) do
+ line_item.variant.stock_items.first.update!(backorderable: false)
+ line_item.variant.stock_items.first.set_count_on_hand(10)
+ create(
+ :stock_reservation,
+ stock_item: line_item.variant.stock_items.first,
+ line_item: line_item,
+ cart: cart,
+ quantity: line_item.quantity,
+ expires_at: 5.minutes.from_now
+ )
+ end
+
+ it 'destroys the reservations via dependent: :destroy on the cart' do
+ reservation_id = reservation.id
+ subject
+ expect(Spree::StockReservation.where(id: reservation_id)).to be_empty
+ end
+ end
+
+ context 'when addresses are assigned to other records' do
+ let!(:other_order) { create(:order_ready_to_ship, ship_address: ship_address, bill_address: bill_address) }
+
+ it 'destroys the cart' do
+ expect(cart.destroyed?).not_to be true
+
+ subject
+
+ expect(cart.destroyed?).to be true
+ end
+
+ it 'destroys line_items, fulfillments and payments, but keeps addresses' do
+ subject
+
+ expect(Spree::LineItem.where(id: line_item_ids)).to be_empty
+ expect(Spree::Fulfillment.where(id: fulfillment_ids)).to be_empty
+ expect(Spree::Payment.where(id: payment_ids)).to be_empty
+
+ expect(Spree::Address.where(id: address_ids)).to contain_exactly(ship_address, bill_address)
+ end
+ end
+
+ context 'when empty service is called first' do
+ before { Spree::Carts::Empty.call(cart: cart) }
+
+ it 'destroys the cart' do
+ expect(cart.destroyed?).not_to be true
+
+ subject
+
+ expect(cart.destroyed?).to be true
+ end
+ end
+ end
+
+ context 'when it cannot be destroyed' do
+ context 'because the cart is completed' do
+ let(:cart) { create(:cart_with_line_items).tap { |record| record.update_columns(completed_at: Time.current) } }
+
+ it 'returns failure' do
+ expect(subject.success?).to be false
+ expect(subject.error.value).to eq Spree.t(:cannot_be_destroyed)
+ end
+ end
+
+ context 'because a payment is completed' do
+ let(:cart) { create(:cart_with_line_items) }
+ let!(:payment) { create(:payment, cart: cart, order: nil, state: 'completed', amount: cart.total) }
+
+ it 'returns failure' do
+ expect(subject.success?).to be false
+ expect(subject.error.value).to eq Spree.t(:cannot_be_destroyed)
+ end
+ end
+ end
+ end
+
+ context 'when nil is given' do
+ let(:cart) { nil }
+
+ before { subject }
+
+ it 'returns failure' do
+ expect(subject.success?).to be false
+ expect(subject.error.value).to eq Spree.t(:cannot_be_destroyed)
+ end
+ end
+ end
+end
diff --git a/spree/core/spec/services/spree/carts/empty_spec.rb b/spree/core/spec/services/spree/carts/empty_spec.rb
new file mode 100644
index 0000000000..ceb6b41f46
--- /dev/null
+++ b/spree/core/spec/services/spree/carts/empty_spec.rb
@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Spree
+ describe Carts::Empty do
+ subject { described_class.call cart: cart }
+
+ context 'when a cart is given' do
+ let(:cart) { create(:cart_with_line_items, line_items_count: 2) }
+ let(:promotion) { create(:promotion, code: '10off') }
+
+ before do
+ Spree::OrderPromotion.create!(cart: cart, promotion: promotion)
+ end
+
+ context 'completed cart' do
+ before do
+ cart.update_columns(completed_at: Time.current)
+ cart.reload
+ end
+
+ it 'returns failure' do
+ expect(subject.success?).to be false
+ expect(subject.value).to eq Spree.t(:cannot_empty)
+ end
+ end
+
+ context 'incomplete cart' do
+ before { subject }
+
+ it 'returns success' do
+ expect(subject.success?).to be true
+ expect(subject.value).to eq(cart)
+ end
+
+ it 'clears out line items, typed rows and totals' do
+ expect(cart.line_items.count).to be_zero
+ expect(cart.discounts.count).to be_zero
+ expect(cart.fulfillments.count).to be_zero
+ expect(cart.order_promotions.count).to be_zero
+ expect(cart.discount_total).to be_zero
+ expect(cart.item_total).to be_zero
+ expect(cart.delivery_total).to be_zero
+ expect(cart.total_quantity).to be_zero
+ end
+ end
+ end
+
+ context 'when nil is given' do
+ let(:cart) { nil }
+
+ before { subject }
+
+ it 'returns failure' do
+ expect(subject.success?).to be false
+ expect(subject.value).to eq Spree.t(:cannot_empty)
+ end
+ end
+
+ context 'with stock reservations' do
+ let(:cart) { create(:cart_with_line_items, line_items_count: 1) }
+ let(:line_item) { cart.line_items.first }
+
+ before do
+ line_item.variant.stock_items.first.update!(backorderable: false)
+ line_item.variant.stock_items.first.set_count_on_hand(10)
+ create(
+ :stock_reservation,
+ stock_item: line_item.variant.stock_items.first,
+ line_item: line_item,
+ cart: cart,
+ quantity: line_item.quantity,
+ expires_at: 5.minutes.from_now
+ )
+ end
+
+ it 'releases all reservations belonging to the cart' do
+ expect { described_class.call(cart: cart) }
+ .to change { Spree::StockReservation.where(cart_id: cart.id).count }.from(1).to(0)
+ end
+ end
+ end
+end
diff --git a/spree/core/spec/services/spree/carts/legacy_associate_spec.rb b/spree/core/spec/services/spree/carts/legacy_associate_spec.rb
deleted file mode 100644
index cf1b87536f..0000000000
--- a/spree/core/spec/services/spree/carts/legacy_associate_spec.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-module Spree
- describe Carts::Associate do
- subject { described_class.call(guest_order: order, user: user) }
- let(:user) { create(:user) }
-
- context 'when guest order is given' do
- let(:order) { create(:order, user: nil) }
-
- it 'assigns order to user' do
- expect(subject).to be_success
- expect(order.user).to eq(user)
- end
- end
-
- context 'when already assigned order is given' do
- let(:assigned_user) { create(:user) }
- let(:order) { create(:order, user: assigned_user) }
-
- it 'reassigns order to new user' do
- expect(subject).to be_success
- expect(order.user).to eq(user)
- end
-
- context 'with guest_only: true' do
- subject { described_class.call(guest_order: order, user: user, guest_only: true) }
-
- it 'returns failure' do
- expect(subject).to be_failure
- expect(order.user).to eq(assigned_user)
- end
- end
- end
- end
-end
diff --git a/spree/core/spec/services/spree/carts/legacy_destroy_spec.rb b/spree/core/spec/services/spree/carts/legacy_destroy_spec.rb
deleted file mode 100644
index 2c0fecfb6e..0000000000
--- a/spree/core/spec/services/spree/carts/legacy_destroy_spec.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-module Spree
- describe Carts::Destroy do
- subject { described_class.call order: order }
-
- context 'when order is given' do
- context 'when can be destroyed' do
- let(:order) { create(:order_with_line_items, ship_address: ship_address, bill_address: bill_address) }
- let(:shipment) { order.shipments.take }
- let!(:payment) { create(:payment, amount: order.total, order: order) }
- let!(:line_item_ids) { order.line_item_ids }
- let!(:shipment_ids) { order.shipment_ids }
- let!(:payment_ids) { order.payment_ids }
-
- let(:ship_address) { create(:address) }
- let(:bill_address) { create(:address) }
- let(:address_ids) { [ship_address.id, bill_address.id] }
-
- it 'returns success' do
- expect(subject.success?).to be true
- end
-
- it 'voids pending payments' do
- expect_any_instance_of(Spree::Payment).to receive(:void).exactly(order.payments.count).times
-
- subject
- end
-
- it 'cancel not shipped shipments' do
- expect_any_instance_of(Spree::Shipment).to receive(:cancel).exactly(order.shipments.count).times
-
- subject
- end
-
- it 'destroys the order' do
- expect(order.destroyed?).not_to be true
-
- subject
-
- expect(order.destroyed?).to be true
- end
-
- it 'destroys line_items, addresses, shipments and payments' do
- subject
-
- expect(Spree::LineItem.where(id: line_item_ids)).to be_empty
- expect(Spree::Shipment.where(id: shipment_ids)).to be_empty
- expect(Spree::Payment.where(id: payment_ids)).to be_empty
- expect(Spree::Address.where(id: address_ids)).to be_empty
- end
-
- context 'with stock reservations' do
- let(:line_item) { order.line_items.first }
- let!(:reservation) do
- line_item.variant.stock_items.first.update!(backorderable: false)
- line_item.variant.stock_items.first.set_count_on_hand(10)
- create(
- :stock_reservation,
- stock_item: line_item.variant.stock_items.first,
- line_item: line_item,
- order: order,
- quantity: line_item.quantity,
- expires_at: 5.minutes.from_now
- )
- end
-
- it 'destroys the reservations via dependent: :destroy on the order' do
- reservation_id = reservation.id
- subject
- expect(Spree::StockReservation.where(id: reservation_id)).to be_empty
- end
- end
-
- context 'when addresses are assigned to other orders' do
- let!(:other_order) { create(:order_ready_to_ship, ship_address: ship_address, bill_address: bill_address) }
-
- it 'destroys the order' do
- expect(order.destroyed?).not_to be true
-
- subject
-
- expect(order.destroyed?).to be true
- end
-
- it 'destroys line_items, shipments and payments, but keeps addresses' do
- subject
-
- expect(Spree::LineItem.where(id: line_item_ids)).to be_empty
- expect(Spree::Shipment.where(id: shipment_ids)).to be_empty
- expect(Spree::Payment.where(id: payment_ids)).to be_empty
-
- expect(Spree::Address.where(id: address_ids)).to contain_exactly(ship_address, bill_address)
- end
- end
-
- context 'when empty service is called first' do
- before { Spree::Carts::Empty.call(order: order) }
-
- it 'destroys the order' do
- expect(order.destroyed?).not_to be true
-
- subject
-
- expect(order.destroyed?).to be true
- end
- end
- end
-
- context 'when cannot be destroyed' do
- let(:order) { create(:completed_order_with_totals) }
-
- it 'returns failure' do
- expect(subject.success?).to be false
- expect(subject.error.value).to eq Spree.t(:cannot_be_destroyed)
- end
- end
- end
-
- context 'when nil is given' do
- let(:order) { nil }
-
- before { subject }
-
- it 'returns failure' do
- expect(subject.success?).to be false
- expect(subject.error.value).to eq Spree.t(:cannot_be_destroyed)
- end
- end
- end
-end
diff --git a/spree/core/spec/services/spree/carts/legacy_empty_spec.rb b/spree/core/spec/services/spree/carts/legacy_empty_spec.rb
deleted file mode 100644
index 4ddbbbf20d..0000000000
--- a/spree/core/spec/services/spree/carts/legacy_empty_spec.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-module Spree
- describe Carts::Empty do
- subject { described_class.call order: order }
-
- context 'when order is given' 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 'returns failure' do
- expect(subject.success?).to be false
- expect(subject.value).to eq Spree.t(:cannot_empty)
- end
- end
-
- context 'incomplete order' do
- before { subject }
-
- it 'returns success' do
- expect(subject.success?).to be true
- expect(subject.value).to eq(order)
- 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.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.ship_total).to be_zero
- end
- end
- end
-
- context 'when nil is given' do
- let(:order) { nil }
-
- before { subject }
-
- it 'returns failure' do
- expect(subject.success?).to be false
- expect(subject.value).to eq Spree.t(:cannot_empty)
- end
- end
-
- context 'with stock reservations' do
- let(:order) { create(:order_with_line_items, line_items_count: 1) }
- let(:line_item) { order.line_items.first }
-
- before do
- line_item.variant.stock_items.first.update!(backorderable: false)
- line_item.variant.stock_items.first.set_count_on_hand(10)
- create(
- :stock_reservation,
- stock_item: line_item.variant.stock_items.first,
- line_item: line_item,
- order: order,
- quantity: line_item.quantity,
- expires_at: 5.minutes.from_now
- )
- end
-
- it 'releases all reservations belonging to the order' do
- expect { described_class.call(order: order) }
- .to change { Spree::StockReservation.where(order_id: order.id).count }.from(1).to(0)
- end
- end
- end
-end
diff --git a/spree/core/spec/services/spree/carts/legacy_remove_item_spec.rb b/spree/core/spec/services/spree/carts/legacy_remove_item_spec.rb
deleted file mode 100644
index aba8cce0bf..0000000000
--- a/spree/core/spec/services/spree/carts/legacy_remove_item_spec.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-module Spree
- describe Carts::RemoveItem do
- subject { described_class }
-
- let(:order) { create :order, line_items: [line_item] }
- let(:line_item) { create :line_item, variant: variant, price: nil }
- let(:variant) { create :variant, price: 20 }
- let(:execute) { subject.call order: order, variant: variant }
- let(:value) { execute.value }
-
- context 'single line item' do
- it 'remove item from order' do
- expect(order.amount).to eq 20
- expect { execute }.to change { order.line_items.count }.by(-1)
- expect(execute).to be_success
- expect(value).to eq line_item
- expect(order.amount).to eq 0
- end
- end
-
- context 'line items with more than one quantity' do
- let(:line_item) { create :line_item, variant: variant, quantity: 2, price: nil }
- let(:execute) { subject.call order: order, variant: variant }
-
- it 'remove quantity from line item' do
- expect { execute }.to change(order, :amount).by(-20)
- expect(execute).to be_success
- expect(value).to eq line_item
- line_item.reload
- expect(order.line_items.count).to eq 1
- expect(line_item.quantity).to eq 1
- end
- end
-
- context 'raise error' do
- let(:variant_2) { create :variant }
- let(:execute) { subject.call order: order, variant: variant_2 }
-
- it 'when try remove non existing item' do
- expect { execute }.to raise_error(ActiveRecord::RecordNotFound)
- end
- end
-
- context 'not given a shipment' do
- let(:execute) { subject.call order: order, variant: variant }
-
- it 'ensures updated shipments' do
- expect(order).to receive(:ensure_updated_fulfillments)
- expect(execute).to be_success
- end
- end
-
- context 'when store_credits payment' do
- let(:order) { create(:order, line_items: [line_item], total: 100) }
- let!(:payment) { create(:store_credit_payment, order: order) }
- let(:execute) { subject.call order: order, variant: variant }
-
- it do
- expect { execute }.to change { order.payments.store_credits.count }.by(-1)
- end
- end
- end
-end
diff --git a/spree/core/spec/services/spree/carts/remove_item_spec.rb b/spree/core/spec/services/spree/carts/remove_item_spec.rb
new file mode 100644
index 0000000000..1692a6d7e4
--- /dev/null
+++ b/spree/core/spec/services/spree/carts/remove_item_spec.rb
@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Spree
+ describe Carts::RemoveItem do
+ subject { described_class }
+
+ let(:cart) { create(:cart) }
+ let!(:line_item) { create(:line_item, cart: cart, order: nil, variant: variant, price: nil) }
+ let(:variant) { create(:variant, price: 20) }
+ let(:execute) { subject.call cart: cart, variant: variant }
+ let(:value) { execute.value }
+
+ before { cart.recalculate_totals! }
+
+ context 'single line item' do
+ it 'removes the item from the cart' do
+ expect(cart.reload.item_total).to eq 20
+ expect { execute }.to change { cart.line_items.count }.by(-1)
+ expect(execute).to be_success
+ expect(value).to eq line_item
+ expect(cart.reload.item_total).to eq 0
+ end
+ end
+
+ context 'line items with more than one quantity' do
+ let!(:line_item) { create(:line_item, cart: cart, order: nil, variant: variant, quantity: 2, price: nil) }
+
+ it 'removes quantity from the line item' do
+ expect { execute }.to change { cart.reload.item_total }.by(-20)
+ expect(execute).to be_success
+ expect(value).to eq line_item
+ line_item.reload
+ expect(cart.line_items.count).to eq 1
+ expect(line_item.quantity).to eq 1
+ end
+ end
+
+ context 'raise error' do
+ let(:other_variant) { create(:variant) }
+ let(:execute) { subject.call cart: cart, variant: other_variant }
+
+ it 'when trying to remove a non-existing item' do
+ expect { execute }.to raise_error(ActiveRecord::RecordNotFound)
+ end
+ end
+
+ context 'not given a fulfillment' do
+ it 'ensures updated fulfillments' do
+ expect(cart).to receive(:ensure_updated_fulfillments)
+ expect(execute).to be_success
+ end
+ end
+
+ context 'when store_credits payment' do
+ let(:cart) { create(:cart, customer: create(:user)) }
+ let!(:payment) { create(:store_credit_payment, cart: cart, order: nil, amount: 10) }
+
+ it 'invalidates the store credit payment' do
+ expect { execute }.to change { cart.payments.store_credits.count }.by(-1)
+ end
+ end
+ end
+end
diff --git a/spree/core/spec/services/spree/carts/legacy_remove_line_item_spec.rb b/spree/core/spec/services/spree/carts/remove_line_item_spec.rb
similarity index 51%
rename from spree/core/spec/services/spree/carts/legacy_remove_line_item_spec.rb
rename to spree/core/spec/services/spree/carts/remove_line_item_spec.rb
index 0a92b05c2a..56e7d088f7 100644
--- a/spree/core/spec/services/spree/carts/legacy_remove_line_item_spec.rb
+++ b/spree/core/spec/services/spree/carts/remove_line_item_spec.rb
@@ -4,74 +4,74 @@ module Spree
describe Carts::RemoveLineItem do
subject { described_class }
- let(:order) { create :order, line_items: [line_item] }
- let(:line_item) { create :line_item, variant: variant, price: nil, quantity: 10 }
- let(:variant) { create :variant, price: 20 }
- let(:execute) { subject.call order: order, line_item: line_item }
+ let(:cart) { create(:cart) }
+ let!(:line_item) { create(:line_item, cart: cart, order: nil, variant: variant, price: nil, quantity: 10) }
+ let(:variant) { create(:variant, price: 20) }
+ let(:execute) { subject.call cart: cart, line_item: line_item }
let(:value) { execute.value }
+ before { cart.recalculate_totals! }
+
context 'remove line item' do
context 'with any quantity' do
- it 'with any quantity' do
- expect(order.amount).to eq 200
- expect { execute }.to change { order.line_items.count }.by(-1)
+ it 'removes the whole line item' do
+ expect(cart.reload.item_total).to eq 200
+ expect { execute }.to change { cart.line_items.count }.by(-1)
expect(execute).to be_success
expect(value).to eq line_item
- expect(order.amount).to eq 0
+ expect(cart.reload.item_total).to eq 0
end
end
context 'with many unique items' do
- let(:order) { create(:order_with_line_items, line_items_count: 2) }
- let(:line_item) {order.line_items.first}
+ let(:cart) { create(:cart_with_line_items, line_items_count: 2) }
+ let!(:line_item) { cart.line_items.first }
- it 'from order with many unique items' do
- expect(order.amount).to eq 20
- expect(order.line_items.count).to eq 2
- expect { execute }.to change { order.line_items.count }.by(-1)
+ it 'removes only the given line item' do
+ expect(cart.reload.item_total).to eq 20
+ expect(cart.line_items.count).to eq 2
+ expect { execute }.to change { cart.line_items.count }.by(-1)
expect(execute).to be_success
expect(value).to eq line_item
- expect(order.amount).to eq 10
+ expect(cart.reload.item_total).to eq 10
end
end
end
- context 'not given a shipment' do
- let(:execute) { subject.call order: order, line_item: line_item }
-
- it 'ensures updated shipments' do
- expect(order).to receive(:ensure_updated_fulfillments)
+ context 'not given a fulfillment' do
+ it 'ensures updated fulfillments' do
+ expect(cart).to receive(:ensure_updated_fulfillments)
expect(execute).to be_success
end
end
context 'stock reservations' do
- let(:order) { create(:order_with_line_items, line_items_count: 2) }
- let(:line_item) { order.line_items.first }
- let(:other_line_item) { order.line_items.last }
+ let(:cart) { create(:cart_with_line_items, line_items_count: 2) }
+ let!(:line_item) { cart.line_items.first }
+ let(:other_line_item) { cart.line_items.last }
before do
- order.line_items.each do |li|
- li.variant.stock_items.first.update!(backorderable: false)
- li.variant.stock_items.first.set_count_on_hand(10)
+ cart.line_items.each do |cart_line_item|
+ cart_line_item.variant.stock_items.first.update!(backorderable: false)
+ cart_line_item.variant.stock_items.first.set_count_on_hand(10)
end
end
- context 'when the order is mid-checkout' do
-
+ context 'when the cart is mid-checkout' do
+ before { cart.update_columns(email: '[email protected]') }
it 'reservation for the removed line item is destroyed via dependent: :destroy' do
create(
:stock_reservation,
stock_item: line_item.variant.stock_items.first,
line_item: line_item,
- order: order,
+ cart: cart,
quantity: line_item.quantity,
expires_at: 5.minutes.from_now
)
- expect { subject.call(order: order, line_item: line_item) }
- .to change { Spree::StockReservation.where(order_id: order.id, line_item_id: line_item.id).count }
+ expect { subject.call(cart: cart, line_item: line_item) }
+ .to change { Spree::StockReservation.where(cart_id: cart.id, line_item_id: line_item.id).count }
.from(1).to(0)
end
@@ -80,14 +80,14 @@ module Spree
:stock_reservation,
stock_item: other_line_item.variant.stock_items.first,
line_item: other_line_item,
- order: order,
+ cart: cart,
quantity: other_line_item.quantity,
expires_at: 1.minute.from_now
)
original_expiry = Spree::StockReservation.find_by(line_item_id: other_line_item.id).expires_at
Timecop.freeze(2.minutes.from_now) do
- subject.call(order: order, line_item: line_item)
+ subject.call(cart: cart, line_item: line_item)
end
new_expiry = Spree::StockReservation.find_by(line_item_id: other_line_item.id).expires_at
@@ -97,11 +97,11 @@ module Spree
it 'leaves no orphaned reservations after removing every line item' do
# Removing the second-to-last item still triggers a Reserve pass over
# the remaining one. Removing the last item must not leave any
- # reservation rows behind for this order.
- subject.call(order: order, line_item: line_item)
- subject.call(order: order, line_item: other_line_item.reload)
+ # reservation rows behind for this cart.
+ subject.call(cart: cart, line_item: line_item)
+ subject.call(cart: cart, line_item: other_line_item.reload)
- expect(Spree::StockReservation.where(order_id: order.id)).to be_empty
+ expect(Spree::StockReservation.where(cart_id: cart.id)).to be_empty
end
it 'returns failure and rolls back the destroy when re-reservation fails' do
@@ -110,22 +110,20 @@ module Spree
# still picks the row.
other_line_item.update_column(:quantity, 5)
other_line_item.variant.stock_items.first.set_count_on_hand(2)
- line_item_count_before = order.line_items.count
+ line_item_count_before = cart.line_items.count
- result = subject.call(order: order, line_item: line_item)
+ result = subject.call(cart: cart, line_item: line_item)
expect(result).to be_failure
expect(result.error.to_s).to include('available')
- expect(order.reload.line_items.count).to eq(line_item_count_before)
+ expect(cart.reload.line_items.count).to eq(line_item_count_before)
end
end
- context 'when the order is in the cart state' do
- before { order.update_columns(email: nil, ship_address_id: nil) }
-
+ context 'when the cart is not yet in checkout' do
it 'does not run a reservation pass' do
expect {
- subject.call(order: order, line_item: line_item)
+ subject.call(cart: cart, line_item: line_item)
}.not_to change { Spree::StockReservation.count }
end
end
diff --git a/spree/core/spec/services/spree/carts/legacy_remove_out_of_stock_items_spec.rb b/spree/core/spec/services/spree/carts/remove_out_of_stock_items_spec.rb
similarity index 76%
rename from spree/core/spec/services/spree/carts/legacy_remove_out_of_stock_items_spec.rb
rename to spree/core/spec/services/spree/carts/remove_out_of_stock_items_spec.rb
index 09676f001d..f238b1dd4f 100644
--- a/spree/core/spec/services/spree/carts/legacy_remove_out_of_stock_items_spec.rb
+++ b/spree/core/spec/services/spree/carts/remove_out_of_stock_items_spec.rb
@@ -5,17 +5,17 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
let(:store) { @default_store }
let(:user) { create(:user) }
- let(:order) { create(:order_with_totals, store: store, user: user) }
- let(:product) { order.products.first }
- let(:variant) { order.variants.first }
- let(:execute) { subject.call(order: order) }
+ let(:cart) { create(:cart_with_line_items, store: store, customer: user) }
+ let(:product) { cart.products.first }
+ let(:variant) { cart.variants.first }
+ let(:execute) { subject.call(cart: cart) }
it 'evaluate service to success' do
expect(execute).to be_success
end
it 'returns empty messages and warnings when cart is valid' do
- _order, messages, warnings = execute.value
+ _cart, messages, warnings = execute.value
expect(messages).to be_empty
expect(warnings).to be_empty
end
@@ -24,12 +24,12 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
before { product.update_columns(status: 'archive') }
it 'removes line item and returns discontinued message' do
- _order, messages, _warnings = execute.value
+ _cart, messages, _warnings = execute.value
expect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))
end
it 'returns structured warning with line_item_removed code' do
- _order, _messages, warnings = execute.value
+ _cart, _messages, warnings = execute.value
expect(warnings.length).to eq(1)
expect(warnings.first[:code]).to eq('line_item_removed')
expect(warnings.first[:variant_id]).to be_present
@@ -40,12 +40,12 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
before { product.stock_items.update_all(count_on_hand: 0, backorderable: false) }
it 'removes line item and returns out of stock message' do
- _order, messages, _warnings = execute.value
+ _cart, messages, _warnings = execute.value
expect(messages.to_sentence).to eq(Spree.t('cart_line_item.out_of_stock', li_name: product.name))
end
it 'returns structured warning with line_item_removed code' do
- _order, _messages, warnings = execute.value
+ _cart, _messages, warnings = execute.value
expect(warnings.length).to eq(1)
expect(warnings.first[:code]).to eq('line_item_removed')
end
@@ -55,7 +55,7 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
before { product.delete }
it 'removes line item and returns discontinued message' do
- _order, messages, _warnings = execute.value
+ _cart, messages, _warnings = execute.value
expect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))
end
end
@@ -64,7 +64,7 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
before { product.update_columns(status: 'discontinued') }
it 'removes line item and returns discontinued message' do
- _order, messages, _warnings = execute.value
+ _cart, messages, _warnings = execute.value
expect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))
end
end
@@ -73,13 +73,13 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
before { variant.discontinue! }
it 'removes line item and returns discontinued message' do
- _order, messages, _warnings = execute.value
+ _cart, messages, _warnings = execute.value
expect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: variant.product.name))
end
end
- context "when the order holds its own stock reservation for the last unit" do
- let(:line_item) { order.line_items.first }
+ context "when the cart holds its own stock reservation for the last unit" do
+ let(:line_item) { cart.line_items.first }
before do
Spree::Config[:stock_reservations_enabled] = true
@@ -90,7 +90,7 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
:stock_reservation,
stock_item: stock_item,
line_item: line_item,
- order: order,
+ cart: cart,
quantity: 1,
expires_at: 5.minutes.from_now
)
@@ -100,10 +100,10 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems do
after { Spree::Config[:stock_reservations_enabled] = true }
it 'keeps the line item in the cart' do
- _order, messages, warnings = execute.value
+ _cart, messages, warnings = execute.value
expect(messages).to be_empty
expect(warnings).to be_empty
- expect(order.reload.line_items).to include(line_item)
+ expect(cart.reload.line_items).to include(line_item)
end
end
end
diff --git a/spree/core/spec/services/spree/carts/legacy_set_quantity_spec.rb b/spree/core/spec/services/spree/carts/set_quantity_spec.rb
similarity index 61%
rename from spree/core/spec/services/spree/carts/legacy_set_quantity_spec.rb
rename to spree/core/spec/services/spree/carts/set_quantity_spec.rb
index a1597d6543..64e9f77839 100644
--- a/spree/core/spec/services/spree/carts/legacy_set_quantity_spec.rb
+++ b/spree/core/spec/services/spree/carts/set_quantity_spec.rb
@@ -5,8 +5,8 @@ module Spree
subject { described_class }
let(:store) { @default_store }
- let(:order) { create(:order, store: store) }
- let(:line_item) { create(:line_item, order: order) }
+ let(:cart) { create(:cart, store: store) }
+ let(:line_item) { create(:line_item, cart: cart, order: nil) }
context 'with non-backorderable item' do
before do
@@ -16,7 +16,7 @@ module Spree
context 'with sufficient stock quantity' do
it 'returns successful result', :aggregate_failures do
- result = subject.call(order: order, line_item: line_item, quantity: 5)
+ result = subject.call(cart: cart, line_item: line_item, quantity: 5)
expect(result.success).to eq(true)
expect(result.value).to be_a LineItem
@@ -25,8 +25,8 @@ module Spree
end
context 'with insufficient stock quantity' do
- it 'return result with success equal false', :aggregate_failures do
- result = subject.call(order: order, line_item: line_item, quantity: 10)
+ it 'returns result with success equal false', :aggregate_failures do
+ result = subject.call(cart: cart, line_item: line_item, quantity: 10)
expect(result.success).to eq(false)
expect(result.value).to be_a LineItem
@@ -37,7 +37,7 @@ module Spree
context 'with backorderable item' do
it 'returns successful result', :aggregate_failures do
- result = subject.call(order: order, line_item: line_item, quantity: 5)
+ result = subject.call(cart: cart, line_item: line_item, quantity: 5)
expect(result.success).to eq(true)
expect(result.value).to be_a LineItem
@@ -51,43 +51,41 @@ module Spree
line_item.variant.stock_items.first.set_count_on_hand(20)
end
- context 'when the order is mid-checkout' do
- before { order.update_columns(email: order.email || '[email protected]', ship_address_id: order.ship_address_id || create(:address).id) }
+ context 'when the cart is mid-checkout' do
+ before { cart.update_columns(email: '[email protected]') }
it 'reserves the new quantity' do
- subject.call(order: order, line_item: line_item, quantity: 4)
+ subject.call(cart: cart, line_item: line_item, quantity: 4)
- reservation = Spree::StockReservation.where(order_id: order.id, line_item_id: line_item.id).first
+ reservation = Spree::StockReservation.where(cart_id: cart.id, line_item_id: line_item.id).first
expect(reservation).to be_present
expect(reservation.quantity).to eq(4)
end
it 'updates an existing reservation in place rather than duplicating' do
- subject.call(order: order, line_item: line_item, quantity: 2)
- subject.call(order: order, line_item: line_item, quantity: 4)
+ subject.call(cart: cart, line_item: line_item, quantity: 2)
+ subject.call(cart: cart, line_item: line_item, quantity: 4)
- reservations = Spree::StockReservation.where(order_id: order.id, line_item_id: line_item.id)
+ reservations = Spree::StockReservation.where(cart_id: cart.id, line_item_id: line_item.id)
expect(reservations.count).to eq(1)
expect(reservations.first.quantity).to eq(4)
end
it 'fails when the new quantity exceeds available stock and rolls back' do
- subject.call(order: order, line_item: line_item, quantity: 2)
+ subject.call(cart: cart, line_item: line_item, quantity: 2)
line_item.variant.stock_items.first.set_count_on_hand(3)
- result = subject.call(order: order, line_item: line_item, quantity: 5)
+ result = subject.call(cart: cart, line_item: line_item, quantity: 5)
expect(result).to be_failure
expect(line_item.reload.quantity).to eq(2)
end
end
- context 'when the order is in the cart state' do
- before { order.update_columns(email: nil, ship_address_id: nil) }
-
+ context 'when the cart is not yet in checkout' do
it 'does not create a reservation' do
expect {
- subject.call(order: order, line_item: line_item, quantity: 4)
+ subject.call(cart: cart, line_item: line_item, quantity: 4)
}.not_to change { Spree::StockReservation.count }
end
end
diff --git a/spree/core/spec/services/spree/carts/update_spec.rb b/spree/core/spec/services/spree/carts/update_spec.rb
index d113ab1670..ac153e861f 100644
--- a/spree/core/spec/services/spree/carts/update_spec.rb
+++ b/spree/core/spec/services/spree/carts/update_spec.rb
@@ -6,7 +6,7 @@ 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(:cart) { create(:cart_with_line_items, user: user, store: store, currency: 'USD') }
+ let(:cart) { create(:cart_with_line_items, customer: user, store: store, currency: 'USD') }
describe '#call' do
subject { described_class.call(cart: cart, params: params) }
@@ -25,22 +25,22 @@ module Spree
it 'updates the customer note' do
expect(subject).to be_success
- expect(cart.reload.special_instructions).to eq('Leave at the door')
+ expect(cart.reload.customer_note).to eq('Leave at the door')
end
context 'when clearing customer_note' do
- let(:cart) { create(:cart_with_line_items, user: user, store: store, special_instructions: 'Existing instructions') }
+ let(:cart) { create(:cart_with_line_items, customer: user, store: store, customer_note: 'Existing instructions') }
it 'clears with empty string' do
result = described_class.call(cart: cart, params: { customer_note: '' })
expect(result).to be_success
- expect(cart.reload.special_instructions).to eq('')
+ expect(cart.reload.customer_note).to eq('')
end
it 'clears with nil' do
result = described_class.call(cart: cart, params: { customer_note: nil })
expect(result).to be_success
- expect(cart.reload.special_instructions).to be_nil
+ expect(cart.reload.customer_note).to be_nil
end
end
end
@@ -79,7 +79,7 @@ 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(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, currency: 'USD') }
+ let(:cart) { create(:cart_with_line_items, customer: user, store: store, market: us_market, currency: 'USD') }
it 'switches market when currency changes' do
result = described_class.call(cart: cart, params: { currency: 'EUR' })
@@ -142,7 +142,7 @@ 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(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, ship_address: us_address, email: '[email protected]') }
+ let(:cart) { create(:cart_with_line_items, customer: 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
@@ -161,7 +161,7 @@ module Spree
context 'when shipping address country is in the new market' do
let(:de_address) { create(:address, country: de_country) }
- let(:cart) { create(:cart_with_line_items, user: user, store: store, market: us_market, ship_address: de_address) }
+ let(:cart) { create(:cart_with_line_items, customer: user, store: store, market: us_market, ship_address: de_address) }
let(:params) { { market_id: eu_market.prefixed_id } }
it 'keeps the shipping address' do
@@ -256,7 +256,7 @@ module Spree
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)) }
+ let(:cart) { create(:cart_with_line_items, customer: 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
@@ -281,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(:cart) { create(:cart_with_line_items, user: user, store: store, email: '[email protected]', ship_address: create(:address, user: user)) }
+ let(:cart) { create(:cart_with_line_items, customer: user, store: store, email: '[email protected]', ship_address: create(:address, user: user)) }
let(:params) do
{
@@ -396,7 +396,7 @@ module Spree
include_examples 'ignores other users address', :billing_address
context 'when the cart has no user (guest cart)' do
- let(:cart) { create(:cart_with_line_items, user: nil, store: store) }
+ let(:cart) { create(:cart_with_line_items, customer: nil, store: store) }
let(:params) { { shipping_address_id: other_users_address.prefixed_id } }
it 'ignores address_id params and keeps existing address' do
@@ -581,8 +581,8 @@ module Spree
let(:params) { { email: '[email protected]', shipping_address: address_params } }
it 'creates reservations when entering checkout' do
- expect(cart.cart?).to be(true)
expect { subject }.to change { Spree::StockReservation.where(cart_id: cart.id).count }.by_at_least(1)
+ expect(cart.reload.in_checkout?).to be(true)
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 847daa4ee9..42bdf9fcf2 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(:cart, user: user, store: store) }
+ let(:cart) { create(:cart, customer: user, store: store) }
let(:variant) { create(:variant) }
let(:variant2) { create(:variant) }
@@ -146,7 +146,7 @@ module Spree
end
context 'with variant not available in cart currency' do
- let(:cart) { create(:cart, user: user, store: store, currency: 'GBP') }
+ let(:cart) { create(:cart, customer: user, store: store, currency: 'GBP') }
let(:items) { [{ variant_id: variant.prefixed_id, quantity: 1 }] }
it 'returns failure with message' do
diff --git a/spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb b/spree/core/spec/workflows/spree/carts/add_item_spec.rb
similarity index 55%
rename from spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb
rename to spree/core/spec/workflows/spree/carts/add_item_spec.rb
index c9e5d4a8e6..6f0c0271b8 100644
--- a/spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb
+++ b/spree/core/spec/workflows/spree/carts/add_item_spec.rb
@@ -4,50 +4,46 @@ module Spree
describe Carts::AddItem do
subject { described_class }
- let(:order) { create :order, total: 100 }
- let(:variant) { create :variant, price: 20 }
+ let(:cart) { create(:cart) }
+ let(:variant) { create(:variant, price: 20) }
let(:qty) { 1 }
- let(:execute) { subject.call(order: order, variant: variant, quantity: qty) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: qty) }
let(:value) { execute.value }
- let(:expected_line_item) { order.reload.line_items.first }
+ let(:expected_line_item) { cart.reload.line_items.first }
- context 'add line item to order' do
- it 'change by one and recalculate amount' do
- expect { execute }.to change { order.line_items.count }.by(1)
+ context 'add line item to cart' do
+ it 'changes by one and recalculates totals' do
+ expect { execute }.to change { cart.line_items.count }.by(1)
expect(execute).to be_success
expect(value).to eq expected_line_item
- expect(order.amount).to eq 20
+ expect(cart.reload.item_total).to eq 20
end
end
context 'with same line item' do
- let(:line_item) { create :line_item, variant: variant }
- let(:order) { create :order, line_items: [line_item] }
+ let!(:line_item) { create(:line_item, cart: cart, order: nil, variant: variant) }
- it 'not to add' do
+ it 'increments the existing line item instead of adding a new one' do
expect(execute).to be_success
expect(value).to eq expected_line_item
- expect(order.line_items.count).to eq 1
+ expect(cart.line_items.count).to eq 1
+ expect(expected_line_item.quantity).to eq(line_item.quantity + 1)
end
end
- context 'not given a shipment' do
- let(:execute) { subject.call(order: order, variant: variant, quantity: qty) }
-
- it 'ensures updated shipments' do
- expect(order).to receive(:ensure_updated_fulfillments)
+ context 'not given a fulfillment' do
+ it 'ensures updated fulfillments' do
+ expect(cart).to receive(:ensure_updated_fulfillments)
expect(execute).to be_success
end
end
context 'with store_credits payment' do
- let!(:order) { create(:order, total: 100) }
- let!(:payment) { create(:store_credit_payment, order: order) }
-
- let(:execute) { subject.call(order: order, variant: variant, quantity: 1) }
+ let(:cart) { create(:cart_with_line_items, customer: create(:user)) }
+ let!(:payment) { create(:store_credit_payment, cart: cart, order: nil, amount: 5) }
- it do
- expect { execute }.to change { order.payments.store_credits.count }.by(-1)
+ it 'invalidates the store credit payment' do
+ expect { execute }.to change { cart.payments.store_credits.count }.by(-1)
end
end
@@ -59,14 +55,14 @@ module Spree
let!(:action) { Spree::Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
before do
- subject.call(order: order, variant: variant, quantity: 1)
- order.reload
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ cart.reload
end
- it 'creates valid discount on order' do
- subject.call(order: order, variant: variant, quantity: 1)
- expect(order.discounts.to_a.sum(&:amount)).not_to eq 0
- expect(order.total).to eq 30
+ it 'creates valid discount on the cart' do
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ expect(cart.discounts.to_a.sum(&:amount)).not_to eq 0
+ expect(cart.reload.total).to eq 30
end
end
@@ -74,14 +70,14 @@ module Spree
let!(:action) { Spree::Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
before do
- subject.call(order: order, variant: variant, quantity: 1)
- order.reload
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ cart.reload
end
- it 'creates valid discount on order' do
- subject.call(order: order, variant: variant, quantity: 1)
- expect(order.line_item_discounts.to_a.sum(&:amount)).not_to eq 0
- expect(order.total).to eq 30
+ it 'creates valid line item discount on the cart' do
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ expect(cart.discounts.for_line_items.to_a.sum(&:amount)).not_to eq 0
+ expect(cart.reload.total).to eq 30
end
end
@@ -101,28 +97,28 @@ module Spree
let!(:action) { Spree::Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
it 'updates included_tax_total' do
- expect(order.included_tax_total.to_f).to eq(0.00)
- subject.call(order: order, variant: variant, quantity: 1)
- expect(order.included_tax_total.to_f).to eq(100)
+ expect(cart.included_tax_total.to_f).to eq(0.00)
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ expect(cart.reload.included_tax_total.to_f).to eq(100)
end
it 'updates included_tax_total after adding two line items' do
- subject.call(order: order, variant: variant, quantity: 1)
- expect(order.included_tax_total.to_f).to eq(100)
- subject.call(order: order, variant: variant, quantity: 1)
- expect(order.included_tax_total.to_f).to eq(200)
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ expect(cart.reload.included_tax_total.to_f).to eq(100)
+ subject.call(cart: cart, variant: variant, quantity: 1)
+ expect(cart.reload.included_tax_total.to_f).to eq(200)
end
end
end
context 'pass valid params hash in options' do
let(:options) { { quantity: 2, variant_id: variant.id } }
- let(:execute) { subject.call(order: order, variant: variant, quantity: nil, options: options) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: nil, options: options) }
- it do
+ it 'takes the quantity from options' do
expect(execute).to be_success
- expect(order.line_items.count).to eq 1
- line_item = order.line_items.first
+ expect(cart.line_items.count).to eq 1
+ line_item = cart.line_items.first
expect(line_item.quantity).to eq 2
end
end
@@ -130,70 +126,70 @@ module Spree
context 'pass invalid arguments' do
context 'different quantity in argument and in options' do
let(:options) { { quantity: 2 } }
- let(:execute) { subject.call(order: order, variant: variant, quantity: 3, options: options) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: 3, options: options) }
- it 'take value from options' do
+ it 'takes value from options' do
expect(execute).to be_success
- line_item = order.line_items.first
+ line_item = cart.line_items.first
expect(line_item.quantity).to eq 2
end
end
- context 'different quantity no quantity in argument and in params' do
+ context 'no quantity in argument nor in options' do
let(:options) { {} }
- let(:execute) { subject.call(order: order, variant: variant, quantity: nil, options: options) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: nil, options: options) }
- it 'set default' do
+ it 'sets the default' do
expect(execute).to be_success
- line_item = order.line_items.first
+ line_item = cart.line_items.first
expect(line_item.quantity).to eq 1
end
end
- context 'not permitted' do
+ context 'not permitted option' do
let(:options) { { dummy_param: true } }
- let(:execute) { subject.call(order: order, variant: variant, quantity: 1, options: options) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: 1, options: options) }
- it do
+ it 'ignores the option' do
expect(execute).to be_success
- line_item = order.line_items.first
+ line_item = cart.line_items.first
expect(line_item.quantity).to eq 1
end
end
context 'pass non-existing variant' do
- let(:variant_2) { create :variant }
- let(:execute) { subject.call(order: order, variant: variant_2, quantity: 1) }
+ let(:other_variant) { create(:variant) }
+ let(:execute) { subject.call(cart: cart, variant: other_variant, quantity: 1) }
- before { Spree::Variant.find(variant_2.id).destroy }
+ before { Spree::Variant.find(other_variant.id).destroy }
- it do
+ it 'fails without adding a line item' do
expect(execute).to be_failure
- order.reload
- expect(order.line_items.count).to eq 0
+ cart.reload
+ expect(cart.line_items.count).to eq 0
end
end
- context 'variant have not desired quantity' do
- let(:execute) { subject.call(order: order, variant: variant, quantity: 10) }
+ context 'variant does not have the desired quantity' do
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: 10) }
before { variant.stock_items.first.update backorderable: false }
- it do
+ it 'fails without adding a line item' do
expect(execute).to be_failure
- order.reload
- expect(order.line_items.count).to eq 0
+ cart.reload
+ expect(cart.line_items.count).to eq 0
end
end
- context 'variant has been descontinued' do
+ context 'variant has been discontinued' do
let(:variant) { create :variant, discontinue_on: 1.day.ago }
- let(:execute) { subject.call(order: order, variant: variant, quantity: 10) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: 10) }
- it do
+ it 'fails without adding a line item' do
expect(execute).to be_failure
- order.reload
- expect(order.line_items.count).to eq 0
+ cart.reload
+ expect(cart.line_items.count).to eq 0
end
end
end
@@ -216,23 +212,23 @@ module Spree
end
it 'adds the not-yet-published, preorderable item to the cart' do
- expect { execute }.to change { order.line_items.count }.by(1)
+ expect { execute }.to change { cart.line_items.count }.by(1)
expect(execute).to be_success
end
it 'caps the pre-order at the backorder_limit' do
- result = subject.call(order: order, variant: variant, quantity: 6)
+ result = subject.call(cart: cart, variant: variant, quantity: 6)
expect(result).to be_failure
- expect(order.reload.line_items).to be_empty
+ expect(cart.reload.line_items).to be_empty
end
context 'with no backorder_limit (unlimited)' do
before { variant.update!(backorder_limit: nil) }
it 'accepts a pre-order beyond any stock count' do
- result = subject.call(order: order, variant: variant, quantity: 100)
+ result = subject.call(cart: cart, variant: variant, quantity: 100)
expect(result).to be_success
- expect(order.reload.line_items.first.quantity).to eq 100
+ expect(cart.reload.line_items.first.quantity).to eq 100
end
end
@@ -245,7 +241,7 @@ module Spree
it 'is rejected because the product is not yet published' do
expect(execute).to be_failure
- expect(order.reload.line_items).to be_empty
+ expect(cart.reload.line_items).to be_empty
end
end
end
@@ -253,46 +249,46 @@ module Spree
context 'setting metadata' do
context 'via metadata param' do
let(:metadata) { { 'gift_message' => 'Happy Birthday!' } }
- let(:execute) { subject.call(order: order, variant: variant, quantity: qty, metadata: metadata) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: qty, metadata: metadata) }
it 'stores metadata on the line item' do
expect(execute).to be_success
- order.reload
- expect(order.line_items.first.metadata).to eq metadata
- expect(order.line_items.first.private_metadata).to eq metadata
+ cart.reload
+ expect(cart.line_items.first.metadata).to eq metadata
+ expect(cart.line_items.first.private_metadata).to eq metadata
end
end
context 'via legacy public_metadata and private_metadata params' do
let(:public_metadata) { { 'prop1' => 'value1' } }
let(:private_metadata) { { 'prop2' => 'value2' } }
- let(:execute) { subject.call(order: order, variant: variant, quantity: qty, public_metadata: public_metadata, private_metadata: private_metadata) }
+ let(:execute) { subject.call(cart: cart, variant: variant, quantity: qty, public_metadata: public_metadata, private_metadata: private_metadata) }
it 'stores private_metadata' do
expect(execute).to be_success
- order.reload
- expect(order.line_items.first.private_metadata).to eq private_metadata
+ cart.reload
+ expect(cart.line_items.first.private_metadata).to eq private_metadata
end
it 'stores public_metadata' do
expect(execute).to be_success
- order.reload
- expect(order.line_items.first.public_metadata).to eq public_metadata
+ cart.reload
+ expect(cart.line_items.first.public_metadata).to eq public_metadata
end
end
end
context 'when variant has price in the cart currency, but with amount set to nil' do
- let(:call_service) { subject.call(order: order, variant: variant, quantity: 1) }
+ let(:call_workflow) { subject.call(cart: cart, variant: variant, quantity: 1) }
before do
allow(Spree::Config).to receive(:allow_empty_price_amount).and_return(true)
variant.prices.first.update(amount: nil)
end
- it 'does not add the item and raises error' do
- expect(call_service).to be_failure
- expect(call_service.error).not_to be_nil
+ it 'does not add the item and returns failure' do
+ expect(call_workflow).to be_failure
+ expect(call_workflow.error).not_to be_nil
end
end
@@ -304,26 +300,26 @@ module Spree
variant.stock_items.first.set_count_on_hand(10)
end
- context 'when the order is mid-checkout' do
- let(:order) { create(:order, total: 100, state: 'address') }
+ context 'when the cart is mid-checkout' do
+ let(:cart) { create(:cart, email: '[email protected]') }
it 'creates a reservation for the new line item' do
- expect { execute }.to change { Spree::StockReservation.where(order_id: order.id).count }.by(1)
+ expect { execute }.to change { Spree::StockReservation.where(cart_id: cart.id).count }.by(1)
expect(execute).to be_success
end
it 'fails when adding more than available and rolls back the line item' do
variant.stock_items.first.set_count_on_hand(0)
- result = subject.call(order: order, variant: variant, quantity: 1)
+ result = subject.call(cart: cart, variant: variant, quantity: 1)
expect(result).to be_failure
- expect(order.reload.line_items).to be_empty
+ expect(cart.reload.line_items).to be_empty
end
end
- context 'when the order is in the cart state' do
- let(:order) { create(:order, total: 100, email: nil, user: nil, bill_address: nil) }
+ context 'when the cart is not yet in checkout' do
+ let(:cart) { create(:cart) }
it 'does not create a reservation' do
expect { execute }.not_to change { Spree::StockReservation.count }
@@ -332,7 +328,7 @@ module Spree
end
context 'when stock_reservations_enabled is false' do
- let(:order) { create(:order, total: 100, state: 'address') }
+ let(:cart) { create(:cart, email: '[email protected]') }
before { Spree::Config[:stock_reservations_enabled] = false }
after { Spree::Config[:stock_reservations_enabled] = true }
@@ -344,7 +340,7 @@ module Spree
end
context 'when the variant is a capped pre-order with partial stock' do
- let(:order) { create(:order, total: 100, state: 'address') }
+ let(:cart) { create(:cart, email: '[email protected]') }
before do
variant.update!(preorderable: true, backorder_limit: 5)
@@ -352,10 +348,10 @@ module Spree
end
it 'skips reservation and accepts quantities beyond on-hand stock' do
- result = subject.call(order: order, variant: variant, quantity: 5)
+ result = subject.call(cart: cart, variant: variant, quantity: 5)
expect(result).to be_success
- expect(Spree::StockReservation.where(order_id: order.id)).to be_empty
+ expect(Spree::StockReservation.where(cart_id: cart.id)).to be_empty
end
end
end
diff --git a/spree/core/spec/workflows/spree/orders/add_item_spec.rb b/spree/core/spec/workflows/spree/orders/add_item_spec.rb
new file mode 100644
index 0000000000..e691de6877
--- /dev/null
+++ b/spree/core/spec/workflows/spree/orders/add_item_spec.rb
@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Spree
+ describe Orders::AddItem do
+ subject { described_class }
+
+ let(:order) { create(:completed_order_with_totals, line_items_count: 1, line_items_price: 10) }
+ let(:variant) { create(:variant, price: 20) }
+
+ describe '#call' do
+ it 'adds a line item to the placed order and re-sums its totals' do
+ expect do
+ result = subject.call(order: order, variant: variant, quantity: 2)
+
+ expect(result).to be_success
+ expect(result.value).to have_attributes(variant: variant, quantity: 2)
+ end.to change { order.line_items.count }.by(1)
+
+ expect(order.reload.item_total).to eq(10 + 40)
+ end
+
+ it 'increments an existing line item instead of adding a new one' do
+ subject.call(order: order, variant: variant, quantity: 1)
+
+ expect do
+ result = subject.call(order: order, variant: variant, quantity: 2)
+
+ expect(result).to be_success
+ end.not_to change { order.line_items.count }
+
+ expect(order.line_items.find_by(variant: variant).quantity).to eq(3)
+ end
+
+ it 'fails when the variant has insufficient stock' do
+ variant.stock_items.first.update!(backorderable: false)
+
+ result = subject.call(order: order, variant: variant, quantity: 10)
+
+ expect(result).to be_failure
+ expect(order.reload.line_items.map(&:variant)).not_to include(variant)
+ end
+
+ it 'does not run a stock reservation pass on a placed order' do
+ expect do
+ subject.call(order: order, variant: variant, quantity: 1)
+ end.not_to change { Spree::StockReservation.count }
+ end
+ end
+ end
+end