solidus_core 2.10.5 → 3.0.8

data/spec/lib/search/variant_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Core::Search::Variant do
-    def assert_found(query_string, variant)
-      expect(described_class.new(query_string).results).to include variant
-    end
-
-    def refute_found(query_string, variant)
-      expect(described_class.new(query_string).results).not_to include variant
-    end
-
-    let(:product) { FactoryBot.create(:product, name: "My Special Product", slug: "my-special-product") }
-    let!(:variant) { FactoryBot.create(:variant, product: product, sku: "abc-123") }
-
-    context "blank string" do
-      it { assert_found(nil, variant) }
-      it { assert_found("", variant) }
-    end
-
-    context "by sku" do
-      it { assert_found("abc-123", variant) }
-      it { assert_found("abc-1", variant) }
-      it { assert_found("aBc-12", variant) }
-      it { refute_found("bca", variant) }
-    end
-
-    context "by product" do
-      it { assert_found("My Special Product", variant) }
-      it { assert_found("My Spec", variant) }
-      it { assert_found("my spec", variant) }
-      it { assert_found("my-special-product", variant) }
-      it { assert_found("my-spec", variant) }
-      it { assert_found("mY-sPec", variant) }
-      it { assert_found("My Product", variant) }
-      it { refute_found("My House", variant) }
-      it { refute_found("my-product", variant) }
-    end
-
-    context "by product + options" do
-      before do
-        variant.option_values << create(:option_value, presentation: "Robin's egg", name: "blue")
-        variant.option_values << create(:option_value, presentation: 'Slim')
-        variant.option_values << create(:option_value, presentation: '30')
-      end
-      it { assert_found("My Spec blue", variant) }
-      it { assert_found("My Spec robin egg Slim", variant) }
-      it { assert_found("My Spec 30 slim", variant) }
-      it { refute_found("My Spec red slim", variant) }
-      it { refute_found("foo product blue slim", variant) }
-    end
-
-    context "custom scope" do
-      it "takes into account a passed in scope" do
-        variant.stock_items.first.set_count_on_hand(10)
-        expect(
-          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
-        ).to include variant
-
-        variant.stock_items.each { |si| si.set_count_on_hand(0) }
-        expect(
-          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
-        ).not_to include variant
-      end
-    end
-
-    context "custom search configuration" do
-      context "removing a search query" do
-        around do |example|
-          search_terms = described_class.search_terms
-          described_class.search_terms -= [:sku_cont]
-          example.run
-          described_class.search_terms = search_terms
-        end
-
-        it { refute_found("abc-123", variant) }
-      end
-
-      context "adding a search query" do
-        around do |example|
-          search_terms = described_class.search_terms
-          described_class.search_terms += [:weight_eq]
-          example.run
-          described_class.search_terms = search_terms
-        end
-        before { variant.update!(weight: 5000) }
-
-        it { assert_found("5000", variant) }
-      end
-    end
-
-    describe '#search_terms' do
-      # Only search by SKU if the search word is a number
-      class NumericSkuSearcher < Core::Search::Variant
-        protected
-
-        def search_terms(word)
-          if word =~ /\A\d+\z/
-            super
-          else
-            super - [:sku_cont]
-          end
-        end
-      end
-
-      let!(:numeric_sku_variant) { FactoryBot.create(:variant, product: product, sku: "123") }
-      let!(:non_numeric_sku_variant) { FactoryBot.create(:variant, product: product, sku: "abc") }
-
-      it { expect(NumericSkuSearcher.new('123').results).to include numeric_sku_variant }
-      it { expect(NumericSkuSearcher.new('abc').results).not_to include non_numeric_sku_variant }
-    end
-  end
-end

data/spec/lib/spree/app_configuration_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::AppConfiguration do
-  let(:prefs) { Spree::Config }
-
-  around do |example|
-    with_unfrozen_spree_preference_store do
-      example.run
-    end
-  end
-
-  it "should be available from the environment" do
-    prefs.layout = "my/layout"
-    expect(prefs.layout).to eq "my/layout"
-  end
-
-  it "should be available as Spree::Config for legacy access" do
-    expect(Spree::Config).to be_a Spree::AppConfiguration
-  end
-
-  it "uses base searcher class by default" do
-    expect(prefs.searcher_class).to eq Spree::Core::Search::Base
-  end
-
-  it "uses variant search class by default" do
-    expect(prefs.variant_search_class).to eq Spree::Core::Search::Variant
-  end
-
-  it "uses variant price selector class by default" do
-    expect(prefs.variant_price_selector_class).to eq Spree::Variant::PriceSelector
-  end
-
-  it "has a getter for the pricing options class provided by the variant price selector class" do
-    expect(prefs.pricing_options_class).to eq Spree::Variant::PriceSelector.pricing_options_class
-  end
-
-  describe '#stock' do
-    subject { prefs.stock }
-    it { is_expected.to be_a Spree::Core::StockConfiguration }
-  end
-
-  describe '@default_country_iso_code' do
-    it 'is the USA by default' do
-      expect(prefs[:default_country_iso]).to eq("US")
-    end
-  end
-
-  describe '@admin_vat_country_iso' do
-    it 'is `nil` by default' do
-      expect(prefs[:admin_vat_country_iso]).to eq(nil)
-    end
-  end
-
-  describe '#environment' do
-    class DummyClass; end;
-
-    subject(:environment) { prefs.environment }
-    it { is_expected.to be_a Spree::Core::Environment }
-
-    shared_examples "working preferences set" do
-      it "allows adding new items" do
-        preferences_set << DummyClass
-        expect(preferences_set).to include DummyClass
-        preferences_set.delete DummyClass
-      end
-    end
-
-    context '.payment_methods' do
-      subject(:preferences_set) { environment.payment_methods }
-      it_should_behave_like "working preferences set"
-    end
-
-    context '.stock_splitters' do
-      subject(:preferences_set) { environment.stock_splitters }
-      it_should_behave_like "working preferences set"
-    end
-
-    context '.calculators' do
-      subject(:calculators) { environment.calculators }
-      it { is_expected.to be_a Spree::Core::Environment::Calculators }
-
-      context '.calculators.shipping_methods' do
-        subject(:preferences_set) { calculators.shipping_methods }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.calculators.tax_rates' do
-        subject(:preferences_set) { calculators.tax_rates }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.calculators.promotion_actions_create_adjustments' do
-        subject(:preferences_set) { calculators.promotion_actions_create_adjustments }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.calculators.promotion_actions_create_item_adjustments' do
-        subject(:preferences_set) { calculators.promotion_actions_create_item_adjustments }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.calculators.promotion_actions_create_quantity_adjustments' do
-        subject(:preferences_set) { calculators.promotion_actions_create_quantity_adjustments }
-        it_should_behave_like "working preferences set"
-      end
-    end
-
-    context '.promotions' do
-      subject(:promotions) { environment.promotions }
-      it { is_expected.to be_a Spree::Core::Environment::Promotions }
-
-      context '.promotions.rules' do
-        subject(:preferences_set) { promotions.rules }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.promotions.actions' do
-        subject(:preferences_set) { promotions.actions }
-        it_should_behave_like "working preferences set"
-      end
-
-      context '.promotions.shipping_actions' do
-        subject(:preferences_set) { promotions.shipping_actions }
-        it_should_behave_like "working preferences set"
-      end
-    end
-  end
-
-  it 'has a default admin VAT location with nil values by default' do
-    expect(prefs.admin_vat_location).to eq(Spree::Tax::TaxLocation.new)
-    expect(prefs.admin_vat_location.state_id).to eq(nil)
-    expect(prefs.admin_vat_location.country_id).to eq(nil)
-  end
-
-  it 'has default Event adapter' do
-    expect(prefs.events.adapter).to eq Spree::Event::Adapters::ActiveSupportNotifications
-  end
-end

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