solidus_core 2.9.6 → 2.11.0

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

data/spec/models/spree/variant_property_rule_condition_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::VariantPropertyRuleCondition, type: :model do
-  context "touching" do
-    let(:rule_condition) { create(:variant_property_rule_condition) }
-
-    before do
-      rule_condition.variant_property_rule.update_columns(updated_at: 1.day.ago)
-    end
-
-    it "should update the variant property rule" do
-      expect { rule_condition.touch }.to change { rule_condition.reload.variant_property_rule.updated_at }
-    end
-  end
-end

data/spec/models/spree/variant_property_rule_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::VariantPropertyRule, type: :model do
-  context "touching" do
-    let(:rule) { create(:variant_property_rule) }
-
-    before do
-      rule.product.update_columns(updated_at: 1.day.ago)
-    end
-
-    it "should update the product" do
-      expect { rule.touch }.to change { rule.reload.product.updated_at }
-    end
-  end
-
-  describe "#matches_option_value_ids?" do
-    let(:first_condition_option_value) { create(:option_value) }
-    let(:second_condition_option_value) { create(:option_value) }
-    let!(:second_condition) do
-      create(:variant_property_rule_condition,
-        variant_property_rule: rule,
-        option_value: second_condition_option_value)
-    end
-    let(:rule) { create(:variant_property_rule, option_value: first_condition_option_value) }
-
-    context "provided ids are the same as the rule's condition's option value ids" do
-      subject do
-        rule.matches_option_value_ids?([second_condition_option_value.id, first_condition_option_value.id])
-      end
-
-      it { is_expected.to eq true }
-    end
-
-    context "some of the provided ids are the same as the rule's condition's option value ids" do
-      subject do
-        rule.matches_option_value_ids?([first_condition_option_value.id])
-      end
-
-      it { is_expected.to eq false }
-    end
-
-    context "none of the provided ids are the same as the rule's condition's option value ids" do
-      let(:other_option_value) { create(:option_value) }
-
-      subject do
-        rule.matches_option_value_ids?([other_option_value.id])
-      end
-
-      it { is_expected.to eq false }
-    end
-  end
-
-  describe "#applies_to_variant?" do
-    let(:variant_option_value_1) { create(:option_value) }
-    let(:variant_option_value_2) { create(:option_value) }
-    let!(:variant) { create(:variant, option_values: option_values) }
-
-    let(:rule_option_value) { create(:option_value) }
-    let(:rule) { create(:variant_property_rule, option_value: rule_option_value) }
-    let!(:rule_condition_1) { create(:variant_property_rule_condition, variant_property_rule: rule, option_value: variant_option_value_1) }
-    let!(:rule_condition_2) { create(:variant_property_rule_condition, variant_property_rule: rule, option_value: variant_option_value_2) }
-
-    subject { rule.applies_to_variant?(variant) }
-
-    context "variant matches some of the rule's conditions" do
-      let(:option_values) { [variant_option_value_1, variant_option_value_2] }
-
-      it { is_expected.to eq true }
-    end
-
-    context "variant matches none of the rule's conditions" do
-      let(:option_values) { [create(:option_value)] }
-
-      it { is_expected.to eq false }
-    end
-
-    context "variant matches all of the rule's conditions" do
-      let(:option_values) { [rule_option_value, variant_option_value_1, variant_option_value_2] }
-
-      it { is_expected.to eq true }
-    end
-  end
-end