solidus_starter_frontend 0.1.0

data/lib/generators/solidus_starter_frontend/views/override_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'rails/generators'
+
+module SolidusStarterFrontend
+  module Views
+    class OverrideGenerator < ::Rails::Generators::Base
+      def self.views_folder
+        Engine.root.join('app', 'views', 'spree')
+      end
+
+      VIEWS = Dir.glob(views_folder.join('**', '*'))
+
+      desc "Override solidus frontend views in your app. You can either provide single files or complete folders."
+
+      class_option :only,
+        type: :string,
+        default: nil,
+        desc: "Name of file or folder to copy exclusively. Can be a substring."
+
+      source_root views_folder
+
+      def copy_views
+        views_to_copy.each do |file|
+          next if File.directory?(file)
+
+          dest_file = Pathname.new(file).relative_path_from(source_dir)
+          copy_file file, Rails.root.join('app', 'views', 'spree', dest_file)
+        end
+      end
+
+      private
+
+      def views_to_copy
+        if @options['only']
+          VIEWS.select do |view|
+            Pathname.new(view).relative_path_from(source_dir).to_s.include?(@options['only'])
+          end
+        else
+          VIEWS
+        end
+      end
+
+      def source_dir
+        self.class.views_folder
+      end
+    end
+  end
+end

data/lib/solidus_starter_frontend.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails/all'
+require 'canonical-rails'
+
+require 'solidus_core'
+require 'solidus_support'
+
+require 'solidus_starter_frontend/solidus_support_extensions'
+require 'solidus_starter_frontend/version'
+require 'solidus_starter_frontend/config'
+require 'solidus_starter_frontend/engine'

data/lib/solidus_starter_frontend/config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'solidus_starter_frontend_configuration'
+
+module SolidusStarterFrontend
+  Config = SolidusStarterFrontendConfiguration.new
+end

data/lib/solidus_starter_frontend/engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spree/core'
+require 'solidus_starter_frontend'
+
+module SolidusStarterFrontend
+  class Engine < Rails::Engine
+    isolate_namespace ::Spree
+
+    engine_name 'solidus_starter_frontend'
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    config.to_prepare do
+      if defined?(Spree::Auth::Engine)
+        [
+          Spree::UserConfirmationsController,
+          Spree::UserPasswordsController,
+          Spree::UserRegistrationsController,
+          Spree::UserSessionsController,
+          Spree::UsersController
+        ].each do |auth_controller|
+          auth_controller.include SolidusStarterFrontend::Taxonomies
+          auth_controller.include SolidusStarterFrontend::AuthViews
+        end
+
+        Spree::StoreController.include SolidusStarterFrontend::AuthViews
+      end
+    end
+  end
+end

data/lib/solidus_starter_frontend/factories.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+end

data/lib/solidus_starter_frontend/solidus_support_extensions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'solidus_support'
+
+module SolidusSupport
+  def self.frontend_available?
+    true
+  end
+end

data/lib/solidus_starter_frontend/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusStarterFrontend
+  VERSION = '0.1.0'
+end

data/lib/solidus_starter_frontend_configuration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class SolidusStarterFrontendConfiguration < Spree::Preferences::Configuration
+  preference :locale, :string, default: I18n.default_locale
+
+  # Add your terms and conditions in app/views/spree/checkout/_terms_and_conditions.en.html.erb
+  preference :require_terms_and_conditions_acceptance, :boolean, default: false
+end

data/lib/views/auth/spree/checkout/registration.html.erb

@@ -0,0 +1,7 @@
+<%= render partial: 'spree/shared/error_messages', locals: { target: @user } %>
+
+<%= render template: 'spree/user_sessions/new' %>
+
+<% if Spree::Config[:allow_guest_checkout] %>
+  <%= render template: 'spree/user_sessions/guest' %>
+<% end %>

data/lib/views/auth/spree/components/navigation/_auth_link.html.erb

@@ -0,0 +1,5 @@
+<% if spree_current_user %>
+  <%= link_to I18n.t('spree.my_account'), spree.account_path, class: 'auth-link' %>
+<% else %>
+  <%= link_to I18n.t('spree.login'), spree.login_path, class: 'auth-link' %>
+<% end %>

data/lib/views/auth/spree/user_passwords/edit.html.erb

@@ -0,0 +1,7 @@
+<%= render partial: 'spree/shared/error_messages', locals: { target: @spree_user } %>
+
+<article class="auth-container" id="change-password">
+  <h1><%= I18n.t('spree.change_my_password') %></h1>
+
+  <%= render partial: 'spree/components/auth/change_form' %>
+</article>

data/lib/views/auth/spree/user_passwords/new.html.erb

@@ -0,0 +1,5 @@
+<article class="auth-container" id="forgot-password">
+  <h1><%= I18n.t('spree.forgot_password') %></h1>
+
+  <%= render partial: 'spree/components/auth/forgot_form' %>
+</article>

data/lib/views/auth/spree/user_registrations/new.html.erb

@@ -0,0 +1,7 @@
+<%= render 'spree/shared/error_messages', target: resource %>
+
+<article class="auth-container" id="new-customer">
+  <h1><%= I18n.t('spree.new_customer') %></h1>
+
+  <%= render partial: 'spree/components/auth/signup_form' %>
+</article>

data/lib/views/auth/spree/user_sessions/guest.html.erb

@@ -0,0 +1,5 @@
+<article class="auth-container" id="guest_checkout">
+  <h1><%= I18n.t('spree.guest_user_account') %></h1>
+
+  <%= render partial: 'spree/components/auth/guest_form' %>
+</article>

data/lib/views/auth/spree/user_sessions/new.html.erb

@@ -0,0 +1,7 @@
+<% @body_id = 'login' %>
+
+<article class="auth-container" id="existing-customer">
+  <h1><%= I18n.t('spree.login_as_existing') %></h1>
+
+  <%= render partial: 'spree/components/auth/login_form' %>
+</article>

data/lib/views/auth/spree/users/edit.html.erb

@@ -0,0 +1,45 @@
+<%= render partial: 'spree/shared/error_messages', locals: { target: @user } %>
+
+<article class="auth-container" id="edit-account">
+  <h1><%= I18n.t('spree.editing_user') %></h1>
+
+  <%= form_for Spree::User.new, as: @user, url: spree.user_path(@user), method: :put do |f| %>
+    <div class="auth-form__input-wrapper">
+      <%= render(
+        "spree/components/forms/inputs/text",
+        id: :spree_user_email,
+        label: I18n.t("spree.email"),
+        name: 'user[email]',
+        type: :email,
+        value: @user.email
+      ) %>
+    </div>
+    <div class="auth-form__input-wrapper">
+      <%= render(
+        "spree/components/forms/inputs/text",
+        id: :password,
+        label: I18n.t("spree.password"),
+        name: 'user[password]',
+        type: :password
+      ) %>
+    </div>
+    <div class="auth-form__input-wrapper">
+      <%= render(
+        "spree/components/forms/inputs/text",
+        id: :password_confirmation,
+        label: I18n.t("spree.confirm_password"),
+        name: 'user[password_confirmation]',
+        type: :password
+      ) %>
+    </div>
+    <div class="auth-form__input-wrapper">
+      <%= render(
+        "spree/components/buttons/button_primary",
+        content: I18n.t('spree.update'),
+        full_width: true,
+        name: :commit,
+        type: :submit
+      ) %>
+    </div>
+  <% end %>
+</article>

data/lib/views/auth/spree/users/show.html.erb

@@ -0,0 +1,55 @@
+<div class="account-summary">
+  <div class="account-summary__profile">
+    <h2><%= I18n.t('spree.email') %></h2>
+    <p><%= @user.email %> (<%= link_to I18n.t('spree.edit'), spree.edit_account_path %>)</p>
+  </div>
+
+  <div class="account-summary__orders">
+    <h2><%= I18n.t('spree.my_orders') %></h2>
+    <% if @orders.present? %>
+      <% @orders.each do |order| %>
+        <dl class="account-order">
+          <div class="account-order__detail">
+            <dt><%= I18n.t(:number, scope: 'activerecord.attributes.spree/order') %></dt>
+            <dd><%= link_to order.number, order_url(order) %></dd>
+          </div>
+
+          <div class="account-order__detail">
+            <dt><%= I18n.t('spree.date') %></dt>
+            <dd><%= l order.completed_at.to_date %></dd>
+          </div>
+
+          <div class="account-order__detail">
+            <dt><%= I18n.t('spree.status') %></dt>
+            <dd><%= I18n.t("spree.order_state.#{order.state}").titleize %></dd>
+          </div>
+
+          <div class="account-order__detail">
+            <dt><%= I18n.t('spree.payment_state') %></dt>
+            <dd><%= I18n.t("spree.payment_states.#{order.payment_state}").titleize if order.payment_state %></dd>
+          </div>
+
+          <div class="account-order__detail">
+            <dt><%= I18n.t('spree.shipment_state') %></dt>
+            <dd><%= I18n.t("spree.shipment_states.#{order.shipment_state}").titleize if order.shipment_state %></dd>
+          </div>
+
+          <div class="account-order__detail">
+            <dt><%= I18n.t('spree.total') %></dt>
+            <dd><%= order.display_total %></dd>
+          </div>
+        </dl>
+      <% end %>
+    <% else %>
+      <p><%= I18n.t('spree.you_have_no_orders_yet') %></p>
+    <% end %>
+  </div>
+
+  <%= form_with(url: spree.logout_path, method: Devise.sign_out_via, local: true) do %>
+    <%= render(
+      "spree/components/buttons/button_primary",
+      content: I18n.t('spree.logout'),
+      type: :submit
+    ) %>
+  <% end %>
+</div>

data/solidus_starter_frontend.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'lib/solidus_starter_frontend/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'solidus_starter_frontend'
+  spec.version = SolidusStarterFrontend::VERSION
+  spec.authors = ['Nebulab']
+  spec.email = 'hello@nebulab.it'
+
+  spec.summary = 'Cart and storefront for the Solidus e-commerce project.'
+  spec.description = spec.summary
+  spec.homepage = 'https://www.nebulab.it'
+  spec.license = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://www.nebulab.it'
+  # spec.metadata['changelog_uri'] = ''
+
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.4')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'canonical-rails', '~> 0.2.0'
+  spec.add_dependency 'generator_spec'
+  spec.add_dependency 'solidus_api', ['>= 2.0', '< 3']
+  spec.add_dependency 'solidus_core', ['>= 2.0.0', '< 3']
+  spec.add_dependency 'solidus_support', '~> 0.5'
+  spec.add_dependency 'truncate_html', '~> 0.9', '>= 0.9.2'
+
+  spec.add_development_dependency 'rails-controller-testing'
+  spec.add_development_dependency 'rspec-activemodel-mocks'
+  spec.add_development_dependency 'selenium-webdriver'
+  spec.add_development_dependency 'solidus_dev_support'
+end

data/spec/controllers/controller_helpers_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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
+  before do
+    I18n.enforce_available_locales = false
+    stub_spree_preferences(SolidusStarterFrontend::Config, locale: :de)
+    I18n.backend.store_translations(:de, spree: {
+      i18n: { this_file_language: "Deutsch (DE)" }
+    })
+  end
+
+  after do
+    I18n.reload!
+    I18n.locale = :en
+    I18n.enforce_available_locales = true
+  end
+
+  # Regression test for https://github.com/spree/spree/issues/1184
+  it "sets the default locale based off SolidusStarterFrontend::Config[:locale]" do
+    expect(I18n.locale).to eq(:en)
+    get :index
+    expect(I18n.locale).to eq(:de)
+  end
+end

data/spec/controllers/locale_controller_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spree::LocaleController, type: :controller do
+  include_context "fr locale"
+
+  context 'switch_to_locale specified' do
+    context "available locale" do
+      it 'sets locale and redirects' do
+        get :set, params: { switch_to_locale: 'fr' }
+        expect(I18n.locale).to eq :fr
+        expect(response).to redirect_to('/')
+        expect(session[:locale]).to eq('fr')
+        expect(flash[:notice]).to eq(I18n.t("spree.locale_changed"))
+      end
+    end
+
+    context "unavailable locale" do
+      it 'does not change locale and redirects' do
+        get :set, params: { switch_to_locale: 'klingon' }
+        expect(I18n.locale).to eq :en
+        expect(response).to redirect_to('/')
+        expect(flash[:error]).to eq(I18n.t("spree.locale_not_changed"))
+      end
+    end
+  end
+
+  context 'locale specified' do
+    context "available locale" do
+      it 'sets locale and redirects' do
+        get :set, params: { locale: 'fr' }
+        expect(I18n.locale).to eq :fr
+        expect(response).to redirect_to('/')
+        expect(flash[:notice]).to eq(I18n.t("spree.locale_changed"))
+      end
+    end
+
+    context "unavailable locale" do
+      it 'does not change locale and redirects' do
+        get :set, params: { locale: 'klingon' }
+        expect(I18n.locale).to eq :en
+        expect(response).to redirect_to('/')
+        expect(flash[:error]).to eq(I18n.t("spree.locale_not_changed"))
+      end
+    end
+  end
+
+  context 'both locale and switch_to_locale specified' do
+    it 'uses switch_to_locale value' do
+      get :set, params: { locale: 'en', switch_to_locale: 'fr' }
+      expect(I18n.locale).to eq :fr
+      expect(response).to redirect_to('/')
+      expect(flash[:notice]).to eq(I18n.t("spree.locale_changed"))
+    end
+  end
+end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -0,0 +1,563 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::CheckoutController, type: :controller do
+  let(:token) { 'some_token' }
+  let(:user) { create(:user) }
+  let(:order) { FactoryBot.create(:order_with_totals) }
+
+  let(:address_params) do
+    address = FactoryBot.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 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
+      get :edit, params: { state: 'address' }
+    end
+
+    it "should redirect to the cart path unless checkout_allowed?" do
+      allow(order).to receive_messages checkout_allowed?: false
+      get :edit, params: { 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)
+      get :edit, params: { 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)
+      get :edit, params: { state: "address" }
+      expect(response).to redirect_to(spree.cart_path)
+    end
+
+    # Regression test for https://github.com/spree/spree/issues/2280
+    it "should redirect to current step trying to access a future step" do
+      order.update_column(:state, "address")
+      get :edit, params: { 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)
+        get :edit
+      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
+      post :update, params: { state: 'address', order: { bill_address_attributes: address_params } }
+    end
+
+    context "save successful" do
+      def post_address
+        post :update, params: {
+          state: "address",
+          order: {
+            bill_address_attributes: address_params,
+            use_billing: true
+          }
+        }
+      end
+
+      let!(:payment_method) { create(:payment_method) }
+      before do
+        # Must have *a* shipping method and a payment method so updating from address works
+        allow(order).to receive_messages ensure_available_shipping_rates: true
+        order.line_items << FactoryBot.create(:line_item)
+      end
+
+      context "with the order in the cart state", partial_double_verification: false do
+        before do
+          order.update! user: user
+          order.update_column(:state, "cart")
+        end
+
+        it "should assign order" do
+          post :update, params: { state: "address", order: { bill_address_attributes: address_params } }
+          expect(assigns[:order]).not_to be_nil
+        end
+
+        it "should advance the state" do
+          post_address
+          expect(order.reload.state).to eq("delivery")
+        end
+
+        it "should redirect the next state" do
+          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)
+            post :update, params: {
+              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
+            post :update, params: {
+              state: "address",
+              order: {
+                bill_address_attributes: address_params,
+                use_billing: true
+              },
+              save_user_address: "1"
+            }
+          end
+        end
+      end
+
+      context "with the order in the address state", partial_double_verification: false do
+        before do
+          order.update! user: user
+          order.update_columns(ship_address_id: create(:address).id, state: "address")
+        end
+
+        context 'landing to address page' do
+          it "tries to associate user addresses to order" do
+            expect(order).to receive(:assign_default_user_addresses)
+            get :edit
+          end
+        end
+
+        context "with a billing and shipping address", partial_double_verification: false do
+          subject do
+            post :update, params: {
+              state: "address",
+              order: {
+                bill_address_attributes: order.bill_address.attributes.except("created_at", "updated_at").compact,
+                ship_address_attributes: order.ship_address.attributes.except("created_at", "updated_at").compact,
+                use_billing: false
+              }
+            }
+          end
+
+          it "doesn't change bill address" do
+            expect {
+              subject
+            }.not_to change { order.reload.ship_address.id }
+          end
+
+          it "doesn't change ship address" do
+            expect {
+              subject
+            }.not_to change { order.reload.bill_address.id }
+          end
+        end
+      end
+
+      # This is the only time that we need the 'set_payment_parameters_amount'
+      # controller code, because otherwise the transition to 'confirm' will
+      # trigger the 'add_store_credit_payments' transition code which will do
+      # the same thing here.
+      # Perhaps we can just remove 'set_payment_parameters_amount' entirely at
+      # some point?
+      context "when there is a checkout step between payment and confirm", partial_double_verification: false do
+        before do
+          @old_checkout_flow = Spree::Order.checkout_flow
+          Spree::Order.class_eval do
+            insert_checkout_step :new_step, after: :payment
+          end
+        end
+
+        after do
+          Spree::Order.checkout_flow(&@old_checkout_flow)
+        end
+
+        let(:order) { create(:order_with_line_items) }
+        let(:payment_method) { create(:credit_card_payment_method) }
+
+        let(:params) do
+          {
+            state: 'payment',
+            order: {
+              payments_attributes: [
+                {
+                  payment_method_id: payment_method.id.to_s,
+                  source_attributes: attributes_for(:credit_card)
+                }
+              ]
+            }
+          }
+        end
+
+        before do
+          order.update! user: user
+          3.times { order.next! } # should put us in the payment state
+        end
+
+        it 'sets the payment amount' do
+          post :update, params: params
+          order.reload
+          expect(order.state).to eq('new_step')
+          expect(order.payments.size).to eq(1)
+          expect(order.payments.first.amount).to eq(order.total)
+        end
+      end
+
+      context "when in the payment state", partial_double_verification: false do
+        let(:order) { create(:order_with_line_items) }
+        let(:payment_method) { create(:credit_card_payment_method) }
+
+        let(:params) do
+          {
+            state: 'payment',
+            order: {
+              payments_attributes: [
+                {
+                  payment_method_id: payment_method.id.to_s,
+                  source_attributes: attributes_for(:credit_card)
+                }
+              ]
+            }
+          }
+        end
+
+        before do
+          order.update! user: user
+          3.times { order.next! } # should put us in the payment state
+        end
+
+        context 'with a permitted payment method' do
+          it 'sets the payment amount' do
+            post :update, params: params
+            order.reload
+            expect(order.state).to eq('confirm')
+            expect(order.payments.size).to eq(1)
+            expect(order.payments.first.amount).to eq(order.total)
+          end
+        end
+
+        context 'with an unpermitted payment method' do
+          before { payment_method.update!(available_to_users: false) }
+
+          it 'sets the payment amount' do
+            expect {
+              post :update, params: params
+            }.to raise_error(ActiveRecord::RecordNotFound)
+
+            expect(order.state).to eq('payment')
+            expect(order.payments).to be_empty
+          end
+        end
+
+        context 'trying to change the address' do
+          let(:params) do
+            {
+              state: 'payment',
+              order: {
+                payments_attributes: [
+                  {
+                    payment_method_id: payment_method.id.to_s,
+                    source_attributes: attributes_for(:credit_card)
+                  }
+                ],
+                ship_address_attributes: {
+                  zipcode: 'TEST'
+                }
+              }
+            }
+          end
+
+          it 'does not change the address' do
+            expect do
+              post :update, params: params
+            end.not_to change { order.reload.ship_address.zipcode }
+          end
+        end
+      end
+
+      context "when in the confirm state" do
+        before do
+          order.update! user: user
+          order.update_column(:state, "confirm")
+          # 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.create_proposed_shipments
+          order.payments.reload
+        end
+
+        # This inadvertently is a regression test for https://github.com/spree/spree/issues/2694
+        it "should redirect to the order view" do
+          post :update, params: { state: "confirm" }
+          expect(response).to redirect_to spree.order_path(order)
+        end
+
+        it "should populate the flash message" do
+          post :update, params: { state: "confirm" }
+          expect(flash.notice).to eq(I18n.t('spree.order_processed_successfully'))
+        end
+
+        it "should remove completed order from current_order" do
+          post :update, params: { state: "confirm" }
+          expect(assigns(:current_order)).to be_nil
+          expect(assigns(:order)).to eql controller.current_order
+        end
+      end
+    end
+
+    context "save unsuccessful" do
+      before do
+        order.update! user: user
+        allow(order).to receive_messages valid?: false
+      end
+
+      it "should not assign order" do
+        post :update, params: { state: "address", order: { email: '' }  }
+        expect(assigns[:order]).not_to be_nil
+      end
+
+      it "should not change the order state" do
+        expect do
+          post :update, params: { state: 'address', order: { bill_address_attributes: address_params } }
+        end.not_to change { order.reload.state }
+      end
+
+      it "should render the edit template" do
+        post :update, params: { state: 'address', order: { bill_address_attributes: address_params } }
+        expect(response).to render_template :edit
+      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)
+        post :update, params: { state: "confirm" }
+      end
+
+      it "should redirect to the cart_path" do
+        post :update, params: { state: "confirm" }
+        expect(response).to redirect_to spree.cart_path
+      end
+    end
+
+    context "Spree::Core::GatewayError" do
+      before do
+        order.update! user: user
+        allow(order).to receive(:next).and_raise(Spree::Core::GatewayError.new("Invalid something or other."))
+        post :update, params: { state: "address", order: { bill_address_attributes: address_params } }
+      end
+
+      it "should render the edit template and display exception message" do
+        expect(response).to render_template :edit
+        expect(flash.now[:error]).to eq(I18n.t('spree.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
+        FactoryBot.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 order is invalid" do
+        before do
+          allow(order).to receive_messages valid?: true, next: nil
+          order.errors.add :base, 'Base error'
+          order.errors.add :adjustments, 'error'
+        end
+
+        it "due to the order having errors" do
+          put :update, params: { state: order.state, order: { bill_address_attributes: address_params } }
+          expect(flash[:error]).to eq("Base error\nAdjustments error")
+          expect(response).to redirect_to(spree.checkout_state_path('address'))
+        end
+      end
+
+      context "when the country is not a shippable country" do
+        let(:foreign_address) { create(:address, country_iso_code: "CA") }
+
+        before do
+          order.update(shipping_address: foreign_address)
+        end
+
+        it "due to no available shipping rates for any of the shipments" do
+          put :update, params: { state: "address", order: { bill_address_attributes: address_params } }
+          expect(flash[:error]).to eq(I18n.t('spree.items_cannot_be_shipped'))
+          expect(response).to redirect_to(spree.checkout_state_path('address'))
+        end
+      end
+    end
+
+    context "when GatewayError is raised" do
+      let(:order) do
+        FactoryBot.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 = FactoryBot.create(:simple_credit_card_payment_method)
+          payment = FactoryBot.create(:payment, payment_method: payment_method, amount: order.total)
+          order.payments << payment
+          order.next!
+        end
+      end
+
+      before do
+        allow(controller).to receive_messages current_order: order
+        allow(controller).to receive_messages check_authorization: true
+      end
+
+      it "fails to transition from payment to complete" do
+        allow_any_instance_of(Spree::Payment).to receive(:process!).and_raise(Spree::Core::GatewayError.new(I18n.t('spree.payment_processing_failed')))
+        put :update, params: { state: order.state, order: {} }
+        expect(flash[:error]).to eq(I18n.t('spree.payment_processing_failed'))
+      end
+    end
+
+    context "when InsufficientStock error is raised" do
+      before do
+        allow(controller).to receive_messages current_order: order
+        allow(controller).to receive_messages check_authorization: true
+        allow(controller).to receive_messages ensure_sufficient_stock_lines: true
+      end
+
+      context "when the order has no shipments" do
+        let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:address) }
+
+        before do
+          allow(order).to receive_messages shipments: []
+          # Order#next is the tipical failure point here:
+          allow(order).to receive(:next).and_raise(Spree::Order::InsufficientStock)
+        end
+
+        it "redirects the customer to the cart page with an error message" do
+          put :update, params: { state: order.state, order: { bill_address_attributes: address_params } }
+          expect(flash[:error]).to eq(I18n.t('spree.insufficient_stock_for_order'))
+          expect(response).to redirect_to(spree.cart_path)
+        end
+      end
+
+      context "when the order has shipments" do
+        let(:order) { Spree::TestingSupport::OrderWalkthrough.up_to(:payment) }
+
+        context "when items become somehow not available anymore" do
+          before { Spree::StockItem.update_all backorderable: false }
+
+          it "redirects the customer to the address checkout page with an error message" do
+            put :update, params: { state: order.state, order: {} }
+            error = I18n.t('spree.inventory_error_flash_for_insufficient_shipment_quantity', unavailable_items: order.products.first.name)
+            expect(flash[:error]).to eq(error)
+            expect(response).to redirect_to(spree.checkout_state_path(state: :address))
+          end
+        end
+      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, name: "Amazing Item" }
+    let(:order) { create(:order) }
+
+    before do
+      allow(order).to receive_messages(line_items: [line_item], state: "payment")
+
+      stub_spree_preferences(track_inventory_levels: true)
+    end
+
+    context "and back orders are not allowed" do
+      before do
+        post :update, params: { 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("Amazing Item became unavailable.")
+      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 a default shipping address on the order" do
+      expect(order).to_not receive(:ship_address=)
+      post :update, params: { state: order.state, order: { bill_address_attributes: address_params } }
+    end
+
+    it "doesn't remove unshippable items before payment" do
+      expect {
+        post :update, params: { 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 {
+      post :update, params: { state: "payment", order: { email: "johndoe@example.com" } }
+    }.to change { order.line_items.to_a.size }.from(1).to(0)
+  end
+
+  context 'trying to apply a coupon code' do
+    let(:order) { create(:order_with_line_items, state: 'payment', guest_token: 'a token') }
+    let(:coupon_code) { "coupon_code" }
+
+    before { cookies.signed[:guest_token] = order.guest_token }
+
+    context "when coupon code is empty" do
+      let(:coupon_code) { "" }
+
+      it 'does not try to apply coupon code' do
+        expect(Spree::PromotionHandler::Coupon).not_to receive :new
+
+        put :update, params: { state: order.state, order: { coupon_code: coupon_code } }
+
+        expect(response).to redirect_to(spree.checkout_state_path('confirm'))
+      end
+    end
+  end
+end