solidus_core 2.10.0 → 2.11.0

data/spec/lib/i18n_spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'spree/i18n'
-
-RSpec.describe "i18n" do
-  before do
-    # This reload avoids an issue with I18n.available_locales being cached
-    I18n.reload!
-
-    I18n.backend.store_translations(:en,
-    {
-      spree: {
-        i18n: {
-          this_file_language: "English"
-        },
-        foo: "bar",
-        bar: {
-          foo: "bar within bar scope",
-          invalid: nil,
-          legacy_translation: "back in the day..."
-        },
-        invalid: nil,
-        legacy_translation: "back in the day..."
-      }
-    })
-  end
-  after do
-    I18n.reload!
-  end
-
-  it "translates within the spree scope" do
-    expect(Spree::Deprecation).to receive(:warn).twice
-    expect(Spree.t(:foo)).to eql("bar")
-    expect(Spree.translate(:foo)).to eql("bar")
-  end
-
-  it "prepends a string scope" do
-    expect(Spree::Deprecation).to receive(:warn)
-    expect(Spree.t(:foo, scope: "bar")).to eql("bar within bar scope")
-  end
-
-  it "prepends to an array scope" do
-    expect(Spree::Deprecation).to receive(:warn)
-    expect(Spree.t(:foo, scope: ["bar"])).to eql("bar within bar scope")
-  end
-
-  it "returns two translations" do
-    expect(Spree::Deprecation).to receive(:warn)
-    expect(Spree.t([:foo, 'bar.foo'])).to eql(["bar", "bar within bar scope"])
-  end
-
-  it "returns reasonable string for missing translations" do
-    expect(Spree::Deprecation).to receive(:warn)
-    expect(Spree.t(:missing_entry)).to include("<span")
-  end
-
-  it "should have a Spree::I18N_GENERIC_PLURAL constant" do
-    expect(Spree::I18N_GENERIC_PLURAL).to eq 2.1
-  end
-
-  describe "i18n_available_locales" do
-    it "should only return :en" do
-      expect(Spree.i18n_available_locales).to eq([:en])
-    end
-
-    context 'with unprefixed translations in another locale' do
-      before do
-        I18n.backend.store_translations(:fr, { cheese: "fromage" })
-      end
-
-      it "should only return :en" do
-        expect(Spree.i18n_available_locales).to eq([:en])
-      end
-    end
-
-    context 'with spree-prefixed translations in another locale' do
-      before do
-        I18n.backend.store_translations(:fr, spree: { cheese: "fromage" })
-      end
-
-      it "should return :en and :fr" do
-        expect(Spree.i18n_available_locales).to eq([:en])
-      end
-    end
-
-    context 'with specific desired key' do
-      before do
-        I18n.backend.store_translations(:fr, spree: { i18n: { this_file_language: "Français" } })
-      end
-
-      it "should return :en and :fr" do
-        expect(Spree.i18n_available_locales).to eq([:en, :fr])
-      end
-    end
-  end
-end

data/spec/lib/search/base_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-require 'spree/core/product_filters'
-
-RSpec.describe Spree::Core::Search::Base do
-  before do
-    include Spree::Core::ProductFilters
-    @taxon = create(:taxon, name: "Ruby on Rails")
-
-    @product1 = create(:product, name: "RoR Mug", price: 9.00)
-    @product1.taxons << @taxon
-    @product2 = create(:product, name: "RoR Shirt", price: 11.00)
-  end
-
-  it "returns all products by default" do
-    params = { per_page: "" }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(2)
-  end
-
-  context "when include_images is included in the initalization params" do
-    let(:params) { { include_images: true, keyword: @product1.name, taxon: @taxon.id } }
-    subject { described_class.new(params).retrieve_products }
-
-    before do
-      @product1.master.images.create(attachment_file_name: "Test", position: 2)
-      @product1.master.images.create(attachment_file_name: "Test1", position: 1)
-      @product1.reload
-    end
-
-    it "returns images in correct order" do
-      expect(subject.first).to eq @product1
-      expect(subject.first.images).to eq @product1.master.images
-    end
-  end
-
-  it "switches to next page according to the page parameter" do
-    @product3 = create(:product, name: "RoR Pants", price: 14.00)
-
-    params = { per_page: "2" }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(2)
-
-    params[:page] = "2"
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "maps search params to named scopes" do
-    params = { per_page: "",
-               search: { "price_range_any" => ["Under $10.00"] } }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "maps multiple price_range_any filters" do
-    params = { per_page: "",
-               search: { "price_range_any" => ["Under $10.00", "$10.00 - $15.00"] } }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
-    if Rails.gem_version >= Gem::Version.new('6.0.0')
-      expect(searcher.send(:get_base_scope).to_sql).to match /between 10\.0 and 15\.0/i
-    else
-      expect(searcher.send(:get_base_scope).to_sql).to match /between 10 and 15/i
-    end
-    expect(searcher.retrieve_products.count).to eq(2)
-  end
-
-  it "uses ransack if scope not found" do
-    params = { per_page: "",
-               search: { "name_not_cont" => "Shirt" } }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "accepts a current user" do
-    user = double
-    searcher = Spree::Core::Search::Base.new({})
-    searcher.current_user = user
-    expect(searcher.current_user).to eql(user)
-  end
-
-  it "finds products in alternate currencies" do
-    create(:price, currency: 'EUR', variant: @product1.master)
-    searcher = Spree::Core::Search::Base.new({})
-    searcher.pricing_options = Spree::Config.pricing_options_class.new(currency: 'EUR')
-    expect(searcher.retrieve_products).to eq([@product1])
-  end
-end

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