solidus_core 2.10.2 → 2.11.0

data/spec/lib/calculated_adjustments_spec.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::CalculatedAdjustments do
-  let(:calculator_class) { Spree::Calculator::FlatRate }
-
-  with_model :Calculable, scope: :all do
-    model do
-      include Spree::CalculatedAdjustments
-    end
-  end
-
-  it "should add has_one :calculator relationship" do
-    expect(Calculable.reflect_on_all_associations(:has_one).map(&:name)).to include(:calculator)
-  end
-
-  describe 'initialization' do
-    context 'with no calculator' do
-      subject { Calculable.new }
-
-      it 'can be initialized' do
-        expect(subject.calculator).to be nil
-      end
-
-      it 'is not valid' do
-        expect(subject).not_to be_valid
-        expect(subject.errors[:calculator]).to eq ["can't be blank"]
-      end
-    end
-
-    context 'with calculator object' do
-      subject { Calculable.new(calculator: calculator_class.new) }
-
-      it 'can be initialized' do
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(calculator_class.count).to eq 0 # not yet saved
-      end
-
-      it 'can be created' do
-        subject.save!
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(calculator_class.count).to eq 1 # saved in database
-      end
-    end
-
-    context 'with calculator_type' do
-      subject { Calculable.new(calculator_type: calculator_class.to_s) }
-
-      it 'can be initialized' do
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(calculator_class.count).to eq 0 # not yet saved
-      end
-
-      it 'can be created' do
-        subject.save!
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(calculator_class.count).to eq 1 # saved in database
-      end
-    end
-
-    context 'with calculator_type and calculator_attributes' do
-      subject { Calculable.new(calculator_type: calculator_class.to_s, calculator_attributes: { preferred_amount: 123 }) }
-
-      it 'can be initialized' do
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(subject.calculator.preferred_amount).to eq 123
-        expect(calculator_class.count).to eq 0 # not yet saved
-      end
-
-      it 'can be created' do
-        subject.save!
-        expect(subject.calculator).to be_a(calculator_class)
-        expect(subject.calculator.preferred_amount).to eq 123
-        expect(calculator_class.count).to eq 1 # saved in database
-      end
-    end
-  end
-
-  describe 'update' do
-    subject { Calculable.create!(calculator_type: calculator_class.to_s) }
-
-    it "can update calculator attributes with id" do
-      subject.update!(calculator_attributes: {
-        id: subject.calculator.id,
-        preferred_amount: 123
-      })
-      expect(subject.calculator.preferred_amount).to eq(123)
-      subject.reload
-      expect(subject.calculator.preferred_amount).to eq(123)
-    end
-
-    it "can update calculator attributes without id" do
-      subject.update!(calculator_attributes: {
-        preferred_amount: 123
-      })
-      expect(subject.calculator.preferred_amount).to eq(123)
-      subject.reload
-      expect(subject.calculator.preferred_amount).to eq(123)
-    end
-
-    it "can update both calculator type and attributes" do
-      subject.update!(calculator_type: 'Spree::Calculator::FlexiRate', calculator_attributes: {
-        preferred_first_item: 123
-      })
-      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
-      expect(subject.calculator.preferred_first_item).to eq(123)
-      subject.reload
-      expect(subject.calculator.class).to eq(Spree::Calculator::FlexiRate)
-      expect(subject.calculator.preferred_first_item).to eq(123)
-    end
-  end
-
-  describe '#calculator_type=' do
-    subject { Calculable.new }
-
-    let(:calculator_subclass) { Spree::Calculator::Shipping::FlatRate }
-    let(:calculator_superclass) { Spree::ShippingCalculator }
-
-    before(:each) do
-      subject.calculator_type = calculator_subclass.to_s
-    end
-
-    it 'sets calculator type' do
-      expect(subject.calculator_type).to eq(calculator_subclass.to_s)
-    end
-
-    it 'switches from calculator subclass to calculator superclass' do
-      subject.calculator_type = calculator_superclass.to_s
-      expect(subject.calculator_type).to eq(calculator_superclass.to_s)
-    end
-  end
-end

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