spree_core 3.2.9 → 3.3.0.rc1

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

@@ -0,0 +1,43 @@
+describe Spree::Order, type: :model do
+  let(:order) { create(:order_with_totals) }
+
+  context "ensure shipments will be updated" do
+    before { Spree::Shipment.create!(order: order, stock_location: create(:stock_location)) }
+
+    it "destroys current shipments" do
+      order.ensure_updated_shipments
+      expect(order.shipments).to be_empty
+    end
+
+    it "puts order back in address state" do
+      order.ensure_updated_shipments
+      expect(order.state).to eq 'address'
+    end
+
+    it "resets shipment_total" do
+      order.update_column(:shipment_total, 5)
+      order.ensure_updated_shipments
+      expect(order.shipment_total).to eq(0)
+    end
+
+    context "except when order is completed, that's OrderInventory job" do
+      it "doesn't touch anything" do
+        allow(order).to receive_messages completed?: true
+        order.update_column(:shipment_total, 5)
+        order.shipments.create!(stock_location: create(:stock_location))
+
+        expect {
+          order.ensure_updated_shipments
+        }.not_to change { order.shipment_total }
+
+        expect {
+          order.ensure_updated_shipments
+        }.not_to change { order.shipments }
+
+        expect {
+          order.ensure_updated_shipments
+        }.not_to change { order.state }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe Spree::Order, type: :model do
+  let(:order) { Spree::Order.new }
+  before do
+    # Ensure state machine has been re-defined correctly
+    Spree::Order.define_state_machine!
+    # We don't care about this validation here
+    allow(order).to receive(:require_email)
+  end
+
+  context "#next!" do
+    context "when current state is confirm" do
+      before do
+        order.state = "confirm"
+        order.run_callbacks(:create)
+        allow(order).to receive_messages payment_required?: true
+        allow(order).to receive_messages process_payments!: true
+      end
+
+      context "when payment processing succeeds" do
+        before do
+          order.payments << FactoryGirl.create(:payment, state: 'checkout', order: order)
+          allow(order).to receive_messages process_payments: true
+        end
+
+        it "should finalize order when transitioning to complete state" do
+          expect(order).to receive(:finalize!)
+          order.next!
+        end
+
+        context "when credit card processing fails" do
+          before { allow(order).to receive_messages process_payments!: false }
+
+          it "should not complete the order" do
+            order.next
+            expect(order.state).to eq("confirm")
+          end
+        end
+      end
+
+      context "when payment processing fails" do
+        before { allow(order).to receive_messages process_payments!: false }
+
+        it "cannot transition to complete" do
+          order.next
+          expect(order.state).to eq("confirm")
+        end
+      end
+    end
+
+    context "when current state is delivery" do
+      before do
+        allow(order).to receive_messages payment_required?: true
+        allow(order).to receive :apply_free_shipping_promotions
+        order.state = "delivery"
+      end
+
+      it "adjusts tax rates when transitioning to delivery" do
+        # Once for the line items
+        expect(Spree::TaxRate).to receive(:adjust).once
+        allow(order).to receive :set_shipments_cost
+        order.next!
+      end
+
+      it "adjusts tax rates twice if there are any shipments" do
+        # Once for the line items, once for the shipments
+        order.shipments.build stock_location: create(:stock_location)
+        expect(Spree::TaxRate).to receive(:adjust).twice
+        allow(order).to receive :set_shipments_cost
+        order.next!
+      end
+    end
+  end
+
+  context "#can_cancel?" do
+    %w(pending backorder ready).each do |shipment_state|
+      it "should be true if shipment_state is #{shipment_state}" do
+        allow(order).to receive_messages completed?: true
+        order.shipment_state = shipment_state
+        expect(order.can_cancel?).to be true
+      end
+    end
+
+    (Spree::Shipment.state_machine.states.keys - [:pending, :backorder, :ready]).each do |shipment_state|
+      it "should be false if shipment_state is #{shipment_state}" do
+        allow(order).to receive_messages completed?: true
+        order.shipment_state = shipment_state
+        expect(order.can_cancel?).to be false
+      end
+    end
+  end
+
+  context "#cancel" do
+    let!(:variant) { stub_model(Spree::Variant) }
+    let!(:inventory_units) { [stub_model(Spree::InventoryUnit, variant: variant),
+                              stub_model(Spree::InventoryUnit, variant: variant)] }
+    let!(:shipment) do
+      shipment = stub_model(Spree::Shipment)
+      allow(shipment).to receive_messages inventory_units: inventory_units, order: order
+      allow(order).to receive_messages shipments: [shipment]
+      shipment
+    end
+
+    before do
+      2.times do
+        create(:line_item, order: order, price: 10)
+      end
+
+      allow(order.line_items).to receive_messages find_by_variant_id: order.line_items.first
+
+      allow(order).to receive_messages completed?: true
+      allow(order).to receive_messages allow_cancel?: true
+
+      shipments = [shipment]
+      allow(order).to receive_messages shipments: shipments
+      allow(shipments).to receive_messages states: []
+      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
+
+    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 :restock_items!
+      mail_message = double "Mail::Message"
+      order_id = nil
+      expect(Spree::OrderMailer).to receive(:cancel_email) { |*args|
+        order_id = args[0]
+        mail_message
+      }
+      expect(mail_message).to receive :deliver_later
+      order.cancel!
+      expect(order_id).to eq(order.id)
+    end
+
+    context "restocking inventory" do
+      before 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_later
+
+      end
+    end
+
+    context "resets payment state" do
+      let(:payment) { create(:payment, amount: order.total) }
+
+      before do
+        # TODO: This is ugly :(
+        # 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 :restock_items!
+        allow(shipment).to receive(:cancel!)
+        allow(payment).to receive(:cancel!)
+        allow(order).to receive_message_chain(:payments, :valid, :size).and_return(1)
+        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
+        it "should set payment state to 'void'" do
+          expect { order.cancel! }.to change{ order.reload.payment_state }.to("void")
+        end
+      end
+
+      context "with shipped items" do
+        before do
+          allow(order).to receive_messages shipment_state: 'partial'
+          allow(order).to receive_messages outstanding_balance?: false
+          allow(order).to receive_messages payment_state: "paid"
+        end
+
+        it "should not alter the payment state" do
+          order.cancel!
+          expect(order.payment_state).to eql "paid"
+        end
+      end
+
+      context "with payments" do
+        let(:payment) { create(:payment) }
+
+        it "should automatically refund all payments" do
+          allow(order).to receive_message_chain(:payments, :valid, :size).and_return(1)
+          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)
+          expect(payment).to receive(:cancel!)
+          order.cancel!
+        end
+      end
+    end
+  end
+
+  # Another regression test for #729
+  context "#resume" do
+    before do
+      allow(order).to receive_messages email: "user@spreecommerce.org"
+      allow(order).to receive_messages state: "canceled"
+      allow(order).to receive_messages allow_resume?: true
+
+    end
+  end
+end

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

@@ -0,0 +1,457 @@
+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 '#remove_store_credit_payments' do
+    let(:order_total) { 500.00 }
+    let(:order) { create(:order, user: store_credit.user, total: order_total) }
+
+    subject { order.remove_store_credit_payments }
+
+    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 { 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