spree_core 3.3.0.rc1 → 3.3.0.rc2

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

@@ -1,43 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,457 +0,0 @@
-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