spree_frontend 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a118448cb011d96539c316ab8c3f38baffb4bb94
-  data.tar.gz: f4aeb314b31c4e38a3161f9784e2e5b939f4580d
+  metadata.gz: 865f2224c34ca0b71d34f282ab6230615d9fe591
+  data.tar.gz: a3c3a5d51fc4a29f640f4b3c73263df3180f9e80
 SHA512:
-  metadata.gz: d0bbc78ad6c7f31c056fffd55c4cd8a5f143980ffc19df470887f4be0aa9c81c1769b71a4f1190f9052474a783ac1a6b57d47f6eb5a79baf32bb7d509fc395e0
-  data.tar.gz: 9966081bb724636547e8c913b94b744705d44e50e929bf073849be16cfb9c1c0df189b00409df41e9f14771a6089681db1df28ddbebcb77896d8a3c4f010c3db
+  metadata.gz: 8c226880c48e91a95fa51ab60dc7b2b45fb4f77fe7abd4d65917799c9cca38e8bfafc41ea2eadf7365bc9b0626306ad29b043e01eeb177a60d5f2dbbccf45f40
+  data.tar.gz: bed762b9f3ab66fe008310ae974f739a8e0ec1bd7ac6d130ca9a66ed8682d0bbc89a4c0053489b523d3cac7e9bc6747c74dbb85160cfb186d24fae0e470d3d73

data/spree_frontend.gemspec

@@ -15,8 +15,7 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://spreecommerce.com'
   s.license     = 'BSD-3-Clause'
 
-  s.files        = `git ls-files`.split("\n")
-  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files        = `git ls-files`.split("\n").reject { |f| f.match(/^spec/) }
   s.require_path = 'lib'
   s.requirements << 'none'
 
@@ -25,7 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'bootstrap-sass',  '>= 3.3.5.1', '< 3.4'
   s.add_dependency 'canonical-rails', '~> 0.1.0'
-  s.add_dependency 'jquery-rails',    '~> 4.1'
+  s.add_dependency 'jquery-rails',    '~> 4.3'
 
   s.add_development_dependency 'capybara-accessible'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_frontend
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
 platform: ruby
 authors:
 - Sean Schofield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-04 00:00:00.000000000 Z
+date: 2017-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_api
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: 3.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: 3.2.2
 - !ruby/object:Gem::Dependency
   name: spree_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: 3.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: 3.2.2
 - !ruby/object:Gem::Dependency
   name: bootstrap-sass
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +78,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.3'
 - !ruby/object:Gem::Dependency
   name: capybara-accessible
   requirement: !ruby/object:Gem::Requirement
@@ -230,44 +230,6 @@ files:
 - lib/tasks/rake_util.rb
 - lib/tasks/taxon.rake
 - script/rails
-- spec/controllers/controller_extension_spec.rb
-- spec/controllers/controller_helpers_spec.rb
-- spec/controllers/spree/checkout_controller_spec.rb
-- spec/controllers/spree/checkout_controller_with_views_spec.rb
-- spec/controllers/spree/content_controller_spec.rb
-- spec/controllers/spree/current_order_tracking_spec.rb
-- spec/controllers/spree/home_controller_spec.rb
-- spec/controllers/spree/orders_controller_ability_spec.rb
-- spec/controllers/spree/orders_controller_spec.rb
-- spec/controllers/spree/orders_controller_transitions_spec.rb
-- spec/controllers/spree/products_controller_spec.rb
-- spec/controllers/spree/taxons_controller_spec.rb
-- spec/features/address_spec.rb
-- spec/features/automatic_promotion_adjustments_spec.rb
-- spec/features/caching/products_spec.rb
-- spec/features/caching/taxons_spec.rb
-- spec/features/cart_spec.rb
-- spec/features/checkout_spec.rb
-- spec/features/checkout_unshippable_spec.rb
-- spec/features/coupon_code_spec.rb
-- spec/features/currency_spec.rb
-- spec/features/delivery_spec.rb
-- spec/features/free_shipping_promotions_spec.rb
-- spec/features/locale_spec.rb
-- spec/features/microdata_spec.rb
-- spec/features/order_spec.rb
-- spec/features/page_promotions_spec.rb
-- spec/features/products_spec.rb
-- spec/features/taxons_spec.rb
-- spec/features/template_rendering_spec.rb
-- spec/fixtures/thinking-cat.jpg
-- spec/helpers/frontend_helper_spec.rb
-- spec/helpers/taxons_helper_spec.rb
-- spec/spec_helper.rb
-- spec/support/shared_contexts/checkout_setup.rb
-- spec/support/shared_contexts/custom_products.rb
-- spec/support/shared_contexts/product_prototypes.rb
-- spec/views/spree/checkout/_summary_spec.rb
 - spree_frontend.gemspec
 - vendor/assets/javascripts/jquery.validate/additional-methods.min.js
 - vendor/assets/javascripts/jquery.validate/jquery.validate.min.js
@@ -340,46 +302,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - none
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Frontend e-commerce functionality for the Spree project.
-test_files:
-- spec/controllers/controller_extension_spec.rb
-- spec/controllers/controller_helpers_spec.rb
-- spec/controllers/spree/checkout_controller_spec.rb
-- spec/controllers/spree/checkout_controller_with_views_spec.rb
-- spec/controllers/spree/content_controller_spec.rb
-- spec/controllers/spree/current_order_tracking_spec.rb
-- spec/controllers/spree/home_controller_spec.rb
-- spec/controllers/spree/orders_controller_ability_spec.rb
-- spec/controllers/spree/orders_controller_spec.rb
-- spec/controllers/spree/orders_controller_transitions_spec.rb
-- spec/controllers/spree/products_controller_spec.rb
-- spec/controllers/spree/taxons_controller_spec.rb
-- spec/features/address_spec.rb
-- spec/features/automatic_promotion_adjustments_spec.rb
-- spec/features/caching/products_spec.rb
-- spec/features/caching/taxons_spec.rb
-- spec/features/cart_spec.rb
-- spec/features/checkout_spec.rb
-- spec/features/checkout_unshippable_spec.rb
-- spec/features/coupon_code_spec.rb
-- spec/features/currency_spec.rb
-- spec/features/delivery_spec.rb
-- spec/features/free_shipping_promotions_spec.rb
-- spec/features/locale_spec.rb
-- spec/features/microdata_spec.rb
-- spec/features/order_spec.rb
-- spec/features/page_promotions_spec.rb
-- spec/features/products_spec.rb
-- spec/features/taxons_spec.rb
-- spec/features/template_rendering_spec.rb
-- spec/fixtures/thinking-cat.jpg
-- spec/helpers/frontend_helper_spec.rb
-- spec/helpers/taxons_helper_spec.rb
-- spec/spec_helper.rb
-- spec/support/shared_contexts/checkout_setup.rb
-- spec/support/shared_contexts/custom_products.rb
-- spec/support/shared_contexts/product_prototypes.rb
-- spec/views/spree/checkout/_summary_spec.rb
+test_files: []

data/spec/controllers/controller_extension_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-# This test tests the functionality within
-# spree/core/controller_helpers/respond_with.rb
-# Rather than duck-punching the existing controllers, let's define a custom one:
-class Spree::CustomController < Spree::BaseController
-  def index
-    respond_with(Spree::Address.new) do |format|
-      format.html { render plain: "neutral" }
-    end
-  end
-
-  def create
-    # Just need a model with validations
-    # Address is good enough, so let's go with that
-    address = Spree::Address.new(params[:address])
-    respond_with(address)
-  end
-end
-
-describe Spree::CustomController, type: :controller do
-  after do
-    Spree::CustomController.clear_overrides!
-  end
-
-  before do
-    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
-      r.draw {
-        get 'index', to: 'spree/custom#index'
-        post 'create', to: 'spree/custom#create'
-      }
-    end
-  end
-
-  context "extension testing" do
-    context "index" do
-      context "specify symbol for handler instead of Proc" do
-        before do
-          Spree::CustomController.class_eval do
-            respond_override({index: {html: {success: :success_method}}})
-
-            private
-
-            def success_method
-              render plain: 'success!!!'
-            end
-          end
-        end
-
-        describe "GET" do
-          it "has value success" do
-            spree_get :index
-            expect(response).to be_success
-            assert (response.body =~ /success!!!/)
-          end
-        end
-      end
-
-      context "render" do
-        before do
-          Spree::CustomController.instance_eval do
-            respond_override(index: { html: { success: lambda { render(plain: 'success!!!') } } })
-            respond_override(index: { html: { failure: lambda { render(plain: 'failure!!!') } } })
-          end
-        end
-
-        describe "GET" do
-          it "has value success" do
-            spree_get :index
-            expect(response).to be_success
-            assert (response.body =~ /success!!!/)
-          end
-        end
-      end
-
-      context "redirect" do
-        before do
-          Spree::CustomController.instance_eval do
-            respond_override({index: {html: {success: lambda { redirect_to('/cart') }}}})
-            respond_override(index: { html: { failure: lambda { render(plain: 'failure!!!') } } })
-          end
-        end
-
-        describe "GET" do
-          it "has value success" do
-            spree_get :index
-            expect(response).to be_redirect
-          end
-        end
-      end
-
-      context "validation error" do
-        before do
-          Spree::CustomController.instance_eval do
-            respond_to :html
-            respond_override(create: { html: { success: lambda { render(plain: 'success!!!') } } })
-            respond_override(create: { html: { failure: lambda { render(plain: 'failure!!!') } } })
-          end
-        end
-
-        describe "POST" do
-          it "has value success" do
-            spree_post :create
-            expect(response).to be_success
-            assert (response.body =~ /success!/)
-          end
-        end
-      end
-
-      context 'A different controllers respond_override. Regression test for #1301' do
-        before do
-          Spree::CheckoutController.instance_eval do
-            respond_override(index: { html: { success: lambda { render(plain: 'success!!!') } } })
-          end
-        end
-
-        describe "POST" do
-          it "should not effect the wrong controller" do
-            spree_get :index
-            assert (response.body =~ /neutral/)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/controller_helpers_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-# In this file, we want to test that the controller helpers function correctly
-# So we need to use one of the controllers inside Spree.
-# ProductsController is good.
-describe Spree::ProductsController, type: :controller do
-
-  let!(:available_locales) { [:en, :de] }
-  let!(:available_locale) { :de }
-  let!(:unavailable_locale) { :ru }
-
-  before do
-    I18n.enforce_available_locales = false
-    expect(I18n).to receive(:available_locales).and_return(available_locales)
-  end
-
-  after do
-    Spree::Frontend::Config[:locale] = :en
-    Rails.application.config.i18n.default_locale = :en
-    I18n.locale = :en
-    I18n.enforce_available_locales = true
-  end
-
-  # Regression test for #1184
-  context 'when session locale not set' do
-    before(:each) do
-      session[:locale] = nil
-    end
-
-    context 'when Spree::Frontend::Config[:locale] not present' do
-      before(:each) do
-        Spree::Frontend::Config[:locale] = nil
-      end
-
-      context 'when rails application default locale not set' do
-        before(:each) do
-          Rails.application.config.i18n.default_locale = nil
-        end
-
-        it "sets the I18n default locale" do
-          spree_get :index
-          expect(I18n.locale).to eq(I18n.default_locale)
-        end
-      end
-
-      context 'when rails application default locale is set' do
-        context 'and not in available_locales' do
-          before(:each) do
-            Rails.application.config.i18n.default_locale = unavailable_locale
-          end
-
-          it "sets the I18n default locale" do
-            spree_get :index
-            expect(I18n.locale).to eq(I18n.default_locale)
-          end
-        end
-
-        context 'and in available_locales' do
-          before(:each) do
-            Rails.application.config.i18n.default_locale = available_locale
-          end
-
-          it "sets the rails app locale" do
-            expect(I18n.locale).to eq(:en)
-            spree_get :index
-            expect(I18n.locale).to eq(available_locale)
-          end
-        end
-      end
-    end
-
-    context 'when Spree::Frontend::Config[:locale] is present' do
-      context 'and not in available_locales' do
-        before(:each) do
-          Spree::Frontend::Config[:locale] = unavailable_locale
-        end
-
-        it "sets the I18n default locale" do
-          spree_get :index
-          expect(I18n.locale).to eq(I18n.default_locale)
-        end
-      end
-
-      context 'and not in available_locales' do
-        before(:each) do
-          Spree::Frontend::Config[:locale] = available_locale
-        end
-
-        it "sets the default locale based on Spree::Frontend::Config[:locale]" do
-          expect(I18n.locale).to eq(:en)
-          spree_get :index
-          expect(I18n.locale).to eq(available_locale)
-        end
-      end
-    end
-  end
-
-  context 'when session locale is set' do
-    context 'and not in available_locales' do
-      before(:each) do
-        session[:locale] = unavailable_locale
-      end
-
-      it "sets the I18n default locale" do
-        spree_get :index
-        expect(I18n.locale).to eq(I18n.default_locale)
-      end
-    end
-
-    context 'and in available_locales' do
-      before(:each) do
-        session[:locale] = available_locale
-      end
-
-      it "sets the session locale" do
-        expect(I18n.locale).to eq(:en)
-        spree_get :index
-        expect(I18n.locale).to eq(available_locale)
-      end
-    end
-  end
-end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -1,515 +0,0 @@
-require 'spec_helper'
-
-describe Spree::CheckoutController, type: :controller do
-  let(:token) { 'some_token' }
-  let(:user) { stub_model(Spree::LegacyUser) }
-  let(:order) { FactoryGirl.create(:order_with_totals) }
-
-  let(:address_params) do
-    address = FactoryGirl.build(:address)
-    address.attributes.except("created_at", "updated_at")
-  end
-
-  before do
-    allow(controller).to receive_messages try_spree_current_user: user
-    allow(controller).to receive_messages spree_current_user: user
-    allow(controller).to receive_messages current_order: order
-  end
-
-  context "#edit" do
-    it 'should check if the user is authorized for :edit' do
-      expect(controller).to receive(:authorize!).with(:edit, order, token)
-      request.cookie_jar.signed[:guest_token] = token
-      spree_get :edit, state: 'address'
-    end
-
-    it "should redirect to the cart path unless checkout_allowed?" do
-      allow(order).to receive_messages checkout_allowed?: false
-      spree_get :edit, state: "delivery"
-      expect(response).to redirect_to(spree.cart_path)
-    end
-
-    it "should redirect to the cart path if current_order is nil" do
-      allow(controller).to receive(:current_order).and_return(nil)
-      spree_get :edit, state: "delivery"
-      expect(response).to redirect_to(spree.cart_path)
-    end
-
-    it "should redirect to cart if order is completed" do
-      allow(order).to receive_messages(completed?: true)
-      spree_get :edit, state: "address"
-      expect(response).to redirect_to(spree.cart_path)
-    end
-
-    # Regression test for #2280
-    it "should redirect to current step trying to access a future step" do
-      order.update_column(:state, "address")
-      spree_get :edit, state: "delivery"
-      expect(response).to redirect_to spree.checkout_state_path("address")
-    end
-
-    context "when entering the checkout" do
-      before do
-        # The first step for checkout controller is address
-        # Transitioning into this state first is required
-        order.update_column(:state, "address")
-      end
-
-      it "should associate the order with a user" do
-        order.update_column :user_id, nil
-        expect(order).to receive(:associate_user!).with(user)
-        spree_get :edit, {}, order_id: 1
-      end
-    end
-  end
-
-  context "#update" do
-    it 'should check if the user is authorized for :edit' do
-      expect(controller).to receive(:authorize!).with(:edit, order, token)
-      request.cookie_jar.signed[:guest_token] = token
-      spree_post :update, state: 'address'
-    end
-
-    context "save successful" do
-      def spree_post_address
-        spree_post :update,
-                   state: "address",
-                   order: {
-                     bill_address_attributes: address_params,
-                     use_billing: true
-                   }
-      end
-
-      before do
-        # Must have *a* shipping method and a payment method so updating from address works
-        allow(order).to receive(:available_shipping_methods).
-          and_return [stub_model(Spree::ShippingMethod)]
-        allow(order).to receive(:available_payment_methods).
-          and_return [stub_model(Spree::PaymentMethod)]
-        allow(order).to receive(:ensure_available_shipping_rates).
-          and_return true
-        order.line_items << FactoryGirl.create(:line_item)
-      end
-
-      context "with the order in the cart state" do
-        before do
-          order.update_column(:state, "cart")
-          allow(order).to receive_messages user: user
-        end
-
-        it "should assign order" do
-          spree_post :update, state: "address"
-          expect(assigns[:order]).not_to be_nil
-        end
-
-        it "should advance the state" do
-          spree_post_address
-          expect(order.reload.state).to eq("delivery")
-        end
-
-        it "should redirect the next state" do
-          spree_post_address
-          expect(response).to redirect_to spree.checkout_state_path("delivery")
-        end
-
-        context "current_user respond to save address method" do
-          it "calls persist order address on user" do
-            expect(user).to receive(:persist_order_address)
-            spree_post :update,
-                       state: "address",
-                       order: {
-                         bill_address_attributes: address_params,
-                         use_billing: true
-                       },
-                       save_user_address: "1"
-          end
-        end
-
-        context "current_user doesnt respond to persist_order_address" do
-          it "doesnt raise any error" do
-            expect do
-              spree_post :update,
-                         state: "address",
-                         order: {
-                           bill_address_attributes: address_params,
-                           use_billing: true
-                         },
-                         save_user_address: "1"
-            end.to_not raise_error
-          end
-        end
-      end
-
-      context "with the order in the address state" do
-        before do
-          order.update_columns(ship_address_id: create(:address).id, state: "address")
-          allow(order).to receive_messages user: user
-        end
-
-        context "with a billing and shipping address" do
-          let(:bill_address_params) do
-            order.bill_address.attributes.except("created_at", "updated_at")
-          end
-          let(:ship_address_params) do
-            order.ship_address.attributes.except("created_at", "updated_at")
-          end
-          let(:update_params) do
-            {
-              state: "address",
-              order: {
-                bill_address_attributes: bill_address_params,
-                ship_address_attributes: ship_address_params,
-                use_billing: false
-              }
-            }
-          end
-
-          before do
-            @expected_bill_address_id = order.bill_address.id
-            @expected_ship_address_id = order.ship_address.id
-
-            spree_post :update, update_params
-            order.reload
-          end
-
-          it "updates the same billing and shipping address" do
-            expect(order.bill_address.id).to eq(@expected_bill_address_id)
-            expect(order.ship_address.id).to eq(@expected_ship_address_id)
-          end
-        end
-      end
-
-      context "when in the confirm state" do
-        before do
-          allow(order).to receive_messages confirmation_required?: true
-          order.update_column(:state, "confirm")
-          allow(order).to receive_messages user: user
-          # An order requires a payment to reach the complete state
-          # This is because payment_required? is true on the order
-          create(:payment, amount: order.total, order: order)
-          order.payments.reload
-        end
-
-        # This inadvertently is a regression test for #2694
-        it "should redirect to the order view" do
-          spree_post :update, state: "confirm"
-          expect(response).to redirect_to spree.order_path(order)
-        end
-
-        it "should populate the flash message" do
-          spree_post :update, state: "confirm"
-          expect(flash.notice).to eq(Spree.t(:order_processed_successfully))
-        end
-
-        it "should remove completed order from current_order" do
-          spree_post :update, { state: "confirm" }, order_id: "foofah"
-          expect(assigns(:current_order)).to be_nil
-          expect(assigns(:order)).to eql controller.current_order
-        end
-      end
-
-      # Regression test for #4190
-      context "state_lock_version" do
-        let(:post_params) do
-          {
-            state: "address",
-            order: {
-              bill_address_attributes: order.bill_address.attributes.except("created_at", "updated_at"),
-              state_lock_version: 0,
-              use_billing: true
-            }
-          }
-        end
-
-        context "correct" do
-          it "should properly update and increment version" do
-            spree_post :update, post_params
-            expect(order.state_lock_version).to eq 1
-          end
-        end
-
-        context "incorrect" do
-          before do
-            order.update_columns(state_lock_version: 1, state: "address")
-          end
-
-          it "order should receieve ensure_valid_order_version callback" do
-            expect_any_instance_of(described_class).to receive(:ensure_valid_state_lock_version)
-            spree_post :update, post_params
-          end
-
-          it "order should receieve with_lock message" do
-            expect(order).to receive(:with_lock)
-            spree_post :update, post_params
-          end
-
-          it "redirects back to current state" do
-            spree_post :update, post_params
-            expect(response).to redirect_to spree.checkout_state_path('address')
-            expect(flash[:error]).to eq "The order has already been updated."
-          end
-        end
-      end
-    end
-
-    context "save unsuccessful" do
-      before do
-        allow(order).to receive_messages user: user
-        allow(order).to receive_messages update_attributes: false
-      end
-
-      it "should not assign order" do
-        spree_post :update, state: "address"
-        expect(assigns[:order]).not_to be_nil
-      end
-
-      it "should not change the order state" do
-        spree_post :update, state: 'address'
-      end
-
-      it "should render the edit template" do
-        spree_post :update, state: 'address'
-        expect(response).to render_template :edit
-      end
-
-      it "should render order in payment state when payment fails" do
-        order.update_column(:state, 'confirm')
-        allow(controller).to receive(:insufficient_payment?).and_return(true)
-        spree_post :update, state: 'confirm'
-        expect(order.state).to eq('payment')
-      end
-    end
-
-    context "when current_order is nil" do
-      before { allow(controller).to receive_messages current_order: nil }
-
-      it "should not change the state if order is completed" do
-        expect(order).not_to receive(:update_attribute)
-        spree_post :update, state: "confirm"
-      end
-
-      it "should redirect to the cart_path" do
-        spree_post :update, state: "confirm"
-        expect(response).to redirect_to spree.cart_path
-      end
-    end
-
-    context "Spree::Core::GatewayError" do
-      before do
-        allow(order).to receive_messages user: user
-        allow(order).to receive(:update_attributes).and_raise(Spree::Core::GatewayError.new("Invalid something or other."))
-        spree_post :update, state: "address"
-      end
-
-      it "should render the edit template and display exception message" do
-        expect(response).to render_template :edit
-        expect(flash.now[:error]).to eq(Spree.t(:spree_gateway_error_flash_for_checkout))
-        expect(assigns(:order).errors[:base]).to include("Invalid something or other.")
-      end
-    end
-
-    context "fails to transition from address" do
-      let(:order) do
-        FactoryGirl.create(:order_with_line_items).tap do |order|
-          order.next!
-          expect(order.state).to eq('address')
-        end
-      end
-
-      before do
-        allow(controller).to receive_messages current_order: order
-        allow(controller).to receive_messages check_authorization: true
-      end
-
-      context "when the country is not a shippable country" do
-        before do
-          order.ship_address.tap do |address|
-            # A different country which is not included in the list of shippable countries
-            address.country = FactoryGirl.create(:country, name: "Australia")
-            address.state_name = 'Victoria'
-            address.save
-          end
-        end
-
-        it "due to no available shipping rates for any of the shipments" do
-          expect(order.shipments.count).to eq(1)
-          order.shipments.first.shipping_rates.delete_all
-
-          spree_put :update, state: order.state, order: {}
-          expect(flash[:error]).to eq(Spree.t(:items_cannot_be_shipped))
-          expect(response).to redirect_to(spree.checkout_state_path('address'))
-        end
-      end
-
-      context "when the order is invalid" do
-        before do
-          allow(order).to receive_messages(update_from_params: true, next: nil)
-          order.errors.add(:base, 'Base error')
-          order.errors.add(:adjustments, 'error')
-        end
-
-        it "due to the order having errors" do
-          spree_put :update, state: order.state, order: {}
-          expect(flash[:error]).to eql("Base error\nAdjustments error")
-          expect(response).to redirect_to(spree.checkout_state_path('address'))
-        end
-      end
-    end
-
-    context "fails to transition from payment to complete" do
-      let(:order) do
-        FactoryGirl.create(:order_with_line_items).tap do |order|
-          until order.state == 'payment'
-            order.next!
-          end
-          # So that the confirmation step is skipped and we get straight to the action.
-          payment_method = FactoryGirl.create(:simple_credit_card_payment_method)
-          payment = FactoryGirl.create(:payment, payment_method: payment_method)
-          order.payments << payment
-        end
-      end
-
-      before do
-        allow(controller).to receive_messages current_order: order
-        allow(controller).to receive_messages check_authorization: true
-      end
-
-      it "when GatewayError is raised" do
-        allow_any_instance_of(Spree::Payment).to receive(:process!).and_raise(Spree::Core::GatewayError.new(Spree.t(:payment_processing_failed)))
-        spree_put :update, state: order.state, order: {}
-        expect(flash[:error]).to eq(Spree.t(:payment_processing_failed))
-      end
-    end
-  end
-
-  context "When last inventory item has been purchased" do
-    let(:product) { mock_model(Spree::Product, name: "Amazing Object") }
-    let(:variant) { mock_model(Spree::Variant) }
-    let(:line_item) { mock_model Spree::LineItem, insufficient_stock?: true, amount: 0 }
-    let(:order) { create(:order) }
-
-    before do
-      allow(order).to receive_messages(line_items: [line_item], state: "payment")
-
-      configure_spree_preferences do |config|
-        config.track_inventory_levels = true
-      end
-    end
-
-    context "and back orders are not allowed" do
-      before do
-        spree_post :update, state: "payment"
-      end
-
-      it "should redirect to cart" do
-        expect(response).to redirect_to spree.cart_path
-      end
-
-      it "should set flash message for no inventory" do
-        expect(flash[:error]).to eq(
-          Spree.t(:inventory_error_flash_for_insufficient_quantity, names: "'#{product.name}'"))
-      end
-    end
-  end
-
-  context "order doesn't have a delivery step" do
-    before do
-      allow(order).to receive_messages(checkout_steps: ["cart", "address", "payment"])
-      allow(order).to receive_messages state: "address"
-      allow(controller).to receive_messages check_authorization: true
-    end
-
-    it "doesn't set shipping address on the order" do
-      expect(order).to_not receive(:ship_address=)
-      spree_post :update, state: order.state
-    end
-
-    it "doesn't remove unshippable items before payment" do
-      expect { spree_post :update, state: "payment" }.
-        to_not change { order.line_items }
-    end
-  end
-
-  it "does remove unshippable items before payment" do
-    allow(order).to receive_messages payment_required?: true
-    allow(controller).to receive_messages check_authorization: true
-
-    expect { spree_post :update, state: "payment" }.
-      to change { order.reload.line_items.length }
-  end
-
-  context 'in the payment step' do
-    let(:order) { OrderWalkthrough.up_to(:payment) }
-    let(:payment_method_id) { Spree::PaymentMethod.first.id }
-
-    before do
-      expect(order.state).to eq 'payment'
-      allow(order).to receive_messages user: user
-      allow(order).to receive_messages confirmation_required?: true
-    end
-
-    it 'does not advance the order extra even when called twice' do
-      spree_put :update, state: 'payment',
-                         order: { payments_attributes: [{ payment_method_id: payment_method_id }] }
-      order.reload
-      expect(order.state).to eq 'confirm'
-      spree_put :update, state: 'payment',
-                         order: { payments_attributes: [{ payment_method_id: payment_method_id }] }
-      order.reload
-      expect(order.state).to eq 'confirm'
-    end
-
-    context 'with store credits payment' do
-      let(:user) { create(:user) }
-      let(:credit_amount) { order.total + 1.00 }
-      let(:put_attrs) do
-        {
-          state: 'payment',
-          apply_store_credit: 'Apply Store Credit',
-          order: {
-            payments_attributes: [{ payment_method_id: payment_method_id }],
-          }
-        }
-      end
-      before do
-        create(:store_credit_payment_method)
-        create(:store_credit, user: user, amount: credit_amount)
-      end
-
-      def expect_one_store_credit_payment(order, amount)
-        expect(order.payments.count).to eq 1
-        expect(order.payments.first.source).to be_a Spree::StoreCredit
-        expect(order.payments.first.amount).to eq amount
-      end
-
-      it 'can fully pay with store credits while removing other payment attributes' do
-        spree_put :update, put_attrs
-
-        order.reload
-        expect(order.state).to eq 'confirm'
-        expect_one_store_credit_payment(order, order.total)
-      end
-
-      it 'can fully pay with store credits while removing an existing card' do
-        credit_card = create(:credit_card, user: user, payment_method: Spree::PaymentMethod.first)
-        put_attrs[:order][:existing_card] = credit_card.id
-        spree_put :update, put_attrs
-
-        order.reload
-        expect(order.state).to eq 'confirm'
-        expect_one_store_credit_payment(order, order.total)
-      end
-
-      context 'partial payment' do
-        let(:credit_amount) { order.total - 1.00 }
-        it 'returns to payment for partial store credit' do
-          spree_put :update, put_attrs
-
-          order.reload
-          expect(order.state).to eq 'payment'
-          expect_one_store_credit_payment(order, credit_amount)
-        end
-      end
-    end
-  end
-end