Skip to content

armgit / spree

Public Imported from GitHub
0

Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.

Improve Cart coverage by testing all purchase concerns against both Cart and Order

Damian Legawiecf1504184d75f
diff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rb
index f4d2de4bba..37d1d2f0da 100644
--- a/spree/core/app/models/spree/cart.rb
+++ b/spree/core/app/models/spree/cart.rb
@@ -139,6 +139,8 @@ module Spree
before_validation :resolve_market_from_currency, if: -> { persisted? && currency_changed? && !skip_market_resolution }
+ before_update :ensure_updated_fulfillments, :homogenize_line_item_currencies, if: :currency_changed?
+
delegate :name, to: :customer, prefix: true, allow_nil: true
# @deprecated Store API bridge — carts have no order-style number; the
diff --git a/spree/core/app/models/spree/payment/gateway_options.rb b/spree/core/app/models/spree/payment/gateway_options.rb
index 555d7c678b..08207a2f07 100644
--- a/spree/core/app/models/spree/payment/gateway_options.rb
+++ b/spree/core/app/models/spree/payment/gateway_options.rb
@@ -3,7 +3,9 @@ module Spree
class GatewayOptions
def initialize(payment)
@payment = payment
- @order = payment.order
+ # The payment's cart or order — the reader keeps the legacy `order`
+ # name because gateway extensions subclass this class.
+ @order = payment.owner
end
attr_reader :payment, :order
diff --git a/spree/core/app/models/spree/payment/processing.rb b/spree/core/app/models/spree/payment/processing.rb
index 6a8643367d..71923742e0 100644
--- a/spree/core/app/models/spree/payment/processing.rb
+++ b/spree/core/app/models/spree/payment/processing.rb
@@ -91,7 +91,7 @@ module Spree
end
def gateway_options
- order.reload
+ owner.reload
gateway_options_class.new(self).to_hash
end
diff --git a/spree/core/spec/models/concerns/spree/purchase/digital_items_spec.rb b/spree/core/spec/models/concerns/spree/purchase/digital_items_spec.rb
new file mode 100644
index 0000000000..966366b588
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/digital_items_spec.rb
@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'a digital items host' do
+ let(:digital_product) { create(:digital_product) }
+
+ def digital_variant
+ create(:variant, digitals: [create(:digital)], product: digital_product)
+ end
+
+ context 'line_item analysis' do
+ it 'understands that all products are digital' do
+ 3.times { add_line_item(record, digital_variant, 1) }
+ expect(record.digital?).to be true
+
+ add_line_item(record, digital_variant, 4)
+ expect(record.digital?).to be true
+ end
+
+ it 'understands that no products are digital' do
+ 3.times { add_line_item(record, create(:variant), 1) }
+ expect(record.digital?).to be false
+ end
+
+ it 'understands that an empty record is not digital' do
+ expect(record.digital?).to be false
+ end
+
+ it 'understands that not all products are digital' do
+ 3.times { add_line_item(record, digital_variant, 1) }
+ add_line_item(record, create(:variant, digitals: [create(:digital)]), 1) # analog product with assets
+
+ expect(record.digital?).to be false
+ end
+ end
+
+ describe '#digital?/#some_digital?' do
+ it 'returns true/true when every item is digital' do
+ 3.times { add_line_item(record, digital_variant, 1) }
+
+ expect(record).to be_digital
+ expect(record).to be_some_digital
+ end
+
+ it 'returns false/true for a mixed record' do
+ 2.times { add_line_item(record, digital_variant, 1) }
+ add_line_item(record, create(:variant), 1)
+
+ expect(record).not_to be_digital
+ expect(record).to be_some_digital
+ end
+
+ it 'returns false/false for an exclusively non-digital record' do
+ 3.times { add_line_item(record, create(:variant), 1) }
+
+ expect(record).not_to be_digital
+ expect(record).not_to be_some_digital
+ end
+ end
+
+ describe '#with_digital_assets? / #digital_line_items' do
+ it 'detects items carrying digital assets' do
+ expect(record.with_digital_assets?).to be false
+
+ add_line_item(record, create(:variant), 1)
+ add_line_item(record, digital_variant, 1)
+
+ expect(record.with_digital_assets?).to be true
+ expect(record.digital_line_items.count).to eq(1)
+ end
+ end
+
+ describe '#digital_links' do
+ let(:digitals) { 2.times.map { create(:digital) } }
+
+ it 'correctly loads the links' do
+ digitals.each { |digital| add_line_item(record, create(:variant, digitals: [digital]), 1) }
+ add_line_item(record, create(:variant), 1)
+
+ links = record.digital_links
+ links_from_digitals = digitals.map(&:reload).map(&:digital_links).flatten
+ expect(links.size).to eq(links_from_digitals.size)
+ links.each { |link| expect(links_from_digitals).to include(link) }
+ end
+ end
+
+ describe '#requires_ship_address?' do
+ it 'is false only for an all-digital record' do
+ add_line_item(record, digital_variant, 1)
+ expect(record.requires_ship_address?).to be false
+
+ add_line_item(record, create(:variant), 1)
+ expect(record.requires_ship_address?).to be true
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::DigitalItems do
+ let(:store) { @default_store }
+
+ context 'included in Spree::Cart' do
+ let(:record) { create(:cart, store: store) }
+
+ def add_line_item(cart, variant, quantity)
+ result = Spree::Carts::AddItem.call(cart: cart, variant: variant, quantity: quantity)
+ raise result.error.to_s if result.failure?
+ end
+
+ it_behaves_like 'a digital items host'
+ end
+
+ context 'included in Spree::Order' do
+ let(:record) { create(:order, store: store) }
+
+ def add_line_item(order, variant, quantity)
+ result = Spree::Orders::AddItem.call(order: order, variant: variant, quantity: quantity)
+ raise result.error.to_s if result.failure?
+ end
+
+ it_behaves_like 'a digital items host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/gift_cards_spec.rb b/spree/core/spec/models/concerns/spree/purchase/gift_cards_spec.rb
new file mode 100644
index 0000000000..5b5d2f496f
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/gift_cards_spec.rb
@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'a gift cards host' do
+ describe '#gift_card_total / #total_minus_gift_cards' do
+ let(:gift_card) { create(:gift_card, amount: record.total) }
+
+ before { record.apply_gift_card(gift_card) }
+
+ it 'returns the applied gift card total' do
+ expect(record.gift_card_total).to eq(gift_card.amount)
+ expect(record.total_minus_gift_cards).to eq(record.total - gift_card.amount)
+ end
+ end
+
+ describe '#apply_gift_card' do
+ let(:gift_card) { create(:gift_card, amount: record.total) }
+
+ it 'applies the gift card to the record' do
+ expect { record.apply_gift_card(gift_card) }.to change(record, :gift_card).from(nil).to(gift_card)
+ end
+ end
+
+ describe '#remove_gift_card' do
+ let(:gift_card) { create(:gift_card) }
+
+ it 'removes the gift card from the record' do
+ record.update!(gift_card: gift_card)
+
+ expect { record.remove_gift_card }.to change(record, :gift_card).from(gift_card).to(nil)
+ end
+ end
+
+ describe '#redeem_gift_card' do
+ it 'is a no-op without a gift card' do
+ expect(record.redeem_gift_card).to be_nil
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::GiftCards do
+ let(:store) { @default_store }
+
+ context 'included in Spree::Cart' do
+ let(:record) { create(:cart_with_line_items, store: store, customer: create(:user)) }
+
+ it_behaves_like 'a gift cards host'
+ end
+
+ context 'included in Spree::Order' do
+ let(:record) { create(:order_with_line_items, store: store) }
+
+ it_behaves_like 'a gift cards host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/line_item_currencies_spec.rb b/spree/core/spec/models/concerns/spree/purchase/line_item_currencies_spec.rb
new file mode 100644
index 0000000000..9e61c60d24
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/line_item_currencies_spec.rb
@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'a line item currencies host' do
+ context 'when changing the record currency' do
+ let!(:euro_price) { create(:price, variant: line_item.variant, amount: 8, currency: 'EUR') }
+
+ describe '#homogenize_line_item_currencies' do
+ it 'succeeds without error' do
+ expect { record.update!(currency: 'EUR') }.not_to raise_error
+ end
+
+ it 'changes the line_item currencies' do
+ expect { record.update!(currency: 'EUR') }.to change { line_item.reload.currency }.from('USD').to('EUR')
+ end
+
+ it 'changes the line_item amounts' do
+ expect { record.update!(currency: 'EUR') }.to change { line_item.reload.amount }.to(8)
+ end
+
+ it 'calculates the item total in the record currency' do
+ expect { record.update!(currency: 'EUR') }.to change { record.item_total }.to(8)
+ end
+
+ context 'when there is a price with nil amount' do
+ let!(:euro_price) do
+ allow(Spree::Config).to receive(:allow_empty_price_amount).and_return(true)
+ create(:price, variant: line_item.variant, amount: nil, currency: 'EUR')
+ end
+
+ it "destroys the line item when we switch to that price's currency" do
+ expect { record.update!(currency: 'EUR') }.to change(Spree::LineItem, :count).by(-1)
+ end
+ end
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::LineItemCurrencies do
+ let(:store) { @default_store }
+
+ context 'included in Spree::Cart' do
+ let(:record) { create(:cart, store: store) }
+ let!(:line_item) { create(:line_item, cart: record, order: nil) }
+
+ it_behaves_like 'a line item currencies host'
+ end
+
+ context 'included in Spree::Order' do
+ let!(:line_item) { create(:line_item) }
+ let(:record) { line_item.order }
+
+ it_behaves_like 'a line item currencies host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/payment_processing_spec.rb b/spree/core/spec/models/concerns/spree/purchase/payment_processing_spec.rb
new file mode 100644
index 0000000000..2115669162
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/payment_processing_spec.rb
@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'a payment processing host' do
+ describe '#process_payments!' do
+ let!(:record) { new_record_with_line_items }
+ let!(:payment) do
+ payment = create_payment(record, amount: 10, state: payment_state)
+ record.payments << payment
+ payment
+ end
+
+ let(:payment_state) { 'checkout' }
+ let(:unprocessed_payments) { [payment] }
+ let(:pending_payments) { [] }
+ let(:total) { 10 }
+
+ before do
+ allow(record).to receive_messages(
+ unprocessed_payments: unprocessed_payments,
+ pending_payments: pending_payments,
+ total: total
+ )
+ end
+
+ it 'processes the payments' do
+ expect(payment).to receive(:process!)
+ expect(record.process_payments!).to be_truthy
+ end
+
+ # Regression spec for https://github.com/spree/spree/issues/5436
+ it 'raises an error if there are no payments to process' do
+ allow(record).to receive_messages unprocessed_payments: []
+ expect(payment).not_to receive(:process!)
+ expect(record.process_payments!).to be_falsey
+ end
+
+ context 'when there are pending payments' do
+ let(:payment_state) { 'pending' }
+ let(:pending_payments) { [payment] }
+ let(:unprocessed_payments) { [] }
+
+ it 'skips processing the payments' do
+ expect(payment).not_to receive(:process!)
+ expect(record.process_payments!).to be_nil
+ end
+
+ context 'when there is other unprocessed payment' do
+ let(:other_payment) { create_payment(record, amount: 5, state: 'checkout') }
+ let(:unprocessed_payments) { [other_payment] }
+
+ before do
+ record.payments << other_payment
+ end
+
+ it 'processes only the other payment' do
+ expect(payment).not_to receive(:process!)
+ expect(other_payment).to receive(:process!)
+
+ expect(record.process_payments!).to be_truthy
+ end
+ end
+ end
+
+ context 'when a payment raises a GatewayError' do
+ before { expect(payment).to receive(:process!).and_raise(Spree::Core::GatewayError) }
+
+ it 'returns true when configured to allow checkout on gateway failures' do
+ Spree::Config.set allow_checkout_on_gateway_error: true
+ expect(record.process_payments!).to be true
+ end
+
+ it 'returns false when not configured to allow checkout on gateway failures' do
+ Spree::Config.set allow_checkout_on_gateway_error: false
+ expect(record.process_payments!).to be false
+ end
+ end
+
+ # Regression spec for https://github.com/spree/spree/issues/8148
+ it 'updates the record with correct payment total' do
+ Spree::Config[:auto_capture] = true
+ record.process_payments!
+
+ expect(payment).to be_completed
+ expect(record.payment_total).to eq payment.amount
+ end
+ end
+
+ describe '#authorize_payments!' do
+ subject { record.authorize_payments! }
+
+ let(:record) { new_record_with_line_items }
+ let(:payment) { create(:payment) }
+
+ before { allow(record).to receive_messages unprocessed_payments: [payment], total: 10 }
+
+ it 'processes payments with authorize!' do
+ expect(payment).to receive(:authorize!)
+ subject
+ end
+
+ it { is_expected.to be_truthy }
+ end
+
+ describe '#capture_payments!' do
+ subject { record.capture_payments! }
+
+ let(:record) { new_record_with_line_items }
+ let(:payment) { create(:payment) }
+
+ before { allow(record).to receive_messages unprocessed_payments: [payment], total: 10 }
+
+ it 'processes payments with purchase!' do
+ expect(payment).to receive(:purchase!)
+ subject
+ end
+
+ it { is_expected.to be_truthy }
+ end
+
+ describe '#pending_payments / #unprocessed_payments' do
+ let(:record) { new_record_with_line_items }
+
+ it 'partitions payments by state' do
+ # Pending first — creating a new payment invalidates existing
+ # checkout-state payments (Payment#invalidate_old_payments).
+ pending_payment = create_payment(record, amount: 5, state: 'pending')
+ checkout_payment = create_payment(record, amount: 5, state: 'checkout')
+
+ expect(record.pending_payments).to contain_exactly(pending_payment)
+ expect(record.unprocessed_payments).to contain_exactly(checkout_payment)
+ end
+ end
+
+ describe '#payment_required?' do
+ let(:record) { new_record_with_line_items }
+
+ context 'total is zero' do
+ before { allow(record).to receive_messages(total: 0) }
+
+ it { expect(record.payment_required?).to be false }
+ end
+
+ context 'total > zero' do
+ before { allow(record).to receive_messages(total: 1) }
+
+ it { expect(record.payment_required?).to be true }
+ end
+ end
+
+ describe '#confirmation_required?' do
+ subject { record.confirmation_required? }
+
+ let(:record) { new_record_with_line_items }
+
+ it 'is computed from data only' do
+ expect(record.class.new.confirmation_required?).to be(false)
+ end
+
+ context 'Spree::Config[:always_include_confirm_step] == true' do
+ before { Spree::Config[:always_include_confirm_step] = true }
+
+ it 'returns true if payments empty' do
+ expect(record.class.new.confirmation_required?).to be(true)
+ end
+ end
+
+ context 'Spree::Config[:always_include_confirm_step] == false' do
+ it 'returns false if payments empty' do
+ expect(record.class.new.confirmation_required?).to be(false)
+ end
+
+ it 'does not bomb out with an unpersisted payment' do
+ blank_record = record.class.new
+ blank_record.payments.build
+
+ expect(blank_record.confirmation_required?).to be(false)
+ end
+ end
+
+ context 'when the payment does not require confirmation' do
+ before do
+ record.update_column(:total, 50)
+ create_payment(record, amount: 50)
+
+ allow_any_instance_of(Spree::Gateway::Bogus).to receive(:confirmation_required?).and_return(false)
+ end
+
+ it { is_expected.to be(false) }
+ end
+
+ context 'when at least one payment method requires confirmation' do
+ before do
+ record.update_column(:total, 50)
+ create_payment(record, amount: 50)
+ end
+
+ it { is_expected.to be(true) }
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::PaymentProcessing do
+ context 'included in Spree::Cart' do
+ def new_record_with_line_items
+ create(:cart_with_line_items, store: @default_store)
+ end
+
+ def create_payment(record, **attributes)
+ create(:payment, cart: record, order: nil, **attributes)
+ end
+
+ it_behaves_like 'a payment processing host'
+ end
+
+ context 'included in Spree::Order' do
+ def new_record_with_line_items
+ create(:order_with_line_items, store: @default_store)
+ end
+
+ def create_payment(record, **attributes)
+ create(:payment, order: record, **attributes)
+ end
+
+ it_behaves_like 'a payment processing host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/purchase_context_spec.rb b/spree/core/spec/models/concerns/spree/purchase/purchase_context_spec.rb
new file mode 100644
index 0000000000..aac858f0a1
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/purchase_context_spec.rb
@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+# Channel/Market/Currency/Locale are one cohesive resolution surface —
+# batteried together, against both hosts.
+RSpec.shared_examples 'a channel host' do
+ let(:store) { @default_store }
+
+ describe '#ensure_channel_presence' do
+ it 'auto-assigns the store default channel on new records' do
+ record = new_record(channel: nil)
+ record.valid?
+
+ expect(record.channel).to eq(store.default_channel)
+ end
+
+ it 'preserves an explicitly set channel' do
+ other = store.channels.find_by(code: 'pos') || store.channels.create!(name: 'POS', code: 'pos')
+ record = new_record(channel: other)
+ record.valid?
+
+ expect(record.channel).to eq(other)
+ end
+ end
+end
+
+RSpec.shared_examples 'a market host' do
+ let(:store) { @default_store }
+
+ describe '#ensure_market_presence' do
+ it 'auto-assigns the store default market on new records' do
+ record = new_record
+ record.valid?
+
+ expect(record.market).to eq(store.default_market)
+ end
+ end
+
+ describe '#resolve_market_from_currency' do
+ let!(:eur_market) do
+ germany = Spree::Country.find_by(iso: 'DE') || create(:country, iso: 'DE')
+ store.markets.find_by(currency: 'EUR') ||
+ store.markets.create!(name: 'Europe', currency: 'EUR', default_locale: 'de', countries: [germany])
+ end
+
+ it 'switches to the market matching the new currency on update' do
+ record = new_record.tap(&:save!)
+ record.update(currency: 'EUR')
+
+ expect(record.market).to eq(eur_market)
+ end
+
+ it 'keeps the current market when no market serves the currency' do
+ record = new_record.tap(&:save!)
+
+ expect { record.update(currency: 'GBP') }.not_to change(record, :market)
+ end
+ end
+end
+
+RSpec.shared_examples 'a currency host' do
+ describe '#ensure_currency' do
+ it 'fills a blank currency from the market' do
+ record = new_record
+ record.currency = nil
+ record.valid?
+
+ expect(record.currency).to eq(record.market.currency)
+ end
+ end
+
+ describe '#currency_must_be_supported_by_store' do
+ it 'rejects a currency the store does not support' do
+ record = new_record
+ record.currency = 'XOF'
+
+ expect(record).not_to be_valid
+ expect(record.errors[:currency]).to be_present
+ end
+ end
+end
+
+RSpec.shared_examples 'a locale host' do
+ describe '#ensure_locale' do
+ it 'fills a blank locale from the current locale or market default' do
+ record = new_record
+ record.locale = nil
+ record.valid?
+
+ expect(record.locale).to be_present
+ end
+ end
+
+ describe '#locale_must_be_supported_by_store' do
+ it 'rejects a locale the store does not support' do
+ record = new_record
+ record.locale = 'xx'
+
+ expect(record).not_to be_valid
+ expect(record.errors[:locale]).to be_present
+ end
+ end
+end
+
+RSpec.describe 'Spree::Purchase context concerns' do
+ context 'included in Spree::Cart' do
+ def new_record(**attributes)
+ build(:cart, store: @default_store, **attributes)
+ end
+
+ it_behaves_like 'a channel host'
+ it_behaves_like 'a market host'
+ it_behaves_like 'a currency host'
+ it_behaves_like 'a locale host'
+ end
+
+ context 'included in Spree::Order' do
+ def new_record(**attributes)
+ build(:order, store: @default_store, **attributes)
+ end
+
+ it_behaves_like 'a channel host'
+ it_behaves_like 'a market host'
+ it_behaves_like 'a currency host'
+ it_behaves_like 'a locale host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/store_credits_spec.rb b/spree/core/spec/models/concerns/spree/purchase/store_credits_spec.rb
new file mode 100644
index 0000000000..11bd6beccc
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/store_credits_spec.rb
@@ -0,0 +1,548 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'check total store credit from payments' do
+ context 'with valid payments' do
+ subject { record }
+
+ let(:record) { new_record(user: create(:user), total: 100.00) }
+ let!(:payment) { create_store_credit_payment(record, amount: 20.0) }
+ let!(:second_payment) { create_store_credit_payment(record, amount: 30.0) }
+
+ it 'returns the sum of the payment amounts' do
+ expect(subject.total_applicable_store_credit).to eq(payment.amount + second_payment.amount)
+ end
+ end
+
+ context 'without valid payments' do
+ subject { record }
+
+ let(:record) { new_record }
+
+ it 'returns 0' do
+ expect(subject.total_applicable_store_credit).to be_zero
+ end
+ end
+end
+
+RSpec.shared_examples 'a store credits host' do
+ describe '#add_store_credit_payments' do
+ subject { record.add_store_credit_payments }
+
+ let(:record_total) { 500.00 }
+
+ before { create(:store_credit_payment_method) }
+
+ context 'there is no store credit' do
+ let(:record) { guest_record(total: record_total) }
+
+ before do
+ # callbacks recalculate total based on line items
+ # this ensures the total is what we expect
+ record.update_column(:total, record_total)
+ subject
+ record.reload
+ end
+
+ it 'does not create a store credit payment' do
+ expect(record.payments.count).to eq 0
+ end
+ end
+
+ context 'there is enough store credit to pay for the entire record' do
+ let(:store_credit) { create(:store_credit, amount: record_total) }
+ let(:record) { new_record(user: store_credit.user, total: record_total) }
+
+ before do
+ subject
+ record.reload
+ end
+
+ it 'creates a store credit payment for the full amount' do
+ expect(record.payments.count).to eq 1
+ expect(record.payments.first).to be_store_credit
+ expect(record.payments.first.amount).to eq record_total
+ end
+ end
+
+ context 'the available store credit is not enough to pay for the entire record' do
+ let(:expected_cc_total) { 100.0 }
+ let(:store_credit_total) { record_total - expected_cc_total }
+ let(:store_credit) { create(:store_credit, amount: store_credit_total) }
+ let(:record) { new_record(user: store_credit.user, total: record_total) }
+
+ before do
+ record.update_column(:total, record_total)
+ subject
+ record.reload
+ end
+
+ it 'creates a store credit payment for the available amount' do
+ expect(record.payments.count).to eq 1
+ expect(record.payments.first).to be_store_credit
+ expect(record.payments.first.amount).to eq store_credit_total
+ end
+ end
+
+ context 'there are multiple store credits' do
+ context 'they have different credit type priorities' do
+ let(:amount_difference) { 100 }
+ let!(:primary_store_credit) { create(:store_credit, amount: (record_total - amount_difference)) }
+ let!(:secondary_store_credit) do
+ create(:store_credit, amount: record_total, user: primary_store_credit.user,
+ credit_type: create(:secondary_credit_type))
+ end
+ let(:record) { new_record(user: primary_store_credit.user, total: record_total) }
+
+ before do
+ Timecop.scale(3600)
+ subject
+ record.reload
+ end
+
+ after { Timecop.return }
+
+ it 'uses the primary store credit type over the secondary' do
+ primary_payment = record.payments.first
+ secondary_payment = record.payments.last
+
+ expect(record.payments.size).to eq 2
+ expect(primary_payment.source).to eq primary_store_credit
+ expect(secondary_payment.source).to eq secondary_store_credit
+ expect(primary_payment.amount).to eq(record_total - amount_difference)
+ expect(secondary_payment.amount).to eq(amount_difference)
+ end
+ end
+ end
+ end
+
+ describe '#remove_store_credit_payments' do
+ subject { record.remove_store_credit_payments }
+
+ let(:record_total) { 500.00 }
+ let(:record) { new_record(user: store_credit.user, total: record_total) }
+
+ context 'when the record is not complete' do
+ let(:store_credit) { create(:store_credit, amount: record_total - 1) }
+
+ before do
+ create(:store_credit_payment_method)
+ record.add_store_credit_payments
+ end
+
+ it { expect { subject }.to change { record.payments.checkout.store_credits.count }.from(1).to(0) }
+ it { expect { subject }.to change { record.payments.with_state(:invalid).store_credits.count }.from(0).to(1) }
+ end
+
+ context 'when the record is complete' do
+ let(:record) { completed_record_with_store_credit_payment }
+ let(:store_credit_payments) { record.payments.checkout.store_credits }
+
+ before do
+ subject
+ record.reload
+ end
+
+ it { expect(record.payments.checkout.store_credits).to eq store_credit_payments }
+ end
+ end
+
+ describe '#covered_by_store_credit' do
+ context "record doesn't have an associated user" do
+ subject { record.covered_by_store_credit? }
+
+ let(:record) { guest_record }
+
+ it { is_expected.to be(false) }
+ end
+
+ context 'record has an associated user' do
+ subject { record.covered_by_store_credit? }
+
+ let(:record) { new_record(user: user, total: record_total) }
+ let(:user) { create(:user) }
+ let(:record_total) { 10.0 }
+
+ context 'user has enough store credit to pay for the record' do
+ let!(:store_credit_payment) { create_store_credit_payment(record, source: store_credit, amount: 10.0) }
+ let(:store_credit) { create(:store_credit, amount: 10.0, store: record.store, user: record.user) }
+
+ it { is_expected.to be(true) }
+ end
+
+ context 'user does not have enough store credit to pay for the record' do
+ before do
+ allow(user).to receive(:total_available_store_credit).and_return(0.0)
+ allow(subject).to receive(:total).and_return(5.0)
+ end
+
+ it { is_expected.to be(false) }
+ end
+
+ context 'record total is zero' do
+ let(:record_total) { 0.0 }
+
+ it { is_expected.to be(false) }
+ end
+ end
+ end
+
+ describe '#total_available_store_credit' do
+ context 'record does not have an associated user' do
+ subject { guest_record }
+
+ it 'returns 0' do
+ expect(subject.total_available_store_credit).to be_zero
+ end
+ end
+
+ context 'record has an associated user' do
+ subject { new_record(user: user) }
+
+ let(:user) { create(:user) }
+ let(:available_store_credit) { 25.0 }
+
+ before do
+ allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
+ end
+
+ it "returns the user's available store credit" do
+ expect(subject.total_available_store_credit).to eq available_store_credit
+ end
+
+ context 'when store is provided' do
+ let!(:store) { @default_store }
+ let!(:second_store) { create(:store) }
+ let!(:store_credit) { create(:store_credit, amount: '100', user: user, store: store) }
+
+ before do
+ allow(user).to receive(:total_available_store_credit).and_call_original
+ end
+
+ context 'and has store credits associated' do
+ before do
+ expect(subject).to receive(:store).and_return(store)
+ end
+
+ it "returns the user's available store credit" do
+ expect(subject.total_available_store_credit).to eq(100)
+ end
+ end
+
+ context 'and has no store credits associated' do
+ before do
+ expect(subject).to receive(:store).and_return(second_store)
+ end
+
+ it "returns the user's available store credit" do
+ expect(subject.total_available_store_credit).to eq(0)
+ end
+ end
+ end
+ end
+ end
+
+ describe '#available_store_credits' do
+ subject { record.available_store_credits }
+
+ context 'record does not have an associated user' do
+ let(:record) { guest_record }
+
+ it { is_expected.to be_empty }
+ end
+
+ context 'record has an associated user' do
+ let(:record) { new_record(user: user, currency: 'USD') }
+ let(:user) { create(:user) }
+
+ let!(:store_credit_1) { create(:store_credit, user: user, amount: 10, currency: 'USD') }
+ let!(:store_credit_2) { create(:store_credit, user: user, amount: 15, currency: 'USD') }
+ let!(:store_credit_3) { create(:store_credit, user: user, amount: 20, currency: 'EUR') }
+
+ it 'returns the user available store credits' do
+ expect(subject).to eq([store_credit_2, store_credit_1])
+ end
+ end
+ end
+
+ describe '#could_use_store_credit?' do
+ let!(:store_credit_payment_method) { create(:store_credit_payment_method) }
+
+ context 'record does not have an associated user' do
+ subject { guest_record }
+
+ it { expect(subject.could_use_store_credit?).to be false }
+ end
+
+ context 'record has an associated user' do
+ subject { new_record(user: user) }
+
+ let(:user) { create(:user) }
+
+ context 'without store credit' do
+ it { expect(subject.could_use_store_credit?).to be false }
+ end
+
+ context 'with store credit' do
+ let(:available_store_credit) { 25.0 }
+
+ before do
+ allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
+ end
+
+ it { expect(subject.could_use_store_credit?).to be true }
+ end
+
+ context 'without active Store Credit Payment' do
+ let(:available_store_credit) { 25.0 }
+
+ before do
+ allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
+ store_credit_payment_method.update_attribute(:active, false)
+ end
+
+ it { expect(subject.could_use_store_credit?).to be false }
+ end
+
+ context 'without Store Credit Payment' do
+ let(:available_store_credit) { 25.0 }
+
+ before do
+ allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
+ store_credit_payment_method.destroy
+ end
+
+ it { expect(subject.could_use_store_credit?).to be false }
+ end
+ end
+ end
+
+ describe '#order_total_after_store_credit' do
+ subject { new_record(total: record_total) }
+
+ let(:record_total) { 100.0 }
+
+ before do
+ allow(subject).to receive(:total_applicable_store_credit).and_return(applicable_store_credit)
+ end
+
+ context "record's user has store credits" do
+ let(:applicable_store_credit) { 10.0 }
+
+ it 'deducts the applicable store credit' do
+ expect(subject.order_total_after_store_credit).to eq(record_total - applicable_store_credit)
+ end
+ end
+
+ context "record's user does not have any store credits" do
+ let(:applicable_store_credit) { 0.0 }
+
+ it 'returns the record total' do
+ expect(subject.order_total_after_store_credit).to eq record_total
+ end
+ end
+ end
+
+ describe '#total_applicable_store_credit' do
+ context 'record has payments (mid-checkout)' do
+ include_examples 'check total store credit from payments'
+ end
+
+ context 'record is completed' do
+ let(:record) { new_record(user: create(:user), total: 100.00) }
+
+ it 'reports the actually applied payments, not the theoretical maximum' do
+ payment = create_store_credit_payment(record, amount: 20.0)
+ second_payment = create_store_credit_payment(record, amount: 30.0)
+ mark_completed(record)
+
+ expect(record.reload.total_applicable_store_credit).to eq(payment.amount + second_payment.amount)
+ end
+ end
+
+ context 'record has no payments and is not completed' do
+ context 'the associated user has store credits' do
+ subject { record }
+
+ let(:store) { @default_store }
+ let(:store_credit) { create(:store_credit, store: store) }
+ let(:record) { new_record(user: store_credit.user) }
+
+ context 'the store credit is more than the record total' do
+ let(:record_total) { store_credit.amount - 1 }
+
+ before { record.update(total: record_total) }
+
+ it 'returns the record total' do
+ expect(subject.total_applicable_store_credit).to eq record_total
+ end
+ end
+
+ context 'the store credit is less than the record total' do
+ let(:record_total) { store_credit.amount * 10 }
+
+ before { record.update(total: record_total) }
+
+ it 'returns the store credit amount' do
+ expect(subject.total_applicable_store_credit).to eq store_credit.amount
+ end
+ end
+ end
+
+ context 'the associated user does not have store credits' do
+ subject { new_record(user: create(:user)) }
+
+ it 'returns 0' do
+ expect(subject.total_applicable_store_credit).to be_zero
+ end
+ end
+
+ context 'the record does not have an associated user' do
+ subject { guest_record }
+
+ it 'returns 0' do
+ expect(subject.total_applicable_store_credit).to be_zero
+ end
+ end
+ end
+ end
+
+ describe '#total_applied_store_credit' do
+ subject(:total_applied_store_credit) { record.total_applied_store_credit }
+
+ let(:record) { new_record(user: create(:user), total: 100.00) }
+
+ context 'with valid payments' do
+ let(:valid_payment) { 10.0 }
+ let(:valid_payment_2) { 20.0 }
+ let(:invalid_payment) { 21.0 }
+ let(:other_record_payment) { 22.0 }
+
+ before do
+ create_store_credit_payment(record, state: 'completed', amount: valid_payment)
+ create_store_credit_payment(record, state: 'completed', amount: valid_payment_2)
+ create_store_credit_payment(record, state: 'invalid', amount: invalid_payment)
+ create_store_credit_payment(new_record(user: create(:user), total: 100.00), state: 'completed', amount: other_record_payment)
+ end
+
+ it 'returns the sum of the payment amounts' do
+ expect(total_applied_store_credit).to eq(valid_payment + valid_payment_2)
+ end
+
+ context 'when payments are loaded' do
+ before { record.payments.load }
+
+ it 'returns the sum of the payment amounts' do
+ expect(total_applied_store_credit).to eq(valid_payment + valid_payment_2)
+ end
+ end
+ end
+
+ context 'without valid payments' do
+ it 'returns 0' do
+ expect(total_applied_store_credit).to be_zero
+ end
+ end
+ end
+
+ describe '#using_store_credit?' do
+ subject { new_record }
+
+ it 'reflects whether store credit is applied' do
+ allow(subject).to receive(:total_applied_store_credit).and_return(10.0)
+ expect(subject.using_store_credit?).to be true
+
+ allow(subject).to receive(:total_applied_store_credit).and_return(0.0)
+ expect(subject.using_store_credit?).to be false
+ end
+ end
+
+ describe 'display money helpers' do
+ subject { new_record }
+
+ it '#display_total_applicable_store_credit returns a negative money amount' do
+ allow(subject).to receive(:total_applicable_store_credit).and_return(10.00)
+
+ expect(subject.display_total_applicable_store_credit).to be_a(Spree::Money)
+ expect(subject.display_total_applicable_store_credit.amount_in_cents).to eq(-1000)
+ end
+
+ it '#display_total_applied_store_credit returns a negative money amount' do
+ allow(subject).to receive(:total_applied_store_credit).and_return(10.00)
+
+ expect(subject.display_total_applied_store_credit).to be_a(Spree::Money)
+ expect(subject.display_total_applied_store_credit.amount_in_cents).to eq(-1000)
+ end
+
+ it '#display_order_total_after_store_credit returns the after-credit amount' do
+ allow(subject).to receive(:order_total_after_store_credit).and_return(10.00)
+
+ expect(subject.display_order_total_after_store_credit.amount_in_cents).to eq(1000)
+ end
+
+ it '#display_total_available_store_credit returns the available amount' do
+ allow(subject).to receive(:total_available_store_credit).and_return(10.00)
+
+ expect(subject.display_total_available_store_credit.amount_in_cents).to eq(1000)
+ end
+
+ it "#display_store_credit_remaining_after_capture returns available minus applied" do
+ allow(subject).to receive(:total_available_store_credit).and_return(10.00)
+ allow(subject).to receive(:total_applicable_store_credit).and_return(5.00)
+
+ expect(subject.display_store_credit_remaining_after_capture.amount_in_cents).to eq(500)
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::StoreCredits do
+ context 'included in Spree::Cart' do
+ def new_record(user: nil, total: nil, currency: nil)
+ create(:cart, { store: @default_store, customer: user, total: total, currency: currency }.compact)
+ end
+
+ def guest_record(total: nil)
+ create(:cart, { store: @default_store, customer: nil, total: total }.compact)
+ end
+
+ def create_store_credit_payment(record, **attributes)
+ create(:store_credit_payment, cart: record, order: nil, **attributes)
+ end
+
+ def mark_completed(record)
+ record.update_columns(completed_at: Time.current)
+ end
+
+ def completed_record_with_store_credit_payment
+ cart = new_record(user: create(:user), total: 50.0)
+ create(:store_credit_payment, cart: cart, order: nil, amount: 50.0)
+ mark_completed(cart)
+ cart
+ end
+
+ it_behaves_like 'a store credits host'
+ end
+
+ context 'included in Spree::Order' do
+ def new_record(user: nil, total: nil, currency: nil)
+ create(:order, { store: @default_store, user: user, total: total, currency: currency }.compact)
+ end
+
+ def guest_record(total: nil)
+ create(:store_credits_order_without_user, { total: total }.compact)
+ end
+
+ def create_store_credit_payment(record, **attributes)
+ create(:store_credit_payment, order: record, **attributes)
+ end
+
+ def mark_completed(record)
+ record.update_columns(completed_at: Time.current, status: 'placed')
+ end
+
+ def completed_record_with_store_credit_payment
+ create(:completed_order_with_store_credit_payment)
+ end
+
+ it_behaves_like 'a store credits host'
+ end
+end
diff --git a/spree/core/spec/models/concerns/spree/purchase/taxation_spec.rb b/spree/core/spec/models/concerns/spree/purchase/taxation_spec.rb
new file mode 100644
index 0000000000..04d9f4f1e4
--- /dev/null
+++ b/spree/core/spec/models/concerns/spree/purchase/taxation_spec.rb
@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'a taxation host' do
+ let(:store) { @default_store }
+ let(:bill_address) { create(:address) }
+ let(:ship_address) { create(:address) }
+
+ describe '#tax_address' do
+ it 'honors the tax_using_ship_address preference' do
+ Spree::Config.set(tax_using_ship_address: true)
+ expect(record.tax_address).to eq(ship_address)
+
+ Spree::Config.set(tax_using_ship_address: false)
+ expect(record.tax_address).to eq(bill_address)
+ end
+ end
+
+ describe '#tax_zone' do
+ let(:zone) { create(:zone) }
+
+ context 'when no zones exist' do
+ it 'returns nil' do
+ expect(record.tax_zone).to be_nil
+ end
+ end
+
+ context 'when tax_using_ship_address: true' do
+ before { Spree::Config.set(tax_using_ship_address: true) }
+
+ it 'calculates using ship_address' do
+ expect(Spree::Zone).to receive(:match).at_least(:once).with(ship_address)
+ expect(Spree::Zone).not_to receive(:match).with(bill_address)
+ record.tax_zone
+ end
+ end
+
+ context 'when tax_using_ship_address: false' do
+ before { Spree::Config.set(tax_using_ship_address: false) }
+
+ it 'calculates using bill_address' do
+ expect(Spree::Zone).to receive(:match).at_least(:once).with(bill_address)
+ expect(Spree::Zone).not_to receive(:match).with(ship_address)
+ record.tax_zone
+ end
+ end
+
+ context 'when there is a default tax zone' do
+ let!(:default_zone) { create(:zone, name: 'foo_zone') }
+
+ before { allow(Spree::Zone).to receive_messages default_tax: default_zone }
+
+ context 'when there is a matching zone' do
+ before { allow(Spree::Zone).to receive_messages(match: zone) }
+
+ it 'returns the matching zone' do
+ expect(record.tax_zone).to eq(zone)
+ end
+ end
+
+ context 'when there is no matching zone' do
+ before { allow(Spree::Zone).to receive_messages(match: nil) }
+
+ it 'returns the default tax zone' do
+ expect(record.tax_zone).to eq(default_zone)
+ end
+ end
+ end
+
+ context 'when no default tax zone' do
+ before { allow(Spree::Zone).to receive_messages default_tax: nil }
+
+ context 'when there is a matching zone' do
+ before { allow(Spree::Zone).to receive_messages(match: zone) }
+
+ it 'returns the matching zone' do
+ expect(record.tax_zone).to eq(zone)
+ end
+ end
+
+ context 'when there is no matching zone' do
+ before { allow(Spree::Zone).to receive_messages(match: nil) }
+
+ it 'returns nil' do
+ expect(record.tax_zone).to be_nil
+ end
+ end
+ end
+ end
+
+ describe '#tax_total' do
+ it 'sums included and additional tax' do
+ record.included_tax_total = 5
+ record.additional_tax_total = 3
+
+ expect(record.tax_total).to eq(8)
+ end
+ end
+
+ describe '#pre_tax_item_amount / #pre_tax_total' do
+ it 'sums line item and fulfillment pre-tax amounts' do
+ create(:line_item, record.is_a?(Spree::Cart) ? { cart: record, order: nil } : { order: record }).update_column(:pre_tax_amount, 7)
+
+ expect(record.pre_tax_item_amount).to eq(7)
+ expect(record.pre_tax_total).to eq(7)
+ end
+ end
+end
+
+RSpec.describe Spree::Purchase::Taxation do
+ context 'included in Spree::Cart' do
+ let(:record) { create(:cart, store: store, ship_address: ship_address, bill_address: bill_address) }
+
+ it_behaves_like 'a taxation host'
+ end
+
+ context 'included in Spree::Order' do
+ let(:record) { create(:order, store: store, ship_address: ship_address, bill_address: bill_address) }
+
+ it_behaves_like 'a taxation host'
+ end
+end
diff --git a/spree/core/spec/models/spree/order/currency_updater_spec.rb b/spree/core/spec/models/spree/order/currency_updater_spec.rb
deleted file mode 100644
index 1c01922ba2..0000000000
--- a/spree/core/spec/models/spree/order/currency_updater_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, type: :model do
- context 'CurrencyUpdater' do
- context 'when changing order currency' do
- let!(:line_item) { create(:line_item) }
- let!(:euro_price) { create(:price, variant: line_item.variant, amount: 8, currency: 'EUR') }
-
- context '#homogenize_line_item_currencies' do
- it 'succeeds without error' do
- expect { line_item.order.update!(currency: 'EUR') }.not_to raise_error
- end
-
- it 'changes the line_item currencies' do
- expect { line_item.order.update!(currency: 'EUR') }.to change { line_item.reload.currency }.from('USD').to('EUR')
- end
-
- it 'changes the line_item amounts' do
- expect { line_item.order.update!(currency: 'EUR') }.to change { line_item.reload.amount }.to(8)
- end
-
- it 'calculates the item total in the order.currency' do
- expect { line_item.order.update!(currency: 'EUR') }.to change { line_item.order.item_total }.to(8)
- end
-
- context 'when there is a price with nil amount' do
- let!(:euro_price) do
- allow(Spree::Config).to receive(:allow_empty_price_amount).and_return(true)
- create(:price, variant: line_item.variant, amount: nil, currency: 'EUR')
- end
-
- it 'destroys the line item when we switch to that price\'s currency' do
- expect { line_item.order.update!(currency: 'EUR') }.to change(Spree::LineItem, :count).by(-1)
- end
- end
- end
- end
- end
-end
diff --git a/spree/core/spec/models/spree/order/digital_spec.rb b/spree/core/spec/models/spree/order/digital_spec.rb
deleted file mode 100644
index a100ce2d55..0000000000
--- a/spree/core/spec/models/spree/order/digital_spec.rb
+++ /dev/null
@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, type: :model do
- let(:digital_shipping_method) { create(:digital_shipping_method) }
- let(:digital_product) { create(:digital_product) }
-
- context 'line_item analysis' do
- it 'understands that all products are digital' do
- order = create(:order)
- 3.times do
- add_line_item_to_order(order, create(:variant, digitals: [create(:digital)], product: digital_product), 1)
- end
- expect(order.digital?).to be true
- add_line_item_to_order(order, create(:variant, digitals: [create(:digital)], product: digital_product), 4)
- expect(order.digital?).to be true
- end
-
- it 'understands that no products are digital' do
- order = create(:order)
- 3.times do
- add_line_item_to_order(order, create(:variant), 1)
- end
- expect(order.digital?).to be false
- end
-
- it 'understands that empty order is not digital' do
- order = create(:order)
- expect(order.digital?).to be false
- end
-
- it 'understands that not all products are digital' do
- order = create(:order)
- 3.times do
- add_line_item_to_order(order, create(:variant, digitals: [create(:digital)], product: digital_product), 1)
- end
- add_line_item_to_order(order, create(:variant, digitals: [create(:digital)]), 1) # this is the analog product
- expect(order.digital?).to be false
- add_line_item_to_order(order, create(:variant, digitals: [create(:digital)], product: digital_product), 4)
- expect(order.digital?).to be false
- end
- end
-
- context 'Spree::Carts::AddItem.call' do
- it 'adds digital Variants of quantity 1 to an order' do
- order = create(:order)
- variants = 3.times.map { create(:variant, digitals: [create(:digital)], product: digital_product) }
- variants.each do |v|
- add_line_item_to_order(order, v, 1)
- end
- expect(order.line_items.first.variant).to eq(variants[0])
- expect(order.line_items.second.variant).to eq(variants[1])
- expect(order.line_items.third.variant).to eq(variants[2])
- end
-
- it 'handles quantity higher than 1 when adding one specific digital Variant' do
- order = create(:order)
- digital_variant = create(:variant, digitals: [create(:digital)], product: digital_product)
- add_line_item_to_order(order, digital_variant, 3)
- expect(order.line_items.first.quantity).to eq(3)
- add_line_item_to_order(order, digital_variant, 2)
- expect(order.line_items.first.quantity).to eq(5)
- end
- end
-
- describe '#digital?/#some_digital?' do
- let(:digital_order) do
- order = create(:order)
- variants = 3.times.map { create(:variant, digitals: [create(:digital)], product: digital_product) }
- variants.each { |v| add_line_item_to_order(order, v, 1) }
- order
- end
-
- let(:mixed_order) do
- order = create(:order)
- variants = 2.times.map { create(:variant, digitals: [create(:digital)], product: digital_product) }
- variants << create(:variant)
- variants.each { |v| add_line_item_to_order(order, v, 1) }
- order
- end
-
- let(:non_digital_order) do
- order = create(:order)
- variants = 3.times.map { create(:variant) }
- variants.each { |v| add_line_item_to_order(order, v, 1) }
- order
- end
-
- it 'returns true/true for a digital order' do
- expect(digital_order).to be_digital
- expect(digital_order).to be_some_digital
- end
-
- it 'returns false/true for a mixed order' do
- expect(mixed_order).not_to be_digital
- expect(mixed_order).to be_some_digital
- end
-
- it 'returns false/false for an exclusively non-digital order' do
- expect(non_digital_order).not_to be_digital
- expect(non_digital_order).not_to be_some_digital
- end
- end
-
- describe '#digital_links' do
- let(:mixed_order_digitals) { 2.times.map { create(:digital) } }
- let(:mixed_order) do
- order = create(:order)
- variants = mixed_order_digitals.map { |d| create(:variant, digitals: [d]) }
- variants << create(:variant)
- variants.each { |v| add_line_item_to_order(order, v, 1) }
- order
- end
-
- it 'correctly loads the links' do
- mixed_order_digital_links = mixed_order.digital_links
- links_from_digitals = mixed_order_digitals.map(&:reload).map(&:digital_links).flatten
- expect(mixed_order_digital_links.size).to eq(links_from_digitals.size)
- mixed_order_digital_links.each do |l|
- expect(links_from_digitals).to include(l)
- end
- end
- end
-
- def add_line_item_to_order(order, variant, quantity)
- Spree::Orders::AddItem.call(order: order, variant: variant, quantity: quantity)
- end
-end
diff --git a/spree/core/spec/models/spree/order/gift_card_spec.rb b/spree/core/spec/models/spree/order/gift_card_spec.rb
deleted file mode 100644
index 3e77bee51b..0000000000
--- a/spree/core/spec/models/spree/order/gift_card_spec.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe 'Order' do
- let(:order) { create(:order_with_line_items) }
-
- describe '#gift_card_total' do
- context 'when there is a gift card' do
- let(:gift_card) { create(:gift_card, amount: order.total) }
-
- before do
- order.apply_gift_card(gift_card)
- end
-
- it 'returns the gift card total' do
- expect(order.gift_card_total).to eq(gift_card.amount)
- end
- end
- end
-
- describe '#apply_gift_card' do
- context 'when there is a gift card' do
- let(:gift_card) { create(:gift_card, amount: order.total) }
-
- it 'applies the gift card to the order' do
- expect { order.apply_gift_card(gift_card) }.to change(order, :gift_card).from(nil).to(gift_card)
- end
- end
- end
-
- describe '#remove_gift_card' do
- context 'when there is a gift card' do
- let(:order) { create(:order_with_line_items, gift_card: gift_card) }
- let(:gift_card) { create(:gift_card) }
-
- it 'removes the gift card from the order' do
- expect { order.remove_gift_card }.to change(order, :gift_card).from(gift_card).to(nil)
- end
- end
- end
-end
diff --git a/spree/core/spec/models/spree/order/payment_spec.rb b/spree/core/spec/models/spree/order/payment_spec.rb
index c7520ad937..2073e68551 100644
--- a/spree/core/spec/models/spree/order/payment_spec.rb
+++ b/spree/core/spec/models/spree/order/payment_spec.rb
@@ -135,121 +135,6 @@ module Spree
end
end
- context '#process_payments!' do
- let!(:order) { create(:order_with_line_items) }
- let!(:payment) do
- payment = create(:payment, amount: 10, order: order, state: payment_state)
- order.payments << payment
- payment
- end
-
- let(:payment_state) { 'checkout' }
- let(:unprocessed_payments) { [payment] }
- let(:pending_payments) { [] }
- let(:total) { 10 }
-
- before do
- allow(order).to receive_messages(
- unprocessed_payments: unprocessed_payments,
- pending_payments: pending_payments,
- total: total
- )
- end
-
- it 'processes the payments' do
- expect(payment).to receive(:process!)
- expect(order.process_payments!).to be_truthy
- end
-
- # Regression spec for https://github.com/spree/spree/issues/5436
- it 'raises an error if there are no payments to process' do
- allow(order).to receive_messages unprocessed_payments: []
- expect(payment).not_to receive(:process!)
- expect(order.process_payments!).to be_falsey
- end
-
- context 'when there are pending payments' do
- let(:payment_state) { 'pending' }
- let(:pending_payments) { [payment] }
- let(:unprocessed_payments) { [] }
-
- it 'skips processing the payments' do
- expect(payment).not_to receive(:process!)
- expect(order.process_payments!).to be_nil
- end
-
- context 'when there is other unprocessed payment' do
- let(:other_payment) { create(:payment, order: order, amount: 5, state: 'checkout') }
- let(:unprocessed_payments) { [other_payment] }
-
- before do
- order.payments << other_payment
- end
-
- it 'processes only the other payment' do
- expect(payment).not_to receive(:process!)
- expect(other_payment).to receive(:process!)
-
- expect(order.process_payments!).to be_truthy
- end
- end
- end
-
- context 'when a payment raises a GatewayError' do
- before { expect(payment).to receive(:process!).and_raise(Spree::Core::GatewayError) }
-
- it 'returns true when configured to allow checkout on gateway failures' do
- Spree::Config.set allow_checkout_on_gateway_error: true
- expect(order.process_payments!).to be true
- end
-
- it 'returns false when not configured to allow checkout on gateway failures' do
- Spree::Config.set allow_checkout_on_gateway_error: false
- expect(order.process_payments!).to be false
- end
- end
-
- # Regression spec for https://github.com/spree/spree/issues/8148
-
- it 'updates order with correct payment total' do
- Spree::Config[:auto_capture] = true
- order.process_payments!
-
- expect(payment).to be_completed
- expect(order.payment_total).to eq payment.amount
- end
- end
-
- context '#authorize_payments!' do
- subject { order.authorize_payments! }
-
- let(:payment) { create(:payment) }
-
- before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
-
- it 'processes payments with attempt_authorization!' do
- expect(payment).to receive(:authorize!)
- subject
- end
-
- it { is_expected.to be_truthy }
- end
-
- context '#capture_payments!' do
- subject { order.capture_payments! }
-
- let(:payment) { create(:payment) }
-
- before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
-
- it 'processes payments with attempt_authorization!' do
- expect(payment).to receive(:purchase!)
- subject
- end
-
- it { is_expected.to be_truthy }
- end
-
context '#outstanding_balance' do
it 'returns positive amount when payment_total is less than total' do
order.payment_total = 20.20
@@ -319,19 +204,5 @@ module Spree
expect(order.outstanding_balance?).to be false
end
end
-
- context 'payment required?' do
- context 'total is zero' do
- before { allow(order).to receive_messages(total: 0) }
-
- it { expect(order.payment_required?).to be false }
- end
-
- context 'total > zero' do
- before { allow(order).to receive_messages(total: 1) }
-
- it { expect(order.payment_required?).to be true }
- end
- end
end
end
diff --git a/spree/core/spec/models/spree/order/store_credit_spec.rb b/spree/core/spec/models/spree/order/store_credit_spec.rb
deleted file mode 100644
index ed4595d5e4..0000000000
--- a/spree/core/spec/models/spree/order/store_credit_spec.rb
+++ /dev/null
@@ -1,557 +0,0 @@
-require 'spec_helper'
-
-shared_examples 'check total store credit from payments' do
- context 'with valid payments' do
- subject { order }
-
- let(:order) { payment.order }
- let!(:payment) { create(:store_credit_payment) }
- let!(:second_payment) { create(:store_credit_payment, order: order) }
-
- it 'returns the sum of the payment amounts' do
- expect(subject.total_applicable_store_credit).to eq (payment.amount + second_payment.amount)
- end
- end
-
- context 'without valid payments' do
- subject { order }
-
- let(:order) { create(:order) }
-
- it 'returns 0' do
- expect(subject.total_applicable_store_credit).to be_zero
- end
- end
-end
-
-describe 'Order' do
- subject(:order) { create(:order, total: 100.00) }
-
- describe '#add_store_credit_payments' do
- subject { order.add_store_credit_payments }
-
- let(:order_total) { 500.00 }
-
- before { create(:store_credit_payment_method) }
-
- context 'there is no store credit' do
- let(:order) { create(:store_credits_order_without_user, total: order_total) }
-
- before do
- # callbacks recalculate total based on line items
- # this ensures the total is what we expect
- order.update_column(:total, order_total)
- subject
- order.reload
- end
-
- it 'does not create a store credit payment' do
- expect(order.payments.count).to eq 0
- end
- end
-
- context 'there is enough store credit to pay for the entire order' do
- let(:store_credit) { create(:store_credit, amount: order_total) }
- let(:order) { create(:order, user: store_credit.user, total: order_total) }
-
- before do
- subject
- order.reload
- end
-
- it 'creates a store credit payment for the full amount' do
- expect(order.payments.count).to eq 1
- expect(order.payments.first).to be_store_credit
- expect(order.payments.first.amount).to eq order_total
- end
- end
-
- context 'the available store credit is not enough to pay for the entire order' do
- let(:expected_cc_total) { 100.0 }
- let(:store_credit_total) { order_total - expected_cc_total }
- let(:store_credit) { create(:store_credit, amount: store_credit_total) }
- let(:order) { create(:order, user: store_credit.user, total: order_total) }
-
- before do
- # callbacks recalculate total based on line items
- # this ensures the total is what we expect
- order.update_column(:total, order_total)
- subject
- order.reload
- end
-
- it 'creates a store credit payment for the available amount' do
- expect(order.payments.count).to eq 1
- expect(order.payments.first).to be_store_credit
- expect(order.payments.first.amount).to eq store_credit_total
- end
- end
-
- context 'there are multiple store credits' do
- context 'they have different credit type priorities' do
- let(:amount_difference) { 100 }
- let!(:primary_store_credit) { create(:store_credit, amount: (order_total - amount_difference)) }
- let!(:secondary_store_credit) do
- create(:store_credit, amount: order_total, user: primary_store_credit.user,
- credit_type: create(:secondary_credit_type))
- end
- let(:order) { create(:order, user: primary_store_credit.user, total: order_total) }
-
- before do
- Timecop.scale(3600)
- subject
- order.reload
- end
-
- after { Timecop.return }
-
- it 'uses the primary store credit type over the secondary' do
- primary_payment = order.payments.first
- secondary_payment = order.payments.last
-
- expect(order.payments.size).to eq 2
- expect(primary_payment.source).to eq primary_store_credit
- expect(secondary_payment.source).to eq secondary_store_credit
- expect(primary_payment.amount).to eq(order_total - amount_difference)
- expect(secondary_payment.amount).to eq(amount_difference)
- end
- end
- end
- end
-
- describe '#remove_store_credit_payments' do
- subject { order.remove_store_credit_payments }
-
- let(:order_total) { 500.00 }
- let(:order) { create(:order, user: store_credit.user, total: order_total) }
-
- context 'when order is not complete' do
- let(:store_credit) { create(:store_credit, amount: order_total - 1) }
-
- before do
- create(:store_credit_payment_method)
- order.add_store_credit_payments
- end
-
- it { expect { subject }.to change { order.payments.checkout.store_credits.count }.from(1).to(0) }
- it { expect { subject }.to change { order.payments.with_state(:invalid).store_credits.count }.from(0).to(1) }
- end
-
- context 'when order is complete' do
- let(:order) { create(:completed_order_with_store_credit_payment) }
- let(:store_credit_payments) { order.payments.checkout.store_credits }
-
- before do
- subject
- order.reload
- end
-
- it { expect(order.payments.checkout.store_credits).to eq store_credit_payments }
- end
- end
-
- describe '#covered_by_store_credit' do
- context "order doesn't have an associated user" do
- subject { order.covered_by_store_credit? }
-
- let(:order) { create(:store_credits_order_without_user) }
-
- it { is_expected.to be(false) }
- end
-
- context 'order has an associated user' do
- subject { order.covered_by_store_credit? }
-
- let(:order) { create(:order, user: user, total: order_total) }
- let(:user) { create(:user) }
- let(:order_total) { 10.0 }
-
- context 'user has enough store credit to pay for the order' do
- let!(:store_credit_payment) { create(:store_credit_payment, order: order, source: store_credit, amount: 10.0) }
- let(:store_credit) { create(:store_credit, amount: 10.0, store: order.store, user: order.user) }
-
- it { is_expected.to be(true) }
- end
-
- context 'user does not have enough store credit to pay for the order' do
- before do
- allow(user).to receive(:total_available_store_credit).and_return(0.0)
- allow(subject).to receive(:total).and_return(5.0)
- end
-
- it { is_expected.to be(false) }
- end
-
- context 'order total is zero' do
- let(:order_total) { 0.0 }
- it { is_expected.to be(false) }
- end
- end
- end
-
- describe '#total_available_store_credit' do
- context 'order does not have an associated user' do
- subject { create(:store_credits_order_without_user) }
-
- it 'returns 0' do
- expect(subject.total_available_store_credit).to be_zero
- end
- end
-
- context 'order has an associated user' do
- subject { create(:order, user: user) }
-
- let(:user) { create(:user) }
- let(:available_store_credit) { 25.0 }
-
- before do
- allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
- end
-
- it "returns the user's available store credit" do
- expect(subject.total_available_store_credit).to eq available_store_credit
- end
-
- context 'when store is provided' do
- let!(:store) { @default_store }
- let!(:second_store) { create(:store) }
- let!(:store_credit) { create(:store_credit, amount: '100', user: user, store: store) }
-
- before do
- allow(user).to receive(:total_available_store_credit).and_call_original
- end
-
- context 'and has store credits associated' do
- before do
- expect(subject).to receive(:store).and_return(store)
- end
-
- it "returns the user's available store credit" do
- expect(subject.total_available_store_credit).to eq(100)
- end
- end
-
- context 'and has no store credits associated' do
- before do
- expect(subject).to receive(:store).and_return(second_store)
- end
-
- it "returns the user's available store credit" do
- expect(subject.total_available_store_credit).to eq(0)
- end
- end
- end
- end
- end
-
- describe '#available_store_credits' do
- subject { order.available_store_credits }
-
- context 'order does not have an associated user' do
- let(:order) { create(:store_credits_order_without_user) }
-
- it { is_expected.to be_empty }
- end
-
- context 'order has an associated user' do
- let(:order) { create(:order, user: user, currency: 'USD') }
- let(:user) { create(:user) }
-
- let!(:store_credit_1) { create(:store_credit, user: user, amount: 10, currency: 'USD') }
- let!(:store_credit_2) { create(:store_credit, user: user, amount: 15, currency: 'USD') }
- let!(:store_credit_3) { create(:store_credit, user: user, amount: 20, currency: 'EUR') }
-
- it 'returns the user available store credits' do
- expect(subject).to eq([store_credit_2, store_credit_1])
- end
- end
- end
-
- describe '#could_use_store_credit?' do
- let!(:store_credit_payment_method) { create(:store_credit_payment_method) }
-
- context 'order does not have an associated user' do
- subject { create(:store_credits_order_without_user) }
-
- it { expect(subject.could_use_store_credit?).to be false }
- end
-
- context 'order has an associated user' do
- subject { create(:order, user: user) }
-
- let(:user) { create(:user) }
-
- context 'without store credit' do
- it { expect(subject.could_use_store_credit?).to be false }
- end
-
- context 'with store credit' do
- let(:available_store_credit) { 25.0 }
-
- before do
- allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
- end
-
- it { expect(subject.could_use_store_credit?).to be true }
- end
-
- context 'without active Store Credit Payment' do
- let(:available_store_credit) { 25.0 }
-
- before do
- allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
- store_credit_payment_method.update_attribute(:active, false)
- end
-
- it { expect(subject.could_use_store_credit?).to be false }
- end
-
-
- context 'without Store Credit Payment' do
- let(:available_store_credit) { 25.0 }
-
- before do
- allow(user).to receive(:total_available_store_credit).and_return(available_store_credit)
- store_credit_payment_method.destroy
- end
-
- it { expect(subject.could_use_store_credit?).to be false }
- end
- end
- end
-
- describe '#order_total_after_store_credit' do
- subject { create(:order, total: order_total) }
-
- let(:order_total) { 100.0 }
-
- before do
- allow(subject).to receive(:total_applicable_store_credit).and_return(applicable_store_credit)
- end
-
- context "order's user has store credits" do
- let(:applicable_store_credit) { 10.0 }
-
- it 'deducts the applicable store credit' do
- expect(subject.order_total_after_store_credit).to eq (order_total - applicable_store_credit)
- end
- end
-
- context "order's user does not have any store credits" do
- let(:applicable_store_credit) { 0.0 }
-
- it 'returns the order total' do
- expect(subject.order_total_after_store_credit).to eq order_total
- end
- end
- end
-
- describe '#total_applicable_store_credit' do
- context 'order has payments (mid-checkout)' do
- include_examples 'check total store credit from payments'
- end
-
- context 'order is completed' do
- before { order.update_columns(completed_at: Time.current, status: 'placed') }
-
- include_examples 'check total store credit from payments'
- end
-
- context 'order has no payments and is not completed' do
- context 'the associated user has store credits' do
- subject { order }
-
- let(:store) { @default_store }
- let(:store_credit) { create(:store_credit, store: store) }
- let(:order) { create(:order, user: store_credit.user, store: store) }
-
- context 'the store credit is more than the order total' do
- let(:order_total) { store_credit.amount - 1 }
-
- before { order.update(total: order_total) }
-
- it 'returns the order total' do
- expect(subject.total_applicable_store_credit).to eq order_total
- end
- end
-
- context 'the store credit is less than the order total' do
- let(:order_total) { store_credit.amount * 10 }
-
- before { order.update(total: order_total) }
-
- it 'returns the store credit amount' do
- expect(subject.total_applicable_store_credit).to eq store_credit.amount
- end
- end
- end
-
- context 'the associated user does not have store credits' do
- subject { order }
-
- let(:order) { create(:order) }
-
- it 'returns 0' do
- expect(subject.total_applicable_store_credit).to be_zero
- end
- end
-
- context 'the order does not have an associated user' do
- subject { create(:store_credits_order_without_user) }
-
- it 'returns 0' do
- expect(subject.total_applicable_store_credit).to be_zero
- end
- end
- end
- end
-
- describe '#total_applied_store_credit' do
- subject(:total_applied_store_credit) { order.total_applied_store_credit }
-
- context 'with valid payments' do
- let(:order_1_valid_payment) { 10.0 }
- let(:order_1_valid_payment_2) { 20.0 }
- let(:order_1_invalid_payment) { 21.0 }
- let(:order_2_valid_payment) { 22.0 }
-
- before do
- create(:store_credit_payment, order: order, state: 'completed', amount: order_1_valid_payment)
- create(:store_credit_payment, order: order, state: 'completed', amount: order_1_valid_payment_2)
- create(:store_credit_payment, order: order, state: 'invalid', amount: order_1_invalid_payment)
- create(:store_credit_payment, order: create(:order, total: 100.00), state: 'completed', amount: order_2_valid_payment)
- end
-
- it 'returns the sum of the payment amounts' do
- expect(total_applied_store_credit).to eq (order_1_valid_payment + order_1_valid_payment_2)
- end
-
- context 'when payments are loaded' do
- before do
- order.payments.load
- end
-
- it 'returns the sum of the payment amounts' do
- expect(total_applied_store_credit).to eq (order_1_valid_payment + order_1_valid_payment_2)
- end
- end
- end
-
- context 'without valid payments' do
- let(:order) { create(:order) }
-
- it 'returns 0' do
- expect(total_applied_store_credit).to be_zero
- end
- end
- end
-
- describe '#using_store_credit?' do
- subject { create(:order) }
-
- context 'order has store credit payment' do
- before { allow(subject).to receive(:total_applied_store_credit).and_return(10.0) }
-
- it { expect(subject.using_store_credit?).to be true }
- end
-
- context 'order has no store credit payments' do
- before { allow(subject).to receive(:total_applied_store_credit).and_return(0.0) }
-
- it { expect(subject.using_store_credit?).to be false }
- end
- end
-
- describe '#display_total_applicable_store_credit' do
- subject { create(:order) }
-
- let(:total_applicable_store_credit) { 10.00 }
-
- before do
- allow(subject).to receive(:total_applicable_store_credit).and_return(total_applicable_store_credit)
- end
-
- it 'returns a money instance' do
- expect(subject.display_total_applicable_store_credit).to be_a(Spree::Money)
- end
-
- it 'returns a negative amount' do
- expect(subject.display_total_applicable_store_credit.amount_in_cents).to eq (total_applicable_store_credit * -100.0)
- end
- end
-
- describe '#display_total_applied_store_credit' do
- subject { create(:order) }
-
- let(:total_applied_store_credit) { 10.00 }
-
- before do
- allow(subject).to receive(:total_applied_store_credit).and_return(total_applied_store_credit)
- end
-
- it 'returns a money instance' do
- expect(subject.display_total_applied_store_credit).to be_a(Spree::Money)
- end
-
- it 'returns a negative amount' do
- expect(subject.display_total_applied_store_credit.amount_in_cents).to eq (total_applied_store_credit * -100.0)
- end
- end
-
- describe '#display_order_total_after_store_credit' do
- subject { create(:order) }
-
- let(:order_total_after_store_credit) { 10.00 }
-
- before do
- allow(subject).to receive(:order_total_after_store_credit).and_return(order_total_after_store_credit)
- end
-
- it 'returns a money instance' do
- expect(subject.display_order_total_after_store_credit).to be_a(Spree::Money)
- end
-
- it 'returns the order_total_after_store_credit amount' do
- expect(subject.display_order_total_after_store_credit.amount_in_cents).to eq (order_total_after_store_credit * 100.0)
- end
- end
-
- describe '#display_total_available_store_credit' do
- subject { create(:order) }
-
- let(:total_available_store_credit) { 10.00 }
-
- before do
- allow(subject).to receive(:total_available_store_credit).and_return(total_available_store_credit)
- end
-
- it 'returns a money instance' do
- expect(subject.display_total_available_store_credit).to be_a(Spree::Money)
- end
-
- it 'returns the total_available_store_credit amount' do
- expect(subject.display_total_available_store_credit.amount_in_cents).to eq (total_available_store_credit * 100.0)
- end
- end
-
- describe '#display_store_credit_remaining_after_capture' do
- subject { create(:order) }
-
- let(:total_available_store_credit) { 10.00 }
- let(:total_applicable_store_credit) { 5.00 }
-
- before do
- allow(subject).to receive(:total_available_store_credit).and_return(total_available_store_credit)
- allow(subject).to receive(:total_applicable_store_credit).and_return(total_applicable_store_credit)
- end
-
- it 'returns a money instance' do
- expect(subject.display_store_credit_remaining_after_capture).to be_a(Spree::Money)
- end
-
- it "returns all of the user's available store credit minus what's applied to the order amount" do
- amount_remaining = total_available_store_credit - total_applicable_store_credit
- expect(subject.display_store_credit_remaining_after_capture.amount_in_cents).to eq (amount_remaining * 100.0)
- end
- end
-end
diff --git a/spree/core/spec/models/spree/order/tax_spec.rb b/spree/core/spec/models/spree/order/tax_spec.rb
deleted file mode 100644
index a0699d0bec..0000000000
--- a/spree/core/spec/models/spree/order/tax_spec.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-module Spree
- describe Spree::Order, type: :model do
- let(:order) { create(:order) }
-
- context '#tax_zone' do
- let(:bill_address) { create :address }
- let(:ship_address) { create :address }
- let(:order) { Spree::Order.create(ship_address: ship_address, bill_address: bill_address) }
- let(:zone) { create :zone }
-
- context 'when no zones exist' do
- it 'returns nil' do
- expect(order.tax_zone).to be_nil
- end
- end
-
- context 'when tax_using_ship_address: true' do
- before { Spree::Config.set(tax_using_ship_address: true) }
-
- it 'calculates using ship_address' do
- expect(Spree::Zone).to receive(:match).at_least(:once).with(ship_address)
- expect(Spree::Zone).not_to receive(:match).with(bill_address)
- order.tax_zone
- end
- end
-
- context 'when tax_using_ship_address: false' do
- before { Spree::Config.set(tax_using_ship_address: false) }
-
- it 'calculates using bill_address' do
- expect(Spree::Zone).to receive(:match).at_least(:once).with(bill_address)
- expect(Spree::Zone).not_to receive(:match).with(ship_address)
- order.tax_zone
- end
- end
-
- context 'when there is a default tax zone' do
- before do
- @default_zone = create(:zone, name: 'foo_zone')
- allow(Spree::Zone).to receive_messages default_tax: @default_zone
- end
-
- context 'when there is a matching zone' do
- before { allow(Spree::Zone).to receive_messages(match: zone) }
-
- it 'returns the matching zone' do
- expect(order.tax_zone).to eq(zone)
- end
- end
-
- context 'when there is no matching zone' do
- before { allow(Spree::Zone).to receive_messages(match: nil) }
-
- it 'returns the default tax zone' do
- expect(order.tax_zone).to eq(@default_zone)
- end
- end
- end
-
- context 'when no default tax zone' do
- before { allow(Spree::Zone).to receive_messages default_tax: nil }
-
- context 'when there is a matching zone' do
- before { allow(Spree::Zone).to receive_messages(match: zone) }
-
- it 'returns the matching zone' do
- expect(order.tax_zone).to eq(zone)
- end
- end
-
- context 'when there is no matching zone' do
- before { allow(Spree::Zone).to receive_messages(match: nil) }
-
- it 'returns nil' do
- expect(order.tax_zone).to be_nil
- end
- end
- end
- end
- end
-end
diff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rb
index cb025d2641..92c4769d7e 100644
--- a/spree/core/spec/models/spree/order_spec.rb
+++ b/spree/core/spec/models/spree/order_spec.rb
@@ -654,59 +654,6 @@ describe Spree::Order, type: :model do
end
end
- describe '#confirmation_required?' do
- subject { order.confirmation_required? }
-
- it 'is computed from data only' do
- order = Spree::Order.new
- assert !order.confirmation_required?
- end
-
- context 'Spree::Config[:always_include_confirm_step] == true' do
- before do
- Spree::Config[:always_include_confirm_step] = true
- end
-
- it 'returns true if payments empty' do
- order = Spree::Order.new
- assert order.confirmation_required?
- end
- end
-
- context 'Spree::Config[:always_include_confirm_step] == false' do
- it 'returns false if payments empty and Spree::Config[:always_include_confirm_step] == false' do
- order = Spree::Order.new
- assert !order.confirmation_required?
- end
-
- it 'does not bomb out when an order has an unpersisted payment' do
- order = Spree::Order.new
- order.payments.build
- assert !order.confirmation_required?
- end
- end
-
- context 'when the payment does not require confirmation' do
- before do
- order.update_column(:total, 50)
- create(:payment, order: order, amount: 50)
-
- allow_any_instance_of(Spree::Gateway::Bogus).to receive(:confirmation_required?).and_return(false)
- end
-
- it { is_expected.to be(false) }
- end
-
- context 'when at least one payment method requires confirmation' do
- before do
- order.update_column(:total, 50)
- create(:payment, order: order, amount: 50)
- end
-
- it { is_expected.to be(true) }
- end
- end
-
context 'add_update_hook' do
before do
Spree::Order.class_eval do
@@ -1496,23 +1443,6 @@ describe Spree::Order, type: :model do
end
end
- describe '#ensure_channel_presence' do
- let(:store) { create(:store) }
-
- it 'auto-assigns the store default channel on new orders' do
- o = build(:order, store: store, channel: nil)
- o.valid?
- expect(o.channel).to eq(store.default_channel)
- end
-
- it 'preserves an explicitly set channel' do
- other = store.channels.create!(name: 'POS', code: 'pos')
- o = build(:order, store: store, channel: other)
- o.valid?
- expect(o.channel).to eq(other)
- end
- end
-
describe '#inferred_preferred_stock_location_id' do
let(:preferred) { create(:stock_location) }
diff --git a/spree/core/spec/models/spree/payment/gateway_options_spec.rb b/spree/core/spec/models/spree/payment/gateway_options_spec.rb
index ad57d8d25e..05e7155ed4 100644
--- a/spree/core/spec/models/spree/payment/gateway_options_spec.rb
+++ b/spree/core/spec/models/spree/payment/gateway_options_spec.rb
@@ -6,7 +6,7 @@ RSpec.describe Spree::Payment::GatewayOptions, type: :model do
let(:payment) do
double(
Spree::Payment,
- order: order,
+ owner: order,
number: 'P1566',
currency: 'EUR',
payment_method: payment_method