solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,56 @@
+# 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

@@ -0,0 +1,29 @@
+# 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
+end

data/spec/models/spree/tax_rate_spec.rb

@@ -0,0 +1,316 @@
+# 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

@@ -0,0 +1,169 @@
+# 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 "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
+
+      # 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
+  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

data/spec/models/spree/taxonomy_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Taxonomy, type: :model do
+  context "#destroy" do
+    subject(:association_options) do
+      described_class.reflect_on_association(:root).options
+    end
+
+    it "should destroy all associated taxons" do
+      expect(association_options[:dependent]).to eq :destroy
+    end
+  end
+end

data/spec/models/spree/unit_cancel_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::UnitCancel do
+  let(:unit_cancel) { Spree::UnitCancel.create!(inventory_unit: inventory_unit, reason: Spree::UnitCancel::SHORT_SHIP) }
+  let(:inventory_unit) { create(:inventory_unit) }
+
+  describe '#adjust!' do
+    subject { unit_cancel.adjust! }
+
+    it "creates an adjustment with the correct attributes" do
+      expect { subject }.to change{ Spree::Adjustment.count }.by(1)
+
+      adjustment = Spree::Adjustment.last
+      expect(adjustment.adjustable).to eq inventory_unit.line_item
+      expect(adjustment.amount).to eq(-10.0)
+      expect(adjustment.order).to eq inventory_unit.order
+      expect(adjustment.label).to eq "Cancellation - Short Ship"
+      expect(adjustment).to be_eligible
+      expect(adjustment).to be_finalized
+    end
+
+    context "when an adjustment has already been created" do
+      before { unit_cancel.adjust! }
+
+      it "raises" do
+        expect { subject }.to raise_error("Adjustment is already created")
+      end
+    end
+  end
+
+  describe '#compute_amount' do
+    subject { unit_cancel.compute_amount(line_item) }
+
+    let(:line_item) { inventory_unit.line_item }
+    let!(:inventory_unit2) { create(:inventory_unit, line_item: inventory_unit.line_item) }
+
+    context "all inventory on the line item are not canceled" do
+      it "divides the line item total by the inventory units size" do
+        expect(subject).to eq(-5.0)
+      end
+    end
+
+    context "some inventory on the line item is canceled" do
+      before { inventory_unit2.cancel! }
+
+      it "divides the line item total by the uncanceled units size" do
+        expect(subject).to eq(-10.0)
+      end
+    end
+
+    context "it is called with a line item that doesnt belong to the inventory unit" do
+      let(:line_item) { create(:line_item) }
+
+      it "raises an error" do
+        expect { subject }.to raise_error RuntimeError, "Adjustable does not match line item"
+      end
+    end
+  end
+end