solidus_core 1.0.7 → 1.1.0.beta1

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

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

@@ -1,111 +0,0 @@
-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.id).and_return mail_message
-      expect(mail_message).to receive :deliver_now
-      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(order).to receive :has_available_shipment
-      allow(Spree::OrderMailer).to receive_message_chain :confirm_email, :deliver_now
-      adjustments = [double]
-      expect(order).to receive(:all_adjustments).and_return(adjustments)
-      adjustments.each do |adj|
-        expect(adj).to receive(:close)
-      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

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

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

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

@@ -1,221 +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
-        allow(order).to receive_messages :ensure_available_shipping_rates => true
-        allow(order).to receive :has_available_shipment
-      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.complete!
-        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
-        expect(Spree::TaxRate).to receive(:adjust).twice
-        allow(order).to receive :set_shipments_cost
-        order.next!
-      end
-    end
-  end
-
-  context "#can_cancel?" do
-    states = [:pending, :backorder, :ready]
-
-    states.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 - states).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_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 :has_available_shipment
-      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_now
-      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_now
-
-        allow(order).to receive :has_available_shipment
-      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_now
-        allow(order).to receive :has_available_shipment
-        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([payment])
-      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
-          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.com"
-      allow(order).to receive_messages state: "canceled"
-      allow(order).to receive_messages allow_resume?: true
-
-      # Stubs method that cause unwanted side effects in this test
-      allow(order).to receive :has_available_shipment
-    end
-  end
-end