solidus_core 2.9.6 → 2.11.0

data/spec/models/spree/tax_calculator/default_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::TaxCalculator::Default do
-  let(:shipping_address) { FactoryBot.create(:address, state: new_york) }
-  let(:order) { FactoryBot.create(:order, ship_address: shipping_address, state: "delivery") }
-
-  let(:new_york) { FactoryBot.create(:state, state_code: "NY") }
-  let(:new_york_zone) { FactoryBot.create(:zone, states: [new_york]) }
-
-  let(:books_category) { FactoryBot.create(:tax_category, name: "Books") }
-  let!(:book_tax_rate) do
-    FactoryBot.create(
-      :tax_rate,
-      name: "New York Sales Tax",
-      tax_categories: [books_category],
-      zone: new_york_zone,
-      included_in_price: false,
-      amount: 0.05
-    )
-  end
-
-  before do
-    book = FactoryBot.create(
-      :product,
-      price: 20,
-      name: "Book",
-      tax_category: books_category,
-    )
-
-    order.contents.add(book.master)
-  end
-
-  let(:calculator) { described_class.new(order) }
-
-  describe '#calculate' do
-    subject(:calculated_taxes) { calculator.calculate }
-
-    it { is_expected.to be_a Spree::Tax::OrderTax }
-
-    it "has tax information for the line item", aggregate_failures: true do
-      expect(calculated_taxes.line_item_taxes.count).to eq 1
-
-      line_item_tax = calculated_taxes.line_item_taxes.first
-      expect(line_item_tax.amount).to eq 1
-      expect(line_item_tax.included_in_price).to be false
-      expect(line_item_tax.tax_rate).to eq book_tax_rate
-      expect(line_item_tax.label).to eq "New York Sales Tax 5.000%"
-    end
-
-    it "has tax information for the shipments" do
-      expect(calculated_taxes.shipment_taxes).to be_empty
-    end
-  end
-end

data/spec/models/spree/tax_category_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::TaxCategory, type: :model do
-  context 'default tax category' do
-    let(:tax_category) { create(:tax_category) }
-    let(:new_tax_category) { create(:tax_category) }
-
-    before do
-      tax_category.update_column(:is_default, true)
-    end
-
-    it "should undefault the previous default tax category" do
-      new_tax_category.update_attributes({ is_default: true })
-      expect(new_tax_category.is_default).to be true
-
-      tax_category.reload
-      expect(tax_category.is_default).to be false
-    end
-
-    it "should undefault the previous default tax category except when updating the existing default tax category" do
-      tax_category.update_column(:description, "Updated description")
-
-      tax_category.reload
-      expect(tax_category.is_default).to be true
-    end
-  end
-
-  context ".discard" do
-    let(:tax_category) { create(:tax_category) }
-
-    it "set deleted_at correctly" do
-      tax_category.discard
-      expect(tax_category.deleted_at).not_to be_blank
-    end
-
-    context "when there are tax_rates associated" do
-      let(:tax_rate) { create(:tax_rate) }
-      let(:tax_category) { tax_rate.tax_categories.first }
-
-      it 'correctly discard association records' do
-        expect { tax_category.discard }
-          .to change { tax_category.tax_rates.size }
-          .from(1)
-          .to(0)
-      end
-    end
-  end
-end

data/spec/models/spree/tax_rate_spec.rb

@@ -1,316 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::TaxRate, type: :model do
-  it { is_expected.to respond_to(:shipping_rate_taxes) }
-
-  context '.for_address' do
-    let(:germany) { create(:country, iso: "DE") }
-    let(:germany_zone) { create(:zone, countries: [germany]) }
-    let!(:german_tax) { create(:tax_rate, zone: germany_zone) }
-    let(:france) { create(:country, iso: "FR") }
-    let(:france_zone) { create(:zone, countries: [france]) }
-    let!(:french_tax) { create(:tax_rate, zone: france_zone) }
-    let(:eu_zone) { create(:zone, countries: [germany, france]) }
-    let!(:eu_tax) { create(:tax_rate, zone: eu_zone) }
-    let(:usa) { create(:country, iso: "US") }
-    let(:us_zone) { create(:zone, countries: [usa]) }
-    let!(:us_tax) { create(:tax_rate, zone: us_zone) }
-    let(:new_york) { create(:state, country: usa, state_code: "NY") }
-    let(:new_york_zone) { create(:zone, states: [new_york]) }
-    let!(:new_york_tax) { create(:tax_rate, zone: new_york_zone) }
-    let(:alabama) { create(:state, country: usa, state_code: "AL") }
-    let(:alabama_zone) { create(:zone, states: [alabama]) }
-    let!(:alabama_tax) { create(:tax_rate, zone: alabama_zone) }
-
-    subject(:rates_for_address) { Spree::TaxRate.for_address(address) }
-
-    context 'when address is in germany' do
-      let(:address) { create(:address, country_iso_code: "DE") }
-      it { is_expected.to contain_exactly(german_tax, eu_tax) }
-    end
-
-    context 'when address is in france' do
-      let(:address) { create(:address, country_iso_code: "FR") }
-      it { is_expected.to contain_exactly(french_tax, eu_tax) }
-    end
-
-    context 'when address is in new york' do
-      let(:address) { create(:address, country_iso_code: "US", state_code: "NY") }
-      it { is_expected.to contain_exactly(new_york_tax, us_tax) }
-    end
-
-    context 'when address is in alabama' do
-      let(:address) { create(:address, country_iso_code: "US", state_code: "AL") }
-      it { is_expected.to contain_exactly(alabama_tax, us_tax) }
-    end
-
-    context 'when address is in alaska' do
-      let(:address) { create(:address, country_iso_code: "US", state_code: "AK") }
-      it { is_expected.to contain_exactly(us_tax) }
-    end
-  end
-
-  context ".for_zone" do
-    subject(:rates_for_zone) { Spree::TaxRate.for_zone(zone) }
-
-    context "when zone is nil" do
-      let(:zone) { nil }
-
-      it "should return an empty array" do
-        expect(subject).to eq([])
-      end
-    end
-
-    context "when no rate zones match the tax zone" do
-      let(:rate_zone) { create(:zone, :with_country) }
-      let!(:rate) { create :tax_rate, zone: rate_zone }
-
-      context "when there is no default tax zone" do
-        context "and the zone has no shared members with the rate zone" do
-          let(:zone) { create(:zone, :with_country) }
-
-          it "should return an empty array" do
-            expect(subject).to eq([])
-          end
-        end
-
-        context "and the zone has shared members with the rate zone" do
-          let(:zone) { create(:zone, countries: rate_zone.countries) }
-
-          it "should return the rate that matches the rate zone" do
-            expect(subject).to eq([rate])
-          end
-        end
-
-        context "there is many rates that match the zone" do
-          let!(:rate2) { create :tax_rate, zone: rate_zone }
-          let(:zone) { create(:zone, countries: rate_zone.countries) }
-
-          it "should return all rates that match the rate zone" do
-            expect(subject).to match_array([rate, rate2])
-          end
-        end
-
-        context "when the tax_zone is contained within a rate zone" do
-          let(:country1) { create :country }
-          let(:country2) { create :country }
-          let(:rate_zone) { create(:zone, countries: [country1, country2]) }
-          let(:zone) { create(:zone, countries: [country1]) }
-
-          it "should return the rate zone" do
-            expect(subject).to eq([rate])
-          end
-        end
-      end
-
-      context "when there is a default tax zone" do
-        let(:default_zone) { create(:zone, :with_country) }
-        let(:included_in_price) { false }
-        let!(:rate) do
-          create(:tax_rate, zone: default_zone, included_in_price: included_in_price)
-        end
-
-        context "when the zone is the default zone" do
-          let(:zone) { default_zone }
-
-          context "when the tax is not a VAT" do
-            it { is_expected.to eq([rate]) }
-          end
-
-          context "when the tax is a VAT" do
-            let(:included_in_price) { true }
-
-            it { is_expected.to eq([rate]) }
-          end
-        end
-
-        context "when the zone is outside the default zone" do
-          let(:zone) { create(:zone, :with_country) }
-
-          it { is_expected.to be_empty }
-        end
-      end
-    end
-  end
-
-  describe "#adjust" do
-    let(:taxable_address) { create(:address) }
-    let(:order) { create(:order_with_line_items, ship_address: order_address) }
-    let(:tax_zone) { create(:zone, countries: [taxable_address.country]) }
-    let(:foreign_address) { create(:address, country_iso_code: "CA") }
-    let!(:foreign_zone) { create(:zone, countries: [foreign_address.country]) }
-    let(:tax_rate) do
-      create(:tax_rate,
-        included_in_price: included_in_price,
-        show_rate_in_label: show_rate_in_label,
-        amount: 0.125,
-        zone: tax_zone)
-    end
-
-    let(:item) { order.line_items.first }
-
-    describe 'adjustments' do
-      before do
-        tax_rate.adjust(nil, item)
-      end
-
-      let(:adjustment_label) { item.adjustments.tax.first.label }
-
-      context 'for included rates' do
-        let(:included_in_price) { true }
-        let(:order_address) { taxable_address }
-
-        context 'with show rate in label' do
-          let(:show_rate_in_label) { true }
-
-          it 'shows the rate in the label' do
-            expect(adjustment_label).to include("12.500%")
-          end
-
-          it 'adds a remark that the rate is included in the price' do
-            expect(adjustment_label).to include("Included in Price")
-          end
-        end
-
-        context 'with show rate in label turned off' do
-          let(:show_rate_in_label) { false }
-
-          it 'does not show the rate in the label' do
-            expect(adjustment_label).not_to include("12.500%")
-          end
-
-          it 'does not have two consecutive spaces' do
-            expect(adjustment_label).not_to include("  ")
-          end
-
-          it 'adds a remark that the rate is included in the price' do
-            expect(adjustment_label).to include("Included in Price")
-          end
-        end
-      end
-
-      context 'for additional rates' do
-        let(:included_in_price) { false }
-        let(:order_address) { taxable_address }
-
-        context 'with show rate in label' do
-          let(:show_rate_in_label) { true }
-
-          it 'shows the rate in the label' do
-            expect(adjustment_label).to include("12.500%")
-          end
-
-          it 'does not add a remark that the rate is included in the price' do
-            expect(adjustment_label).not_to include("Included in Price")
-          end
-        end
-
-        context 'with show rate in label turned off' do
-          let(:show_rate_in_label) { false }
-
-          it 'does not show the rate in the label' do
-            expect(adjustment_label).not_to include("12.500%")
-          end
-
-          it 'does not add a remark that the rate is included in the price' do
-            expect(adjustment_label).not_to include("Included in Price")
-          end
-        end
-      end
-    end
-  end
-
-  describe "#active?" do
-    subject(:rate) { create(:tax_rate, validity).active? }
-
-    context "when validity is not set" do
-      let(:validity) { {} }
-
-      it { is_expected.to eq(true) }
-    end
-
-    context "when starts_at is set" do
-      context "now" do
-        let(:validity) { { starts_at: Time.current } }
-
-        it { is_expected.to eq(true) }
-      end
-
-      context "in the past" do
-        let(:validity) { { starts_at: 1.day.ago } }
-
-        it { is_expected.to eq(true) }
-      end
-
-      context "in the future" do
-        let(:validity) { { starts_at: 1.day.from_now } }
-
-        it { is_expected.to eq(false) }
-      end
-    end
-
-    context "when expires_at is set" do
-      context "now" do
-        let(:validity) { { expires_at: Time.current } }
-
-        it { is_expected.to eq(false) }
-      end
-
-      context "in the past" do
-        let(:validity) { { expires_at: 1.day.ago } }
-
-        it { is_expected.to eq(false) }
-      end
-
-      context "in the future" do
-        let(:validity) { { expires_at: 1.day.from_now } }
-
-        it { is_expected.to eq(true) }
-      end
-    end
-
-    context "when starts_at and expires_at are set" do
-      context "so that today is in range" do
-        let(:validity) { { starts_at: 1.day.ago, expires_at: 1.day.from_now } }
-
-        it { is_expected.to eq(true) }
-      end
-
-      context "both in the past" do
-        let(:validity) { { starts_at: 2.days.ago, expires_at: 1.day.ago } }
-
-        it { is_expected.to eq(false) }
-      end
-
-      context "both in the future" do
-        let(:validity) { { starts_at: 1.day.from_now, expires_at: 2.days.from_now } }
-
-        it { is_expected.to eq(false) }
-      end
-    end
-  end
-
-  describe '#tax_category (deprecated)' do
-    let(:tax_rate) { create(:tax_rate, tax_categories: [tax_category]) }
-    let(:tax_category) { create(:tax_category) }
-
-    it "returns the first tax category" do
-      tax_category = Spree::Deprecation.silence { tax_rate.tax_category }
-      expect(tax_category).to eq(tax_category)
-    end
-  end
-
-  describe '#tax_category= (deprecated)' do
-    let(:tax_rate) { Spree::TaxRate.new }
-    let(:tax_category) { create(:tax_category) }
-
-    it "can assign the tax categories" do
-      Spree::Deprecation.silence {
-        tax_rate.tax_category = tax_category
-      }
-      expect(tax_rate.tax_categories).to eq([tax_category])
-    end
-  end
-end

data/spec/models/spree/taxon_spec.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Taxon, type: :model do
-  context "#destroy" do
-    subject(:nested_set_options) { described_class.acts_as_nested_set_options }
-
-    it "should destroy all associated taxons" do
-      expect(nested_set_options[:dependent]).to eq :destroy
-    end
-  end
-
-  describe '#to_param' do
-    let(:taxon) { FactoryBot.build(:taxon, name: "Ruby on Rails") }
-
-    subject { super().to_param }
-    it { is_expected.to eql taxon.permalink }
-  end
-
-  context "set_permalink" do
-    let(:taxon) { FactoryBot.build(:taxon, name: "Ruby on Rails") }
-
-    it "should set permalink correctly when no parent present" do
-      taxon.set_permalink
-      expect(taxon.permalink).to eql "ruby-on-rails"
-    end
-
-    context "updating a taxon permalink" do
-      it 'parameterizes permalink correctly' do
-        taxon.save!
-        taxon.update_attributes(permalink: 'spécial&charactèrs')
-        expect(taxon.permalink).to eql "special-characters"
-      end
-    end
-
-    context "with parent taxon" do
-      let(:parent) { FactoryBot.build(:taxon, permalink: "brands") }
-      before       { allow(taxon).to receive_messages parent: parent }
-
-      it "should set permalink correctly when taxon has parent" do
-        taxon.set_permalink
-        expect(taxon.permalink).to eql "brands/ruby-on-rails"
-      end
-
-      it "should set permalink correctly with existing permalink present" do
-        taxon.permalink = "b/rubyonrails"
-        taxon.set_permalink
-        expect(taxon.permalink).to eql "brands/rubyonrails"
-      end
-
-      it 'parameterizes permalink correctly' do
-        taxon.save!
-        taxon.update_attributes(permalink_part: 'spécial&charactèrs')
-        expect(taxon.reload.permalink).to eql "brands/special-characters"
-      end
-
-      # Regression test for https://github.com/spree/spree/issues/3390
-      context "setting a new node sibling position via :child_index=" do
-        let(:idx) { rand(0..100) }
-        before { allow(parent).to receive(:move_to_child_with_index) }
-
-        context "taxon is not new" do
-          before { allow(taxon).to receive(:new_record?).and_return(false) }
-
-          it "passes the desired index move_to_child_with_index of :parent " do
-            expect(taxon).to receive(:move_to_child_with_index).with(parent, idx)
-
-            taxon.child_index = idx
-          end
-        end
-      end
-    end
-  end
-
-  context "updating permalink" do
-    let(:taxonomy) { create(:taxonomy, name: 't') }
-    let(:root) { taxonomy.root }
-    let(:taxon1) { create(:taxon, name: 't1', taxonomy: taxonomy, parent: root) }
-    let(:taxon2) { create(:taxon, name: 't2', taxonomy: taxonomy, parent: root) }
-    let(:taxon2_child) { create(:taxon, name: 't2_child', taxonomy: taxonomy, parent: taxon2) }
-
-    context "changing parent" do
-      subject do
-        -> { taxon2.update!(parent: taxon1) }
-      end
-
-      it "changes own permalink" do
-        is_expected.to change{ taxon2.reload.permalink }.from('t/t2').to('t/t1/t2')
-      end
-
-      it "changes child's permalink" do
-        is_expected.to change{ taxon2_child.reload.permalink }.from('t/t2/t2_child').to('t/t1/t2/t2_child')
-      end
-    end
-
-    context "changing own permalink" do
-      subject do
-        -> { taxon2.update!(permalink: 'foo') }
-      end
-
-      it "changes own permalink" do
-        is_expected.to change{ taxon2.reload.permalink }.from('t/t2').to('t/foo')
-      end
-
-      it "changes child's permalink" do
-        is_expected.to change{ taxon2_child.reload.permalink }.from('t/t2/t2_child').to('t/foo/t2_child')
-      end
-    end
-
-    context "changing own permalink part" do
-      subject do
-        -> { taxon2.update!(permalink_part: 'foo') }
-      end
-
-      it "changes own permalink" do
-        is_expected.to change{ taxon2.reload.permalink }.from('t/t2').to('t/foo')
-      end
-
-      it "changes child's permalink" do
-        is_expected.to change{ taxon2_child.reload.permalink }.from('t/t2/t2_child').to('t/foo/t2_child')
-      end
-    end
-
-    context "changing parent and own permalink" do
-      subject do
-        -> { taxon2.update!(parent: taxon1, permalink: 'foo') }
-      end
-
-      it "changes own permalink" do
-        is_expected.to change{ taxon2.reload.permalink }.from('t/t2').to('t/t1/foo')
-      end
-
-      it "changes child's permalink" do
-        is_expected.to change{ taxon2_child.reload.permalink }.from('t/t2/t2_child').to('t/t1/foo/t2_child')
-      end
-    end
-
-    context 'changing parent permalink with special characters ' do
-      subject do
-        -> { taxon2.update!(permalink: 'spécial&charactèrs') }
-      end
-
-      it 'changes own permalink with parameterized characters' do
-        is_expected.to change{ taxon2.reload.permalink }.from('t/t2').to('t/special-characters')
-      end
-
-      it 'changes child permalink with parameterized characters' do
-        is_expected.to change{ taxon2_child.reload.permalink }.from('t/t2/t2_child').to('t/special-characters/t2_child')
-      end
-    end
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/2620
-  context "creating a child node using first_or_create" do
-    let(:taxonomy) { create(:taxonomy) }
-
-    it "does not error out" do
-      taxonomy.root.children.unscoped.where(name: "Some name").first_or_create
-    end
-  end
-
-  context 'leaves of the taxon tree' do
-    let(:taxonomy) { create(:taxonomy, name: 't') }
-    let(:root) { taxonomy.root }
-    let(:taxon) { create(:taxon, name: 't1', taxonomy: taxonomy, parent: root) }
-    let(:child) { create(:taxon, name: 'child taxon', taxonomy: taxonomy, parent: taxon) }
-    let(:grandchild) { create(:taxon, name: 'grandchild taxon', taxonomy: taxonomy, parent: child) }
-    let(:product1) { create(:product) }
-    let(:product2) { create(:product) }
-    let(:product3) { create(:product) }
-    before do
-      product1.taxons << taxon
-      product2.taxons << child
-      product3.taxons << grandchild
-      taxon.reload
-
-      [product1, product2, product3].each { |p| 2.times.each { create(:variant, product: p) } }
-    end
-
-    describe '#all_products' do
-      it 'returns all descendant products' do
-        products = taxon.all_products
-        expect(products.count).to eq(3)
-        expect(products).to match_array([product1, product2, product3])
-      end
-    end
-
-    describe '#all_variants' do
-      it 'returns all descendant variants' do
-        variants = taxon.all_variants
-        expect(variants.count).to eq(9)
-        expect(variants).to match_array([product1, product2, product3].map{ |p| p.variants_including_master }.flatten)
-      end
-    end
-  end
-end