solidus_frontend 2.10.2 → 2.11.0

data/spec/controllers/spree/checkout_controller_with_views_spec.rb

@@ -1,37 +0,0 @@
-# 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('.rate-cost').text).to eq "£10.00"
-      end
-    end
-  end
-end

data/spec/controllers/spree/content_controller_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-describe Spree::ContentController, type: :controller do
-  it "should display CVV page" do
-    get :cvv
-    expect(response.response_code).to eq(200)
-  end
-end

data/spec/controllers/spree/current_order_tracking_spec.rb

@@ -1,47 +0,0 @@
-# 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
-
-describe Spree::OrdersController, type: :controller do
-  let(:user) { create(:user) }
-
-  before { allow(controller).to receive_messages(try_spree_current_user: user) }
-
-  describe Spree::OrdersController do
-    it "doesn't create a new order out of the blue" do
-      expect {
-        get :edit
-      }.not_to change { Spree::Order.count }
-    end
-  end
-end

data/spec/controllers/spree/home_controller_spec.rb

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

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

@@ -1,254 +0,0 @@
-# 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
-
-          context "when coupon code is applied" do
-            let(:promotion_handler) { instance_double('Spree::PromotionHandler::Coupon', error: nil, success: 'Coupon Applied!') }
-
-            it "continues checkout flow normally" do
-              expect(Spree::Deprecation).to receive(:warn)
-
-              expect(Spree::PromotionHandler::Coupon)
-                .to receive_message_chain(:new, :apply)
-                .and_return(promotion_handler)
-
-              put :update, params: { state: order.state, order: { coupon_code: coupon_code } }
-
-              expect(response).to redirect_to(spree.cart_path)
-              expect(flash.now[:success]).to eq('Coupon Applied!')
-            end
-
-            context "when coupon code is not applied" do
-              let(:promotion_handler) { instance_double('Spree::PromotionHandler::Coupon', error: 'Some error', success: false) }
-
-              it "render cart with coupon error" do
-                expect(Spree::Deprecation).to receive(:warn)
-
-                expect(Spree::PromotionHandler::Coupon)
-                  .to receive_message_chain(:new, :apply)
-                  .and_return(promotion_handler)
-
-                put :update, params: { state: order.state, order: { coupon_code: coupon_code } }
-
-                expect(response).to render_template :edit
-                expect(flash.now[:error]).to eq('Some error')
-              end
-            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
-end