solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/order_stock_location_spec.rb

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

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

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