solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/line_item_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe Spree::LineItem, :type => :model do
-  let(:order) { create :order_with_line_items, line_items_count: 1 }
-  let(:line_item) { order.line_items.first }
-
-  context '#destroy' do
-    it "fetches deleted products" do
-      line_item.product.destroy
-      expect(line_item.reload.product).to be_a Spree::Product
-    end
-
-    it "fetches deleted variants" do
-      line_item.variant.destroy
-      expect(line_item.reload.variant).to be_a Spree::Variant
-    end
-
-    it "returns inventory when a line item is destroyed" do
-      expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-      line_item.destroy
-    end
-
-    it "deletes inventory units" do
-      expect { line_item.destroy }.to change { line_item.inventory_units.count }.from(1).to(0)
-    end
-  end
-
-  context "#save" do
-    context "line item changes" do
-      before do
-        line_item.quantity = line_item.quantity + 1
-      end
-
-      it "triggers adjustment total recalculation" do
-        expect(line_item).to receive(:update_tax_charge) # Regression test for https://github.com/spree/spree/issues/4671
-        expect(line_item).to receive(:recalculate_adjustments)
-        line_item.save
-      end
-    end
-
-    context "line item does not change" do
-      it "does not trigger adjustment total recalculation" do
-        expect(line_item).not_to receive(:recalculate_adjustments)
-        line_item.save
-      end
-    end
-
-    context "target_shipment is provided" do
-      it "verifies inventory" do
-        line_item.target_shipment = Spree::Shipment.new
-        expect_any_instance_of(Spree::OrderInventory).to receive(:verify)
-        line_item.save
-      end
-    end
-  end
-
-  context "#create" do
-    let(:variant) { create(:variant) }
-
-    before do
-      create(:tax_rate, :zone => order.tax_zone, :tax_category => variant.tax_category)
-    end
-
-    context "when order has a tax zone" do
-      before do
-        expect(order.tax_zone).to be_present
-      end
-
-      it "creates a tax adjustment" do
-        order.contents.add(variant)
-        line_item = order.find_line_item_by_variant(variant)
-        expect(line_item.adjustments.tax.count).to eq(1)
-      end
-    end
-
-    context "when order does not have a tax zone" do
-      before do
-        order.bill_address = nil
-        order.ship_address = nil
-        order.save
-        expect(order.reload.tax_zone).to be_nil
-      end
-
-      it "does not create a tax adjustment" do
-        order.contents.add(variant)
-        line_item = order.find_line_item_by_variant(variant)
-        expect(line_item.adjustments.tax.count).to eq(0)
-      end
-    end
-  end
-
-  # Test for #3391
-  context '#copy_price' do
-    it "copies over a variant's prices" do
-      line_item.price = nil
-      line_item.cost_price = nil
-      line_item.currency = nil
-      line_item.copy_price
-      variant = line_item.variant
-      expect(line_item.price).to eq(variant.price)
-      expect(line_item.cost_price).to eq(variant.cost_price)
-      expect(line_item.currency).to eq(variant.currency)
-    end
-  end
-
-  # Test for #3481
-  context '#copy_tax_category' do
-    it "copies over a variant's tax category" do
-      line_item.tax_category = nil
-      line_item.copy_tax_category
-      expect(line_item.tax_category).to eq(line_item.variant.tax_category)
-    end
-  end
-
-  describe '.discounted_amount' do
-    it "returns the amount minus any discounts" do
-      line_item.price = 10
-      line_item.quantity = 2
-      line_item.promo_total = -5
-      expect(line_item.discounted_amount).to eq(15)
-    end
-  end
-
-  describe "#discounted_money" do
-    it "should return a money object with the discounted amount" do
-      expect(line_item.discounted_money.to_s).to eq "$10.00"
-    end
-  end
-
-  describe '.currency' do
-    it 'returns the globally configured currency' do
-      line_item.currency == 'USD'
-    end
-  end
-
-  describe ".money" do
-    before do
-      line_item.price = 3.50
-      line_item.quantity = 2
-    end
-
-    it "returns a Spree::Money representing the total for this line item" do
-      expect(line_item.money.to_s).to eq("$7.00")
-    end
-  end
-
-  describe '.single_money' do
-    before { line_item.price = 3.50 }
-    it "returns a Spree::Money representing the price for one variant" do
-      expect(line_item.single_money.to_s).to eq("$3.50")
-    end
-  end
-
-  context "currency same as order.currency" do
-    it "is a valid line item" do
-      line_item = order.line_items.first
-      line_item.currency = order.currency
-      line_item.valid?
-
-      expect(line_item.error_on(:currency).size).to eq(0)
-    end
-  end
-
-  context "currency different than order.currency" do
-    it "is not a valid line item" do
-      line_item = order.line_items.first
-      line_item.currency = "no currency"
-      line_item.valid?
-
-      expect(line_item.error_on(:currency).size).to eq(1)
-    end
-  end
-
-  describe "#options=" do
-    it "can handle updating a blank line item with no order" do
-      line_item.options = { price: 123 }
-    end
-
-    it "updates the data provided in the options" do
-      line_item.options = { price: 123 }
-      expect(line_item.price).to eq 123
-    end
-
-    it "updates the price based on the options provided" do
-      expect(line_item).to receive(:gift_wrap=).with(true)
-      expect(line_item.variant).to receive(:gift_wrap_price_modifier_amount_in).with("USD", true).and_return 1.99
-      line_item.options = { gift_wrap: true }
-      expect(line_item.price).to eq 21.98
-    end
-  end
-end

data/spec/models/spree/option_type_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Spree::OptionType, :type => :model do
-  context "touching" do
-    it "should touch a product" do
-      product_option_type = create(:product_option_type)
-      option_type = product_option_type.option_type
-      product = product_option_type.product
-      product.update_column(:updated_at, 1.day.ago)
-      option_type.touch
-      expect(product.reload.updated_at).to be_within(3.seconds).of(Time.now)
-    end
-  end
-end

data/spec/models/spree/option_value_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Spree::OptionValue, :type => :model do
-  context "touching" do
-    it "should touch a variant" do
-      variant = create(:variant)
-      option_value = variant.option_values.first
-      variant.update_column(:updated_at, 1.day.ago)
-      option_value.touch
-      expect(variant.reload.updated_at).to be_within(3.seconds).of(Time.now)
-    end
-  end
-
-  describe "#presentation_with_option_type" do
-    let(:option_value) { build(:option_value) }
-    subject { option_value.presentation_with_option_type }
-
-    it "returns a string in the correct form" do
-      expect(subject).to eq "Size - S"
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, :type => :model do
-  let(:order) { Spree::Order.new }
-
-  context 'validation' do
-    context "when @use_billing is populated" do
-      before do
-        order.bill_address = stub_model(Spree::Address)
-        order.ship_address = nil
-      end
-
-      context "with true" do
-        before { order.use_billing = true }
-
-        it "clones the bill address to the ship address" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with 'true'" do
-        before { order.use_billing = 'true' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with '1'" do
-        before { order.use_billing = '1' }
-
-        it "clones the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to eq(order.bill_address)
-        end
-      end
-
-      context "with something other than a 'truthful' value" do
-        before { order.use_billing = '0' }
-
-        it "does not clone the bill address to the shipping" do
-          order.valid?
-          expect(order.ship_address).to be_nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, :type => :model do
-  context "#all_adjustments" do
-    # Regression test for #4537
-    it "does not show adjustments from other, non-order adjustables" do
-      order = Spree::Order.new(:id => 1)
-      where_sql = order.all_adjustments.where_values.to_s
-      expect(where_sql).to include("(adjustable_id = 1 AND adjustable_type = 'Spree::Order')")
-    end
-  end
-
-  # Regression test for #2191
-  context "when an order has an adjustment that zeroes the total, but another adjustment for shipping that raises it above zero" do
-    let!(:persisted_order) { create(:order) }
-    let!(:line_item) { create(:line_item) }
-    let!(:shipping_method) do
-      sm = create(:shipping_method)
-      sm.calculator.preferred_amount = 10
-      sm.save
-      sm
-    end
-
-    before do
-      # Don't care about available payment methods in this test
-      allow(persisted_order).to receive_messages(:has_available_payment => false)
-      persisted_order.line_items << line_item
-      create(:adjustment, amount: -line_item.amount, label: "Promotion", adjustable: line_item, order: persisted_order)
-      persisted_order.state = 'delivery'
-      persisted_order.save # To ensure new state_change event
-    end
-
-    it "transitions from delivery to payment" do
-      allow(persisted_order).to receive_messages(payment_required?: true)
-      persisted_order.next!
-      expect(persisted_order.state).to eq("payment")
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Order, :type => :model do
-  let(:order) { stub_model(Spree::Order) }
-  before do
-    Spree::Order.define_state_machine!
-  end
-
-  context "validations" do
-    context "email validation" do
-      # Regression test for #1238
-      it "o'brien@gmail.com is a valid email address" do
-        order.state = 'address'
-        order.email = "o'brien@gmail.com"
-        expect(order.error_on(:email).size).to eq(0)
-      end
-    end
-  end
-
-  context "#save" do
-    context "when associated with a registered user" do
-      let(:user) { double(:user, :email => "test@example.com") }
-
-      before do
-        allow(order).to receive_messages :user => user
-      end
-
-      it "should assign the email address of the user" do
-        order.run_callbacks(:create)
-        expect(order.email).to eq(user.email)
-      end
-    end
-  end
-
-  context "in the cart state" do
-    it "should not validate email address" do
-      order.state = "cart"
-      order.email = nil
-      expect(order.error_on(:email).size).to eq(0)
-    end
-  end
-end

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

@@ -1,902 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/order_walkthrough'
-
-describe Spree::Order, :type => :model do
-  let(:order) { Spree::Order.new }
-
-  def assert_state_changed(order, from, to)
-    state_change_exists = order.state_changes.where(:previous_state => from, :next_state => to).exists?
-    assert state_change_exists, "Expected order to transition from #{from} to #{to}, but didn't."
-  end
-
-  context "with default state machine" do
-    transitions = [
-      { :address => :delivery },
-      { :delivery => :payment },
-      { :payment => :confirm },
-      { :delivery => :confirm },
-    ]
-
-    transitions.each do |transition|
-      it "transitions from #{transition.keys.first} to #{transition.values.first}" do
-        transition = Spree::Order.find_transition(:from => transition.keys.first, :to => transition.values.first)
-        expect(transition).not_to be_nil
-      end
-    end
-
-    it '.find_transition when contract was broken' do
-      expect(Spree::Order.find_transition({foo: :bar, baz: :dog})).to be_falsey
-    end
-
-    describe "remove_transition" do
-      after do
-        Spree::Order.checkout_flow(&@old_checkout_flow)
-      end
-
-      it '.remove_transition' do
-        options = {:from => transitions.first.keys.first, :to => transitions.first.values.first}
-        allow(Spree::Order).to receive(:next_event_transition).and_return([options])
-        expect(Spree::Order.remove_transition(options)).to be_truthy
-      end
-
-      it '.remove_transition when contract was broken' do
-        expect(Spree::Order.remove_transition(nil)).to be_falsey
-      end
-    end
-
-    it "always return integer on checkout_step_index" do
-      expect(order.checkout_step_index("imnotthere")).to be_a Integer
-      expect(order.checkout_step_index("delivery")).to be > 0
-    end
-
-    it "passes delivery state when transitioning from address over delivery to payment" do
-      allow(order).to receive_messages :payment_required? => true
-      order.state = "address"
-      expect(order.passed_checkout_step?("delivery")).to be false
-      order.state = "delivery"
-      expect(order.passed_checkout_step?("delivery")).to be false
-      order.state = "payment"
-      expect(order.passed_checkout_step?("delivery")).to be true
-    end
-
-    context "#checkout_steps" do
-      context "when confirmation not required" do
-        before do
-          allow(order).to receive_messages :payment_required? => true
-        end
-
-        specify do
-          expect(order.checkout_steps).to eq(%w(address delivery payment confirm complete))
-        end
-      end
-
-      context "when confirmation required" do
-        before do
-          allow(order).to receive_messages :payment_required? => true
-        end
-
-        specify do
-          expect(order.checkout_steps).to eq(%w(address delivery payment confirm complete))
-        end
-      end
-
-      context "when payment not required" do
-        before { allow(order).to receive_messages :payment_required? => false }
-        specify do
-          expect(order.checkout_steps).to eq(%w(address delivery confirm complete))
-        end
-      end
-
-      context "when payment required" do
-        before { allow(order).to receive_messages :payment_required? => true }
-        specify do
-          expect(order.checkout_steps).to eq(%w(address delivery payment confirm complete))
-        end
-      end
-    end
-
-    it "starts out at cart" do
-      expect(order.state).to eq("cart")
-    end
-
-    context "to address" do
-      before do
-        order.email = "user@example.com"
-        order.save!
-      end
-
-      context "with a line item" do
-        before do
-          order.line_items << FactoryGirl.create(:line_item)
-        end
-
-        it "transitions to address" do
-          order.next!
-          assert_state_changed(order, 'cart', 'address')
-          expect(order.state).to eq("address")
-        end
-
-        it "doesn't raise an error if the default address is invalid" do
-          order.user = mock_model(Spree::LegacyUser, ship_address: Spree::Address.new, bill_address: Spree::Address.new)
-          expect { order.next! }.to_not raise_error
-        end
-
-        context "with default addresses" do
-          let(:default_address) { FactoryGirl.create(:address) }
-
-          before do
-            order.user = FactoryGirl.create(:user, "#{address_kind}_address" => default_address)
-            order.next!
-            order.reload
-          end
-
-          shared_examples "it cloned the default address" do
-            it do
-              default_attributes = default_address.attributes
-              order_attributes = order.send("#{address_kind}_address".to_sym).try(:attributes) || {}
-
-              expect(order_attributes.except('id', 'created_at', 'updated_at')).to eql(default_attributes.except('id', 'created_at', 'updated_at'))
-            end
-          end
-
-          it_behaves_like "it cloned the default address" do
-            let(:address_kind) { 'ship' }
-          end
-
-          it_behaves_like "it cloned the default address" do
-            let(:address_kind) { 'bill' }
-          end
-        end
-      end
-
-      it "cannot transition to address without any line items" do
-        expect(order.line_items).to be_blank
-        expect { order.next! }.to raise_error(StateMachines::InvalidTransition, /#{Spree.t(:there_are_no_items_for_this_order)}/)
-      end
-    end
-
-    context "from address" do
-      let(:ship_address) { FactoryGirl.create(:ship_address) }
-
-      before do
-        order.state = 'address'
-        order.ship_address = ship_address
-        allow(order).to receive(:has_available_payment)
-        shipment = FactoryGirl.create(:shipment, :order => order, :cost => 10)
-        order.email = "user@example.com"
-        order.save!
-      end
-
-      context "no shipping address" do
-        let(:ship_address) { nil }
-
-        it "does not transition without a ship address" do
-          expect { order.next! }.to raise_error StateMachines::InvalidTransition
-        end
-      end
-
-      it "updates totals" do
-        line_item = FactoryGirl.create(:line_item, :price => 10, :adjustment_total => 10)
-        order.line_items << line_item
-        tax_rate = create(:tax_rate, :tax_category => line_item.tax_category, :amount => 0.05)
-        allow(Spree::TaxRate).to receive_messages :match => [tax_rate]
-        FactoryGirl.create(:tax_adjustment, :adjustable => line_item, :source => tax_rate, order: order)
-        order.email = "user@example.com"
-        order.next!
-        expect(order.adjustment_total).to eq(0.5)
-        expect(order.additional_tax_total).to eq(0.5)
-        expect(order.included_tax_total).to eq(0)
-        expect(order.total).to eq(20.5)
-      end
-
-      it "transitions to delivery" do
-        allow(order).to receive_messages(:ensure_available_shipping_rates => true)
-        order.next!
-        assert_state_changed(order, 'address', 'delivery')
-        expect(order.state).to eq("delivery")
-      end
-
-      it "does not call persist_order_address if there is no address on the order" do
-        # otherwise, it will crash
-        allow(order).to receive_messages(:ensure_available_shipping_rates => true)
-
-        order.user = FactoryGirl.create(:user)
-        order.save!
-
-        expect(order.user).to_not receive(:persist_order_address).with(order)
-        order.next!
-      end
-
-      it "calls persist_order_address on the order's user" do
-        allow(order).to receive_messages(:ensure_available_shipping_rates => true)
-
-        order.user = FactoryGirl.create(:user)
-        order.ship_address = FactoryGirl.create(:address)
-        order.bill_address = FactoryGirl.create(:address)
-        order.save!
-
-        expect(order.user).to receive(:persist_order_address).with(order)
-        order.next!
-      end
-
-      it "does not call persist_order_address on the order's user for a temporary address" do
-        allow(order).to receive_messages(:ensure_available_shipping_rates => true)
-
-        order.user = FactoryGirl.create(:user)
-        order.temporary_address = true
-        order.save!
-
-        expect(order.user).to_not receive(:persist_order_address)
-        order.next!
-      end
-    end
-
-    context "to delivery" do
-      let(:ship_address) { FactoryGirl.create(:ship_address) }
-
-      before do
-        order.ship_address = ship_address
-      end
-
-      context 'when order has default selected_shipping_rate_id' do
-        let(:shipment) { create(:shipment, order: order) }
-        let(:shipping_method) { create(:shipping_method) }
-        let(:shipping_rate) { [
-          Spree::ShippingRate.create!(shipping_method: shipping_method, cost: 10.00, shipment: shipment)
-        ] }
-
-        before do
-          order.state = 'address'
-          shipment.selected_shipping_rate_id = shipping_rate.first.id
-          order.email = "user@example.com"
-          order.save!
-
-          allow(order).to receive(:has_available_payment)
-          allow(order).to receive(:create_proposed_shipments)
-          allow(order).to receive(:ensure_available_shipping_rates) { true }
-        end
-
-        it 'should invoke set_shipment_cost' do
-          expect(order).to receive(:set_shipments_cost)
-          order.next!
-        end
-
-        it 'should update shipment_total' do
-          expect { order.next! }.to change{ order.shipment_total }.by(10.00)
-        end
-      end
-
-      context "cannot transition to delivery" do
-        context "if there are no shipping rates for any shipment" do
-          let!(:line_item){ create :line_item, order: order }
-          before do
-            order.state = 'address'
-            order.email = 'user@example.com'
-          end
-          specify do
-            transition = lambda { order.next! }
-            expect(transition).to raise_error(StateMachines::InvalidTransition, /#{Spree.t(:items_cannot_be_shipped)}/)
-          end
-        end
-      end
-    end
-
-    context "from delivery" do
-      let(:ship_address) { FactoryGirl.create(:ship_address) }
-
-      before do
-        order.ship_address = ship_address
-        order.state = 'delivery'
-        allow(order).to receive(:apply_free_shipping_promotions)
-        allow(order).to receive(:ensure_available_shipping_rates) { true }
-      end
-
-      it "attempts to apply free shipping promotions" do
-        expect(order).to receive(:apply_free_shipping_promotions)
-        order.next!
-      end
-
-      context "with payment required" do
-        before do
-          allow(order).to receive_messages :payment_required? => true
-        end
-
-        it "transitions to payment" do
-          expect(order).to receive(:set_shipments_cost)
-          order.next!
-          assert_state_changed(order, 'delivery', 'payment')
-          expect(order.state).to eq('payment')
-        end
-      end
-
-      context "without payment required" do
-        before do
-          allow(order).to receive_messages :payment_required? => false
-        end
-
-        it "transitions to complete" do
-          order.next!
-          expect(order.state).to eq("confirm")
-        end
-      end
-
-      context "correctly determining payment required based on shipping information" do
-        let(:shipment) do
-          FactoryGirl.create(:shipment)
-        end
-
-        before do
-          # Needs to be set here because we're working with a persisted order object
-          order.email = "test@example.com"
-          order.save!
-          order.shipments << shipment
-        end
-
-        context "with a shipment that has a price" do
-          before do
-            shipment.shipping_rates.first.update_column(:cost, 10)
-            order.set_shipments_cost
-          end
-
-          it "transitions to payment" do
-            order.next!
-            expect(order.state).to eq("payment")
-          end
-        end
-
-        context "with a shipment that is free" do
-          before do
-            shipment.shipping_rates.first.update_column(:cost, 0)
-            order.set_shipments_cost
-          end
-
-          it "skips payment, transitions to confirm" do
-            order.next!
-            expect(order.state).to eq("confirm")
-          end
-        end
-      end
-    end
-
-    context "to payment" do
-      let(:user_bill_address)   { nil }
-      let(:order_bill_address)  { nil }
-      let(:default_credit_card) { create(:credit_card) }
-
-      before do
-        @default_credit_card = FactoryGirl.create(:credit_card)
-        user = Spree::LegacyUser.new(email: 'spree@example.org', bill_address: user_bill_address)
-        allow(user).to receive(:default_credit_card) { @default_credit_card }
-        order.user = user
-
-        allow(order).to receive_messages(payment_required?: true)
-        order.state = 'delivery'
-        order.bill_address = order_bill_address
-        order.save!
-        order.next!
-        order.reload
-      end
-
-      it "assigns the user's default credit card" do
-        expect(order.state).to eq 'payment'
-        expect(order.payments.count).to eq 1
-        expect(order.payments.first.source).to eq @default_credit_card
-      end
-
-      context "order already has a billing address" do
-        let(:order_bill_address) { create(:address) }
-
-        it "keeps the order's billing address" do
-          expect(order.bill_address).to eq order_bill_address
-        end
-      end
-
-      context "order doesn't have a billing address" do
-        let(:user_bill_address) { create(:address) }
-
-        it "assigns the user's billing address to the order" do
-          expect(order.bill_address).to eq user_bill_address
-        end
-      end
-    end
-
-    context "from payment" do
-      before do
-        order.state = 'payment'
-        allow(order).to receive(:ensure_available_shipping_rates) { true }
-      end
-
-      context "with confirmation required" do
-        before do
-        end
-
-        it "transitions to confirm" do
-          order.next!
-          assert_state_changed(order, 'payment', 'confirm')
-          expect(order.state).to eq("confirm")
-        end
-      end
-
-      context "without confirmation required" do
-        before do
-          order.email = "spree@example.com"
-          order.store = FactoryGirl.build(:store)
-          allow(order).to receive_messages :payment_required? => true
-          order.payments << FactoryGirl.create(:payment, state: payment_state, order: order)
-        end
-
-        context 'when there is at least one valid payment' do
-          let(:payment_state) { 'checkout' }
-
-          before do
-            expect(order).to receive(:process_payments!).once { true }
-          end
-
-          it "transitions to complete" do
-            order.complete!
-            assert_state_changed(order, 'payment', 'complete')
-            expect(order.state).to eq('complete')
-          end
-        end
-
-        context 'when there is only an invalid payment' do
-          let(:payment_state) { 'failed' }
-
-          it "raises a StateMachines::InvalidTransition" do
-            expect {
-              order.complete!
-            }.to raise_error(StateMachines::InvalidTransition, /#{Spree.t(:no_payment_found)}/)
-
-            expect(order.errors[:base]).to include(Spree.t(:no_payment_found))
-          end
-        end
-      end
-
-      # Regression test for #2028
-      context "when payment is not required" do
-        before do
-          allow(order).to receive_messages :payment_required? => false
-        end
-
-        it "does not call process payments" do
-          expect(order).not_to receive(:process_payments!)
-          order.next!
-          assert_state_changed(order, 'payment', 'confirm')
-          expect(order.state).to eq("confirm")
-        end
-      end
-    end
-  end
-
-  context "from confirm" do
-    before do
-      order.state = 'confirm'
-      order.save!
-    end
-
-    it "returns false on next" do
-      expect(order.next).to be_falsy
-    end
-
-    it "is unable to next" do
-      expect(order).not_to be_can_next
-    end
-  end
-
-  context "to complete" do
-    before do
-      order.state = 'confirm'
-      order.save!
-    end
-
-    context "out of stock" do
-      before do
-        order.user = FactoryGirl.create(:user)
-        order.email = 'spree@example.org'
-        order.payments << FactoryGirl.create(:payment)
-        allow(order).to receive_messages(payment_required?: true)
-        order.line_items << FactoryGirl.create(:line_item)
-        order.line_items.first.variant.stock_items.each do |si|
-          si.set_count_on_hand(0)
-          si.update_attributes(:backorderable => false)
-        end
-
-        Spree::OrderUpdater.new(order).update
-        order.save!
-      end
-
-      it "does not allow the order to complete" do
-        expect {
-          order.complete!
-        }.to raise_error Spree::Order::InsufficientStock
-
-        expect(order.state).to eq 'confirm'
-        expect(order.line_items.first.errors[:quantity]).to be_present
-        expect(order.payments.first.state).to eq('checkout')
-      end
-    end
-
-    context "no inventory units" do
-      before do
-        order.user = FactoryGirl.create(:user)
-        order.email = 'spree@example.com'
-        order.payments << FactoryGirl.create(:payment)
-        allow(order).to receive_messages(payment_required?: true)
-        allow(order).to receive(:ensure_available_shipping_rates) { true }
-        order.line_items << FactoryGirl.create(:line_item)
-
-        Spree::OrderUpdater.new(order).update
-        order.save!
-      end
-
-      it "does not allow order to complete" do
-        expect { order.complete! }.to raise_error Spree::Order::InsufficientStock
-
-        expect(order.state).to eq 'confirm'
-        expect(order.line_items.first.errors[:inventory]).to be_present
-        expect(order.payments.first.state).to eq('checkout')
-      end
-    end
-
-    context "exchange order completion" do
-      before do
-        order.email = 'spree@example.org'
-        order.payments << FactoryGirl.create(:payment)
-        order.shipments.create!
-        allow(order).to receive_messages(payment_required?: true)
-        allow(order).to receive(:ensure_available_shipping_rates).and_return(true)
-      end
-
-      context 'when the line items are not available' do
-        before do
-          order.line_items << FactoryGirl.create(:line_item)
-          order.store = FactoryGirl.build(:store)
-          Spree::OrderUpdater.new(order).update
-
-          order.save!
-        end
-
-        context 'when the exchange is for an unreturned item' do
-          before do
-            order.shipments.first.update_attributes!(created_at: order.created_at - 1.day)
-            expect(order.unreturned_exchange?).to eq true
-          end
-
-          it 'allows the order to complete' do
-            order.complete!
-
-            expect(order).to be_complete
-          end
-        end
-
-        context 'when the exchange is not for an unreturned item' do
-          it 'does not allow the order to completed' do
-            expect { order.complete! }.to raise_error  Spree::Order::InsufficientStock
-            expect(order.payments.first.state).to eq('checkout')
-          end
-        end
-      end
-    end
-
-    context "default credit card" do
-      before do
-        order.user = FactoryGirl.create(:user)
-        order.store = FactoryGirl.create(:store)
-        order.email = 'spree@example.org'
-        order.payments << FactoryGirl.create(:payment)
-
-        # make sure we will actually capture a payment
-        allow(order).to receive_messages(payment_required?: true)
-        allow(order).to receive_messages(ensure_available_shipping_rates: true)
-        allow(order).to receive_messages(validate_line_item_availability: true)
-        order.line_items << FactoryGirl.create(:line_item)
-        order.create_proposed_shipments
-        Spree::OrderUpdater.new(order).update
-
-        order.save!
-      end
-
-      it "makes the current credit card a user's default credit card" do
-        order.complete!
-        expect(order.state).to eq 'complete'
-        expect(order.user.reload.default_credit_card.try(:id)).to eq(order.credit_cards.first.id)
-      end
-
-      it "does not assign a default credit card if temporary_credit_card is set" do
-        order.temporary_credit_card = true
-        order.complete!
-        expect(order.user.reload.default_credit_card).to be_nil
-      end
-    end
-
-    context "a payment fails during processing" do
-      before do
-        order.user = FactoryGirl.create(:user)
-        order.email = 'spree@example.org'
-        payment = FactoryGirl.create(:payment)
-        allow(payment).to receive(:process!).and_raise(Spree::Core::GatewayError.new('processing failed'))
-        order.line_items.each { |li| li.inventory_units.create! }
-        order.payments << payment
-
-        # make sure we will actually capture a payment
-        allow(order).to receive_messages(payment_required?: true)
-        allow(order).to receive_messages(ensure_available_shipping_rates: true)
-        allow(order).to receive_messages(validate_line_item_availability: true)
-        order.line_items << FactoryGirl.create(:line_item)
-        order.create_proposed_shipments
-        Spree::OrderUpdater.new(order).update
-      end
-
-      it "transitions to the payment state" do
-        expect { order.complete! }.to raise_error StateMachines::InvalidTransition
-        expect(order.reload.state).to eq 'payment'
-      end
-    end
-
-    context 'the order is already paid' do
-      let(:order) { create(:order_with_line_items) }
-
-      it 'can complete the order' do
-        payment = create(:payment, state: 'completed', order: order, amount: order.total)
-        order.update!
-        expect(order.complete).to eq(true)
-      end
-    end
-  end
-
-  context "subclassed order" do
-    # This causes another test above to fail, but fixing this test should make
-    #   the other test pass
-    class SubclassedOrder < Spree::Order
-      checkout_flow do
-        go_to_state :payment
-        go_to_state :complete
-      end
-    end
-
-    skip "should only call default transitions once when checkout_flow is redefined" do
-      order = SubclassedOrder.new
-      allow(order).to receive_messages :payment_required? => true
-      expect(order).to receive(:process_payments!).once
-      order.state = "payment"
-      order.next!
-      assert_state_changed(order, 'payment', 'complete')
-      expect(order.state).to eq("complete")
-    end
-  end
-
-  context "re-define checkout flow" do
-    before do
-      @old_checkout_flow = Spree::Order.checkout_flow
-      Spree::Order.class_eval do
-        checkout_flow do
-          go_to_state :payment
-          go_to_state :complete
-        end
-      end
-    end
-
-    after do
-      Spree::Order.checkout_flow(&@old_checkout_flow)
-    end
-
-    it "should not keep old event transitions when checkout_flow is redefined" do
-      expect(Spree::Order.next_event_transitions).to eq([{:cart=>:payment}, {:payment=>:complete}])
-    end
-
-    it "should not keep old events when checkout_flow is redefined" do
-      state_machine = Spree::Order.state_machine
-      expect(state_machine.states.any? { |s| s.name == :address }).to be false
-      known_states = state_machine.events[:next].branches.map(&:known_states).flatten
-      expect(known_states).not_to include(:address)
-      expect(known_states).not_to include(:delivery)
-      expect(known_states).not_to include(:confirm)
-    end
-  end
-
-  # Regression test for #3665
-  context "with only a complete step" do
-    let!(:line_item){ create :line_item, order: order }
-
-    before do
-      @old_checkout_flow = Spree::Order.checkout_flow
-      Spree::Order.class_eval do
-        checkout_flow do
-          go_to_state :complete
-        end
-      end
-    end
-
-    after do
-      Spree::Order.checkout_flow(&@old_checkout_flow)
-    end
-
-    it "does not attempt to process payments" do
-      order.email = 'user@example.com'
-      order.store = FactoryGirl.build(:store)
-      allow(order).to receive(:ensure_available_shipping_rates).and_return(true)
-      allow(order).to receive(:ensure_promotions_eligible).and_return(true)
-      allow(order).to receive(:ensure_line_item_variants_are_not_deleted).and_return(true)
-      allow(order).to receive_message_chain(:line_items, :present?).and_return(true)
-      allow(order).to receive_messages(validate_line_item_availability: true)
-      expect(order).not_to receive(:payment_required?)
-      expect(order).not_to receive(:process_payments!)
-      order.next!
-      assert_state_changed(order, 'cart', 'complete')
-    end
-
-  end
-
-  context "insert checkout step" do
-    before do
-      @old_checkout_flow = Spree::Order.checkout_flow
-      Spree::Order.class_eval do
-        remove_transition from: :delivery, to: :confirm
-      end
-      Spree::Order.class_eval do
-        insert_checkout_step :new_step, before: :address
-      end
-    end
-
-    after do
-      Spree::Order.checkout_flow(&@old_checkout_flow)
-    end
-
-    it "should maintain removed transitions" do
-      transition = Spree::Order.find_transition(:from => :delivery, :to => :confirm)
-      expect(transition).to be_nil
-    end
-
-    context "before" do
-      before do
-        Spree::Order.class_eval do
-          insert_checkout_step :before_address, before: :address
-        end
-      end
-
-      specify do
-        order = Spree::Order.new
-        expect(order.checkout_steps).to eq(%w(new_step before_address address delivery confirm complete))
-      end
-    end
-
-    context "after" do
-      before do
-        Spree::Order.class_eval do
-          insert_checkout_step :after_address, after: :address
-        end
-      end
-
-      specify do
-        order = Spree::Order.new
-        expect(order.checkout_steps).to eq(%w(new_step address after_address delivery confirm complete))
-      end
-    end
-  end
-
-  context "remove checkout step" do
-    before do
-      @old_checkout_flow = Spree::Order.checkout_flow
-      Spree::Order.class_eval do
-        remove_transition from: :delivery, to: :confirm
-      end
-      Spree::Order.class_eval do
-        remove_checkout_step :address
-      end
-    end
-
-    after do
-      Spree::Order.checkout_flow(&@old_checkout_flow)
-    end
-
-    it "should maintain removed transitions" do
-      transition = Spree::Order.find_transition(:from => :delivery, :to => :confirm)
-      expect(transition).to be_nil
-    end
-
-    specify do
-      order = Spree::Order.new
-      expect(order.checkout_steps).to eq(%w(delivery confirm complete))
-    end
-  end
-
-  describe 'update_from_params' do
-    let(:permitted_params) { {} }
-    let(:params) { {} }
-
-    it 'calls update_atributes without order params' do
-      expect(order).to receive(:update_attributes).with({})
-      order.update_from_params( params, permitted_params)
-    end
-
-    it 'runs the callbacks' do
-      expect(order).to receive(:run_callbacks).with(:updating_from_params)
-      order.update_from_params( params, permitted_params)
-    end
-
-    context "passing a credit card" do
-      let(:permitted_params) do
-        Spree::PermittedAttributes.checkout_attributes +
-          [payments_attributes: Spree::PermittedAttributes.payment_attributes]
-      end
-
-      let(:credit_card) { create(:credit_card, user_id: order.user_id) }
-
-      let(:params) do
-        ActionController::Parameters.new(
-          order: { payments_attributes: [{payment_method_id: 1}], existing_card: credit_card.id },
-          cvc_confirm: "737",
-          payment_source: {
-            "1" => { name: "Luis Braga",
-                     number: "4111 1111 1111 1111",
-                     expiry: "06 / 2016",
-                     verification_value: "737",
-                     cc_type: "" }
-          }
-        )
-      end
-
-      before { order.user_id = 3 }
-
-      it "sets confirmation value when its available via :cvc_confirm" do
-        allow(Spree::CreditCard).to receive_messages find: credit_card
-        expect(credit_card).to receive(:verification_value=)
-        order.update_from_params(params, permitted_params)
-      end
-
-      it "sets existing card as source for new payment" do
-        expect {
-          order.update_from_params(params, permitted_params)
-        }.to change { Spree::Payment.count }.by(1)
-
-        expect(Spree::Payment.last.source).to eq credit_card
-      end
-
-      it "sets request_env on payment" do
-        request_env = { "USER_AGENT" => "Firefox" }
-
-        expected_hash = { "payments_attributes" => [hash_including("request_env" => request_env)] }
-        expect(order).to receive(:update_attributes).with expected_hash
-
-        order.update_from_params(params, permitted_params, request_env)
-      end
-
-      it "dont let users mess with others users cards" do
-        credit_card.update_column :user_id, 5
-
-        expect {
-          order.update_from_params(params, permitted_params)
-        }.to raise_error Spree::Core::GatewayError
-      end
-    end
-
-    context 'has params' do
-      let(:permitted_params) { [ :good_param ] }
-      let(:params) { ActionController::Parameters.new(order: {  bad_param: 'okay' } ) }
-
-      it 'does not let through unpermitted attributes' do
-        expect(order).to receive(:update_attributes).with({})
-        order.update_from_params(params, permitted_params)
-      end
-
-      context 'has allowed params' do
-        let(:params) { ActionController::Parameters.new(order: {  good_param: 'okay' } ) }
-
-        it 'accepts permitted attributes' do
-          expect(order).to receive(:update_attributes).with({"good_param" => 'okay'})
-          order.update_from_params(params, permitted_params)
-        end
-      end
-
-      context 'callbacks halt' do
-        before do
-          expect(order).to receive(:update_params_payment_source).and_return false
-        end
-        it 'does not let through unpermitted attributes' do
-          expect(order).not_to receive(:update_attributes).with({})
-          order.update_from_params(params, permitted_params)
-        end
-      end
-    end
-  end
-end