spree_core 3.0.5 → 3.0.6

data/spec/models/spree/stock_location_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+module Spree
+  describe StockLocation, :type => :model do
+    subject { create(:stock_location_with_items, backorderable_default: true) }
+    let(:stock_item) { subject.stock_items.order(:id).first }
+    let(:variant) { stock_item.variant }
+
+    it 'creates stock_items for all variants' do
+      expect(subject.stock_items.count).to eq Variant.count
+    end
+
+    context "handling stock items" do
+      let!(:variant) { create(:variant) }
+
+      context "given a variant" do
+        subject { StockLocation.create(name: "testing", propagate_all_variants: false) }
+
+        context "set up" do
+          it "creates stock item" do
+            expect(subject).to receive(:propagate_variant)
+            subject.set_up_stock_item(variant)
+          end
+
+          context "stock item exists" do
+            let!(:stock_item) { subject.propagate_variant(variant) }
+
+            it "returns existing stock item" do
+              expect(subject.set_up_stock_item(variant)).to eq(stock_item)
+            end
+          end
+        end
+
+        context "propagate variants" do
+          let(:stock_item) { subject.propagate_variant(variant) }
+
+          it "creates a new stock item" do
+            expect {
+              subject.propagate_variant(variant)
+            }.to change{ StockItem.count }.by(1)
+          end
+
+          context "passes backorderable default config" do
+            context "true" do
+              before { subject.backorderable_default = true }
+              it { expect(stock_item.backorderable).to be true }
+            end
+
+            context "false" do
+              before { subject.backorderable_default = false }
+              it { expect(stock_item.backorderable).to be false }
+            end
+          end
+        end
+
+        context "propagate all variants" do
+          subject { StockLocation.new(name: "testing") }
+
+          context "true" do
+            before { subject.propagate_all_variants = true }
+
+            specify do
+              expect(subject).to receive(:propagate_variant).at_least(:once)
+              subject.save!
+            end
+          end
+
+          context "false" do
+            before { subject.propagate_all_variants = false }
+
+            specify do
+              expect(subject).not_to receive(:propagate_variant)
+              subject.save!
+            end
+          end
+        end
+      end
+    end
+
+    it 'finds a stock_item for a variant' do
+      stock_item = subject.stock_item(variant)
+      expect(stock_item.count_on_hand).to eq 10
+    end
+
+    it 'finds a stock_item for a variant by id' do
+      stock_item = subject.stock_item(variant.id)
+      expect(stock_item.variant).to eq variant
+    end
+
+    it 'returns nil when stock_item is not found for variant' do
+      stock_item = subject.stock_item(100)
+      expect(stock_item).to be_nil
+    end
+
+    describe '#stock_item_or_create' do
+      before do
+        variant = create(:variant)
+        variant.stock_items.destroy_all
+        variant.save
+      end
+
+      it 'creates a stock_item if not found for a variant' do
+        stock_item = subject.stock_item_or_create(variant)
+        expect(stock_item.variant).to eq variant
+      end
+    end
+
+    it 'finds a count_on_hand for a variant' do
+       expect(subject.count_on_hand(variant)).to eq 10
+    end
+
+    it 'finds determines if you a variant is backorderable' do
+      expect(subject.backorderable?(variant)).to be true
+    end
+
+    it 'restocks a variant with a positive stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, 5, originator)
+      subject.restock(variant, 5, originator)
+    end
+
+    it 'unstocks a variant with a negative stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, -5, originator)
+      subject.unstock(variant, 5, originator)
+    end
+
+    it 'it creates a stock_movement' do
+      expect {
+        subject.move variant, 5
+      }.to change { subject.stock_movements.where(stock_item_id: stock_item).count }.by(1)
+    end
+
+    it 'can be deactivated' do
+      create(:stock_location, :active => true)
+      create(:stock_location, :active => false)
+      expect(Spree::StockLocation.active.count).to eq 1
+    end
+
+    it 'ensures only one stock location is default at a time' do
+      first = create(:stock_location, :active => true, :default => true)
+      second = create(:stock_location, :active => true, :default => true)
+
+      expect(first.reload.default).to eq false
+      expect(second.reload.default).to eq true
+
+      first.default = true
+      first.save!
+
+      expect(first.reload.default).to eq true
+      expect(second.reload.default).to eq false
+    end
+
+    context 'fill_status' do
+      it 'all on_hand with no backordered' do
+        on_hand, backordered = subject.fill_status(variant, 5)
+        expect(on_hand).to eq 5
+        expect(backordered).to eq 0
+      end
+
+      it 'some on_hand with some backordered' do
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 10
+        expect(backordered).to eq 10
+      end
+
+      it 'zero on_hand with all backordered' do
+        zero_stock_item = mock_model(StockItem,
+                                     count_on_hand: 0,
+                                     backorderable?: true)
+        expect(subject).to receive(:stock_item).with(variant).and_return(zero_stock_item)
+
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 0
+        expect(backordered).to eq 20
+      end
+
+      context 'when backordering is not allowed' do
+        before do
+          @stock_item = mock_model(StockItem, backorderable?: false)
+          expect(subject).to receive(:stock_item).with(variant).and_return(@stock_item)
+        end
+
+        it 'all on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 10)
+
+          on_hand, backordered = subject.fill_status(variant, 5)
+          expect(on_hand).to eq 5
+          expect(backordered).to eq 0
+        end
+
+        it 'some on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 10)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 10
+          expect(backordered).to eq 0
+        end
+
+        it 'zero on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 0)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+
+      context 'without stock_items' do
+        subject { create(:stock_location) }
+        let(:variant) { create(:base_variant) }
+
+        it 'zero on_hand and backordered' do
+          subject
+          variant.stock_items.destroy_all
+          on_hand, backordered = subject.fill_status(variant, 1)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+    end
+
+    context '#state_text' do
+      context 'state is blank' do
+        subject { StockLocation.create(name: "testing", state: nil, state_name: 'virginia') }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+
+      context 'both name and abbr is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('va') }
+      end
+
+      context 'only name is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+    end
+
+  end
+end

data/spec/models/spree/stock_movement_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Spree::StockMovement, :type => :model do
+  let(:stock_location) { create(:stock_location_with_items) }
+  let(:stock_item) { stock_location.stock_items.order(:id).first }
+  subject { build(:stock_movement, stock_item: stock_item) }
+
+  it 'should belong to a stock item' do
+    expect(subject).to respond_to(:stock_item)
+  end
+
+  it 'is readonly unless new' do
+    subject.save
+    expect {
+      subject.save
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'does not update count on hand when track inventory levels is false' do
+    Spree::Config[:track_inventory_levels] = false
+    subject.quantity = 1
+    subject.save
+    stock_item.reload
+    expect(stock_item.count_on_hand).to eq(10)
+  end
+
+  it 'does not update count on hand when variant inventory tracking is off' do
+    stock_item.variant.track_inventory = false
+    subject.quantity = 1
+    subject.save
+    stock_item.reload
+    expect(stock_item.count_on_hand).to eq(10)
+  end
+
+  context "when quantity is negative" do
+    context "after save" do
+      it "should decrement the stock item count on hand" do
+        subject.quantity = -1
+        subject.save
+        stock_item.reload
+        expect(stock_item.count_on_hand).to eq(9)
+      end
+    end
+  end
+
+  context "when quantity is positive" do
+    context "after save" do
+      it "should increment the stock item count on hand" do
+        subject.quantity = 1
+        subject.save
+        stock_item.reload
+        expect(stock_item.count_on_hand).to eq(11)
+      end
+    end
+  end
+end

data/spec/models/spree/stock_transfer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Spree
+  describe StockTransfer, :type => :model do
+    let(:destination_location) { create(:stock_location_with_items) }
+    let(:source_location) { create(:stock_location_with_items) }
+    let(:stock_item) { source_location.stock_items.order(:id).first }
+    let(:variant) { stock_item.variant }
+
+    subject { StockTransfer.create(reference: 'PO123') }
+
+    describe '#reference' do
+      subject { super().reference }
+      it { is_expected.to eq 'PO123' }
+    end
+
+    describe '#to_param' do
+      subject { super().to_param }
+      it { is_expected.to match /T\d+/ }
+    end
+
+    it 'transfers variants between 2 locations' do
+      variants = { variant => 5 }
+
+      subject.transfer(source_location,
+                       destination_location,
+                       variants)
+
+      expect(source_location.count_on_hand(variant)).to eq 5
+      expect(destination_location.count_on_hand(variant)).to eq 5
+
+      expect(subject.source_location).to eq source_location
+      expect(subject.destination_location).to eq destination_location
+
+      expect(subject.source_movements.first.quantity).to eq -5
+      expect(subject.destination_movements.first.quantity).to eq 5
+    end
+
+    it 'receive new inventory (from a vendor)' do
+      variants = { variant => 5 }
+
+      subject.receive(destination_location, variants)
+
+      expect(destination_location.count_on_hand(variant)).to eq 5
+
+      expect(subject.source_location).to be_nil
+      expect(subject.destination_location).to eq destination_location
+    end
+  end
+end

data/spec/models/spree/store_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Spree::Store, :type => :model do
+
+  describe ".by_url" do
+    let!(:store)    { create(:store, url: "website1.com\nwww.subdomain.com") }
+    let!(:store_2)  { create(:store, url: 'freethewhales.com') }
+
+    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' do
+    # there is a default store created with the test_app rake task.
+    let!(:store_1) { Spree::Store.first || create(:store) }
+
+    let!(:store_2) { create(:store, default: false, url: 'www.subdomain.com') }
+
+    it 'should return default when no domain' do
+      expect(subject.class.current).to eql(store_1)
+    end
+
+    it 'should return store for domain' do
+      expect(subject.class.current('spreecommerce.com')).to eql(store_1)
+      expect(subject.class.current('www.subdomain.com')).to eql(store_2)
+    end
+  end
+
+  describe ".default" do
+    let!(:store)    { create(:store) }
+    let!(:store_2)  { create(:store, default: true) }
+
+    it "should ensure there is a default if one doesn't exist yet" do
+      expect(store_2.default).to be true
+    end
+
+    it "should ensure there is only one default" do
+      [store, store_2].each(&:reload)
+
+      expect(Spree::Store.where(default: true).count).to eq(1)
+      expect(store_2.default).to be true
+      expect(store.default).not_to be true
+    end
+  end
+
+end

data/spec/models/spree/tax_category_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+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,382 @@
+require 'spec_helper'
+
+describe Spree::TaxRate, :type => :model do
+  context "match" do
+    let(:order) { create(:order) }
+    let(:country) { create(:country) }
+    let(:tax_category) { create(:tax_category) }
+    let(:calculator) { Spree::Calculator::FlatRate.new }
+
+    it "should return an empty array when tax_zone is nil" do
+      allow(order).to receive_messages :tax_zone => nil
+      expect(Spree::TaxRate.match(order.tax_zone)).to eq([])
+    end
+
+    context "when no rate zones match the tax zone" do
+      before do
+        Spree::TaxRate.create(:amount => 1, :zone => create(:zone))
+      end
+
+      context "when there is no default tax zone" do
+        before do
+          @zone = create(:zone, :name => "Country Zone", :default_tax => false, :zone_members => [])
+          @zone.zone_members.create(:zoneable => country)
+        end
+
+        it "should return an empty array" do
+          allow(order).to receive_messages :tax_zone => @zone
+          expect(Spree::TaxRate.match(order.tax_zone)).to eq([])
+        end
+
+        it "should return the rate that matches the rate zone" do
+          rate = Spree::TaxRate.create(
+            :amount => 1,
+            :zone => @zone,
+            :tax_category => tax_category,
+            :calculator => calculator
+          )
+
+          allow(order).to receive_messages :tax_zone => @zone
+          expect(Spree::TaxRate.match(order.tax_zone)).to eq([rate])
+        end
+
+        it "should return all rates that match the rate zone" do
+          rate1 = Spree::TaxRate.create(
+            :amount => 1,
+            :zone => @zone,
+            :tax_category => tax_category,
+            :calculator => calculator
+          )
+
+          rate2 = Spree::TaxRate.create(
+            :amount => 2,
+            :zone => @zone,
+            :tax_category => tax_category,
+            :calculator => Spree::Calculator::FlatRate.new
+          )
+
+          allow(order).to receive_messages :tax_zone => @zone
+          expect(Spree::TaxRate.match(order.tax_zone)).to match_array([rate1, rate2])
+        end
+
+        context "when the tax_zone is contained within a rate zone" do
+          before do
+            sub_zone = create(:zone, :name => "State Zone", :zone_members => [])
+            sub_zone.zone_members.create(:zoneable => create(:state, :country => country))
+            allow(order).to receive_messages :tax_zone => sub_zone
+            @rate = Spree::TaxRate.create(
+              :amount => 1,
+              :zone => @zone,
+              :tax_category => tax_category,
+              :calculator => calculator
+            )
+          end
+
+          it "should return the rate zone" do
+            expect(Spree::TaxRate.match(order.tax_zone)).to eq([@rate])
+          end
+        end
+      end
+
+      context "when there is a default tax zone" do
+        before do
+          @zone = create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => [])
+          @zone.zone_members.create(:zoneable => country)
+        end
+
+        let(:included_in_price) { false }
+        let!(:rate) do
+          Spree::TaxRate.create(:amount => 1,
+                                :zone => @zone,
+                                :tax_category => tax_category,
+                                :calculator => calculator,
+                                :included_in_price => included_in_price)
+        end
+
+        subject { Spree::TaxRate.match(order.tax_zone) }
+
+        context "when the order has the same tax zone" do
+          before do
+            allow(order).to receive_messages :tax_zone => @zone
+            allow(order).to receive_messages :tax_address => tax_address
+          end
+
+          let(:tax_address) { stub_model(Spree::Address) }
+
+          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 order has a different tax zone" do
+          before do
+            allow(order).to receive_messages :tax_zone => create(:zone, :name => "Other Zone")
+            allow(order).to receive_messages :tax_address => tax_address
+          end
+
+          context "when the order has a tax_address" do
+            let(:tax_address) { stub_model(Spree::Address) }
+
+            context "when the tax is a VAT" do
+              let(:included_in_price) { true }
+              # The rate should match in this instance because:
+              # 1) It's the default rate (and as such, a negative adjustment should apply)
+              it { is_expected.to eq([rate]) }
+            end
+
+            context "when the tax is not VAT" do
+              it "returns no tax rate" do
+                expect(subject).to be_empty
+              end
+            end
+          end
+
+          context "when the order does not have a tax_address" do
+            let(:tax_address) { nil}
+
+            context "when the tax is a VAT" do
+              let(:included_in_price) { true }
+              # The rate should match in this instance because:
+              # 1) The order has no tax address by this stage
+              # 2) With no tax address, it has no tax zone
+              # 3) Therefore, we assume the default tax zone
+              # 4) This default zone has a default tax rate.
+              it { is_expected.to eq([rate]) }
+            end
+
+            context "when the tax is not a VAT" do
+              it { is_expected.to be_empty }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context ".adjust" do
+    let(:order) { stub_model(Spree::Order) }
+    let(:tax_category_1) { stub_model(Spree::TaxCategory) }
+    let(:tax_category_2) { stub_model(Spree::TaxCategory) }
+    let(:rate_1) { stub_model(Spree::TaxRate, :tax_category => tax_category_1) }
+    let(:rate_2) { stub_model(Spree::TaxRate, :tax_category => tax_category_2) }
+
+    context "with line items" do
+      let(:line_item) do
+        stub_model(Spree::LineItem,
+          :price => 10.0,
+          :quantity => 1,
+          :tax_category => tax_category_1,
+          :variant => stub_model(Spree::Variant)
+        )
+      end
+
+      let(:line_items) { [line_item] }
+
+      before do
+        allow(Spree::TaxRate).to receive_messages :match => [rate_1, rate_2]
+      end
+
+      it "should apply adjustments for two tax rates to the order" do
+        expect(rate_1).to receive(:adjust)
+        expect(rate_2).not_to receive(:adjust)
+        Spree::TaxRate.adjust(order, line_items)
+      end
+    end
+
+    context "with shipments" do
+      let(:shipments) { [stub_model(Spree::Shipment, :cost => 10.0, :tax_category => tax_category_1)] }
+
+      before do
+        allow(Spree::TaxRate).to receive_messages :match => [rate_1, rate_2]
+      end
+
+      it "should apply adjustments for two tax rates to the order" do
+        expect(rate_1).to receive(:adjust)
+        expect(rate_2).not_to receive(:adjust)
+        Spree::TaxRate.adjust(order, shipments)
+      end
+    end
+  end
+
+  context "#adjust" do
+    before do
+      @country = create(:country)
+      @zone = create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => [])
+      @zone.zone_members.create(:zoneable => @country)
+      @category    = Spree::TaxCategory.create :name => "Taxable Foo"
+      @category2   = Spree::TaxCategory.create(:name => "Non Taxable")
+      @rate1        = Spree::TaxRate.create(
+        :amount => 0.10,
+        :calculator => Spree::Calculator::DefaultTax.create,
+        :tax_category => @category,
+        :zone => @zone
+      )
+      @rate2       = Spree::TaxRate.create(
+        :amount => 0.05,
+        :calculator => Spree::Calculator::DefaultTax.create,
+        :tax_category => @category,
+        :zone => @zone
+      )
+      @order       = Spree::Order.create!
+      @taxable     = create(:product, :tax_category => @category)
+      @nontaxable  = create(:product, :tax_category => @category2)
+    end
+
+    context "not taxable line item " do
+      let!(:line_item) { @order.contents.add(@nontaxable.master, 1) }
+
+      it "should not create a tax adjustment" do
+        Spree::TaxRate.adjust(@order, @order.line_items)
+        expect(line_item.adjustments.tax.charge.count).to eq(0)
+      end
+
+      it "should not create a refund" do
+        Spree::TaxRate.adjust(@order, @order.line_items)
+        expect(line_item.adjustments.credit.count).to eq(0)
+      end
+    end
+
+    context "taxable line item" do
+      let!(:line_item) { @order.contents.add(@taxable.master, 1) }
+
+      context "when price includes tax" do
+        before do
+          @rate1.update_column(:included_in_price, true)
+          @rate2.update_column(:included_in_price, true)
+          Spree::TaxRate.store_pre_tax_amount(line_item, [@rate1, @rate2])
+        end
+
+        context "when zone is contained by default tax zone" do
+          it "should create two adjustments, one for each tax rate" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.count).to eq(1)
+          end
+
+          it "should not create a tax refund" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.credit.count).to eq(0)
+          end
+        end
+
+        context "when order's zone is neither the default zone, or included in the default zone, but matches the rate's zone" do
+          before do
+            # With no zone members, this zone will not contain anything
+            # Previously:
+            # Zone.stub_chain :default_tax, :contains? => false
+            @zone.zone_members.delete_all
+          end
+          it "should create an adjustment" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.charge.count).to eq(1)
+          end
+
+          it "should not create a tax refund for each tax rate" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.credit.count).to eq(0)
+          end
+        end
+
+        context "when order's zone does not match default zone, is not included in the default zone, AND does not match the rate's zone" do
+          before do
+            @new_zone = create(:zone, :name => "New Zone", :default_tax => false)
+            @new_country = create(:country, :name => "New Country")
+            @new_zone.zone_members.create(:zoneable => @new_country)
+            @order.ship_address = create(:address, :country => @new_country)
+            @order.save
+            @order.reload
+          end
+
+          it "should not create positive adjustments" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.charge.count).to eq(0)
+          end
+
+          it "should create a tax refund for each tax rate" do
+            Spree::TaxRate.adjust(@order, @order.line_items)
+            expect(line_item.adjustments.credit.count).to eq(1)
+          end
+        end
+
+        context "when price does not include tax" do
+          before do
+            allow(@order).to receive_messages :tax_zone => @zone
+            [@rate1, @rate2].each do |rate|
+              rate.included_in_price = false
+              rate.zone = @zone
+              rate.save
+            end
+            Spree::TaxRate.adjust(@order, @order.line_items)
+          end
+
+          it "should delete adjustments for open order when taxrate is deleted" do
+            @rate1.destroy!
+            @rate2.destroy!
+            expect(line_item.adjustments.count).to eq(0)
+          end
+
+          it "should not delete adjustments for complete order when taxrate is deleted" do
+            @order.update_column :completed_at, Time.now
+            @rate1.destroy!
+            @rate2.destroy!
+            expect(line_item.adjustments.count).to eq(2)
+          end
+
+          it "should create an adjustment" do
+            expect(line_item.adjustments.count).to eq(2)
+          end
+
+          it "should not create a tax refund" do
+            expect(line_item.adjustments.credit.count).to eq(0)
+          end
+
+          describe 'tax adjustments' do
+            before { Spree::TaxRate.adjust(@order, @order.line_items) }
+
+            it "should apply adjustments when a tax zone is present" do
+              expect(line_item.adjustments.count).to eq(2)
+              line_item.adjustments.each do |adjustment|
+                expect(adjustment.label).to eq("#{adjustment.source.tax_category.name} #{adjustment.source.amount * 100}%")
+              end
+            end
+
+            describe 'when the tax zone is removed' do
+              before { allow(@order).to receive_messages :tax_zone => nil }
+
+              it 'does not apply any adjustments' do
+                Spree::TaxRate.adjust(@order, @order.line_items)
+                expect(line_item.adjustments.count).to eq(0)
+              end
+            end
+          end
+        end
+
+        context "when two rates apply" do
+          before do
+            @price_before_taxes = line_item.price / (1 + @rate1.amount + @rate2.amount)
+            # Use the same rounding method as in DefaultTax calculator
+            @price_before_taxes = BigDecimal.new(@price_before_taxes).round(2, BigDecimal::ROUND_HALF_UP)
+            line_item.update_column(:pre_tax_amount, @price_before_taxes)
+            # Clear out any previously automatically-applied adjustments
+            @order.all_adjustments.delete_all
+            @rate1.adjust(@order, line_item)
+            @rate2.adjust(@order, line_item)
+          end
+
+          it "should create two price adjustments" do
+            expect(@order.line_item_adjustments.count).to eq(2)
+          end
+
+          it "price adjustments should be accurate" do
+            included_tax = @order.line_item_adjustments.sum(:amount)
+            expect(@price_before_taxes + included_tax).to eq(line_item.price)
+          end
+        end
+      end
+    end
+  end
+end