solidus_core 1.0.2 → 1.0.3

data/spec/models/spree/order_stock_location_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderStockLocation do
+    describe ".fulfill_for_order_with_stock_location" do
+      subject { OrderStockLocation.fulfill_for_order_with_stock_location(order, stock_location) }
+
+      let(:order) { create(:order) }
+      let(:stock_location) { create(:stock_location) }
+      let!(:order_stock_location) { Spree::OrderStockLocation.create!(order: order, stock_location: stock_location) }
+
+      it "fulfills the shipment for the order and stock location combination" do
+        subject
+        expect(order_stock_location.reload.shipment_fulfilled).to eq(true)
+      end
+    end 
+  end
+end

data/spec/models/spree/order_updater_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderUpdater, type: :model do
+    let(:order) { Spree::Order.create }
+    let(:updater) { Spree::OrderUpdater.new(order) }
+
+    context "order totals" do
+      before do
+        2.times do
+          create(:line_item, order: order, price: 10)
+        end
+      end
+
+      it "updates payment totals" do
+        create(:payment_with_refund, order: order)
+        Spree::OrderUpdater.new(order).update_payment_total
+        expect(order.payment_total).to eq(40.75)
+      end
+
+      it "update item total" do
+        updater.update_item_total
+        expect(order.item_total).to eq(20)
+      end
+
+      it "update shipment total" do
+        create(:shipment, order: order, cost: 10)
+        updater.update_shipment_total
+        expect(order.shipment_total).to eq(10)
+      end
+
+      context 'with order promotion followed by line item addition' do
+        let(:promotion) { Spree::Promotion.create!(name: "10% off") }
+        let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
+
+        let(:promotion_action) do
+          Promotion::Actions::CreateAdjustment.create!({
+            calculator: calculator,
+            promotion: promotion,
+          })
+        end
+
+        before do
+          updater.update
+          create(:adjustment, source: promotion_action, adjustable: order, order: order)
+          create(:line_item, :order => order, price: 10) # in addition to the two already created
+          updater.update
+        end
+
+        it "updates promotion total" do
+          expect(order.promo_total).to eq(-3)
+        end
+      end
+
+      it "update order adjustments" do
+        # A line item will not have both additional and included tax,
+        # so please just humour me for now.
+        order.line_items.first.update_columns({
+          adjustment_total: 10.05,
+          additional_tax_total: 0.05,
+          included_tax_total: 0.05,
+        })
+        updater.update_adjustment_total
+        expect(order.adjustment_total).to eq(10.05)
+        expect(order.additional_tax_total).to eq(0.05)
+        expect(order.included_tax_total).to eq(0.05)
+      end
+    end
+
+    context "updating shipment state" do
+      before do
+        allow(order).to receive_messages backordered?: false
+        allow(order).to receive_message_chain(:shipments, :shipped, :count).and_return(0)
+        allow(order).to receive_message_chain(:shipments, :ready, :count).and_return(0)
+        allow(order).to receive_message_chain(:shipments, :pending, :count).and_return(0)
+      end
+
+      it "is backordered" do
+        allow(order).to receive_messages backordered?: true
+        updater.update_shipment_state
+
+        expect(order.shipment_state).to eq('backorder')
+      end
+
+      it "is nil" do
+        allow(order).to receive_message_chain(:shipments, :states).and_return([])
+        allow(order).to receive_message_chain(:shipments, :count).and_return(0)
+
+        updater.update_shipment_state
+        expect(order.shipment_state).to be_nil
+      end
+
+
+      ["shipped", "ready", "pending"].each do |state|
+        it "is #{state}" do
+          allow(order).to receive_message_chain(:shipments, :states).and_return([state])
+          updater.update_shipment_state
+          expect(order.shipment_state).to eq(state.to_s)
+        end
+      end
+
+      it "is partial" do
+        allow(order).to receive_message_chain(:shipments, :states).and_return(["pending", "ready"])
+        updater.update_shipment_state
+        expect(order.shipment_state).to eq('partial')
+      end
+    end
+
+    context "updating payment state" do
+      let(:order) { Order.new }
+      let(:updater) { order.updater }
+
+      context 'no valid payments with non-zero order total' do
+        it "is failed" do
+          allow(order).to receive_message_chain(:payments, :valid, :size).and_return(0)
+          order.total = 1
+          order.payment_total = 0
+
+          updater.update_payment_state
+          expect(order.payment_state).to eq('failed')
+        end
+      end
+
+      context 'invalid payments are present but order total is zero' do
+        it 'is paid' do
+          order.payments << Spree::Payment.new(state: 'invalid')
+          order.total = 0
+          order.payment_total = 0
+
+          expect {
+            updater.update_payment_state
+          }.to change { order.payment_state }.to 'paid'
+        end
+      end
+
+      context "payment total is greater than order total" do
+        it "is credit_owed" do
+          order.payment_total = 2
+          order.total = 1
+
+          expect {
+            updater.update_payment_state
+          }.to change { order.payment_state }.to 'credit_owed'
+        end
+      end
+
+      context "order total is greater than payment total" do
+        it "is balance_due" do
+          order.payment_total = 1
+          order.total = 2
+
+          expect {
+            updater.update_payment_state
+          }.to change { order.payment_state }.to 'balance_due'
+        end
+      end
+
+      context "order total equals payment total" do
+        it "is paid" do
+          order.payment_total = 30
+          order.total = 30
+
+          expect {
+            updater.update_payment_state
+          }.to change { order.payment_state }.to 'paid'
+        end
+      end
+
+      context "order is canceled" do
+
+        before do
+          order.state = 'canceled'
+        end
+
+        context "and is still unpaid" do
+          it "is void" do
+            order.payment_total = 0
+            order.total = 30
+            expect {
+              updater.update_payment_state
+            }.to change { order.payment_state }.to 'void'
+          end
+        end
+
+        context "and is paid" do
+
+          it "is credit_owed" do
+            order.payment_total = 30
+            order.total = 30
+            allow(order).to receive_message_chain(:payments, :valid, :size).and_return(1)
+            allow(order).to receive_message_chain(:payments, :completed, :size).and_return(1)
+            expect {
+              updater.update_payment_state
+            }.to change { order.payment_state }.to 'credit_owed'
+          end
+
+        end
+
+        context "and payment is refunded" do
+          it "is void" do
+            order.payment_total = 0
+            order.total = 30
+            expect {
+              updater.update_payment_state
+            }.to change { order.payment_state }.to 'void'
+          end
+        end
+      end
+
+    end
+
+    it "state change" do
+      order.shipment_state = 'shipped'
+      state_changes = double
+      allow(order).to receive_messages state_changes: state_changes
+      expect(state_changes).to receive(:create).with(
+        previous_state: nil,
+        next_state: 'shipped',
+        name: 'shipment',
+        user_id: nil
+      )
+
+      order.state_changed('shipment')
+    end
+
+    context "completed order" do
+      before { allow(order).to receive_messages completed?: true }
+
+      it "updates payment state" do
+        expect(updater).to receive(:update_payment_state)
+        updater.update
+      end
+
+      it "updates shipment state" do
+        expect(updater).to receive(:update_shipment_state)
+        updater.update
+      end
+
+      it "updates each shipment" do
+        shipment = stub_model(Spree::Shipment, order: order)
+        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: []
+
+        expect(shipment).to receive(:update!).with(order)
+        updater.update_shipments
+      end
+
+      it "refreshes shipment rates" do
+        shipment = stub_model(Spree::Shipment, order: order)
+        shipments = [shipment]
+        allow(order).to receive_messages shipments: shipments
+
+        expect(shipment).to receive(:refresh_rates)
+        updater.update_shipments
+      end
+
+      it "updates the shipment amount" do
+        shipment = stub_model(Spree::Shipment, order: order)
+        shipments = [shipment]
+        allow(order).to receive_messages shipments: shipments
+
+        expect(shipment).to receive(:update_amounts)
+        updater.update_shipments
+      end
+    end
+
+    context "incompleted order" do
+      before { allow(order).to receive_messages completed?: false }
+
+      it "doesnt update payment state" do
+        expect(updater).not_to receive(:update_payment_state)
+        updater.update
+      end
+
+      it "doesnt update shipment state" do
+        expect(updater).not_to receive(:update_shipment_state)
+        updater.update
+      end
+
+      it "doesnt update each shipment" do
+        shipment = stub_model(Spree::Shipment)
+        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(updater).to receive(:update_totals) # Otherwise this gets called and causes a scene
+        expect(updater).not_to receive(:update_shipments).with(order)
+        updater.update
+      end
+    end
+  end
+end

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

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe Spree::PaymentMethod::StoreCredit do
+  let(:order)           { create(:order) }
+  let(:payment)         { create(:payment, order: order) }
+  let(:gateway_options) { payment.gateway_options }
+
+  context "#authorize" do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.authorize(auth_amount, store_credit, gateway_options)
+    end
+
+    let(:auth_amount) { store_credit.amount_remaining * 100 }
+    let(:store_credit) { create(:store_credit) }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:originator) { nil }
+
+    context 'without an invalid store credit' do
+      let(:store_credit) { nil }
+      let(:auth_amount) { 10 }
+
+      it "declines an unknown store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.unable_to_find')
+      end
+    end
+
+    context 'with insuffient funds' do
+      let(:auth_amount) { (store_credit.amount_remaining * 100) + 1 }
+
+      it "declines a store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.insufficient_funds')
+      end
+    end
+
+    context 'when the currency does not match the order currency' do
+      let(:store_credit) { create(:store_credit, currency: 'AUD') }
+
+      it "declines the credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.currency_mismatch')
+      end
+    end
+
+    context 'with a valid request' do
+      it "authorizes a valid store credit" do
+        expect(subject.success?).to be true
+        expect(subject.authorization).not_to be_nil
+      end
+
+      context 'with an originator' do
+        let(:originator) { double('originator') }
+
+        it 'passes the originator' do
+          expect_any_instance_of(Spree::StoreCredit).to receive(:authorize)
+            .with(anything, anything, action_originator: originator)
+          subject
+        end
+      end
+    end
+  end
+
+  context "#capture" do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.capture(capture_amount, auth_code, gateway_options)
+    end
+
+    let(:capture_amount) { 10_00 }
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+
+    let(:authorized_amount) { capture_amount/100.0 }
+    let(:auth_event) { create(:store_credit_auth_event, store_credit: store_credit, amount: authorized_amount) }
+    let(:store_credit) { create(:store_credit, amount_authorized: authorized_amount) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { -1 }
+
+      it "declines an unknown store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.unable_to_find')
+      end
+    end
+
+    context 'when unable to authorize the amount' do
+      let(:authorized_amount) { (capture_amount-1)/100 }
+
+      before do
+        allow_any_instance_of(Spree::StoreCredit).to receive_messages(authorize: true)
+      end
+
+      it "declines a store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.insufficient_authorized_amount')
+      end
+    end
+
+    context 'when the currency does not match the order currency' do
+      let(:store_credit) { create(:store_credit, currency: 'AUD', amount_authorized: authorized_amount) }
+
+      it "declines the credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.currency_mismatch')
+      end
+    end
+
+    context 'with a valid request' do
+      it "captures the store credit" do
+        expect(subject.message).to include Spree.t('store_credit.successful_action', action: Spree::StoreCredit::CAPTURE_ACTION)
+        expect(subject.success?).to be true
+      end
+
+      context 'with an originator' do
+        let(:originator) { double('originator') }
+
+        it 'passes the originator' do
+          expect_any_instance_of(Spree::StoreCredit).to receive(:capture)
+            .with(anything, anything, anything, action_originator: originator)
+          subject
+        end
+      end
+    end
+  end
+
+  context "#void" do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.void(auth_code, gateway_options)
+    end
+
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:auth_event) { create(:store_credit_auth_event) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { 1 }
+
+      it "declines an unknown store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.unable_to_find')
+      end
+    end
+
+    context 'when the store credit is not voided successfully' do
+      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(void: false) }
+
+      it "returns an error response" do
+        expect(subject.success?).to be false
+      end
+    end
+
+    it "voids a valid store credit void request" do
+      expect(subject.success?).to be true
+      expect(subject.message).to include Spree.t('store_credit.successful_action', action: Spree::StoreCredit::VOID_ACTION)
+    end
+
+    context 'with an originator' do
+      let(:originator) { double('originator') }
+
+      it 'passes the originator' do
+        expect_any_instance_of(Spree::StoreCredit).to receive(:void)
+          .with(anything, action_originator: originator)
+        subject
+      end
+    end
+  end
+
+  context "#purchase" do
+    it "declines a purchase if it can't find a pending credit for the correct amount" do
+      amount = 100.0
+      store_credit = create(:store_credit)
+      auth_code = store_credit.generate_authorization_code
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
+                                               amount: amount,
+                                               authorization_code: auth_code)
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::CAPTURE_ACTION,
+                                               amount: amount,
+                                               authorization_code: auth_code)
+
+      resp = subject.purchase(amount * 100.0, store_credit, gateway_options)
+      expect(resp.success?).to be false
+      expect(resp.message).to include Spree.t('store_credit.unable_to_find')
+    end
+
+    it "captures a purchase if it can find a pending credit for the correct amount" do
+      amount = 100.0
+      store_credit = create(:store_credit)
+      auth_code = store_credit.generate_authorization_code
+      store_credit.store_credit_events.create!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
+                                               amount: amount,
+                                               authorization_code: auth_code)
+
+      resp = subject.purchase(amount * 100.0, store_credit, gateway_options)
+      expect(resp.success?).to be true
+      expect(resp.message).to include Spree.t('store_credit.successful_action', action: Spree::StoreCredit::CAPTURE_ACTION)
+    end
+  end
+
+  context "#credit" do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.credit(credit_amount, auth_code, gateway_options)
+    end
+
+    let(:credit_amount) { 100.0 }
+    let(:auth_code) { auth_event.authorization_code }
+    let(:gateway_options) { super().merge(originator: originator) }
+    let(:auth_event) { create(:store_credit_auth_event) }
+    let(:originator) { nil }
+
+    context 'with an invalid auth code' do
+      let(:auth_code) { 1 }
+
+      it "declines an unknown store credit" do
+        expect(subject.success?).to be false
+        expect(subject.message).to include Spree.t('store_credit.unable_to_find')
+      end
+    end
+
+    context "when the store credit isn't credited successfully" do
+      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(credit: false) }
+
+      it "returns an error response" do
+        expect(subject.success?).to be false
+      end
+    end
+
+    context 'with a valid credit request' do
+      before { allow_any_instance_of(Spree::StoreCredit).to receive_messages(credit: true) }
+
+      it "credits a valid store credit credit request" do
+        expect(subject.success?).to be true
+        expect(subject.message).to include Spree.t('store_credit.successful_action', action: Spree::StoreCredit::CREDIT_ACTION)
+      end
+    end
+
+    context 'with an originator' do
+      let(:originator) { double('originator') }
+
+      it 'passes the originator' do
+        expect_any_instance_of(Spree::StoreCredit).to receive(:credit)
+          .with(anything, anything, anything, action_originator: originator)
+        subject
+      end
+    end
+  end
+
+  context "#cancel" do
+    subject do
+      Spree::PaymentMethod::StoreCredit.new.cancel(auth_code)
+    end
+
+    let(:store_credit) { create(:store_credit, amount_used: captured_amount) }
+    let(:auth_code)    { "1-SC-20141111111111" }
+    let(:captured_amount) { 10.0 }
+
+    context "capture event found" do
+      let!(:store_credit_event) { create(:store_credit_capture_event,
+                                        authorization_code: auth_code,
+                                        amount: captured_amount,
+                                        store_credit: store_credit) }
+
+      it "creates a store credit for the same amount that was captured" do
+        expect_any_instance_of(Spree::StoreCredit).to receive(:credit).with(captured_amount, auth_code, store_credit.currency)
+        subject
+      end
+    end
+
+    context "capture event not found" do
+      context "auth event found" do
+        let!(:store_credit_event) { create(:store_credit_auth_event,
+                                          authorization_code: auth_code,
+                                          amount: captured_amount,
+                                          store_credit: store_credit) }
+
+        it "creates a store credit for the same amount that was captured" do
+          expect_any_instance_of(Spree::StoreCredit).to receive(:void).with(auth_code)
+          subject
+        end
+      end
+
+      context "store credit event not found" do
+        subject do
+          Spree::PaymentMethod::StoreCredit.new.cancel('INVALID')
+        end
+
+        it "returns false" do
+          expect(subject).to be false
+        end
+      end
+    end
+  end
+end