spree_core 3.2.9 → 3.3.0.rc1

data/spec/models/spree/order_updater_spec.rb

@@ -0,0 +1,305 @@
+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
+
+    describe "#update_with_updater!" do
+      it "updates item count" do
+        create(:line_item, order: order)
+        create(:line_item, order: order)
+
+        order.update_with_updater!
+
+        expect(order.item_count).to eq(2)
+      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 }
+
+      it "is failed if no valid payments" do
+        allow(order).to receive_message_chain(:payments, :valid, :size).and_return(0)
+
+        updater.update_payment_state
+        expect(order.payment_state).to eq('failed')
+      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 }
+
+      describe "#update" do
+        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 shipments total again after updating shipments" do
+          expect(updater).to receive(:update_shipment_total).ordered
+          expect(updater).to receive(:update_shipments).ordered
+          expect(updater).to receive(:update_shipment_total).ordered
+          updater.update
+        end
+      end
+
+      describe "#update_shipments" do
+        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
+    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/gateway_options_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+RSpec.describe Spree::Payment::GatewayOptions, type: :model do
+  let(:options) { Spree::Payment::GatewayOptions.new(payment) }
+
+  let(:payment) do
+    double(
+      Spree::Payment,
+      order: order,
+      number: "P1566",
+      currency: "EUR",
+      payment_method: payment_method
+    )
+  end
+
+  let(:payment_method) do
+    double(
+      Spree::Gateway::Bogus,
+      exchange_multiplier: Spree::Gateway::FROM_DOLLAR_TO_CENT_RATE
+    )
+  end
+
+  let(:order) do
+    double(
+      Spree::Order,
+      email: "test@email.com",
+      user_id: 144,
+      last_ip_address: "0.0.0.0",
+      number: "R1444",
+      ship_total: "12.44".to_d,
+      additional_tax_total: "1.53".to_d,
+      item_total: "15.11".to_d,
+      promo_total: "2.57".to_d,
+      bill_address: bill_address,
+      ship_address: ship_address
+    )
+  end
+
+  let(:bill_address) do
+    double Spree::Address, active_merchant_hash: { bill: :address }
+  end
+
+  let(:ship_address) do
+    double Spree::Address, active_merchant_hash: { ship: :address }
+  end
+
+  describe "#email" do
+    subject { options.email }
+    it { should == "test@email.com" }
+  end
+
+  describe "#customer" do
+    subject { options.customer }
+    it { should == "test@email.com" }
+  end
+
+  describe "#customer_id" do
+    subject { options.customer_id }
+    it { should == 144 }
+  end
+
+  describe "#ip" do
+    subject { options.ip }
+    it { should == "0.0.0.0" }
+  end
+
+  describe "#order_id" do
+    subject { options.order_id }
+    it { should == "R1444-P1566" }
+  end
+
+  describe "#shipping" do
+    subject { options.shipping }
+    it { should == 1244 }
+  end
+
+  describe "#tax" do
+    subject { options.tax }
+    it { should == 153 }
+  end
+
+  describe "#subtotal" do
+    subject { options.subtotal }
+    it { should == 1511 }
+  end
+
+  describe "#discount" do
+    subject { options.discount }
+    it { should == 257 }
+  end
+
+  describe "#currency" do
+    subject { options.currency }
+    it { should == "EUR" }
+  end
+
+  describe "#billing_address" do
+    subject { options.billing_address }
+    it { should == { bill: :address } }
+  end
+
+  describe "#shipping_address" do
+    subject { options.shipping_address }
+    it { should == { ship: :address } }
+  end
+
+  describe "#to_hash" do
+    subject { options.to_hash }
+    let(:expected) do
+      {
+        email: "test@email.com",
+        customer: "test@email.com",
+        customer_id: 144,
+        ip: "0.0.0.0",
+        order_id: "R1444-P1566",
+        shipping: "1244".to_d,
+        tax: "153".to_d,
+        subtotal: "1511".to_d,
+        discount: "257".to_d,
+        currency: "EUR",
+        billing_address: { bill: :address },
+        shipping_address: { ship: :address }
+      }
+    end
+    it { should == expected }
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'Payment' do
+  context '#cancel!' do
+    subject { payment.cancel! }
+
+    context 'a store credit' do
+      let(:store_credit) { create(:store_credit, amount_used: captured_amount) }
+      let(:auth_code) { '1-SC-20141111111111' }
+      let(:captured_amount) { 10.0 }
+      let(:payment) { create(:store_credit_payment, response_code: auth_code) }
+
+      let!(:capture_event) do
+        create(:store_credit_auth_event,
+               action: Spree::StoreCredit::CAPTURE_ACTION,
+               authorization_code: auth_code,
+               amount: captured_amount,
+               store_credit: store_credit)
+      end
+
+      let(:successful_response) do
+        ActiveMerchant::Billing::Response.new(
+          true,
+          Spree.t('store_credit_payment_method.successful_action', action: :cancel),
+          {},
+          authorization: payment.response_code
+        )
+      end
+
+      let(:failed_response) do
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Spree.t('store_credit_payment_method.unable_to_find_for_action', action: :cancel,
+                                                                           auth_code: payment.response_code),
+          {},
+          {}
+        )
+      end
+
+      it 'attemps to cancels the payment' do
+        expect(payment.payment_method).to receive(:cancel).with(payment.response_code) { successful_response }
+        subject
+      end
+
+      context 'cancels successfully' do
+        it 'voids the payment' do
+          expect { subject }.to change { payment.state }.to('void')
+        end
+      end
+
+      context 'does not cancel successfully' do
+        it 'does not change the payment state' do
+          expect(payment.payment_method).to receive(:cancel).with(payment.response_code) { failed_response }
+          expect { subject }.to raise_error(Spree::Core::GatewayError)
+          expect(payment.reload.state).not_to eq 'void'
+        end
+      end
+    end
+  end
+end