solidus_core 2.3.1 → 2.4.0.beta1

data/spec/models/spree/order/checkout_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'spree/testing_support/order_walkthrough'
 
-describe Spree::Order, type: :model do
+RSpec.describe Spree::Order, type: :model do
   let!(:store) { create(:store) }
   let(:order) { Spree::Order.new(store: store) }
 
@@ -281,12 +281,12 @@ describe Spree::Order, type: :model do
       before do
         order.ship_address = ship_address
         order.state = 'delivery'
-        allow(order).to receive(:apply_free_shipping_promotions)
+        allow(order).to receive(:apply_shipping_promotions)
         allow(order).to receive(:ensure_available_shipping_rates) { true }
       end
 
       it "attempts to apply free shipping promotions" do
-        expect(order).to receive(:apply_free_shipping_promotions)
+        expect(order).to receive(:apply_shipping_promotions)
         order.next!
       end
 
@@ -328,7 +328,7 @@ describe Spree::Order, type: :model do
         context "with a shipment that has a price" do
           before do
             shipment.shipping_rates.first.update_column(:cost, 10)
-            order.update!
+            order.recalculate
           end
 
           it "transitions to payment" do
@@ -595,7 +595,7 @@ describe Spree::Order, type: :model do
 
       it 'can complete the order' do
         create(:payment, state: 'completed', order: order, amount: order.total)
-        order.update!
+        order.recalculate
         expect(order.complete).to eq(true)
       end
     end

data/spec/models/spree/order/finalizing_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Order, type: :model do
+RSpec.describe Spree::Order, type: :model do
   let(:order) { stub_model("Spree::Order") }
 
   context "#finalize!" do
@@ -18,7 +18,7 @@ describe Spree::Order, type: :model do
 
     it "should sell inventory units" do
       order.shipments.each do |shipment|
-        expect(shipment).to receive(:update!)
+        expect(shipment).to receive(:update_state)
         expect(shipment).to receive(:finalize!)
       end
       order.finalize!

data/spec/models/spree/order/number_generator_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 RSpec.describe Spree::Order::NumberGenerator do
   subject { described_class.new.generate }

data/spec/models/spree/order/outstanding_balance_integration_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 # This method in particular has been difficult to get right.
 # Many things will affect this amount
@@ -18,7 +18,7 @@ RSpec.describe "Outstanding balance integration tests" do
 
   subject do
     order.reload
-    order.update!
+    order.recalculate
     order.outstanding_balance
   end
 
@@ -63,7 +63,7 @@ RSpec.describe "Outstanding balance integration tests" do
 
     context 'with a removed item' do
       before do
-        item_amount = item_1.final_amount
+        item_amount = item_1.total
         order.contents.remove(item_1.variant)
         create(:refund, payment: payment, amount: item_amount)
       end

data/spec/models/spree/order/payment_spec.rb

@@ -1,57 +1,88 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
-  describe Spree::Order, type: :model do
+  RSpec.describe Spree::Order, type: :model do
     let(:order) { stub_model(Spree::Order) }
     let(:updater) { Spree::OrderUpdater.new(order) }
 
     context "processing payments" do
       let(:order) { create(:order_with_line_items, shipment_cost: 0, line_items_price: 100) }
+
       before do
         # So that Payment#purchase! is called during processing
         Spree::Config[:auto_capture] = true
       end
 
-      it 'processes all checkout payments' do
-        payment_1 = create(:payment, order: order, amount: 50)
-        payment_2 = create(:payment, order: order, amount: 50)
+      let(:payment_method) { create(:credit_card_payment_method) }
+
+      let!(:payment_1) do
+        create(:payment, payment_method: payment_method, order: order, amount: 50)
+      end
 
-        order.process_payments!
-        updater.update_payment_state
+      context 'sharing the same payment method' do
+        let!(:payment_2) do
+          create(:payment, payment_method: payment_method, order: order, amount: 50)
+        end
 
-        expect(order.payment_state).to eq('paid')
-        expect(order.payment_total).to eq(100)
+        it 'processes only new payments' do
+          order.process_payments!
+          updater.update_payment_state
 
-        expect(payment_1).to be_completed
-        expect(payment_2).to be_completed
+          expect(order.payment_state).to eq('balance_due')
+          expect(order.payment_total).to eq(50)
+
+          expect(payment_1).to be_invalid
+          expect(payment_2).to be_completed
+        end
       end
 
-      it 'does not go over total for order' do
-        payment_1 = create(:payment, order: order, amount: 50)
-        payment_2 = create(:payment, order: order, amount: 50)
-        payment_3 = create(:payment, order: order, amount: 50)
+      context 'with different payment methods that are store credit' do
+        let!(:payment_2) { create(:store_credit_payment, order: order, amount: 50) }
+
+        it 'processes all checkout payments' do
+          order.process_payments!
+          updater.update_payment_state
 
-        order.process_payments!
-        updater.update_payment_state
+          expect(order.payment_state).to eq('paid')
+          expect(order.payment_total).to eq(100)
 
-        expect(order.payment_state).to eq('paid')
-        expect(order.payment_total).to eq(100)
+          expect(payment_1).to be_completed
+          expect(payment_2).to be_completed
+        end
+
+        context 'with over paid payments' do
+          let!(:payment_3) { create(:store_credit_payment, order: order, amount: 50) }
 
-        expect(payment_1).to be_completed
-        expect(payment_2).to be_completed
-        expect(payment_3).to be_checkout
+          it 'does not go over total for order' do
+            order.process_payments!
+            updater.update_payment_state
+
+            expect(order.payment_state).to eq('paid')
+            expect(order.payment_total).to eq(100)
+            expect(payment_1).to be_completed
+            expect(payment_2).to be_completed
+            expect(payment_3).to be_checkout
+          end
+        end
       end
 
-      it "does not use failed payments" do
-        payment1 = create(:payment, order: order, amount: 50)
-        payment2 = create(:payment, order: order, amount: 50, state: 'failed')
+      context 'with failed payments' do
+        let!(:payment_2) do
+          create(:payment,
+            payment_method: payment_method,
+            order: order,
+            amount: 50,
+            state: 'failed')
+        end
 
-        expect(payment1).to receive(:process!).and_call_original
-        expect(payment2).not_to receive(:process!)
+        it "does not use failed payments" do
+          expect(payment_1).to receive(:process!).and_call_original
+          expect(payment_2).not_to receive(:process!)
 
-        order.process_payments!
+          order.process_payments!
 
-        expect(order.payment_total).to eq(50)
+          expect(order.payment_total).to eq(50)
+        end
       end
     end
 
@@ -176,7 +207,7 @@ module Spree
                           payment: reimbursement.order.payments.first,
                           reimbursement: reimbursement
           # Update the order totals so payment_total goes to 0 reflecting the refund..
-          order.update!
+          order.recalculate
         end
 
         context "for canceled orders" do

data/spec/models/spree/order/risk_assessment_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Order, type: :model do
+RSpec.describe Spree::Order, type: :model do
   let(:order) { stub_model('Spree::Order') }
 
   describe ".is_risky?" do

data/spec/models/spree/order/state_machine_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Order, type: :model do
+RSpec.describe Spree::Order, type: :model do
   let(:order) { create(:order_with_line_items) }
 
   context "#next!" do

data/spec/models/spree/order/totals_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
-  describe Order, type: :model do
+  RSpec.describe Order, type: :model do
     let(:order) { create(:order) }
     let(:shirt) { create(:variant) }
 

data/spec/models/spree/order/updating_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Order, type: :model do
+RSpec.describe Spree::Order, type: :model do
   let(:order) { create(:order) }
 
   context "#update!" do
@@ -9,7 +9,7 @@ describe Spree::Order, type: :model do
       after { Spree::Order.update_hooks.clear }
       it "should call each of the update hooks" do
         expect(order).to receive :foo
-        order.update!
+        order.recalculate
       end
     end
   end

data/spec/models/spree/order/validations_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
-  describe Spree::Order, type: :model do
+  RSpec.describe Spree::Order, type: :model do
     context "validations" do
       # Regression test for https://github.com/spree/spree/issues/2214
       it "does not return two error messages when email is blank" do

data/spec/models/spree/order_cancellations_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::OrderCancellations do
+RSpec.describe Spree::OrderCancellations do
   describe "#cancel_unit" do
     subject { Spree::OrderCancellations.new(order).cancel_unit(inventory_unit) }
     let(:order) { create(:shipped_order, line_items_count: 1) }
@@ -148,7 +148,7 @@ describe Spree::OrderCancellations do
           source: promotion_action,
           finalized: true,
         )
-        order.update!
+        order.recalculate
       end
 
       it "generates the correct total amount" do

data/spec/models/spree/order_capturing_spec.rb

@@ -1,150 +1,14 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::OrderCapturing do
+RSpec.describe Spree::OrderCapturing do
   describe '#capture_payments' do
-    subject { Spree::OrderCapturing.new(order, payment_methods).capture_payments }
+    subject { Spree::OrderCapturing.new(order).capture_payments }
 
-    # Regression for https://github.com/solidusio/solidus/pull/407
-    # See also https://github.com/solidusio/solidus/pull/1406
-    context "updating the order" do
-      let(:order) { create :completed_order_with_totals }
-      let(:payment_methods) { [] }
-      let!(:payment) { create(:payment, order: order, amount: order.total) }
-      let(:changes_spy) { spy('changes_spy') }
+    let(:order) { build(:completed_order_with_totals) }
 
-      before do
-        payment.pend!
-
-        allow_any_instance_of(Spree::Order).to receive(:thingamajig) do |order|
-          changes_spy.change_callback_occured if order.changes.any?
-        end
-
-        @update_hooks = Spree::Order.update_hooks.dup
-        Spree::Order.register_update_hook :thingamajig
-      end
-
-      after do
-        Spree::Order.update_hooks = @update_hooks
-      end
-
-      it "keeps the order up to date when updating and only changes it once" do
-        subject
-        expect(changes_spy).to have_received(:change_callback_occured).once
-      end
-    end
-
-    context "payment methods specified" do
-      let!(:order) { create(:order, ship_address: create(:address)) }
-
-      let!(:product) { create(:product, price: 10.00) }
-      let!(:variant) do
-        create(:variant, price: 10, product: product, track_inventory: false, tax_category: tax_rate.tax_categories.first)
-      end
-      let!(:shipping_method) { create(:free_shipping_method) }
-      let(:tax_rate) { create(:tax_rate, amount: 0.1, zone: create(:global_zone, name: "Some Tax Zone")) }
-      let(:secondary_total) { 10.0 }
-      let(:bogus_total) { order.total - secondary_total }
-
-      before do
-        order.contents.add(variant, 3)
-        order.update!
-        @secondary_bogus_payment = create(:payment, order: order, amount: secondary_total, payment_method: secondary_payment_method.create!(name: 'So bogus'))
-        @bogus_payment = create(:payment, order: order, amount: bogus_total)
-        order.contents.advance
-        order.complete!
-        order.reload
-      end
-
-      context "payment method ordering" do
-        let(:secondary_payment_method) { SecondaryBogusPaymentMethod }
-
-        class SecondaryBogusPaymentMethod < Spree::PaymentMethod::BogusCreditCard; end
-
-        context "SecondaryBogusPaymentMethod payments are prioritized" do
-          let(:payment_methods) { [SecondaryBogusPaymentMethod, Spree::PaymentMethod::BogusCreditCard] }
-
-          it "captures SecondaryBogusPaymentMethod payments first" do
-            @bogus_payment.update!(amount: bogus_total + 100)
-            subject
-            expect(@secondary_bogus_payment.reload.capture_events.sum(:amount)).to eq(10.0)
-            expect(@bogus_payment.reload.capture_events.sum(:amount)).to eq(order.total - 10.0)
-          end
-        end
-
-        context "Bogus payments are prioritized" do
-          let(:payment_methods) { [Spree::PaymentMethod::BogusCreditCard, SecondaryBogusPaymentMethod] }
-
-          it "captures Bogus payments first" do
-            @secondary_bogus_payment.update!(amount: secondary_total + 100)
-            subject
-            expect(@bogus_payment.reload.capture_events.sum(:amount)).to eq(order.total - 10.0)
-            expect(@secondary_bogus_payment.reload.capture_events.sum(:amount)).to eq(10.0)
-          end
-        end
-
-        context "when the payment method ordering is configured" do
-          subject { Spree::OrderCapturing.new(order, payment_methods).capture_payments }
-
-          let(:payment_methods) { nil }
-
-          before do
-            allow(Spree::OrderCapturing).to receive(:sorted_payment_method_classes).and_return(
-              [SecondaryBogusPaymentMethod, Spree::PaymentMethod::BogusCreditCard]
-            )
-          end
-
-          it "captures in the order specified" do
-            subject
-            expect(@secondary_bogus_payment.reload.capture_events.sum(:amount)).to eq(10.0)
-            expect(@bogus_payment.reload.capture_events.sum(:amount)).to eq(order.total - 10.0)
-          end
-        end
-      end
-
-      context "when a payment is not needed to capture the entire order" do
-        let(:secondary_payment_method) { SecondaryBogusPaymentMethod }
-        let(:payment_methods) { [Spree::PaymentMethod::BogusCreditCard, SecondaryBogusPaymentMethod] }
-
-        before do
-          @bogus_payment.update!(amount: order.total)
-        end
-
-        context "when void_unused_payments is true" do
-          before { allow(Spree::OrderCapturing).to receive(:void_unused_payments).and_return(true) }
-
-          it "captures for the order and voids the unused payment" do
-            subject
-            expect(order.reload.payment_state).to eq 'paid'
-            expect(@secondary_bogus_payment.reload.state).to eq 'void'
-          end
-        end
-
-        context "when void_unused_payments is false" do
-          it "captures for the order and leaves the unused payment in a pending state" do
-            subject
-            expect(order.reload.payment_state).to eq 'paid'
-            expect(@secondary_bogus_payment.reload.state).to eq 'pending'
-          end
-        end
-      end
-
-      context "when there is an error processing a payment" do
-        let(:secondary_payment_method) { ExceptionallyBogusPaymentMethod }
-        let(:bogus_total) { order.total - 1 }
-        let(:secondary_total) { 1 }
-        let(:payment_methods) { [Spree::PaymentMethod::BogusCreditCard, ExceptionallyBogusPaymentMethod] }
-
-        class ExceptionallyBogusPaymentMethod < Spree::PaymentMethod::BogusCreditCard
-          def capture(*_args)
-            raise ActiveMerchant::ConnectionError.new("foo", nil)
-          end
-        end
-
-        it "raises an error and leaves the order in a reasonable state" do
-          expect { subject }.to raise_error(Spree::Core::GatewayError)
-          expect(order.payments.to_a.sum(&:uncaptured_amount)).to eq 1.0
-        end
-      end
+    it 'is deprecated' do
+      expect(Spree::Deprecation).to(receive(:warn))
+      subject
     end
   end
 end