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
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.rbindex f4d2de4bba..37d1d2f0da 100644--- a/spree/core/app/models/spree/cart.rb+++ b/spree/core/app/models/spree/cart.rb@@ -139,6 +139,8 @@ module Spreebefore_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; thediff --git a/spree/core/app/models/spree/payment/gateway_options.rb b/spree/core/app/models/spree/payment/gateway_options.rbindex 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 Spreeclass GatewayOptionsdef 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.ownerendattr_reader :payment, :orderdiff --git a/spree/core/app/models/spree/payment/processing.rb b/spree/core/app/models/spree/payment/processing.rbindex 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 Spreeenddef gateway_options- order.reload+ owner.reloadgateway_options_class.new(self).to_hashenddiff --git a/spree/core/spec/models/concerns/spree/purchase/digital_items_spec.rb b/spree/core/spec/models/concerns/spree/purchase/digital_items_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/concerns/spree/purchase/gift_cards_spec.rb b/spree/core/spec/models/concerns/spree/purchase/gift_cards_spec.rbnew file mode 100644index 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+enddiff --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.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/concerns/spree/purchase/payment_processing_spec.rb b/spree/core/spec/models/concerns/spree/purchase/payment_processing_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/concerns/spree/purchase/purchase_context_spec.rb b/spree/core/spec/models/concerns/spree/purchase/purchase_context_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/concerns/spree/purchase/store_credits_spec.rb b/spree/core/spec/models/concerns/spree/purchase/store_credits_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/concerns/spree/purchase/taxation_spec.rb b/spree/core/spec/models/concerns/spree/purchase/taxation_spec.rbnew file mode 100644index 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+enddiff --git a/spree/core/spec/models/spree/order/currency_updater_spec.rb b/spree/core/spec/models/spree/order/currency_updater_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/order/digital_spec.rb b/spree/core/spec/models/spree/order/digital_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/order/gift_card_spec.rb b/spree/core/spec/models/spree/order/gift_card_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/order/payment_spec.rb b/spree/core/spec/models/spree/order/payment_spec.rbindex 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 Spreeendend- 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' doit 'returns positive amount when payment_total is less than total' doorder.payment_total = 20.20@@ -319,19 +204,5 @@ module Spreeexpect(order.outstanding_balance?).to be falseendend-- 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- endendenddiff --git a/spree/core/spec/models/spree/order/store_credit_spec.rb b/spree/core/spec/models/spree/order/store_credit_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/order/tax_spec.rb b/spree/core/spec/models/spree/order/tax_spec.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rbindex 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 doendend- 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' dobefore doSpree::Order.class_eval do@@ -1496,23 +1443,6 @@ describe Spree::Order, type: :model doendend- 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' dolet(: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.rbindex 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 dolet(:payment) dodouble(Spree::Payment,- order: order,+ owner: order,number: 'P1566',currency: 'EUR',payment_method: payment_method