solidus_core 2.10.5 → 2.11.0

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

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

@@ -1,815 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe "Taxation system integration tests" do
-  let(:order) { create :order, ship_address: shipping_address, state: "delivery" }
-  let(:book_product) do
-    create :product,
-           price: 20,
-           name: "Book",
-           tax_category: books_category,
-           shipping_category: books_shipping_category
-  end
-  let(:download_product) do
-    create :product,
-           price: 10,
-           name: "Download",
-           tax_category: digital_category,
-           shipping_category: digital_shipping_category
-  end
-  let(:sweater_product) do
-    create :product,
-           price: 30,
-           name: "Download",
-           tax_category: normal_category,
-           shipping_category: normal_shipping_category
-  end
-  let(:fruit_product) do
-    create :product,
-      price: 5,
-      name: "Food",
-      tax_category: fruit_category,
-      shipping_category: normal_shipping_category
-  end
-
-  let(:book) { book_product.master }
-  let(:download) { download_product.master }
-  let(:sweater) { sweater_product.master }
-  let(:fruit) { fruit_product.master }
-
-  let(:books_category) { create :tax_category, name: "Books" }
-  let(:normal_category) { create :tax_category, name: "Normal" }
-  let(:digital_category) { create :tax_category, name: "Digital Goods" }
-  let(:fruit_category) { create :tax_category, name: "Fruit Product" }
-  let(:milk_category) { create :tax_category, name: "Milk Product" }
-
-  let(:books_shipping_category) { create :shipping_category, name: "Book Shipping" }
-  let(:normal_shipping_category) { create :shipping_category, name: "Normal Shipping" }
-  let(:digital_shipping_category) { create :shipping_category, name: "Digital Premium Download" }
-
-  let(:line_item) { order.line_items.first }
-  let(:shipment) { order.shipments.first }
-  let(:shipping_rate) { shipment.shipping_rates.first }
-
-  context 'selling from germany' do
-    let(:germany) { create :country, iso: "DE" }
-    let!(:germany_zone) { create :zone, countries: [germany] }
-    let(:romania) { create(:country, iso: "RO") }
-    let(:romania_zone) { create(:zone, countries: [romania] ) }
-    let(:eu_zone) { create(:zone, countries: [romania, germany]) }
-    let(:world_zone) { create(:zone, :with_country) }
-
-    let!(:german_book_vat) do
-      create(
-        :tax_rate,
-        name: "German reduced VAT",
-        included_in_price: true,
-        amount: 0.07,
-        tax_categories: [books_category],
-        zone: eu_zone
-      )
-    end
-    let!(:german_normal_vat) do
-      create(
-        :tax_rate,
-        name: "German VAT",
-        included_in_price: true,
-        amount: 0.19,
-        tax_categories: [normal_category],
-        zone: eu_zone
-      )
-    end
-    let!(:german_digital_vat) do
-      create(
-        :tax_rate,
-        name: "German VAT",
-        included_in_price: true,
-        amount: 0.19,
-        tax_categories: [digital_category],
-        zone: germany_zone
-      )
-    end
-    let!(:german_food_vat) do
-      create(
-        :tax_rate,
-        name: "German Food VAT",
-        included_in_price: true,
-        amount: 0.09,
-        tax_categories: [fruit_category, milk_category],
-        zone: germany_zone
-      )
-    end
-    let!(:romanian_digital_vat) do
-      create(
-        :tax_rate,
-        name: "Romanian VAT",
-        included_in_price: true,
-        amount: 0.24,
-        tax_categories: [digital_category],
-        zone: romania_zone
-      )
-    end
-    let!(:book_shipping_method) do
-      create :shipping_method,
-             cost: 8.00,
-             shipping_categories: [books_shipping_category],
-             tax_category: books_category,
-             zones: [eu_zone, world_zone]
-    end
-
-    let!(:sweater_shipping_method) do
-      create :shipping_method,
-             cost: 16.00,
-             shipping_categories: [normal_shipping_category],
-             tax_category: normal_category,
-             zones: [eu_zone, world_zone]
-    end
-
-    let!(:premium_download_shipping_method) do
-      create :shipping_method,
-             cost: 2.00,
-             shipping_categories: [digital_shipping_category],
-             tax_category: digital_category,
-             zones: [eu_zone, world_zone]
-    end
-
-    before do
-      stub_spree_preferences(admin_vat_country_iso: "DE")
-      order.contents.add(variant)
-    end
-
-    context 'to germany' do
-      let(:shipping_address) { create :address, country_iso_code: "DE" }
-
-      context 'an order with a book' do
-        let(:variant) { book }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(20)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 1.13 cents of included tax' do
-          expect(line_item.included_tax_total).to eq(1.31)
-        end
-      end
-
-      context 'an order with a book and a shipment' do
-        let(:variant) { book }
-
-        before { 2.times { order.next! } }
-
-        it 'has a shipment for 8.00 dollars' do
-          expect(shipment.amount).to eq(8.00)
-        end
-
-        it 'has a shipment with 0.52 included tax' do
-          expect(shipment.included_tax_total).to eq(0.52)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$8.00 (incl. $0.52 German reduced VAT)")
-        end
-      end
-
-      context 'an order with a sweater' do
-        let(:variant) { sweater }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(30)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 4,78 of included tax' do
-          expect(line_item.included_tax_total).to eq(4.79)
-        end
-      end
-
-      context 'an order with a sweater and a shipment' do
-        let(:variant) { sweater }
-
-        before { 2.times { order.next! } }
-
-        it 'has a shipment for 16.00 dollars' do
-          expect(shipment.amount).to eq(16.00)
-        end
-
-        it 'has a shipment with 2.55 included tax' do
-          expect(shipment.included_tax_total).to eq(2.55)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$16.00 (incl. $2.55 German VAT)")
-        end
-      end
-
-      context 'an order with a download' do
-        let(:variant) { download }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(10)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 1.60 of included tax' do
-          expect(line_item.included_tax_total).to eq(1.60)
-        end
-      end
-
-      context 'an order with a download and a shipment' do
-        let(:variant) { download }
-
-        before { 2.times { order.next! } }
-
-        it 'has a shipment for 4.00 dollars' do
-          expect(shipment.amount).to eq(2.00)
-        end
-
-        it 'has a shipment with 0.64 included tax' do
-          expect(shipment.included_tax_total).to eq(0.32)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$2.00 (incl. $0.32 German VAT)")
-        end
-      end
-
-      context 'an order containg a fruit' do
-        let(:variant) { fruit }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(5)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 0.45 of included tax' do
-          expect(line_item.included_tax_total).to eq(0.41)
-        end
-      end
-    end
-
-    context 'to romania' do
-      let(:shipping_address) { create :address, country_iso_code: "RO" }
-
-      context 'an order with a book' do
-        let(:variant) { book }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(20)
-        end
-
-        it 'is adjusted to the original price' do
-          expect(line_item.total).to eq(20)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 1.13 cents of included tax' do
-          expect(line_item.included_tax_total).to eq(1.31)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(18.69)
-        end
-      end
-
-      context 'an order with a book and a shipment' do
-        let(:variant) { book }
-
-        before { 2.times { order.next! } }
-
-        it 'has a shipment for 8.00 dollars' do
-          expect(shipment.amount).to eq(8.00)
-        end
-
-        it 'has a shipment with 0.52 included tax' do
-          expect(shipment.included_tax_total).to eq(0.52)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$8.00 (incl. $0.52 German reduced VAT)")
-        end
-      end
-
-      context 'an order with a sweater' do
-        let(:variant) { sweater }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(30)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 4.79 of included tax' do
-          expect(line_item.included_tax_total).to eq(4.79)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(25.21)
-        end
-      end
-
-      context 'an order with a sweater and a shipment' do
-        let(:variant) { sweater }
-
-        before { 2.times { order.next! } }
-
-        it 'has a shipment for 16.00 dollars' do
-          expect(shipment.amount).to eq(16.00)
-        end
-
-        it 'has a shipment with 2.55 included tax' do
-          expect(shipment.included_tax_total).to eq(2.55)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$16.00 (incl. $2.55 German VAT)")
-        end
-      end
-
-      context 'an order with a download' do
-        let(:variant) { download }
-
-        it 'still has an adjusted price for romania' do
-          expect(line_item.price).to eq(10.42)
-        end
-
-        it 'has one tax adjustment' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has 2.02 of included tax' do
-          expect(line_item.included_tax_total).to eq(2.02)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(8.40)
-        end
-      end
-
-      context 'an order with a download and a shipment' do
-        let(:variant) { download }
-
-        before { 2.times { order.next! } }
-
-        it 'it has a shipment with worth 2.00' do
-          expect(shipment.amount).to eq(2.00)
-        end
-
-        it 'has a shipment with 0.40 included tax' do
-          expect(shipment.included_tax_total).to eq(0.39)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$2.00 (incl. $0.39 Romanian VAT)")
-        end
-      end
-    end
-    # Technically, this can't be the case yet as the order won't pass the shipment stage,
-    # but the taxation code shouldn't implicitly depend on the shipping code.
-    context 'to an address that does not have a zone associated' do
-      let(:shipping_address) { create :address, country_iso_code: "IT" }
-
-      context 'an order with a book' do
-        let(:variant) { book }
-
-        it 'should sell at the net price' do
-          expect(line_item.price).to eq(18.69)
-        end
-
-        it 'is adjusted to the net price' do
-          expect(line_item.total).to eq(18.69)
-        end
-
-        it 'has no tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(0)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has no additional tax' do
-          expect(line_item.additional_tax_total).to eq(0)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(18.69)
-        end
-      end
-    end
-
-    # International delivery, no tax applies whatsoever
-    context 'to anywhere else in the world' do
-      let(:shipping_address) { create :address, country: world_zone.countries.first }
-
-      context 'an order with a book' do
-        let(:variant) { book }
-
-        it 'should sell at the net price' do
-          expect(line_item.price).to eq(18.69)
-        end
-
-        it 'is adjusted to the net price' do
-          expect(line_item.total).to eq(18.69)
-        end
-
-        it 'has no tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(0)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has no additional tax' do
-          expect(line_item.additional_tax_total).to eq(0)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(18.69)
-        end
-
-        context 'an order with a book and a shipment' do
-          let(:variant) { book }
-
-          before { 2.times { order.next! } }
-
-          it 'it has a shipment that costs $8.00' do
-            expect(shipment.amount).to eq(8.00)
-          end
-
-          it 'has a shipment with no included tax' do
-            expect(shipment.included_tax_total).to eq(0)
-          end
-
-          it 'has a shipping rate that correctly reflects the shipment' do
-            expect(shipping_rate.display_price).to eq("$8.00")
-          end
-        end
-      end
-
-      context 'an order with a sweater' do
-        let(:variant) { sweater }
-
-        it 'should sell at the net price' do
-          expect(line_item.price).to eq(25.21)
-        end
-
-        it 'has no tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(0)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has no additional tax' do
-          expect(line_item.additional_tax_total).to eq(0)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(25.21)
-        end
-
-        context 'an order with a sweater and a shipment' do
-          let(:variant) { sweater }
-
-          before { 2.times { order.next! } }
-
-          it 'it has a shipment costing $16.00' do
-            expect(shipment.amount).to eq(16.00)
-          end
-
-          it 'has a shipment with no included tax' do
-            expect(shipment.included_tax_total).to eq(0)
-          end
-
-          it 'has a shipping rate that correctly reflects the shipment' do
-            expect(shipping_rate.display_price).to eq("$16.00")
-          end
-        end
-      end
-
-      context 'an order with a download' do
-        let(:variant) { download }
-
-        it 'should sell at the net price' do
-          expect(line_item.price).to eq(8.40)
-        end
-
-        it 'has no tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(0)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has no additional tax' do
-          expect(line_item.additional_tax_total).to eq(0)
-        end
-
-        it 'has a constant amount pre tax' do
-          expect(line_item.total_before_tax - line_item.included_tax_total).to eq(8.40)
-        end
-      end
-
-      context 'an order with a download and a shipment' do
-        let(:variant) { download }
-
-        before { 2.times { order.next! } }
-
-        it 'it has a shipment costing 2.00' do
-          expect(shipment.amount).to eq(2.00)
-        end
-
-        it 'has a shipment with no included tax' do
-          expect(shipment.included_tax_total).to eq(0)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$2.00")
-        end
-      end
-    end
-  end
-
-  # Choosing New York here because in the US, states matter
-  context 'selling from new york' do
-    let(:new_york) { create(:state, state_code: "NY") }
-    let(:united_states) { new_york.country }
-    let(:new_york_zone) { create(:zone, states: [new_york]) }
-    let(:united_states_zone) { create(:zone, countries: [united_states]) }
-    # Creating two rates for books here to
-    # mimick the existing specs
-    let!(:new_york_books_tax) do
-      create(
-        :tax_rate,
-        name: "New York Sales Tax",
-        tax_categories: [books_category],
-        zone: new_york_zone,
-        included_in_price: false,
-        amount: 0.05
-      )
-    end
-
-    let!(:federal_books_tax) do
-      create(
-        :tax_rate,
-        name: "Federal Sales Tax",
-        tax_categories: [books_category],
-        zone: united_states_zone,
-        included_in_price: false,
-        amount: 0.10
-      )
-    end
-
-    let!(:federal_digital_tax) do
-      create(
-        :tax_rate,
-        name: "Federal Sales Tax",
-        tax_categories: [digital_category],
-        zone: united_states_zone,
-        included_in_price: false,
-        amount: 0.20
-      )
-    end
-
-    let!(:book_shipping_method) do
-      create :shipping_method,
-             cost: 8.00,
-             shipping_categories: [books_shipping_category],
-             tax_category: books_category,
-             zones: [united_states_zone]
-    end
-
-    let!(:sweater_shipping_method) do
-      create :shipping_method,
-             cost: 16.00,
-             shipping_categories: [normal_shipping_category],
-             tax_category: normal_category,
-             zones: [united_states_zone]
-    end
-
-    let!(:premium_download_shipping_method) do
-      create :shipping_method,
-             cost: 2.00,
-             shipping_categories: [digital_shipping_category],
-             tax_category: digital_category,
-             zones: [united_states_zone]
-    end
-
-    before do
-      order.contents.add(variant)
-    end
-
-    context 'to new york' do
-      let(:shipping_address) { create :address, state_code: "NY" }
-
-      # A fictional case for an item with two applicable rates
-      context 'an order with a book' do
-        let(:variant) { book }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(20)
-        end
-
-        it 'sells for the line items amount plus additional tax' do
-          expect(line_item.total).to eq(23)
-        end
-
-        it 'has two tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(2)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has 15% additional tax' do
-          expect(line_item.additional_tax_total).to eq(3)
-        end
-
-        it "should delete adjustments for open order when taxrate is soft-deleted" do
-          new_york_books_tax.discard
-          federal_books_tax.discard
-          expect(line_item.adjustments.count).to eq(0)
-        end
-
-        it "should not delete adjustments for complete order when taxrate is soft-deleted" do
-          order.update_column :completed_at, Time.now
-          new_york_books_tax.discard
-          federal_books_tax.discard
-          expect(line_item.adjustments.count).to eq(2)
-        end
-
-        context 'when tax address is later cleared' do
-          before do
-            order.ship_address = nil
-            order.recalculate
-          end
-
-          it 'removes all tax adjustments' do
-            aggregate_failures do
-              expect(line_item.adjustments.tax.count).to eq(0)
-              expect(line_item).to have_attributes(
-                price: 20,
-                total: 20,
-                included_tax_total: 0,
-                additional_tax_total: 0
-              )
-            end
-          end
-        end
-      end
-
-      context 'an order with a book and a shipment' do
-        let(:variant) { book }
-
-        before { 2.times { order.next! } }
-
-        it 'it has a shipment with a price of 8.00' do
-          expect(shipment.amount).to eq(8.00)
-        end
-
-        it 'has a shipment with no included tax' do
-          expect(shipment.included_tax_total).to eq(0)
-        end
-
-        it 'has a shipment with additional tax of 1.20' do
-          expect(shipment.additional_tax_total).to eq(1.20)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to include("$8.00")
-          expect(shipping_rate.display_price).to include("+ $0.80 Federal Sales Tax")
-          expect(shipping_rate.display_price).to include("+ $0.40 New York Sales Tax")
-        end
-      end
-
-      # This is a fictional case for when no taxes apply at all.
-      context 'an order with a sweater' do
-        let(:variant) { sweater }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(30)
-        end
-
-        it 'sells for the line items amount plus additional tax' do
-          expect(line_item.total).to eq(30)
-        end
-
-        it 'has no tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(0)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has no additional tax' do
-          expect(line_item.additional_tax_total).to eq(0)
-        end
-      end
-
-      context 'an order with a sweater and a shipment' do
-        let(:variant) { sweater }
-
-        before { 2.times { order.next! } }
-
-        it 'it has a shipment with a price of 16.00' do
-          expect(shipment.amount).to eq(16.00)
-        end
-
-        it 'has a shipment with no included tax' do
-          expect(shipment.included_tax_total).to eq(0)
-        end
-
-        it 'has a shipment with no additional tax' do
-          expect(shipment.additional_tax_total).to eq(0)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$16.00")
-        end
-      end
-
-      # A fictional case with one applicable rate
-      context 'an order with a download' do
-        let(:variant) { download }
-
-        it 'still has the original price' do
-          expect(line_item.price).to eq(10)
-        end
-
-        it 'sells for the line items amount plus additional tax' do
-          expect(line_item.total).to eq(12)
-        end
-
-        it 'has one tax adjustments' do
-          expect(line_item.adjustments.tax.count).to eq(1)
-        end
-
-        it 'has no included tax' do
-          expect(line_item.included_tax_total).to eq(0)
-        end
-
-        it 'has 15% additional tax' do
-          expect(line_item.additional_tax_total).to eq(2)
-        end
-      end
-
-      context 'an order with a download and a shipment' do
-        let(:variant) { download }
-
-        before { 2.times { order.next! } }
-
-        it 'it has a shipment with a price of 2.00' do
-          expect(shipment.amount).to eq(2.00)
-        end
-
-        it 'has a shipment with no included tax' do
-          expect(shipment.included_tax_total).to eq(0)
-        end
-
-        it 'has a shipment with additional tax of 0.40' do
-          expect(shipment.additional_tax_total).to eq(0.40)
-        end
-
-        it 'has a shipping rate that correctly reflects the shipment' do
-          expect(shipping_rate.display_price).to eq("$2.00 (+ $0.40 Federal Sales Tax)")
-        end
-      end
-    end
-
-    context 'when no tax zone is given' do
-      let(:shipping_address) { nil }
-
-      context 'and we buy a book' do
-        let(:variant) { book }
-
-        it 'does not create adjustments' do
-          expect(line_item.adjustments.count).to eq(0)
-        end
-      end
-    end
-  end
-end