solidus_core 2.10.5 → 3.0.8

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

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

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

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

@@ -1,35 +0,0 @@
-# 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
-      stub_spree_preferences(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

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

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