solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/store_selector/by_server_name_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::StoreSelector::ByServerName do
+  describe "#store" do
+    subject { described_class.new(request).store }
+
+    context "with a default" do
+      let(:request) { double(headers: {}, env: {}) }
+      let!(:store_1) { create :store, default: true }
+
+      it "returns the default store" do
+        expect(subject).to eq(store_1)
+      end
+
+      context "with a domain match" do
+        let(:request) { double(headers: {}, env: { "SERVER_NAME" => url } ) }
+        let(:url) { "server-name.org" }
+        let!(:store_2) { create :store, default: false, url: url }
+
+        it "returns the store with the matching domain" do
+          expect(subject).to eq(store_2)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/store_selector/legacy_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::StoreSelector::Legacy do
+  describe "#store" do
+    subject { described_class.new(request).store }
+
+    context "with a default" do
+      let(:request) { double(headers: {}, env: {}) }
+      let!(:store_1) { create :store, default: true }
+
+      it "returns the default store" do
+        expect(subject).to eq(store_1)
+      end
+
+      context "with a domain match" do
+        let(:request) { double(headers: {}, env: { "SERVER_NAME" => url } ) }
+        let(:url) { "server-name.org" }
+        let!(:store_2) { create :store, default: false, url: url }
+
+        it "returns the store with the matching domain" do
+          expect(subject).to eq(store_2)
+        end
+
+        context 'the store has multiple URLs' do
+          let!(:store_2) { create :store, default: false, url: "foo\n#{url}\nbar" }
+
+          it "returns the store with the matching domain" do
+            expect(subject).to eq(store_2)
+          end
+        end
+
+        context "with headers" do
+          let(:request) { double(headers: { "HTTP_SPREE_STORE" => headers_code }, env: {}) }
+          let(:headers_code) { "HEADERS" }
+          let!(:store_3) { create :store, code: headers_code, default: false }
+
+          it "returns the store with the matching code" do
+            expect(subject).to eq(store_3)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/store_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Store, type: :model do
+  it { is_expected.to respond_to(:cart_tax_country_iso) }
+
+  describe ".by_url (deprecated)" do
+    let!(:store)    { create(:store, url: "website1.com\nwww.subdomain.com") }
+    let!(:store_2)  { create(:store, url: 'freethewhales.com') }
+
+    around do |example|
+      Spree::Deprecation.silence { example.run }
+    end
+
+    it "should find stores by url" do
+      by_domain = Spree::Store.by_url('www.subdomain.com')
+
+      expect(by_domain).to include(store)
+      expect(by_domain).not_to include(store_2)
+    end
+  end
+
+  describe '.current (deprecated)' do
+    let!(:store_1) { create(:store) }
+    let!(:store_default) { create(:store, name: 'default', default: true) }
+    let!(:store_2) { create(:store, default: false, url: 'www.subdomain.com') }
+    let!(:store_3) { create(:store, default: false, url: 'www.another.com', code: 'CODE') }
+
+    delegate :current, to: :described_class
+
+    around do |example|
+      Spree::Deprecation.silence { example.run }
+    end
+
+    context "with no match" do
+      it 'should return the default domain' do
+        expect(current('foobar.com')).to eql(store_default)
+      end
+    end
+
+    context "with matching url" do
+      it 'should return matching store' do
+        expect(current('www.subdomain.com')).to eql(store_2)
+      end
+    end
+
+    context "with matching code" do
+      it 'should return matching store' do
+        expect(current('CODE')).to eql(store_3)
+      end
+    end
+  end
+
+  describe ".default" do
+    it "should ensure saved store becomes default if one doesn't exist yet" do
+      expect(Spree::Store.where(default: true).count).to eq(0)
+      store = build(:store)
+      expect(store.default).not_to be true
+
+      store.save!
+
+      expect(store.default).to be true
+    end
+
+    it "should ensure there is only one default" do
+      orig_default_store = create(:store, default: true)
+      expect(orig_default_store.reload.default).to be true
+
+      new_default_store = create(:store, default: true)
+
+      expect(Spree::Store.where(default: true).count).to eq(1)
+
+      [orig_default_store, new_default_store].each(&:reload)
+
+      expect(new_default_store.default).to be true
+      expect(orig_default_store.default).not_to be true
+    end
+  end
+
+  describe '#default_cart_tax_location' do
+    subject { described_class.new(cart_tax_country_iso: cart_tax_country_iso) }
+    context "when there is no cart_tax_country_iso set" do
+      let(:cart_tax_country_iso) { '' }
+      it "responds with an empty default_cart_tax_location" do
+        expect(subject.default_cart_tax_location).to be_empty
+      end
+    end
+
+    context "when there is a cart_tax_country_iso set" do
+      let(:country) { create(:country, iso: "DE") }
+      let(:cart_tax_country_iso) { country.iso }
+
+      it "responds with a default_cart_tax_location with that country" do
+        expect(subject.default_cart_tax_location).to eq(Spree::Tax::TaxLocation.new(country: country))
+      end
+    end
+  end
+
+  describe '#available_locales' do
+    let(:store) { described_class.new(available_locales: locales) }
+    subject { store.available_locales }
+
+    context 'with available_locales: []' do
+      let(:locales) { [] }
+
+      it "returns all available locales" do
+        expect(subject).to eq([:en])
+      end
+
+      it "serializes as nil" do
+        expect(store[:available_locales]).to be nil
+      end
+    end
+
+    context 'with available_locales: [:en]' do
+      let(:locales) { [:en] }
+
+      it "returns [:en]" do
+        expect(subject).to eq([:en])
+      end
+
+      it "serializes correctly" do
+        expect(store[:available_locales]).to eq("en")
+      end
+    end
+
+    context 'with available_locales: [:en, :fr]' do
+      let(:locales) { [:en, :fr] }
+
+      it "returns [:fr]" do
+        expect(subject).to eq([:en, :fr])
+      end
+
+      it "serializes correctly" do
+        expect(store[:available_locales]).to eq("en,fr")
+      end
+    end
+
+    context 'with available_locales: [:fr]' do
+      let(:locales) { [:fr] }
+
+      it "returns [:fr]" do
+        expect(subject).to eq([:fr])
+      end
+    end
+
+    context 'with available_locales: ["fr"]' do
+      let(:locales) { ["fr"] }
+
+      it "returns symbols [:fr]" do
+        expect(subject).to eq([:fr])
+      end
+    end
+  end
+end

data/spec/models/spree/tax/order_adjuster_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Tax::OrderAdjuster do
+  subject(:adjuster) { described_class.new(order) }
+
+  describe 'initialization' do
+    let(:order) { Spree::Order.new }
+
+    it 'sets order to adjustable' do
+      expect(adjuster.order).to eq(order)
+    end
+  end
+
+  describe '#adjust!' do
+    let(:order) { Spree::Order.new }
+
+    let(:custom_calculator_class) { double }
+    let(:custom_calculator_instance) { double }
+
+    before do
+      Spree::Config.tax_calculator_class = custom_calculator_class
+    end
+
+    it 'calls the configured tax calculator' do
+      expect(custom_calculator_class).to receive(:new).with(order).at_least(:once).and_return(custom_calculator_instance)
+      expect(custom_calculator_instance).to receive(:calculate).at_least(:once).and_return(
+        Spree::Tax::OrderTax.new(order_id: order.id, line_item_taxes: [], shipment_taxes: [])
+      )
+
+      adjuster.adjust!
+    end
+  end
+end

data/spec/models/spree/tax/shipping_rate_taxer_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Tax::ShippingRateTaxer do
+  let(:shipping_rate) { build_stubbed(:shipping_rate) }
+
+  subject(:taxer) { described_class.new(shipping_rate) }
+
+  describe '#tax' do
+    subject(:taxer) { described_class.new.tax(shipping_rate) }
+
+    context 'with no matching tax rates' do
+      it 'returns the object' do
+        expect(subject).to eq(shipping_rate)
+        expect(subject.taxes).to eq([])
+      end
+    end
+
+    context 'with tax rates' do
+      let(:ship_address) { create :address }
+      let(:tax_category) { create :tax_category }
+      let(:order) { create :order, ship_address: ship_address }
+      let(:shipment) { create :shipment, order: order }
+      let!(:shipping_method) { create :shipping_method, tax_category: tax_category, zones: [zone] }
+      let(:zone) { create :zone, countries: [ship_address.country] }
+      let!(:tax_rate_one) { create :tax_rate, tax_categories: [tax_category], zone: zone, amount: 0.1 }
+      let!(:tax_rate_two) do
+        create(
+          :tax_rate,
+          tax_categories: [create(:tax_category), tax_category],
+          zone: zone,
+          amount: 0.2
+        )
+      end
+      let!(:non_applicable_rate) { create :tax_rate, zone: zone }
+      let(:shipping_rate) { create :shipping_rate, cost: 10, shipping_method: shipping_method }
+
+      it 'builds a shipping rate tax for every matching tax rate' do
+        expect(subject.taxes.length).to eq(2)
+        expect(subject.taxes.map(&:tax_rate)).to include(tax_rate_one)
+        expect(subject.taxes.map(&:tax_rate)).to include(tax_rate_two)
+        # This rate has a different tax category.
+        expect(subject.taxes.map(&:tax_rate)).not_to include(non_applicable_rate)
+      end
+
+      it 'will produce a shipping rate that, when saved, also saves the taxes' do
+        expect { subject.save }.to change(Spree::ShippingRateTax, :count).by(2)
+      end
+
+      it 'will produce a shipping rate with correct taxes' do
+        tax_one = subject.taxes.detect { |tax| tax.tax_rate == tax_rate_one }
+        tax_two = subject.taxes.detect { |tax| tax.tax_rate == tax_rate_two }
+        expect(tax_one.amount).to eq(shipping_rate.cost * tax_rate_one.amount)
+        expect(tax_two.amount).to eq(shipping_rate.cost * tax_rate_two.amount)
+      end
+    end
+  end
+end

data/spec/models/spree/tax/tax_location_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Tax::TaxLocation do
+  let(:country) { build_stubbed(:country) }
+  let(:state) { build_stubbed(:state) }
+
+  subject { described_class.new }
+
+  it { is_expected.to respond_to(:state_id) }
+  it { is_expected.to respond_to(:country_id) }
+
+  describe "default values" do
+    it "has a nil state and country id" do
+      expect(subject.state_id).to eq(nil)
+      expect(subject.country_id).to eq(nil)
+    end
+  end
+
+  describe '#==' do
+    let(:other) { described_class.new(state: nil, country: nil) }
+
+    it 'compares the values of state id and country id and does not care about object identity' do
+      expect(subject).to eq(other)
+    end
+  end
+
+  describe "initialization" do
+    subject { described_class.new(args) }
+
+    context 'with a country object' do
+      let(:args) { { country: country } }
+
+      it "will yield a location with that country's id" do
+        expect(subject.country_id).to eq(country.id)
+      end
+    end
+  end
+
+  describe "#country" do
+    let(:country) { create(:country) }
+    subject { described_class.new(args).country }
+
+    context 'with a country object' do
+      let(:args) { { country: country } }
+
+      it { is_expected.to eq(country) }
+    end
+
+    context 'with no country object' do
+      let(:args) { { country: nil } }
+
+      it { is_expected.to be nil }
+    end
+  end
+
+  describe "#empty?" do
+    subject { described_class.new(args).empty? }
+
+    context 'with a country present' do
+      let(:args) { { country: country } }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with a state present' do
+      let(:args) { { state: state } }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with no region data present' do
+      let(:args) { {} }
+
+      it { is_expected.to be true }
+    end
+  end
+end