solidus_starter_frontend 0.1.0

data/spec/controllers/spree/checkout_controller_with_views_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# This spec is useful for when we just want to make sure a view is rendering correctly
+# Walking through the entire checkout process is rather tedious, don't you think?
+describe Spree::CheckoutController, type: :controller do
+  render_views
+  let(:token) { 'some_token' }
+  let(:user) { stub_model(Spree::LegacyUser) }
+
+  before do
+    allow(controller).to receive_messages try_spree_current_user: user
+  end
+
+  # Regression test for https://github.com/spree/spree/issues/3246
+  context "when using GBP" do
+    before do
+      stub_spree_preferences(currency: "GBP")
+    end
+
+    context "when order is in delivery" do
+      before do
+        # Using a let block won't acknowledge the currency setting
+        # Therefore we just do it like this...
+        order = Spree::TestingSupport::OrderWalkthrough.up_to(:address)
+        allow(controller).to receive_messages current_order: order
+      end
+
+      it "displays rate cost in correct currency" do
+        get :edit
+        html = Nokogiri::HTML(response.body)
+        expect(html.css('.shipping-methods__rate').text.strip).to have_content("£10.00")
+      end
+    end
+  end
+end

data/spec/controllers/spree/current_order_tracking_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'current order tracking', type: :controller do
+  let!(:store) { create(:store) }
+  let(:user) { create(:user) }
+
+  controller(Spree::StoreController) do
+    def index
+      head :ok
+    end
+  end
+
+  let(:order) { FactoryBot.create(:order) }
+
+  it 'automatically tracks who the order was created by & IP address' do
+    allow(controller).to receive_messages(try_spree_current_user: user)
+    get :index
+    expect(controller.current_order(create_order_if_necessary: true).created_by).to eq controller.try_spree_current_user
+    expect(controller.current_order.last_ip_address).to eq "0.0.0.0"
+  end
+
+  context "current order creation" do
+    before { allow(controller).to receive_messages(try_spree_current_user: user) }
+
+    it "doesn't create a new order out of the blue" do
+      expect {
+        get :index
+      }.not_to change { Spree::Order.count }
+    end
+  end
+end

data/spec/controllers/spree/home_controller_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::HomeController, type: :controller do
+  it "provides current user to the searcher class" do
+    user = mock_model(Spree.user_class, last_incomplete_spree_order: nil, spree_api_key: 'fake')
+    allow(controller).to receive_messages try_spree_current_user: user
+    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
+    get :index
+    expect(response.status).to eq(200)
+  end
+
+  context "layout" do
+    it "renders default layout" do
+      get :index
+      expect(response).to render_template(layout: 'spree/layouts/spree_application')
+    end
+
+    context "different layout specified in config" do
+      before { stub_spree_preferences(layout: 'layouts/application') }
+
+      it "renders specified layout" do
+        get :index
+        expect(response).to render_template(layout: 'layouts/application')
+      end
+    end
+  end
+end

data/spec/controllers/spree/orders_controller_ability_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Spree
+  describe OrdersController, type: :controller do
+    ORDER_TOKEN = 'ORDER_TOKEN'
+
+    let!(:store) { create(:store) }
+    let(:order) { Spree::Order.create }
+    let(:variant) { create(:variant) }
+
+    it 'should understand order routes with token' do
+      expect(spree.token_order_path('R123456', 'ABCDEF')).to eq('/orders/R123456/token/ABCDEF')
+    end
+
+    context 'when an order exists in the cookies.signed' do
+      let(:token) { 'some_token' }
+
+      before do
+        allow(controller).to receive_messages current_order: order
+      end
+
+      context '#populate' do
+        it 'should check if user is authorized for :update' do
+          expect(controller).to receive(:authorize!).with(:update, order, token)
+          post :populate, params: { variant_id: variant.id, token: token }
+        end
+      end
+
+      context '#edit' do
+        it 'should check if user is authorized for :read' do
+          expect(controller).to receive(:authorize!).with(:read, order, token)
+          get :edit, params: { token: token }
+        end
+      end
+
+      context '#update' do
+        it 'should check if user is authorized for :update' do
+          allow(order).to receive :update
+          expect(controller).to receive(:authorize!).with(:update, order, token)
+          post :update, params: { order: { email: "foo@bar.com" }, token: token }
+        end
+      end
+
+      context '#empty' do
+        it 'should check if user is authorized for :update' do
+          expect(controller).to receive(:authorize!).with(:update, order, token)
+          post :empty, params: { token: token }
+        end
+      end
+
+      context "#show" do
+        let(:specified_order) { create(:order) }
+
+        it "should check against the specified order" do
+          expect(controller).to receive(:authorize!).with(:read, specified_order, token)
+          get :show, params: { id: specified_order.number, token: token }
+        end
+      end
+    end
+
+    context 'when no authenticated user' do
+      let(:order) { create(:order, number: 'R123') }
+
+      context '#show' do
+        context 'when token parameter present' do
+          it 'always ooverride existing token when passing a new one' do
+            cookies.signed[:guest_token] = "soo wrong"
+            get :show, params: { id: 'R123', token: order.guest_token }
+            expect(cookies.signed[:guest_token]).to eq(order.guest_token)
+          end
+
+          it 'should store as guest_token in session' do
+            get :show, params: { id: 'R123', token: order.guest_token }
+            expect(cookies.signed[:guest_token]).to eq(order.guest_token)
+          end
+        end
+
+        context 'when no token present' do
+          it 'should respond with 404' do
+            expect {
+              get :show, params: { id: 'R123' }
+            }.to raise_error(ActiveRecord::RecordNotFound)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/controllers/spree/orders_controller_spec.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::OrdersController, type: :controller do
+  let!(:store) { create(:store) }
+  let(:user) { create(:user) }
+
+  context "Order model mock" do
+    let(:order) do
+      Spree::Order.create!
+    end
+    let(:variant) { create(:variant) }
+
+    before do
+      allow(controller).to receive_messages(try_spree_current_user: user)
+    end
+
+    context "#populate" do
+      it "should create a new order when none specified" do
+        post :populate, params: { variant_id: variant.id }
+        expect(response).to be_redirect
+        expect(cookies.signed[:guest_token]).not_to be_blank
+
+        order_by_token = Spree::Order.find_by(guest_token: cookies.signed[:guest_token])
+        assigned_order = assigns[:order]
+
+        expect(assigned_order).to eq order_by_token
+        expect(assigned_order).to be_persisted
+      end
+
+      context "with Variant" do
+        it "should handle population" do
+          expect do
+            post :populate, params: { variant_id: variant.id, quantity: 5 }
+          end.to change { user.orders.count }.by(1)
+          order = user.orders.last
+          expect(response).to redirect_to spree.cart_path
+          expect(order.line_items.size).to eq(1)
+          line_item = order.line_items.first
+          expect(line_item.variant_id).to eq(variant.id)
+          expect(line_item.quantity).to eq(5)
+        end
+
+        it "shows an error when population fails" do
+          request.env["HTTP_REFERER"] = spree.root_path
+          allow_any_instance_of(Spree::LineItem).to(
+            receive(:valid?).and_return(false)
+          )
+          allow_any_instance_of(Spree::LineItem).to(
+            receive_message_chain(:errors, :full_messages).
+              and_return(["Order population failed"])
+          )
+
+          post :populate, params: { variant_id: variant.id, quantity: 5 }
+
+          expect(response).to redirect_to(spree.root_path)
+          expect(flash[:error]).to eq("Order population failed")
+        end
+
+        it "shows an error when quantity is invalid" do
+          request.env["HTTP_REFERER"] = spree.root_path
+
+          post(
+            :populate,
+            params: { variant_id: variant.id, quantity: -1 }
+          )
+
+          expect(response).to redirect_to(spree.root_path)
+          expect(flash[:error]).to eq(
+            I18n.t('spree.please_enter_reasonable_quantity')
+          )
+        end
+
+        context "when quantity is empty string" do
+          it "should populate order with 1 of given variant" do
+            expect do
+              post :populate, params: { variant_id: variant.id, quantity: '' }
+            end.to change { Spree::Order.count }.by(1)
+            order = Spree::Order.last
+            expect(response).to redirect_to spree.cart_path
+            expect(order.line_items.size).to eq(1)
+            line_item = order.line_items.first
+            expect(line_item.variant_id).to eq(variant.id)
+            expect(line_item.quantity).to eq(1)
+          end
+        end
+
+        context "when quantity is nil" do
+          it "should populate order with 1 of given variant" do
+            expect do
+              post :populate, params: { variant_id: variant.id, quantity: nil }
+            end.to change { Spree::Order.count }.by(1)
+            order = Spree::Order.last
+            expect(response).to redirect_to spree.cart_path
+            expect(order.line_items.size).to eq(1)
+            line_item = order.line_items.first
+            expect(line_item.variant_id).to eq(variant.id)
+            expect(line_item.quantity).to eq(1)
+          end
+        end
+      end
+    end
+
+    context '#edit' do
+      before do
+        allow(controller).to receive :authorize!
+        allow(controller).to receive_messages current_order: order
+      end
+
+      it 'should render cart' do
+        get :edit, params: { id: order.number }
+
+        expect(flash[:error]).to be_nil
+        expect(response).to be_ok
+      end
+
+      context 'with another order number than the current_order' do
+        let(:other_order) { create(:completed_order_with_totals) }
+
+        it 'should display error message' do
+          get :edit, params: { id: other_order.number }
+
+          expect(flash[:error]).to eq "You may only edit your current shopping cart."
+          expect(response).to redirect_to cart_path
+        end
+      end
+    end
+
+    context "#update" do
+      context "with authorization" do
+        before do
+          allow(controller).to receive :authorize!
+          allow(controller).to receive_messages current_order: order
+        end
+
+        it "should render the edit view (on failure)" do
+          # email validation is only after address state
+          order.update_column(:state, "delivery")
+          put :update, params: { order: { email: "" } }
+          expect(response).to render_template :edit
+        end
+
+        it "should redirect to cart path (on success)" do
+          allow(order).to receive(:update).and_return true
+          put :update
+          expect(response).to redirect_to(spree.cart_path)
+        end
+
+        it "should advance the order if :checkout button is pressed" do
+          allow(order).to receive(:update).and_return true
+          expect(order).to receive(:next)
+          put :update, params: { checkout: true }
+          expect(response).to redirect_to checkout_state_path('address')
+        end
+
+        context 'trying to apply a coupon code' do
+          let(:order) { create(:order_with_line_items, state: 'cart') }
+          let(:coupon_code) { "coupon_code" }
+
+          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.cart_path)
+            end
+          end
+        end
+      end
+    end
+
+    context "#empty" do
+      before do
+        allow(controller).to receive :authorize!
+      end
+
+      it "should destroy line items in the current order" do
+        allow(controller).to receive(:current_order).and_return(order)
+        expect(order).to receive(:empty!)
+        put :empty
+        expect(response).to redirect_to(spree.cart_path)
+      end
+    end
+
+    # Regression test for https://github.com/spree/spree/issues/2750
+    context "#update" do
+      before do
+        allow(user).to receive :last_incomplete_spree_order
+        allow(controller).to receive :set_current_order
+      end
+
+      it "cannot update a blank order" do
+        put :update, params: { order: { email: "foo" } }
+        expect(flash[:error]).to eq(I18n.t('spree.order_not_found'))
+        expect(response).to redirect_to(spree.root_path)
+      end
+    end
+  end
+
+  context "line items quantity is 0" do
+    let(:order) { Spree::Order.create(store: store) }
+    let(:variant) { create(:variant) }
+    let!(:line_item) { order.contents.add(variant, 1) }
+
+    before do
+      allow(controller).to receive :authorize!
+      allow(controller).to receive_messages(current_order: order)
+    end
+
+    it "removes line items on update" do
+      expect(order.line_items.count).to eq 1
+      put :update, params: { order: { line_items_attributes: { "0" => { id: line_item.id, quantity: 0 } } } }
+      expect(order.reload.line_items.count).to eq 0
+    end
+  end
+
+  describe '#edit' do
+    subject { get :edit }
+    let(:user) { build :user }
+
+    it "builds a new valid order with complete meta-data" do
+      allow(controller).to receive_messages(try_spree_current_user: user)
+
+      subject
+
+      order = controller.instance_variable_get(:@order)
+
+      aggregate_failures do
+        expect(order).to be_valid
+        expect(order).not_to be_persisted
+        expect(order.store).to be_present
+        expect(order.user).to eq(user)
+        expect(order.created_by).to eq(user)
+      end
+    end
+  end
+end

data/spec/controllers/spree/orders_controller_transitions_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+Spree::Order.class_eval do
+  attr_accessor :did_transition
+end
+
+module Spree
+  describe OrdersController, type: :controller do
+    # Regression test for https://github.com/spree/spree/issues/2004
+    context "with a transition callback on first state" do
+      let(:order) { Spree::Order.new }
+
+      before do
+        allow(controller).to receive_messages current_order: order
+        expect(controller).to receive(:authorize!).at_least(:once).and_return(true)
+
+        first_state, = Spree::Order.checkout_steps.first
+        Spree::Order.state_machine.after_transition to: first_state do |order|
+          order.did_transition = true
+        end
+      end
+
+      it "correctly calls the transition callback" do
+        expect(order.did_transition).to be_nil
+        order.line_items << FactoryBot.create(:line_item)
+        put :update, params: { checkout: "checkout" }
+        expect(order.did_transition).to be true
+      end
+    end
+  end
+end