solidus_core 2.10.5 → 2.11.0

data/spec/lib/spree/core/class_constantizer_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'spree/core/class_constantizer'
-
-module ClassConstantizerTest
-  ClassA = Class.new
-  ClassB = Class.new
-
-  def self.reload
-    [:ClassA, :ClassB].each do |klass|
-      remove_const(klass)
-      const_set(klass, Class.new)
-    end
-  end
-end
-
-RSpec.describe Spree::Core::ClassConstantizer::Set do
-  let(:set) { described_class.new }
-
-  describe "#concat" do
-    it "can add one item" do
-      set.concat(['ClassConstantizerTest::ClassA'])
-      expect(set).to include(ClassConstantizerTest::ClassA)
-    end
-
-    it "can add two items" do
-      set.concat(['ClassConstantizerTest::ClassA', ClassConstantizerTest::ClassB])
-      expect(set).to include(ClassConstantizerTest::ClassA)
-      expect(set).to include(ClassConstantizerTest::ClassB)
-    end
-
-    it "returns itself" do
-      expect(set.concat(['String'])).to eql(set)
-    end
-  end
-
-  describe "<<" do
-    it "can add by string" do
-      set << "ClassConstantizerTest::ClassA"
-      expect(set).to include(ClassConstantizerTest::ClassA)
-    end
-
-    it "can add by class" do
-      set << ClassConstantizerTest::ClassA
-      expect(set).to include(ClassConstantizerTest::ClassA)
-    end
-
-    describe "class redefinition" do
-      shared_examples "working code reloading" do
-        it "works with a class" do
-          original = ClassConstantizerTest::ClassA
-
-          ClassConstantizerTest.reload
-
-          # Sanity check
-          expect(original).not_to eq(ClassConstantizerTest::ClassA)
-
-          expect(set).to include(ClassConstantizerTest::ClassA)
-          expect(set).to_not include(original)
-        end
-      end
-
-      context "with a class" do
-        before { set << ClassConstantizerTest::ClassA }
-        it_should_behave_like "working code reloading"
-      end
-
-      context "with a string" do
-        before { set << "ClassConstantizerTest::ClassA" }
-        it_should_behave_like "working code reloading"
-      end
-    end
-  end
-
-  describe "#delete" do
-    before do
-      set << ClassConstantizerTest::ClassA
-    end
-
-    it "can delete by string" do
-      set.delete "ClassConstantizerTest::ClassA"
-      expect(set).not_to include(ClassConstantizerTest::ClassA)
-    end
-
-    it "can delete by class" do
-      set.delete ClassConstantizerTest::ClassA
-      expect(set).not_to include(ClassConstantizerTest::ClassA)
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/auth_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Auth
-  def index; render plain: 'index'; end
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Auth, type: :controller do
-  controller(FakesController) {}
-
-  describe '#current_ability' do
-    it 'returns Spree::Ability instance' do
-      expect(controller.current_ability.class).to eq Spree::Ability
-    end
-  end
-
-  describe '#redirect_back_or_default' do
-    controller(FakesController) do
-      def index; redirect_back_or_default('/'); end
-    end
-    it 'redirects to session url' do
-      session[:spree_user_return_to] = '/redirect'
-      get :index
-      expect(response).to redirect_to('/redirect')
-    end
-    it 'redirects to default page' do
-      get :index
-      expect(response).to redirect_to('/')
-    end
-  end
-
-  describe '#set_guest_token' do
-    controller(FakesController) do
-      def index
-        set_guest_token
-        render plain: 'index'
-      end
-    end
-    it 'sends cookie header' do
-      get :index
-      expect(response.headers["Set-Cookie"]).to match(/guest_token.*HttpOnly/)
-      expect(response.cookies['guest_token']).not_to be_nil
-    end
-  end
-
-  describe '#store_location' do
-    it 'sets session return url' do
-      allow(controller).to receive_messages(request: double(fullpath: '/redirect'))
-      controller.store_location
-      expect(session[:spree_user_return_to]).to eq '/redirect'
-    end
-  end
-
-  describe '#try_spree_current_user' do
-    it 'calls spree_current_user when define spree_current_user method' do
-      without_partial_double_verification do
-        expect(controller).to receive(:spree_current_user)
-      end
-      controller.try_spree_current_user
-    end
-    it 'calls current_spree_user when define current_spree_user method' do
-      without_partial_double_verification do
-        expect(controller).to receive(:current_spree_user)
-      end
-      controller.try_spree_current_user
-    end
-    it 'returns nil' do
-      expect(controller.try_spree_current_user).to eq nil
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/order_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Order
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Order, type: :controller do
-  controller(FakesController) {}
-
-  let(:user) { create(:user) }
-  let(:order) { create(:order, user: user, store: store) }
-  let(:store) { create(:store) }
-
-  before do
-    allow(controller).to receive_messages(current_store: store)
-    allow(controller).to receive_messages(current_pricing_options: Spree::Config.pricing_options_class.new(currency: Spree::Config.currency))
-    allow(controller).to receive_messages(try_spree_current_user: user)
-  end
-
-  describe '#simple_current_order' do
-    it "returns an empty order" do
-      Spree::Deprecation.silence do
-        expect(controller.simple_current_order.item_count).to eq 0
-      end
-    end
-    it 'returns Spree::Order instance' do
-      Spree::Deprecation.silence do
-        allow(controller).to receive_messages(cookies: double(signed: { guest_token: order.guest_token }))
-        expect(controller.simple_current_order).to eq order
-      end
-    end
-    it 'assigns the current_store id' do
-      Spree::Deprecation.silence do
-        expect(controller.simple_current_order.store_id).to eq store.id
-      end
-    end
-    it 'is deprecated' do
-      Spree::Deprecation.silence do
-        expect(Spree::Deprecation).to(receive(:warn))
-        controller.simple_current_order
-      end
-    end
-  end
-
-  describe '#current_order' do
-    context 'create_order_if_necessary option is false' do
-      let!(:order) { create :order, user: user, store: store }
-      it 'returns current order' do
-        expect(controller.current_order).to eq order
-      end
-    end
-
-    context 'create_order_if_necessary option is true' do
-      subject { controller.current_order(create_order_if_necessary: true) }
-
-      it 'creates new order' do
-        expect {
-          subject
-        }.to change(Spree::Order, :count).from(0).to(1)
-      end
-
-      it 'assigns the current_store id' do
-        subject
-        expect(Spree::Order.last.store_id).to eq store.id
-      end
-
-      it 'records last_ip_address' do
-        expect {
-          subject
-        }.to change {
-          Spree::Order.last.try!(:last_ip_address)
-        }.from(nil).to("0.0.0.0")
-      end
-    end
-  end
-
-  describe '#associate_user' do
-    before { allow(controller).to receive_messages(current_order: order) }
-    context "user's email is blank" do
-      let(:user) { create(:user, email: '') }
-      it 'calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-    context "user isn't blank" do
-      it 'does not calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).not_to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-  end
-
-  describe '#set_current_order' do
-    let(:incomplete_order) { create(:order, store: incomplete_order_store, user: user) }
-
-    context 'when current order not equal to users incomplete orders' do
-      before { allow(controller).to receive_messages(current_order: order, last_incomplete_order: incomplete_order, cookies: double(signed: { guest_token: 'guest_token' })) }
-
-      context "an order from another store" do
-        let(:incomplete_order_store) { create(:store) }
-
-        it 'doesnt call Spree::Order#merge! method' do
-          expect(order).to_not receive(:merge!)
-          controller.set_current_order
-        end
-      end
-      context "an order from the same store" do
-        let(:incomplete_order_store) { store }
-
-        it 'calls Spree::Order#merge! method' do
-          expect(order).to receive(:merge!).with(incomplete_order, user)
-          controller.set_current_order
-        end
-      end
-    end
-  end
-
-  describe '#ip_address' do
-    it 'returns remote ip' do
-      expect(controller.ip_address).to eq request.remote_ip
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/payment_parameters_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Core::ControllerHelpers::PaymentParameters, type: :controller do
-  controller(ApplicationController) do
-    include Spree::Core::ControllerHelpers::PaymentParameters
-  end
-
-  let(:params_hash) { subject.permit!.to_h.deep_symbolize_keys }
-
-  shared_examples "unpermitted params" do
-    it "is unpermitted ActionController::Parameters" do
-      expect(subject).to be_a(ActionController::Parameters)
-      expect(subject).not_to be_permitted
-    end
-  end
-
-  shared_examples "unchanged params" do
-    let!(:original_param_hash) { params.dup.permit!.to_h.deep_symbolize_keys }
-
-    it 'returns the original hash' do
-      expect(params_hash).to eq(original_param_hash)
-    end
-
-    it_behaves_like "unpermitted params"
-  end
-
-  describe '#move_payment_source_into_payments_attributes' do
-    subject do
-      controller.move_payment_source_into_payments_attributes(params)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        payment_source: {
-          payment_method_1.id.to_s => credit_card_1_params,
-          payment_method_2.id.to_s => credit_card_2_params
-        },
-        order: {
-          payments_attributes: [
-            {
-              payment_method_id: payment_method_1.id.to_s
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    let(:payment_method_1) { create(:credit_card_payment_method) }
-    let(:payment_method_2) { create(:credit_card_payment_method) }
-    let(:credit_card_1_params) { attributes_for(:credit_card, name: 'Jordan1') }
-    let(:credit_card_2_params) { attributes_for(:credit_card, name: 'Jordan2') }
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [
-            {
-              payment_method_id: payment_method_1.id.to_s,
-              source_attributes: credit_card_1_params
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    it_behaves_like "unpermitted params"
-
-    context 'when payment_source is missing' do
-      before { params.delete(:payment_source) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when order params are missing' do
-      before { params.delete(:order) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when payment_attributes are missing' do
-      before { params[:order].delete(:payments_attributes) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when the payment_method_id is missing' do
-      before { params[:order][:payments_attributes][0].delete(:payment_method_id) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when the payment_method_id does not match a payments source' do
-      before { params[:order][:payments_attributes][0][:payment_method_id] = -1 }
-      it_behaves_like "unchanged params"
-    end
-  end
-
-  describe '#move_existing_card_into_payments_attributes' do
-    subject do
-      controller.move_existing_card_into_payments_attributes(params)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        order: {
-          existing_card: '123',
-          other_order_param: 1
-        },
-        cvc_confirm: '456',
-        other_param: 2
-      )
-    end
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [
-            {
-              source_attributes: {
-                existing_card_id: '123',
-                verification_value: '456'
-              }
-            }
-          ],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-
-    it_behaves_like "unpermitted params"
-
-    context 'when cvc_confirm is missing' do
-      before { params.delete(:cvc_confirm) }
-
-      it 'produces the expected hash' do
-        expect(params_hash).to eq(
-          order: {
-            payments_attributes: [
-              {
-                source_attributes: {
-                  existing_card_id: '123',
-                  verification_value: nil
-                }
-              }
-            ],
-            other_order_param: 1
-          },
-          other_param: 2
-        )
-      end
-
-      it_behaves_like "unpermitted params"
-    end
-
-    context 'when order params are missing' do
-      before { params.delete(:order) }
-      it_behaves_like "unchanged params"
-    end
-
-    context 'when existing_card is missing' do
-      before { params[:order].delete(:existing_card) }
-      it_behaves_like "unchanged params"
-    end
-  end
-
-  describe '#set_payment_parameters_amount' do
-    subject do
-      controller.set_payment_parameters_amount(params, order)
-    end
-
-    let(:params) do
-      ActionController::Parameters.new(
-        order: {
-          payments_attributes: [{}],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-    let(:order) { create(:order_with_line_items, line_items_price: 101.00, line_items_count: 1, shipment_cost: 0) }
-
-    it 'produces the expected hash' do
-      expect(params_hash).to eq(
-        order: {
-          payments_attributes: [{ amount: 101 }],
-          other_order_param: 1
-        },
-        other_param: 2
-      )
-    end
-  end
-end