spree_core 3.0.9 → 3.2.0

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

@@ -16,7 +16,6 @@ describe Spree::Order, type: :model do
         order.run_callbacks(:create)
         allow(order).to receive_messages payment_required?: true
         allow(order).to receive_messages process_payments!: true
-        allow(order).to receive :has_available_shipment
       end
 
       context "when payment processing succeeds" do
@@ -119,6 +118,7 @@ describe Spree::Order, type: :model do
       allow(shipments).to receive_messages ready: []
       allow(shipments).to receive_messages pending: []
       allow(shipments).to receive_messages shipped: []
+      allow(shipments).to receive(:sum).with(:cost).and_return(shipment.cost)
 
       allow_any_instance_of(Spree::OrderUpdater).to receive(:update_adjustment_total) { 10 }
     end
@@ -126,7 +126,6 @@ describe Spree::Order, type: :model do
     it "should send a cancel email" do
       # Stub methods that cause side-effects in this test
       allow(shipment).to receive(:cancel!)
-      allow(order).to receive :has_available_shipment
       allow(order).to receive :restock_items!
       mail_message = double "Mail::Message"
       order_id = nil
@@ -144,9 +143,8 @@ describe Spree::Order, type: :model do
         allow(shipment).to receive(:ensure_correct_adjustment)
         allow(shipment).to receive(:update_order)
         allow(Spree::OrderMailer).to receive(:cancel_email).and_return(mail_message = double)
-        allow(mail_message).to receive :deliver
+        allow(mail_message).to receive :deliver_later
 
-        allow(order).to receive :has_available_shipment
       end
     end
 
@@ -158,7 +156,6 @@ describe Spree::Order, type: :model do
         # Stubs methods that cause unwanted side effects in this test
         allow(Spree::OrderMailer).to receive(:cancel_email).and_return(mail_message = double)
         allow(mail_message).to receive :deliver_later
-        allow(order).to receive :has_available_shipment
         allow(order).to receive :restock_items!
         allow(shipment).to receive(:cancel!)
         allow(payment).to receive(:cancel!)
@@ -166,6 +163,7 @@ describe Spree::Order, type: :model do
         allow(order).to receive_message_chain(:payments, :completed).and_return([payment])
         allow(order).to receive_message_chain(:payments, :completed, :includes).and_return([payment])
         allow(order).to receive_message_chain(:payments, :last).and_return(payment)
+        allow(order).to receive_message_chain(:payments, :store_credits, :pending).and_return([])
       end
 
       context "without shipped items" do
@@ -205,12 +203,10 @@ describe Spree::Order, type: :model do
   # Another regression test for #729
   context "#resume" do
     before do
-      allow(order).to receive_messages email: "user@spreecommerce.com"
+      allow(order).to receive_messages email: "user@spreecommerce.org"
       allow(order).to receive_messages state: "canceled"
       allow(order).to receive_messages allow_resume?: true
 
-      # Stubs method that cause unwanted side effects in this test
-      allow(order).to receive :has_available_shipment
     end
   end
 end

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

@@ -0,0 +1,426 @@
+require 'spec_helper'
+
+shared_examples "check total store credit from payments" do
+  context 'with valid payments' do
+    let(:order) { payment.order }
+    let!(:payment) { create(:store_credit_payment) }
+    let!(:second_payment) { create(:store_credit_payment, order: order) }
+
+    subject { 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
+    let(:order) { create(:order) }
+
+    subject { order }
+
+    it 'returns 0' do
+      expect(subject.total_applicable_store_credit).to be_zero
+    end
+  end
+end
+
+describe 'Order' do
+  describe '#add_store_credit_payments' do
+    let(:order_total) { 500.00 }
+
+    before { create(:store_credit_payment_method) }
+
+    subject { order.add_store_credit_payments }
+
+    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 '#covered_by_store_credit' do
+    context "order doesn't have an associated user" do
+      subject { create(:store_credits_order_without_user) }
+
+      it 'returns false' do
+        expect(subject.covered_by_store_credit).to be false
+      end
+    end
+
+    context 'order has an associated user' do
+      let(:user) { create(:user) }
+
+      subject { create(:order, user: user) }
+
+      context 'user has enough store credit to pay for the order' do
+        before do
+          allow(user).to receive(:total_available_store_credit).and_return(10.0)
+          allow(subject).to receive(:total).and_return(5.0)
+        end
+
+        it 'returns true' do
+          expect(subject.covered_by_store_credit).to be true
+        end
+      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 'returns false' do
+          expect(subject.covered_by_store_credit).to be false
+        end
+      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
+      let(:user) { create(:user) }
+      let(:available_store_credit) { 25.0 }
+
+      subject { create(:order, user: user) }
+
+      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
+    end
+  end
+
+  describe '#could_use_store_credit?' do
+    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
+      let(:user) { create(:user) }
+
+      subject { create(:order, user: 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
+    end
+  end
+
+  describe '#order_total_after_store_credit' do
+    let(:order_total) { 100.0 }
+
+    subject { create(:order, total: order_total) }
+
+    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 is in the confirm state' do
+      before { order.update_attributes(state: 'confirm') }
+      include_examples 'check total store credit from payments'
+    end
+
+    context 'order is completed' do
+      before { order.update_attributes(state: 'complete') }
+      include_examples 'check total store credit from payments'
+    end
+
+    context 'order is in any state other than confirm or complete' do
+      context 'the associated user has store credits' do
+        let(:store_credit) { create(:store_credit) }
+        let(:order) { create(:order, user: store_credit.user) }
+
+        subject { order }
+
+        context 'the store credit is more than the order total' do
+          let(:order_total) { store_credit.amount - 1 }
+
+          before { order.update_attributes(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_attributes(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
+        let(:order) { create(:order) }
+
+        subject { 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
+    context 'with valid payments' do
+      let(:order) { payment.order }
+      let!(:payment) { create(:store_credit_payment) }
+      let!(:second_payment) { create(:store_credit_payment, order: order) }
+
+      subject { order }
+
+      it 'returns the sum of the payment amounts' do
+        expect(subject.total_applied_store_credit).to eq (payment.amount + second_payment.amount)
+      end
+    end
+
+    context 'without valid payments' do
+      let(:order) { create(:order) }
+
+      subject { order }
+
+      it 'returns 0' do
+        expect(subject.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
+    let(:total_applicable_store_credit) { 10.00 }
+
+    subject { create(:order) }
+
+    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.money.cents).to eq (total_applicable_store_credit * -100.0)
+    end
+  end
+
+  describe '#display_total_applied_store_credit' do
+    let(:total_applied_store_credit) { 10.00 }
+
+    subject { create(:order) }
+
+    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.money.cents).to eq (total_applied_store_credit * -100.0)
+    end
+  end
+
+  describe '#display_order_total_after_store_credit' do
+    let(:order_total_after_store_credit) { 10.00 }
+
+    subject { create(:order) }
+
+    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.money.cents).to eq (order_total_after_store_credit * 100.0)
+    end
+  end
+
+  describe '#display_total_available_store_credit' do
+    let(:total_available_store_credit) { 10.00 }
+
+    subject { create(:order) }
+
+    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.money.cents).to eq (total_available_store_credit * 100.0)
+    end
+  end
+
+  describe '#display_store_credit_remaining_after_capture' do
+    let(:total_available_store_credit)  { 10.00 }
+    let(:total_applicable_store_credit) { 5.00 }
+
+    subject { create(:order) }
+
+    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.money.cents).to eq (amount_remaining * 100.0)
+    end
+  end
+end

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Order, :type => :model do
+  describe Spree::Order, type: :model do
     let(:order) { stub_model(Spree::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(:order) { Spree::Order.create(ship_address: ship_address, bill_address: bill_address) }
       let(:zone) { create :zone }
 
       context "when no zones exist" do
@@ -16,8 +16,8 @@ module Spree
         end
       end
 
-      context "when :tax_using_ship_address => true" do
-        before { Spree::Config.set(:tax_using_ship_address => true) }
+      context "when tax_using_ship_address: true" do
+        before { Spree::Config.set(tax_using_ship_address: true) }
 
         it "should calculate using ship_address" do
           expect(Spree::Zone).to receive(:match).at_least(:once).with(ship_address)
@@ -26,8 +26,8 @@ module Spree
         end
       end
 
-      context "when :tax_using_ship_address => false" do
-        before { Spree::Config.set(:tax_using_ship_address => false) }
+      context "when tax_using_ship_address: false" do
+        before { Spree::Config.set(tax_using_ship_address: false) }
 
         it "should calculate using bill_address" do
           expect(Spree::Zone).to receive(:match).at_least(:once).with(bill_address)
@@ -38,12 +38,12 @@ module Spree
 
       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
+          @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) }
+          before { allow(Spree::Zone).to receive_messages(match: zone) }
 
           it "should return the matching zone" do
             expect(order.tax_zone).to eq(zone)
@@ -51,7 +51,7 @@ module Spree
         end
 
         context "when there is no matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => nil) }
+          before { allow(Spree::Zone).to receive_messages(match: nil) }
 
           it "should return the default tax zone" do
             expect(order.tax_zone).to eq(@default_zone)
@@ -60,10 +60,10 @@ module Spree
       end
 
       context "when no default tax zone" do
-        before { allow(Spree::Zone).to receive_messages :default_tax => nil }
+        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) }
+          before { allow(Spree::Zone).to receive_messages(match: zone) }
 
           it "should return the matching zone" do
             expect(order.tax_zone).to eq(zone)
@@ -71,7 +71,7 @@ module Spree
         end
 
         context "when there is no matching zone" do
-          before { allow(Spree::Zone).to receive_messages(:match => nil) }
+          before { allow(Spree::Zone).to receive_messages(match: nil) }
 
           it "should return nil" do
             expect(order.tax_zone).to be_nil

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module Spree
-  describe Order, :type => :model do
+  describe Order, type: :model do
     let(:order) { Order.create }
     let(:shirt) { create(:variant) }
 
     context "adds item to cart and activates promo" do
       let(:promotion) { Promotion.create name: 'Huhu' }
-      let(:calculator) { Calculator::FlatPercentItemTotal.new(:preferred_flat_percent => 10) }
+      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
       let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
 
       before { order.contents.add(shirt, 1) }

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

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe Spree::Order, :type => :model do
+describe Spree::Order, type: :model do
   let(:order) { create(:order) }
 
-  context "#update!" do
-    let(:line_items) { [mock_model(Spree::LineItem, :amount => 5) ]}
+  context "#update_with_updater!" do
+    let(:line_items) { [mock_model(Spree::LineItem, amount: 5) ]}
 
     context "when there are update hooks" do
       before { Spree::Order.register_update_hook :foo }
       after { Spree::Order.update_hooks.clear }
       it "should call each of the update hooks" do
         expect(order).to receive :foo
-        order.update!
+        order.update_with_updater!
       end
     end
   end

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::Order, :type => :model do
+  describe Spree::Order, type: :model do
     context "validations" do
       # Regression test for #2214
       it "does not return two error messages when email is blank" do
         order = Spree::Order.new
-        allow(order).to receive_messages(:require_email => true)
+        allow(order).to receive_messages(require_email: true)
         order.valid?
         expect(order.errors[:email]).to eq(["can't be blank"])
       end