solidus_core 2.10.2 → 2.11.0

data/spec/models/spree/validations/db_maximum_length_validator_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Validations::DbMaximumLengthValidator, type: :model do
-  with_model 'LimitedProduct', scope: :all do
-    table do |t|
-      t.string :slug, limit: 255
-    end
-
-    model do
-      validates_with Spree::Validations::DbMaximumLengthValidator, field: :slug
-    end
-  end
-
-  let(:record) { LimitedProduct.new(slug: slug) }
-
-  context "when slug is below limit" do
-    let(:slug) { 'a' * 255 }
-    it 'should be valid' do
-      expect(record).to be_valid
-      expect(record.errors).to be_empty
-    end
-  end
-
-  context "when slug is too long" do
-    let(:slug) { 'a' * 256 }
-    it 'should be invalid and set error' do
-      expect(record).not_to be_valid
-      expect(record.errors[:slug]).to include(I18n.t("errors.messages.too_long", count: 255))
-    end
-  end
-end

data/spec/models/spree/variant/price_selector_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Variant::PriceSelector do
-  let(:variant) { build_stubbed(:variant) }
-
-  subject { described_class.new(variant) }
-
-  it { is_expected.to respond_to(:variant) }
-  it { is_expected.to respond_to(:price_for) }
-
-  describe ".pricing_options_class" do
-    it "returns the standard pricing options class" do
-      expect(described_class.pricing_options_class).to eq(Spree::Variant::PricingOptions)
-    end
-  end
-
-  describe "#price_for(options)" do
-    let(:variant) { create(:variant, price: 12.34) }
-
-    context "with the default currency" do
-      let(:pricing_options) { described_class.pricing_options_class.new(currency: "USD") }
-
-      it "returns the correct (default) price as a Spree::Money object" do
-        expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(12.34, currency: "USD"))
-      end
-
-      context "with the another country iso" do
-        let(:country) { create(:country, iso: "DE") }
-
-        let(:pricing_options) do
-          described_class.pricing_options_class.new(currency: "USD", country_iso: "DE")
-        end
-
-        context "with a price for that country present" do
-          before do
-            variant.prices.create(amount: 44.44, country: country, currency: Spree::Config.currency)
-          end
-
-          it "returns the correct price" do
-            expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(44.44, currency: "USD"))
-          end
-        end
-
-        context "with no price for that country present" do
-          context "and no fallback price for the variant present" do
-            before do
-              variant.prices.delete_all
-            end
-
-            it "returns nil" do
-              expect(subject.price_for(pricing_options)).to be_nil
-            end
-          end
-
-          context "and a fallback price for the variant present" do
-            before do
-              variant.prices.create(amount: 55.44, country: nil, currency: Spree::Config.currency)
-            end
-
-            it "returns the fallback price" do
-              expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(55.44, currency: "USD"))
-            end
-          end
-        end
-      end
-    end
-
-    context "with a different currency" do
-      let(:pricing_options) { described_class.pricing_options_class.new(currency: "EUR") }
-
-      context "when there is a price for that currency" do
-        before do
-          variant.prices.create(amount: 99.00, currency: "EUR")
-        end
-
-        it "returns the price in the correct currency as a Spree::Money object" do
-          expect(subject.price_for(pricing_options)).to eq(Spree::Money.new(99.00, currency: "EUR"))
-        end
-      end
-
-      context "when there is no price for that currency" do
-        it "returns nil" do
-          expect(subject.price_for(pricing_options)).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/variant/pricing_options_spec.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Variant::PricingOptions do
-  subject { described_class.new }
-
-  context '.default_price_attributes' do
-    subject { described_class.default_price_attributes }
-
-    it { is_expected.to have_key(:currency) }
-    it { is_expected.to have_key(:country_iso) }
-
-    it 'can be passed into a WHERE clause on Spree::Prices' do
-      expect(Spree::Price.where(subject).to_a).to eq([])
-    end
-
-    context "with a matching price present" do
-      let!(:price) { create(:price) }
-
-      it 'returns a matching price' do
-        expect(Spree::Price.where(subject).to_a).to include(price)
-      end
-    end
-  end
-
-  context ".from_line_item" do
-    let(:line_item) { build_stubbed(:line_item) }
-    subject { described_class.from_line_item(line_item) }
-
-    it "returns the order's currency" do
-      expect(subject.desired_attributes[:currency]).to eq("USD")
-    end
-
-    it "takes the orders tax address country" do
-      expect(subject.desired_attributes[:country_iso]).to eq("US")
-    end
-
-    context 'if order has no currency' do
-      before do
-        expect(line_item.order).to receive(:currency).at_least(:once).and_return(nil)
-        expect(Spree::Config).to receive(:currency).at_least(:once).and_return("RUB")
-      end
-
-      it "returns the configured default currency" do
-        expect(subject.desired_attributes[:currency]).to eq("RUB")
-      end
-    end
-
-    context "if line item has no order" do
-      before do
-        expect(line_item).to receive(:order).at_least(:once).and_return(nil)
-        expect(Spree::Config).to receive(:currency).at_least(:once).and_return("RUB")
-      end
-
-      it "returns the configured default currency" do
-        expect(subject.desired_attributes[:currency]).to eq("RUB")
-      end
-    end
-  end
-
-  context ".from_price" do
-    let(:country) { create(:country) }
-    let(:price) { create(:price, country: country) }
-
-    subject { described_class.from_price(price) }
-    it "gets the currency from the previous price" do
-      expect(subject.currency).to eq(price.currency)
-      expect(subject.country_iso).to eq(country.iso)
-    end
-  end
-
-  context ".from_context" do
-    let(:view_context) { double(ApplicationController, current_store: store) }
-    subject { described_class.from_context(view_context) }
-
-    context "if the store has not defined default_currency" do
-      let(:store) { FactoryBot.create :store, default_currency: nil, cart_tax_country_iso: nil }
-
-      it "fallbacks to Spree::Config.currency" do
-        expect(Spree::Variant::PricingOptions).to receive(:new).with(currency: Spree::Config.currency, country_iso: nil)
-        expect(subject).to be_nil
-      end
-    end
-
-    context 'if the store has default_currency and cart_tax_country_iso' do
-      let(:store) { FactoryBot.create :store, default_currency: 'MXN' }
-
-      it "uses current_store information" do
-        expect(Spree::Variant::PricingOptions).to receive(:new).with(currency: store.default_currency, country_iso: store.cart_tax_country_iso)
-        expect(subject).to be_nil
-      end
-    end
-  end
-
-  describe '#desired_attributes' do
-    context "when called with no arguments" do
-      it "returns the default pricing options" do
-        expect(subject.desired_attributes).to eq(described_class.default_price_attributes)
-      end
-    end
-
-    context "when called with a different currency" do
-      subject { described_class.new(currency: "EUR") }
-
-      it "returns a Hash with the correct currency" do
-        expect(subject.desired_attributes[:currency]).to eq("EUR")
-      end
-    end
-
-    context "when called with a different country_iso" do
-      subject { described_class.new(country_iso: "DE") }
-
-      it "returns a Hash with the correct country" do
-        expect(subject.desired_attributes[:country_iso]).to eq("DE")
-      end
-    end
-  end
-
-  describe "#currency" do
-    context "when initialized with no currency" do
-      it "returns the default currency" do
-        expect(Spree::Config.currency).to eq("USD")
-        expect(subject.currency).to eq("USD")
-      end
-    end
-
-    context "when initialized with a different currency" do
-      subject { described_class.new(currency: "EUR") }
-
-      it "returns that currency" do
-        expect(subject.currency).to eq("EUR")
-      end
-    end
-  end
-
-  describe "#country_iso" do
-    context "when initialized with no country_iso" do
-      it "returns the default country_iso" do
-        expect(Spree::Config).to receive(:admin_vat_country_iso).and_return("US")
-        expect(subject.country_iso).to eq("US")
-      end
-    end
-
-    context "when initialized with a different country_iso" do
-      subject { described_class.new(country_iso: "DE") }
-
-      it "returns that country_iso" do
-        expect(subject.country_iso).to eq("DE")
-      end
-    end
-  end
-
-  describe "#cache_key" do
-    it 'creates a cache key out of the values of the attributes hash' do
-      expect(subject.cache_key).to eq("USD")
-    end
-
-    context "with another currency" do
-      subject { described_class.new(currency: "EUR") }
-
-      it 'creates the correct cache key' do
-        expect(subject.cache_key).to eq("EUR")
-      end
-
-      context "and another country" do
-        subject { described_class.new(currency: "EUR", country_iso: "DE") }
-
-        it 'creates the correct cache key' do
-          expect(subject.cache_key).to eq("EUR/DE")
-        end
-      end
-    end
-  end
-
-  describe "#search_arguments" do
-    let!(:price) { create(:price, currency: "EUR") }
-    let(:options) { {} }
-
-    subject { described_class.new(options).search_arguments }
-
-    context "with a currency given" do
-      let(:options) { { currency: "EUR" } }
-
-      it 'can be passed into a `where` clause' do
-        expect(Spree::Price.where(subject)).to eq([price])
-      end
-    end
-
-    context "with no country given" do
-      it "is an array with only nil inside" do
-        expect(subject[:country_iso]).to eq([nil])
-      end
-    end
-
-    context "with a country given" do
-      let(:options) { { country_iso: "DE" } }
-
-      it "is an array with the country and nil" do
-        expect(subject[:country_iso]).to eq(["DE", nil])
-      end
-    end
-  end
-end

data/spec/models/spree/variant/scopes_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe "Variant scopes", type: :model do
-  let!(:product) { create(:product) }
-  let!(:variant_1) { create(:variant, product: product) }
-  let!(:variant_2) { create(:variant, product: product) }
-
-  context ".with_prices" do
-    context "when searching for the default pricing options" do
-      it "finds all variants" do
-        expect(Spree::Variant.with_prices).to contain_exactly(product.master, variant_1, variant_2)
-      end
-    end
-
-    context "when searching for different pricing options" do
-      let(:pricing_options) { Spree::Config.pricing_options_class.new(currency: "EUR") }
-      context "when only one variant has price in Euro" do
-        before do
-          variant_1.prices.create(amount: 99.00, currency: "EUR")
-        end
-
-        context "and we search for variants with only prices in Euro" do
-          it "finds the one variant with a price in Euro" do
-            expect(Spree::Variant.with_prices(pricing_options)).to contain_exactly(variant_1)
-          end
-        end
-      end
-    end
-
-    context 'when searching for a variant that has two eligible prices (one fallback)' do
-      let(:france) { create(:country, iso: "FR") }
-      let(:pricing_options) { Spree::Variant::PricingOptions.new(country_iso: "FR", currency: "EUR") }
-
-      subject { Spree::Variant.with_prices(pricing_options) }
-
-      before do
-        variant_1.prices.create!(currency: "EUR", country: france, amount: 10)
-        variant_1.prices.create!(currency: "EUR", country: nil, amount: 10)
-      end
-
-      it { is_expected.to eq([variant_1]) }
-    end
-  end
-
-  it ".descend_by_popularity" do
-    # Requires a product with at least two variants, where one has a higher number of
-    # orders than the other
-    Spree::LineItem.delete_all # FIXME leaky database - too many line_items
-    create(:line_item, variant: variant_1)
-    expect(Spree::Variant.descend_by_popularity.first).to eq(variant_1)
-  end
-
-  context "finding by option values" do
-    let!(:option_type) { create(:option_type, name: "bar") }
-    let!(:option_value_1) do
-      option_value = create(:option_value, name: "foo", option_type: option_type)
-      variant_1.option_values << option_value
-      option_value
-    end
-
-    let!(:option_value_2) do
-      option_value = create(:option_value, name: "fizz", option_type: option_type)
-      variant_1.option_values << option_value
-      option_value
-    end
-
-    let!(:product_variants) { product.variants_including_master }
-
-    it "by objects" do
-      variants = product_variants.has_option(option_type, option_value_1)
-      expect(variants).to include(variant_1)
-      expect(variants).not_to include(variant_2)
-    end
-
-    it "by names" do
-      variants = product_variants.has_option("bar", "foo")
-      expect(variants).to include(variant_1)
-      expect(variants).not_to include(variant_2)
-    end
-
-    it "by ids" do
-      variants = product_variants.has_option(option_type.id, option_value_1.id)
-      expect(variants).to include(variant_1)
-      expect(variants).not_to include(variant_2)
-    end
-
-    it "by mixed conditions" do
-      variants = product_variants.has_option(option_type.id, "foo", option_value_2)
-      expect(variants).to be_empty
-    end
-  end
-end

data/spec/models/spree/variant/vat_price_generator_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Spree::Variant::VatPriceGenerator do
-  let(:tax_category) { create(:tax_category) }
-  let(:product) { variant.product }
-  let(:variant) { create(:variant, price: 10, tax_category: tax_category) }
-
-  subject { described_class.new(variant).run }
-
-  context "with Germany as default admin country" do
-    let(:germany) { create(:country, iso: "DE") }
-    let(:germany_zone) { create(:zone, countries: [germany]) }
-    let!(:german_vat) { create(:tax_rate, included_in_price: true, amount: 0.19, zone: germany_zone, tax_categories: [tax_category]) }
-    let(:france) { create(:country, iso: "FR") }
-    let(:france_zone) { create(:zone, countries: [france]) }
-    let!(:french_vat) { create(:tax_rate, included_in_price: true, amount: 0.20, zone: france_zone, tax_categories: [tax_category]) }
-
-    before do
-      stub_spree_preferences(admin_vat_country_iso: "DE")
-    end
-
-    it "builds a correct price including VAT for all VAT countries" do
-      subject
-      variant.save
-      variant.reload
-      expect(variant.default_price.for_any_country?).to be false
-      expect(variant.prices.detect { |p| p.country_iso == "DE" }.try!(:amount)).to eq(10.00)
-      expect(variant.prices.detect { |p| p.country_iso == "FR" }.try!(:amount)).to eq(10.08)
-      expect(variant.prices.detect { |p| p.country_iso.nil? }.try!(:amount)).to eq(8.40)
-    end
-
-    it "will not build prices that are already present" do
-      expect { subject }.not_to change { variant.prices.length }
-    end
-
-    # We need to remove the price for FR from the database so it is created in memory, and then run VatPriceGenerator twice to trigger the duplicate price issue.
-    it "will not build duplicate prices on multiple runs" do
-      variant.prices.where(country_iso: "FR").each(&:really_destroy!)
-      variant.reload
-      described_class.new(variant).run
-      expect { subject }.not_to change { variant.prices.size }
-    end
-  end
-
-  context "with no default admin country" do
-    let(:germany) { create(:country, iso: "DE") }
-    let(:germany_zone) { create(:zone, countries: [germany]) }
-    let!(:german_vat) { create(:tax_rate, included_in_price: true, amount: 0.19, zone: germany_zone, tax_categories: [tax_category]) }
-    let(:france) { create(:country, iso: "FR") }
-    let(:france_zone) { create(:zone, countries: [france]) }
-    let!(:french_vat) { create(:tax_rate, included_in_price: true, amount: 0.20, zone: france_zone, tax_categories: [tax_category]) }
-
-    it "builds a correct price including VAT for all VAT countries" do
-      subject
-      variant.save
-      variant.reload
-      expect(variant.default_price.for_any_country?).to be true
-      expect(variant.prices.detect { |p| p.country_iso == "DE" }.try!(:amount)).to eq(11.90)
-      expect(variant.prices.detect { |p| p.country_iso == "FR" }.try!(:amount)).to eq(12.00)
-      expect(variant.prices.detect { |p| p.country_iso.nil? }.try!(:amount)).to eq(10.00)
-    end
-  end
-
-  context "for a variant with not tax category" do
-    let(:tax_category) { nil }
-
-    before do
-      product.update(tax_category: nil)
-    end
-
-    it "creates no addditional prices" do
-      expect { subject }.not_to change { variant.prices.length }
-    end
-  end
-end