solidus_core 1.1.0 → 1.1.1

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Spree::Order, :type => :model do
+  context 'CurrencyUpdater' do
+    context "when changing order currency" do
+      let!(:line_item) { create(:line_item) }
+      let!(:euro_price) { create(:price, variant: line_item.variant, amount: 8, currency: 'EUR') }
+
+      context "#homogenize_line_item_currencies" do
+        it "succeeds without error" do
+          expect { line_item.order.update_attributes!(currency: 'EUR') }.to_not raise_error
+        end
+
+        it "changes the line_item currencies" do
+          expect { line_item.order.update_attributes!(currency: 'EUR') }.to change{ line_item.reload.currency }.from('USD').to('EUR')
+        end
+
+        it "changes the line_item amounts" do
+          expect { line_item.order.update_attributes!(currency: 'EUR') }.to change{ line_item.reload.amount }.to(8)
+        end
+
+        it "fails to change the order currency when no prices are available in that currency" do
+          expect { line_item.order.update_attributes!(currency: 'GBP') }.to raise_error RuntimeError
+        end
+
+        it "calculates the item total in the order.currency" do
+          expect { line_item.order.update_attributes!(currency: 'EUR') }.to change{ line_item.order.item_total }.to(8)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Spree::Order, :type => :model do
+  let(:order) { stub_model("Spree::Order") }
+
+  context "#finalize!" do
+    let(:order) { Spree::Order.create(email: 'test@example.com', store: store) }
+    let(:store) { FactoryGirl.build(:store) }
+
+    before do
+      order.update_column :state, 'complete'
+    end
+
+    it "should set completed_at" do
+      expect(order).to receive(:touch).with(:completed_at)
+      order.finalize!
+    end
+
+    it "should sell inventory units" do
+      order.shipments.each do |shipment|
+        expect(shipment).to receive(:update!)
+        expect(shipment).to receive(:finalize!)
+      end
+      order.finalize!
+    end
+
+    it "should decrease the stock for each variant in the shipment" do
+      order.shipments.each do |shipment|
+        expect(shipment.stock_location).to receive(:decrease_stock_for_variant)
+      end
+      order.finalize!
+    end
+
+    it "should change the shipment state to ready if order is paid" do
+      Spree::Shipment.create(order: order)
+      order.shipments.reload
+
+      allow(order).to receive_messages(:paid? => true, :complete? => true)
+      order.finalize!
+      order.reload # reload so we're sure the changes are persisted
+      expect(order.shipment_state).to eq('ready')
+    end
+
+    after { Spree::Config.set :track_inventory_levels => true }
+    it "should not sell inventory units if track_inventory_levels is false" do
+      Spree::Config.set :track_inventory_levels => false
+      expect(Spree::InventoryUnit).not_to receive(:sell_units)
+      order.finalize!
+    end
+
+    it "should send an order confirmation email" do
+      mail_message = double "Mail::Message"
+      expect(Spree::OrderMailer).to receive(:confirm_email).with(order).and_return mail_message
+      expect(mail_message).to receive :deliver_later
+      order.finalize!
+    end
+
+    it "sets confirmation delivered when finalizing" do
+      expect(order.confirmation_delivered?).to be false
+      order.finalize!
+      expect(order.confirmation_delivered?).to be true
+    end
+
+    it "should not send duplicate confirmation emails" do
+      allow(order).to receive_messages(:confirmation_delivered? => true)
+      expect(Spree::OrderMailer).not_to receive(:confirm_email)
+      order.finalize!
+    end
+
+    it "should freeze all adjustments" do
+      # Stub this method as it's called due to a callback
+      # and it's irrelevant to this test
+      allow(Spree::OrderMailer).to receive_message_chain :confirm_email, :deliver_later
+      adjustments = [double]
+      expect(order).to receive(:all_adjustments).and_return(adjustments)
+      adjustments.each do |adj|
+        expect(adj).to receive(:finalize!)
+      end
+      order.finalize!
+    end
+
+    context "order is considered risky" do
+      before do
+        allow(order).to receive_messages :is_risky? => true
+      end
+
+      context "and order is approved" do
+        before do
+          allow(order).to receive_messages :approved? => true
+        end
+
+        it "should leave order in complete state" do
+          order.finalize!
+          expect(order.state).to eq 'complete'
+        end
+      end
+    end
+
+    context "order is not considered risky" do
+      before do
+        allow(order).to receive_messages :is_risky? => false
+      end
+
+      it "should set completed_at" do
+        order.finalize!
+        expect(order.completed_at).to be_present
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+module Spree
+  describe Spree::Order, :type => :model do
+    let(:order) { stub_model(Spree::Order) }
+    let(:updater) { Spree::OrderUpdater.new(order) }
+
+    context "processing payments" do
+      before do
+        # So that Payment#purchase! is called during processing
+        Spree::Config[:auto_capture] = true
+
+        allow(order).to receive_message_chain(:line_items, :empty?).and_return(false)
+        allow(order).to receive_messages :total => 100
+      end
+
+      it 'processes all checkout payments' do
+        payment_1 = create(:payment, :amount => 50)
+        payment_2 = create(:payment, :amount => 50)
+        allow(order).to receive(:unprocessed_payments).and_return([payment_1, payment_2])
+
+        order.process_payments!
+        updater.update_payment_state
+        expect(order.payment_state).to eq('paid')
+
+        expect(payment_1).to be_completed
+        expect(payment_2).to be_completed
+      end
+
+      it 'does not go over total for order' do
+        payment_1 = create(:payment, :amount => 50)
+        payment_2 = create(:payment, :amount => 50)
+        payment_3 = create(:payment, :amount => 50)
+        allow(order).to receive(:unprocessed_payments).and_return([payment_1, payment_2, payment_3])
+
+        order.process_payments!
+        updater.update_payment_state
+        expect(order.payment_state).to eq('paid')
+
+        expect(payment_1).to be_completed
+        expect(payment_2).to be_completed
+        expect(payment_3).to be_checkout
+      end
+
+      it "does not use failed payments" do
+        payment_1 = create(:payment, :amount => 50)
+        payment_2 = create(:payment, :amount => 50, :state => 'failed')
+        allow(order).to receive(:pending_payments).and_return([payment_1])
+
+        expect(payment_2).not_to receive(:process!)
+
+        order.process_payments!
+      end
+    end
+
+    context "with no payments" do
+      it "should return falsy" do
+        expect(order).to receive_messages total: 100
+        expect(order.process_payments!).to be_falsy
+      end
+    end
+
+    context "with payments completed" do
+      it "should not fail transitioning to complete when paid" do
+        expect(order).to receive_messages total: 100, payment_total: 100
+        expect(order.process_payments!).to be_truthy
+      end
+    end
+
+    context "ensure source attributes stick around" do
+      # For the reason of this test, please see spree/spree_gateway#132
+      it "does not have inverse_of defined" do
+        expect(Spree::Order.reflections['payments'].options[:inverse_of]).to be_nil
+      end
+
+      it "keeps source attributes after updating" do
+        persisted_order = Spree::Order.create
+        credit_card_payment_method = create(:credit_card_payment_method)
+        attributes = {
+          :payments_attributes => [
+            {
+              :payment_method_id => credit_card_payment_method.id,
+              :source_attributes => {
+                :name => "Ryan Bigg",
+                :number => "41111111111111111111",
+                :expiry => "01 / 15",
+                :verification_value => "123"
+              }
+            }
+          ]
+        }
+
+        persisted_order.update_attributes(attributes)
+        expect(persisted_order.unprocessed_payments.last.source.number).to be_present
+      end
+    end
+
+    context "checking if order is paid" do
+      context "payment_state is paid" do
+        before { allow(order).to receive_messages payment_state: 'paid' }
+        it { expect(order).to be_paid }
+      end
+
+      context "payment_state is credit_owned" do
+        before { allow(order).to receive_messages payment_state: 'credit_owed' }
+        it { expect(order).to be_paid }
+      end
+    end
+
+    context "#process_payments!" do
+      let(:payment) { stub_model(Spree::Payment) }
+      before { allow(order).to receive_messages unprocessed_payments: [payment], total: 10 }
+
+      it "should process the payments" do
+        expect(payment).to receive(:process!)
+        expect(order.process_payments!).to be_truthy
+      end
+
+      # Regression spec for https://github.com/spree/spree/issues/5436
+      it 'should raise an error if there are no payments to process' do
+        allow(order).to receive_messages unprocessed_payments: []
+        expect(payment).to_not receive(:process!)
+        expect(order.process_payments!).to be_falsey
+      end
+
+      context "when a payment raises a GatewayError" do
+        before { expect(payment).to receive(:process!).and_raise(Spree::Core::GatewayError) }
+
+        it "should return true when configured to allow checkout on gateway failures" do
+          Spree::Config.set :allow_checkout_on_gateway_error => true
+          expect(order.process_payments!).to be true
+        end
+
+        it "should return false when not configured to allow checkout on gateway failures" do
+          Spree::Config.set :allow_checkout_on_gateway_error => false
+          expect(order.process_payments!).to be false
+        end
+      end
+    end
+
+    context "#authorize_payments!" do
+      let(:payment) { stub_model(Spree::Payment) }
+      before { allow(order).to receive_messages :unprocessed_payments => [payment], :total => 10 }
+      subject { order.authorize_payments! }
+
+      it "processes payments with attempt_authorization!" do
+        expect(payment).to receive(:authorize!)
+        subject
+      end
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "#capture_payments!" do
+      let(:payment) { stub_model(Spree::Payment) }
+      before { allow(order).to receive_messages :unprocessed_payments => [payment], :total => 10 }
+      subject { order.capture_payments! }
+
+      it "processes payments with attempt_authorization!" do
+        expect(payment).to receive(:purchase!)
+        subject
+      end
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "#outstanding_balance" do
+      it "should return positive amount when payment_total is less than total" do
+        order.payment_total = 20.20
+        order.total = 30.30
+        expect(order.outstanding_balance).to eq(10.10)
+      end
+      it "should return negative amount when payment_total is greater than total" do
+        order.total = 8.20
+        order.payment_total = 10.20
+        expect(order.outstanding_balance).to be_within(0.001).of(-2.00)
+      end
+
+      context "with reimburesements on the order" do
+        let(:amount) { 10.0 }
+        let(:reimbursement) { create(:reimbursement) }
+        let(:order) { reimbursement.order.reload }
+
+        before do
+          # Set the payment amount to actually be the order total of 110
+          reimbursement.order.payments.first.update_column :amount, amount
+          # Creates a refund of 110
+          create :refund, amount: amount,
+                          payment: reimbursement.order.payments.first,
+                          reimbursement: reimbursement
+          # Update the order totals so payment_total goes to 0 reflecting the refund..
+          order.update!
+        end
+
+        context "for canceled orders" do
+          before { order.update_attributes(state: 'canceled') }
+
+          it "it should be a negative amount incorporating reimbursements" do
+            expect(order.outstanding_balance).to eq -10
+          end
+        end
+
+        context "for non-canceled orders" do
+          it 'should incorporate refund reimbursements' do
+            # Order Total - (Payment Total + Reimbursed)
+            # 110 - (0 + 10) = 100
+            expect(order.outstanding_balance).to eq 100
+          end
+        end
+      end
+    end
+
+    context "#outstanding_balance?" do
+      it "should be true when total greater than payment_total" do
+        order.total = 10.10
+        order.payment_total = 9.50
+        expect(order.outstanding_balance?).to be true
+      end
+      it "should be true when total less than payment_total" do
+        order.total = 8.25
+        order.payment_total = 10.44
+        expect(order.outstanding_balance?).to be true
+      end
+      it "should be false when total equals payment_total" do
+        order.total = 10.10
+        order.payment_total = 10.10
+        expect(order.outstanding_balance?).to be false
+      end
+    end
+
+    context "payment required?" do
+      context "total is zero" do
+        before { allow(order).to receive_messages(total: 0) }
+        it { expect(order.payment_required?).to be false }
+      end
+
+      context "total > zero" do
+        before { allow(order).to receive_messages(total: 1) }
+        it { expect(order.payment_required?).to be true }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Spree::Order, :type => :model do
+  let(:order) { stub_model('Spree::Order') }
+
+  describe ".is_risky?" do
+    context "Not risky order" do
+      let(:order) { FactoryGirl.create(:order, payments: [payment]) }
+      context "with avs_response == D" do
+        let(:payment) { FactoryGirl.create(:payment, avs_response: "D") }
+        it "is not considered risky" do
+          expect(order.is_risky?).to eq(false)
+        end
+      end
+
+      context "with avs_response == M" do
+        let(:payment) { FactoryGirl.create(:payment, avs_response: "M") }
+        it "is not considered risky" do
+          expect(order.is_risky?).to eq(false)
+        end
+      end
+
+      context "with avs_response == ''" do
+        let(:payment) { FactoryGirl.create(:payment, avs_response: "") }
+        it "is not considered risky" do
+          expect(order.is_risky?).to eq(false)
+        end
+      end
+
+      context "with cvv_response_code == M" do
+        let(:payment) { FactoryGirl.create(:payment, cvv_response_code: "M") }
+        it "is not considered risky" do
+          expect(order.is_risky?).to eq(false)
+        end
+      end
+
+      context "with cvv_response_message == ''" do
+        let(:payment) { FactoryGirl.create(:payment, cvv_response_message: "") }
+        it "is not considered risky" do
+          expect(order.is_risky?).to eq(false)
+        end
+      end
+    end
+
+    context "Risky order" do
+      context "AVS response message" do
+        let(:order) { FactoryGirl.create(:order, payments: [FactoryGirl.create(:payment, avs_response: "A")]) }
+        it "returns true if the order has an avs_response" do
+          expect(order.is_risky?).to eq(true)
+        end
+      end
+
+      context "CVV response code" do
+        let(:order) { FactoryGirl.create(:order, payments: [FactoryGirl.create(:payment, cvv_response_code: "N")]) }
+        it "returns true if the order has an cvv_response_code" do
+          expect(order.is_risky?).to eq(true)
+        end
+      end
+
+      context "state == 'failed'" do
+        let(:order) { FactoryGirl.create(:order, payments: [FactoryGirl.create(:payment, state: 'failed')]) }
+        it "returns true if the order has state == 'failed'" do
+          expect(order.is_risky?).to eq(true)
+        end
+      end
+    end
+  end
+end