solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/adjustment_spec.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Adjustment, type: :model do
+  let!(:store) { create :store }
+  let(:order) { Spree::Order.new }
+  let(:line_item) { create :line_item, order: order }
+
+  let(:adjustment) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: order, order: order, amount: 5) }
+
+  context '#save' do
+    let(:adjustment) { Spree::Adjustment.create(label: "Adjustment", amount: 5, order: order, adjustable: line_item) }
+
+    it 'touches the adjustable' do
+      line_item.update_columns(updated_at: 1.day.ago)
+      expect { adjustment.save! }.to change { line_item.updated_at }
+    end
+  end
+
+  describe 'non_tax scope' do
+    subject do
+      Spree::Adjustment.non_tax.to_a
+    end
+
+    let!(:tax_adjustment) do
+      create(:adjustment, adjustable: order, order: order, source: create(:tax_rate))
+    end
+
+    let!(:non_tax_adjustment_with_source) do
+      create(:adjustment, adjustable: order, order: order, source_type: 'Spree::Order', source_id: nil)
+    end
+
+    let!(:non_tax_adjustment_without_source) do
+      create(:adjustment, adjustable: order, order: order, source: nil)
+    end
+
+    it 'select non-tax adjustments' do
+      expect(subject).to_not include tax_adjustment
+      expect(subject).to     include non_tax_adjustment_with_source
+      expect(subject).to     include non_tax_adjustment_without_source
+    end
+  end
+
+  context '#currency' do
+    let(:order) { Spree::Order.new currency: 'JPY' }
+
+    it 'returns the adjustables currency' do
+      expect(adjustment.currency).to eq 'JPY'
+    end
+
+    context 'adjustable is nil' do
+      before do
+        adjustment.adjustable = nil
+      end
+      it 'uses the global currency of USD' do
+        expect(adjustment.currency).to eq 'USD'
+      end
+    end
+  end
+
+  context "#display_amount" do
+    before { adjustment.amount = 10.55 }
+
+    it "shows the amount" do
+      expect(adjustment.display_amount.to_s).to eq "$10.55"
+    end
+
+    context "with currency set to JPY" do
+      let(:order) { Spree::Order.new currency: 'JPY' }
+
+      context "when adjustable is set to an order" do
+        it "displays in JPY" do
+          expect(adjustment.display_amount.to_s).to eq "¥11"
+        end
+      end
+    end
+  end
+
+  context '#recalculate' do
+    subject { adjustment.recalculate }
+    let(:adjustment) do
+      line_item.adjustments.create!(
+        label: 'Adjustment',
+        order: order,
+        adjustable: order,
+        amount: 5,
+        finalized: finalized,
+        source: source,
+      )
+    end
+    let(:order) { create(:order_with_line_items, line_items_price: 100) }
+    let(:line_item) { order.line_items.to_a.first }
+
+    context "when adjustment is finalized" do
+      let(:finalized) { true }
+
+      context 'with a promotion adjustment' do
+        let(:source) { promotion.actions.first! }
+        let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: 7) }
+
+        it 'does not update the adjustment' do
+          expect { subject }.not_to change { adjustment.amount }
+        end
+      end
+
+      context 'with a tax adjustment' do
+        let(:source) { mock_model(Spree::TaxRate, compute_amount: 10) }
+
+        it 'updates the adjustment' do
+          expect { subject }.to change { adjustment.amount }.from(5).to(10)
+        end
+      end
+
+      context 'with a sourceless adjustment' do
+        let(:source) { nil }
+
+        it 'does nothing' do
+          expect { subject }.not_to change { adjustment.amount }
+        end
+      end
+    end
+
+    context "when adjustment isn't finalized" do
+      let(:finalized) { false }
+
+      context 'with a promotion adjustment' do
+        let(:source) { promotion.actions.first! }
+        let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: 7) }
+
+        context 'when the promotion is eligible' do
+          it 'updates the adjustment' do
+            expect { subject }.to change { adjustment.amount }.from(5).to(-7)
+          end
+
+          it 'sets the adjustment elgiible to true' do
+            subject
+            expect(adjustment.eligible).to eq(true)
+          end
+        end
+
+        context 'when the promotion is not eligible' do
+          before do
+            promotion.update!(starts_at: 1.day.from_now)
+          end
+
+          it 'zeros out the adjustment' do
+            expect { subject }.to change { adjustment.amount }.from(5).to(0)
+          end
+
+          it 'sets the adjustment elgiible to false' do
+            subject
+            expect(adjustment.eligible).to eq(false)
+          end
+        end
+      end
+
+      context 'with a tax adjustment' do
+        let(:source) { mock_model(Spree::TaxRate, compute_amount: 10) }
+
+        it 'updates the adjustment' do
+          expect { subject }.to change { adjustment.amount }.from(5).to(10)
+        end
+      end
+
+      context 'with a sourceless adjustment' do
+        let(:source) { nil }
+
+        it 'does nothing' do
+          expect { subject }.to_not change { adjustment.amount }
+        end
+      end
+    end
+  end
+
+  describe "promotion code presence error" do
+    subject do
+      adjustment.valid?
+      adjustment.errors[:promotion_code]
+    end
+
+    context "when the adjustment is not a promotion adjustment" do
+      let(:adjustment) { build(:adjustment) }
+
+      it { is_expected.to be_blank }
+    end
+
+    context "when the adjustment is a promotion adjustment" do
+      let(:adjustment) { build(:adjustment, source: promotion.actions.first) }
+      let(:promotion) { create(:promotion, :with_order_adjustment) }
+
+      context "when the promotion does not have a code" do
+        it { is_expected.to be_blank }
+      end
+
+      context "when the promotion has a code" do
+        let!(:promotion_code) { create(:promotion_code, promotion: promotion) }
+
+        it { is_expected.to include("can't be blank") }
+      end
+    end
+  end
+
+  describe 'repairing adjustment associations' do
+    context 'on create' do
+      let(:adjustable) { order }
+      let(:adjustment_source) { promotion.actions[0] }
+      let(:order) { create(:order) }
+      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+
+      def expect_deprecation_warning
+        expect(Spree::Deprecation).to(
+          receive(:warn).
+          with(
+            /Adjustment \d+ was not added to #{adjustable.class} #{adjustable.id}/,
+            instance_of(Array),
+          )
+        )
+      end
+
+      context 'when adding adjustments via the wrong association' do
+        def create_adjustment
+          adjustment_source.adjustments.create!(
+            amount: 10,
+            adjustable: adjustable,
+            order: order,
+            label: 'some label',
+          )
+        end
+
+        context 'when adjustable.adjustments is loaded' do
+          before { adjustable.adjustments.to_a }
+
+          it 'repairs adjustable.adjustments' do
+            expect_deprecation_warning
+            adjustment = create_adjustment
+            expect(adjustable.adjustments).to include(adjustment)
+          end
+
+          context 'when the adjustment is destroyed before after_commit runs' do
+            it 'does not repair' do
+              expect(Spree::Deprecation).not_to receive(:warn)
+              Spree::Adjustment.transaction do
+                adjustment = create_adjustment
+                adjustment.destroy!
+              end
+            end
+          end
+        end
+
+        context 'when adjustable.adjustments is not loaded' do
+          it 'does repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            create_adjustment
+          end
+        end
+      end
+
+      context 'when adding adjustments via the correct association' do
+        def create_adjustment
+          adjustable.adjustments.create!(
+            amount: 10,
+            source: adjustment_source,
+            order: order,
+            label: 'some label',
+          )
+        end
+
+        context 'when adjustable.adjustments is loaded' do
+          before { adjustable.adjustments.to_a }
+
+          it 'does not repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            create_adjustment
+          end
+        end
+
+        context 'when adjustable.adjustments is not loaded' do
+          it 'does not repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            create_adjustment
+          end
+        end
+      end
+    end
+
+    context 'on destroy' do
+      let(:adjustment) { create(:adjustment) }
+      let(:adjustable) { adjustment.adjustable }
+
+      def expect_deprecation_warning(adjustable)
+        expect(Spree::Deprecation).to(
+          receive(:warn).
+          with(
+            /Adjustment #{adjustment.id} was not removed from #{adjustable.class} #{adjustable.id}/,
+            instance_of(Array),
+          )
+        )
+      end
+
+      context 'when destroying adjustments not via association' do
+        context 'when adjustable.adjustments is loaded' do
+          before { adjustable.adjustments.to_a }
+
+          it 'repairs adjustable.adjustments' do
+            expect_deprecation_warning(adjustable)
+            adjustment.destroy!
+            expect(adjustable.adjustments).not_to include(adjustment)
+          end
+        end
+
+        context 'when adjustable.adjustments is not loaded' do
+          it 'does not repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            adjustment.destroy!
+          end
+        end
+      end
+
+      context 'when destroying adjustments via the association' do
+        context 'when adjustable.adjustments is loaded' do
+          before { adjustable.adjustments.to_a }
+
+          it 'does not repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            adjustable.adjustments.destroy(adjustment)
+          end
+        end
+
+        context 'when adjustable.adjustments is not loaded' do
+          it 'does not repair' do
+            expect(Spree::Deprecation).not_to receive(:warn)
+            adjustable.adjustments.destroy(adjustment)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/app_configuration_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::AppConfiguration, type: :model do
+  let(:prefs) { Spree::Config }
+
+  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
+
+  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
+end

data/spec/models/spree/asset_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Asset, type: :model do
+  describe "#viewable" do
+    it "touches association" do
+      product = build(:custom_product)
+
+      expect do
+        Spree::Asset.create! { |a| a.viewable = product.master }
+      end.to change { product.updated_at }
+    end
+  end
+
+  describe "#acts_as_list scope" do
+    it "should start from first position for different viewables" do
+      asset1 = Spree::Asset.create(viewable_type: 'Spree::Image', viewable_id: 1)
+      asset2 = Spree::Asset.create(viewable_type: 'Spree::LineItem', viewable_id: 1)
+
+      expect(asset1.position).to eq 1
+      expect(asset2.position).to eq 1
+    end
+  end
+end

data/spec/models/spree/calculator/default_tax_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'shared_examples/calculator_shared_examples'
+
+RSpec.describe Spree::Calculator::DefaultTax, type: :model do
+  let(:address) { create(:address) }
+  let!(:zone) { create(:zone, name: "Country Zone", countries: [tax_rate_country]) }
+  let(:tax_rate_country) { address.country }
+  let(:tax_category) { create(:tax_category) }
+  let(:starts_at) { nil }
+  let(:expires_at) { nil }
+  let!(:rate) do
+    create(:tax_rate, tax_categories: [tax_category], amount: 0.05,
+                      included_in_price: included_in_price, zone: zone,
+                      starts_at: starts_at, expires_at: expires_at)
+  end
+  let(:included_in_price) { false }
+  subject(:calculator) { Spree::Calculator::DefaultTax.new(calculable: rate ) }
+
+  it_behaves_like 'a calculator with a description'
+
+  context "#compute" do
+    context "when given an order" do
+      let(:order) do
+        create(
+          :order_with_line_items,
+          line_items_attributes: [
+            { price: 10, quantity: 3, tax_category: tax_category }.merge(line_item_one_options),
+            { price: 10, quantity: 3, tax_category: tax_category }.merge(line_item_two_options)
+          ],
+          ship_address: address
+        )
+      end
+      let(:line_item_one_options) { {} }
+      let(:line_item_two_options) { {} }
+
+      context "when all items matches the rate's tax category" do
+        it "should be equal to the sum of the item totals * rate" do
+          expect(calculator.compute(order)).to eq(3)
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
+      end
+
+      context "when no line items match the tax category" do
+        let(:other_tax_category) { create(:tax_category) }
+        let(:line_item_one_options) { { tax_category: other_tax_category } }
+        let(:line_item_two_options) { { tax_category: other_tax_category } }
+
+        it "should be 0" do
+          expect(calculator.compute(order)).to eq(0)
+        end
+      end
+
+      context "when one item matches the tax category" do
+        let(:other_tax_category) { create(:tax_category) }
+        let(:line_item_two_options) { { tax_category: other_tax_category } }
+
+        it "should be equal to the item total * rate" do
+          expect(calculator.compute(order)).to eq(1.5)
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
+
+        context "correctly rounds to within two decimal places" do
+          let(:line_item_one_options) { { price: 10.333, quantity: 1 } }
+
+          specify do
+            # Amount is 0.51665, which will be rounded to...
+            expect(calculator.compute(order)).to eq(0.52)
+          end
+        end
+      end
+
+      context "when tax is included in price" do
+        let(:included_in_price) { true }
+
+        it "will return the deducted amount from the totals" do
+          # total price including 5% tax = $60
+          # ex pre-tax = $57.14
+          # 57.14 + %5 = 59.997 (or "close enough" to $60)
+          # 60 - 57.14 = $2.86
+          expect(calculator.compute(order).to_f).to eql 2.86
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(order)).to eq(0)
+          end
+        end
+      end
+    end
+  end
+
+  shared_examples_for 'computing any item' do
+    let(:adjustment_total) { 0 }
+    let(:adjustments) do
+      if adjustment_total.zero?
+        []
+      else
+       [Spree::Adjustment.new(included: false, source: nil, amount: adjustment_total)]
+      end
+    end
+    let(:order) { build_stubbed(:order, ship_address: address) }
+
+    context "when tax is included in price" do
+      let(:included_in_price) { true }
+
+      context "when the variant matches the tax category" do
+        it "should be equal to the item's full price * rate" do
+          expect(calculator.compute(item)).to eql 1.43
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
+
+        context "when line item is adjusted" do
+          let(:adjustment_total) { -1 }
+
+          it "should be equal to the item's adjusted total * rate" do
+            expect(calculator.compute(item)).to eql 1.38
+          end
+        end
+      end
+    end
+
+    context "when tax is not included in price" do
+      context "when the item has an adjustment" do
+        let(:adjustment_total) { -1 }
+
+        it "should be equal to the item's pre-tax total * rate" do
+          expect(calculator.compute(item)).to eq(1.45)
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
+      end
+
+      context "when the variant matches the tax category" do
+        it "should be equal to the item pre-tax total * rate" do
+          expect(calculator.compute(item)).to eq(1.50)
+        end
+
+        context "when rate is not in its validity period" do
+          let(:starts_at) { 1.day.from_now }
+          let(:expires_at) { 2.days.from_now }
+
+          it "should be 0" do
+            expect(calculator.compute(item)).to eq(0)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'when given a line item' do
+    let(:item) do
+      build_stubbed(
+        :line_item,
+        price: 10,
+        quantity: 3,
+        adjustments: adjustments,
+        order: order,
+        tax_category: tax_category
+      )
+    end
+
+    it_behaves_like 'computing any item'
+  end
+
+  describe 'when given a shipment' do
+    let(:shipping_method) do
+      build_stubbed(
+        :shipping_method,
+        tax_category: tax_category
+      )
+    end
+
+    let(:shipping_rate) do
+      build_stubbed(
+        :shipping_rate,
+        selected: true,
+        shipping_method: shipping_method
+      )
+    end
+
+    let(:item) do
+      build_stubbed(
+        :shipment,
+        cost: 30,
+        adjustments: adjustments,
+        order: order,
+        shipping_rates: [shipping_rate]
+      )
+    end
+
+    it_behaves_like 'computing any item'
+  end
+
+  describe 'when given a shipping rate' do
+    let(:shipping_method) do
+      build_stubbed(
+        :shipping_method,
+        tax_category: tax_category
+      )
+    end
+
+    let(:shipment) do
+      build_stubbed(
+        :shipment,
+        order: order
+      )
+    end
+
+    let(:item) do
+      # cost and adjusted amount for shipping rates are the same as they
+      # can not be adjusted. for the sake of passing tests, the cost is
+      # adjusted here.
+      build_stubbed(
+        :shipping_rate,
+        cost: 30 + adjustment_total,
+        selected: true,
+        shipping_method: shipping_method,
+        shipment: shipment
+      )
+    end
+
+    it_behaves_like 'computing any item'
+  end
+end