Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
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.rbindex 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: :controendit 'removes the row and re-sums totals' do- order.updater.resum_typed_totals!+ order.recalculate_totals!with_discount_total = order.reload.totaldelete :destroy, params: { order_id: order.prefixed_id, id: manual_discount.prefixed_id }, as: :jsondiff --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.rbindex 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: :controllerlet!(: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.totalpatch :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: :controllerlet!(: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.totaldelete :destroy, params: { order_id: order.prefixed_id, id: fee.prefixed_id }, as: :jsondiff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rbindex 773d25fd2b..7386eedaf5 100644--- a/spree/core/app/models/spree/cart.rb+++ b/spree/core/app/models/spree/cart.rb@@ -50,6 +50,11 @@ module Spreealias_attribute :ship_total, :delivery_totalbelongs_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_idbelongs_to :ship_address, class_name: 'Spree::Address', optional: true, dependent: :destroybelongs_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 Spreecompleting_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 Spreetotal - payment_totalend+ # 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 != 0enddiff --git a/spree/core/app/models/spree/fulfillment.rb b/spree/core/app/models/spree/fulfillment.rbindex 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'enddef discounted_costdiff --git a/spree/core/app/models/spree/line_item.rb b/spree/core/app/models/spree/line_item.rbindex 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 stockdiff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rbindex 2528ef0a9a..feae653627 100644--- a/spree/core/app/models/spree/order.rb+++ b/spree/core/app/models/spree/order.rb@@ -259,6 +259,8 @@ module Spreevalidates :discount_total, NEGATIVE_MONEY_VALIDATIONvalidates :total, MONEY_VALIDATION+ # @deprecated Both warn and run the full recalculation; use+ # {#recalculate_totals!}. Removed in 6.1.delegate :update_totals, :persist_totals, to: :updaterdelegate :merge!, to: :mergerdelegate :firstname, :lastname, to: :bill_address, prefix: true, allow_nil: true@@ -379,10 +381,17 @@ module Spree(item_total + line_items.sum(:promo_total)).to_fend- def shipping_discount+ # Total fulfillment discount applied by promotions, as a positive amount.+ def fulfillment_discountdiscounts.for_fulfillments.sum(:amount) * -1end+ # @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)enddiff --git a/spree/core/app/models/spree/order_updater.rb b/spree/core/app/models/spree/order_updater.rbindex 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 OrderUpdaterattr_reader :orderdelegate :payments, :line_items, :fulfillments, :update_hooks, :quantity, to: :order@@ -12,284 +19,154 @@ module Spree@order = orderend- # @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_totalsend- # 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_totalsend+ # @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_totalend- 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_totalend+ # @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.totalend- # 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_totalend+ # @deprecated Use {Spree::Carts::RecalculateTotals}; removed in 6.1.def update_item_count- order.total_quantity = quantity+ deprecate_totals(__method__)+ recalculate_totals+ order.total_quantityend- 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_totalend- 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_statusend- 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_statusend- # 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+ endend- # 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 }endprivate- # 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.")endendenddiff --git a/spree/core/app/models/spree/promotion.rb b/spree/core/app/models/spree/promotion.rbindex 2368615447..42ffa53ab7 100644--- a/spree/core/app/models/spree/promotion.rb+++ b/spree/core/app/models/spree/promotion.rb@@ -107,7 +107,8 @@ module Spreeenddef 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?)enddef 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.rbindex 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 Spreeenddef order_total(order)- order.item_total + order.ship_total - order.shipping_discount+ order.item_total + order.delivery_total - order.fulfillment_discountendendenddiff --git a/spree/core/app/models/spree/stock/quantifier.rb b/spree/core/app/models/spree/stock/quantifier.rbindex 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 Spreeclass Quantifierattr_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 Spreereturn @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_idreservations.sum(&:quantity)endelsereservations = 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_idreservations.sum(:quantity)endenddiff --git a/spree/core/app/services/spree/carts/empty.rb b/spree/core/app/services/spree/carts/empty.rbindex 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 Spreecart.discounts.destroy_allcart.fees.destroy_allcart.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.rbindex 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 Spreedef 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 doassign_cart_attributes@@ -18,7 +18,7 @@ module Spreeprocess_itemstry_advance- sync_stock_reservations(was_in_cart: was_in_cart)+ sync_stock_reservations(was_in_checkout: was_in_checkout)endsuccess(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)+ elseresult = 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)endend@@ -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.rbindex 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 Spreeaccept_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&.dupdiff --git a/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rb b/spree/core/lib/spree/testing_support/factories/fulfillment_factory.rbindex 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 dotracking { 'U10000' }cost { 100.00 }status { 'pending' }- order+ order { cart.present? ? nil : association(:order) }stock_locationafter(: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.rbindex 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 dofactory :store_credit_payment, class: Spree::Payment, parent: :payment dopayment_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) }endenddiff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rbindex 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 doit 'update and persist totals' doexpect(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_costenddiff --git a/spree/core/spec/models/spree/order_updater_spec.rb b/spree/core/spec/models/spree/order_updater_spec.rbindex 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 Spreeendend+ # 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_stateexpect(order.fulfillment_status).to eq('backorder')endit '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_statusexpect(order.fulfillment_status).to be_nilend- ['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)endend- 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')+ endendit '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')endend+ # 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' doupdater.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')endcontext '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')endendcontext 'order total equals payment total' doit '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')endendcontext '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')endendcontext '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')endendend@@ -239,21 +243,21 @@ module Spreeallow(shipments).to receive_messages shipped: []expect(shipment).to receive(:update!).with(order)- updater.update_fulfillments+ updater.update_shipmentsendit 'refreshes shipment rates' doallow(order).to receive_messages fulfillments: shipmentsexpect(shipment).to receive(:refresh_rates)- updater.update_fulfillments+ updater.update_shipmentsendit 'updates the shipment amount' doallow(order).to receive_messages fulfillments: shipmentsexpect(shipment).to receive(:update_amounts)- updater.update_fulfillments+ updater.update_shipmentsendcontext 'refresh rates' do@@ -298,7 +302,7 @@ module Spreelet(:order) { ::OrderWalkthrough.up_to(:delivery) }it 'resets shipping method to frontend-available' do- Spree::CartUpdater.new(order).update_shipments+ Spree::OrderUpdater.new(order).update_shipmentsexpect(order.fulfillments.first.delivery_method).to eq Spree::ShippingMethod.find_by(display_on: 'both')endenddiff --git a/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rb b/spree/core/spec/models/spree/promotion/actions/create_adjustment_spec.rbindex 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 dolet(: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) dodescribed_class.create!(promotion: promotion, calculator: Spree::Calculator::FlatRate.new(preferred_amount: 4))enddiff --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.rbindex 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 dolet(: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) dodescribed_class.create!(promotion: promotion, calculator: Spree::Calculator::FlatRate.new(preferred_amount: 3))enddiff --git a/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rb b/spree/core/spec/models/spree/promotion/actions/free_shipping_spec.rbindex 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 dolet(: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' dodiff --git a/spree/core/spec/services/spree/carts/associate_spec.rb b/spree/core/spec/services/spree/carts/associate_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/services/spree/carts/destroy_spec.rb b/spree/core/spec/services/spree/carts/destroy_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/services/spree/carts/empty_spec.rb b/spree/core/spec/services/spree/carts/empty_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/services/spree/carts/legacy_associate_spec.rb b/spree/core/spec/services/spree/carts/legacy_associate_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/services/spree/carts/legacy_destroy_spec.rb b/spree/core/spec/services/spree/carts/legacy_destroy_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/services/spree/carts/legacy_empty_spec.rb b/spree/core/spec/services/spree/carts/legacy_empty_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/services/spree/carts/legacy_remove_item_spec.rb b/spree/core/spec/services/spree/carts/legacy_remove_item_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/services/spree/carts/remove_item_spec.rb b/spree/core/spec/services/spree/carts/remove_item_spec.rbnew file mode 100644index 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+enddiff --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.rbsimilarity index 51%rename from spree/core/spec/services/spree/carts/legacy_remove_line_item_spec.rbrename to spree/core/spec/services/spree/carts/remove_line_item_spec.rbindex 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 Spreedescribe Carts::RemoveLineItem dosubject { 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' docontext '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_successexpect(value).to eq line_item- expect(order.amount).to eq 0+ expect(cart.reload.item_total).to eq 0endendcontext '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_successexpect(value).to eq line_item- expect(order.amount).to eq 10+ expect(cart.reload.item_total).to eq 10endendend- 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_successendendcontext '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)endend- 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' docreate(: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_atTimecop.freeze(2.minutes.from_now) do- subject.call(order: order, line_item: line_item)+ subject.call(cart: cart, line_item: line_item)endnew_expiry = Spree::StockReservation.find_by(line_item_id: other_line_item.id).expires_at@@ -97,11 +97,11 @@ module Spreeit '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_emptyendit '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_failureexpect(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)endend- 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' doit 'does not run a reservation pass' doexpect {- subject.call(order: order, line_item: line_item)+ subject.call(cart: cart, line_item: line_item)}.not_to change { Spree::StockReservation.count }endenddiff --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.rbsimilarity index 76%rename from spree/core/spec/services/spree/carts/legacy_remove_out_of_stock_items_spec.rbrename to spree/core/spec/services/spree/carts/remove_out_of_stock_items_spec.rbindex 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 dolet(: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' doexpect(execute).to be_successendit 'returns empty messages and warnings when cart is valid' do- _order, messages, warnings = execute.value+ _cart, messages, warnings = execute.valueexpect(messages).to be_emptyexpect(warnings).to be_emptyend@@ -24,12 +24,12 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems dobefore { product.update_columns(status: 'archive') }it 'removes line item and returns discontinued message' do- _order, messages, _warnings = execute.value+ _cart, messages, _warnings = execute.valueexpect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))endit 'returns structured warning with line_item_removed code' do- _order, _messages, warnings = execute.value+ _cart, _messages, warnings = execute.valueexpect(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 dobefore { 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.valueexpect(messages.to_sentence).to eq(Spree.t('cart_line_item.out_of_stock', li_name: product.name))endit 'returns structured warning with line_item_removed code' do- _order, _messages, warnings = execute.value+ _cart, _messages, warnings = execute.valueexpect(warnings.length).to eq(1)expect(warnings.first[:code]).to eq('line_item_removed')end@@ -55,7 +55,7 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems dobefore { product.delete }it 'removes line item and returns discontinued message' do- _order, messages, _warnings = execute.value+ _cart, messages, _warnings = execute.valueexpect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))endend@@ -64,7 +64,7 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems dobefore { product.update_columns(status: 'discontinued') }it 'removes line item and returns discontinued message' do- _order, messages, _warnings = execute.value+ _cart, messages, _warnings = execute.valueexpect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: product.name))endend@@ -73,13 +73,13 @@ RSpec.describe Spree::Carts::RemoveOutOfStockItems dobefore { variant.discontinue! }it 'removes line item and returns discontinued message' do- _order, messages, _warnings = execute.value+ _cart, messages, _warnings = execute.valueexpect(messages.to_sentence).to eq(Spree.t('cart_line_item.discontinued', li_name: variant.product.name))endend- 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 doSpree::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 doafter { Spree::Config[:stock_reservations_enabled] = true }it 'keeps the line item in the cart' do- _order, messages, warnings = execute.value+ _cart, messages, warnings = execute.valueexpect(messages).to be_emptyexpect(warnings).to be_empty- expect(order.reload.line_items).to include(line_item)+ expect(cart.reload.line_items).to include(line_item)endendenddiff --git a/spree/core/spec/services/spree/carts/legacy_set_quantity_spec.rb b/spree/core/spec/services/spree/carts/set_quantity_spec.rbsimilarity index 61%rename from spree/core/spec/services/spree/carts/legacy_set_quantity_spec.rbrename to spree/core/spec/services/spree/carts/set_quantity_spec.rbindex 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 Spreesubject { 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' dobefore do@@ -16,7 +16,7 @@ module Spreecontext 'with sufficient stock quantity' doit '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 Spreeendcontext '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 Spreecontext 'with backorderable item' doit '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 Spreeline_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).firstexpect(reservation).to be_presentexpect(reservation.quantity).to eq(4)endit '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)endit '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_failureexpect(line_item.reload.quantity).to eq(2)endend- 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' doit 'does not create a reservation' doexpect {- 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 }endenddiff --git a/spree/core/spec/services/spree/carts/update_spec.rb b/spree/core/spec/services/spree/carts/update_spec.rbindex 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 Spreelet!(:store_stock_location) { create(:stock_location, store: store, backorderable_default: true) }let!(:store_delivery_method) { create(:shipping_method, store: store) }let(:user) { create(:user) }- let(: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' dosubject { described_class.call(cart: cart, params: params) }@@ -25,22 +25,22 @@ module Spreeit 'updates the customer note' doexpect(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')endcontext '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' doresult = 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('')endit 'clears with nil' doresult = 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_nilendendend@@ -79,7 +79,7 @@ module Spreelet(:de_country) { create(:country, iso: 'DE', name: 'Germany') }let!(:us_market) { store.default_market }let!(:eu_market) { create(:market, :eu, store: store, countries: [de_country]) }- let(: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' doresult = described_class.call(cart: cart, params: { currency: 'EUR' })@@ -142,7 +142,7 @@ module Spreecontext 'when shipping address country is not in the new market' dolet!(:us_state) { us_country.states.find_by(abbr: 'NY') || create(:state, country: us_country, abbr: 'NY', name: 'New York') }let(:us_address) { create(:address, country: us_country, state: us_state) }- let(: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 Spreecontext 'when shipping address country is in the new market' dolet(: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 Spreeendcontext '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' doexpect(subject).to be_success@@ -281,7 +281,7 @@ module Spreedescribe 'billing address does not reset checkout state' dolet(:country) { Spree::Country.find_by(iso: 'US') || create(:country, iso: 'US') }let!(:state) { country.states.find_by(abbr: 'NY') || create(:state, country: country, abbr: 'NY', name: 'New York') }- let(: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 Spreeinclude_examples 'ignores other users address', :billing_addresscontext '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 Spreelet(: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)endenddiff --git a/spree/core/spec/services/spree/carts/upsert_items_spec.rb b/spree/core/spec/services/spree/carts/upsert_items_spec.rbindex 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 SpreeRSpec.describe Carts::UpsertItems dolet(: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 Spreeendcontext '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' dodiff --git a/spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rb b/spree/core/spec/workflows/spree/carts/add_item_spec.rbsimilarity index 55%rename from spree/core/spec/workflows/spree/carts/legacy_add_item_spec.rbrename to spree/core/spec/workflows/spree/carts/add_item_spec.rbindex 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 Spreedescribe Carts::AddItem dosubject { 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_successexpect(value).to eq expected_line_item- expect(order.amount).to eq 20+ expect(cart.reload.item_total).to eq 20endendcontext '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' doexpect(execute).to be_successexpect(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)endend- 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_successendendcontext '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)endend@@ -59,14 +55,14 @@ module Spreelet!(: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.reloadend- 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 30endend@@ -74,14 +70,14 @@ module Spreelet!(: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.reloadend- 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 30endend@@ -101,28 +97,28 @@ module Spreelet!(: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)endit '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)endendendcontext 'pass valid params hash in options' dolet(: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' doexpect(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.firstexpect(line_item.quantity).to eq 2endend@@ -130,70 +126,70 @@ module Spreecontext 'pass invalid arguments' docontext 'different quantity in argument and in options' dolet(: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' doexpect(execute).to be_success- line_item = order.line_items.first+ line_item = cart.line_items.firstexpect(line_item.quantity).to eq 2endend- context 'different quantity no quantity in argument and in params' do+ context 'no quantity in argument nor in options' dolet(: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' doexpect(execute).to be_success- line_item = order.line_items.first+ line_item = cart.line_items.firstexpect(line_item.quantity).to eq 1endend- context 'not permitted' do+ context 'not permitted option' dolet(: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' doexpect(execute).to be_success- line_item = order.line_items.first+ line_item = cart.line_items.firstexpect(line_item.quantity).to eq 1endendcontext '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' doexpect(execute).to be_failure- order.reload- expect(order.line_items.count).to eq 0+ cart.reload+ expect(cart.line_items.count).to eq 0endend- 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' doexpect(execute).to be_failure- order.reload- expect(order.line_items.count).to eq 0+ cart.reload+ expect(cart.line_items.count).to eq 0endend- context 'variant has been descontinued' do+ context 'variant has been discontinued' dolet(: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' doexpect(execute).to be_failure- order.reload- expect(order.line_items.count).to eq 0+ cart.reload+ expect(cart.line_items.count).to eq 0endendend@@ -216,23 +212,23 @@ module Spreeendit '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_successendit '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_emptyendcontext 'with no backorder_limit (unlimited)' dobefore { 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 100endend@@ -245,7 +241,7 @@ module Spreeit 'is rejected because the product is not yet published' doexpect(execute).to be_failure- expect(order.reload.line_items).to be_empty+ expect(cart.reload.line_items).to be_emptyendendend@@ -253,46 +249,46 @@ module Spreecontext 'setting metadata' docontext 'via metadata param' dolet(: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' doexpect(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 metadataendendcontext 'via legacy public_metadata and private_metadata params' dolet(: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' doexpect(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_metadataendit 'stores public_metadata' doexpect(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_metadataendendendcontext '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 doallow(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_nilendend@@ -304,26 +300,26 @@ module Spreevariant.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_successendit 'fails when adding more than available and rolls back the line item' dovariant.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_emptyendend- 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' doexpect { execute }.not_to change { Spree::StockReservation.count }@@ -332,7 +328,7 @@ module Spreeendcontext '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 Spreeendcontext '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 dovariant.update!(preorderable: true, backorder_limit: 5)@@ -352,10 +348,10 @@ module Spreeendit '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_emptyendendenddiff --git a/spree/core/spec/workflows/spree/orders/add_item_spec.rb b/spree/core/spec/workflows/spree/orders/add_item_spec.rbnew file mode 100644index 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