spree_core 3.0.9 → 3.2.0

data/spec/models/spree/store_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Store, :type => :model do
+describe Spree::Store, type: :model do
 
   describe ".by_url" do
     let!(:store)    { create(:store, url: "website1.com\nwww.subdomain.com") }
@@ -30,20 +30,48 @@ describe Spree::Store, :type => :model do
     end
   end
 
-  describe ".default" do
-    let!(:store)    { create(:store) }
-    let!(:store_2)  { create(:store, default: true) }
+  describe '.default' do
+    context 'when a default store is already present' 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 return the already existing default store' do
+        expect(Spree::Store.default).to eq(store_2)
+      end
+
+      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)
 
-    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
+
+      context 'when store is not saved' do
+        before do
+          store.default = true
+          store.code = nil
+          store.save
+        end
+
+        it 'ensure old default location still default' do
+          [store, store_2].each(&:reload)
+          expect(store.default).to be false
+          expect(store_2.default).to be true
+        end
+      end
+    end
 
-      expect(Spree::Store.where(default: true).count).to eq(1)
-      expect(store_2.default).to be true
-      expect(store.default).not_to be true
+    context 'when a default store is not present' do
+      it 'should build a new default store' do
+        expect(Spree::Store.default.class).to eq(Spree::Store)
+        expect(Spree::Store.default.persisted?).to eq(false)
+        expect(Spree::Store.default.default).to be(true)
+      end
     end
   end
 

data/spec/models/spree/tax_category_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
-describe Spree::TaxCategory, :type => :model do
+describe Spree::TaxCategory, type: :model do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:name) }
+    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:deleted_at).case_insensitive.allow_blank }
+  end
+
   context 'default tax category' do
     let(:tax_category) { create(:tax_category) }
     let(:new_tax_category) { create(:tax_category) }
@@ -10,7 +15,7 @@ describe Spree::TaxCategory, :type => :model do
     end
 
     it "should undefault the previous default tax category" do
-      new_tax_category.update_attributes({:is_default => true})
+      new_tax_category.update_attributes({is_default: true})
       expect(new_tax_category.is_default).to be true
 
       tax_category.reload

data/spec/models/spree/tax_rate_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::TaxRate, :type => :model do
+describe Spree::TaxRate, type: :model do
   context "match" do
     let(:order) { create(:order) }
     let(:country) { create(:country) }
@@ -8,67 +8,67 @@ describe Spree::TaxRate, :type => :model do
     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
+      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))
+        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)
+          @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
+          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
+            amount: 1,
+            zone: @zone,
+            tax_category: tax_category,
+            calculator: calculator
           )
 
-          allow(order).to receive_messages :tax_zone => @zone
+          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
+            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
+            amount: 2,
+            zone: @zone,
+            tax_category: tax_category,
+            calculator: Spree::Calculator::FlatRate.new
           )
 
-          allow(order).to receive_messages :tax_zone => @zone
+          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
+            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
+              amount: 1,
+              zone: @zone,
+              tax_category: tax_category,
+              calculator: calculator
             )
           end
 
@@ -80,29 +80,26 @@ describe Spree::TaxRate, :type => :model do
 
       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)
+          @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)
+          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
+            allow(order).to receive_messages tax_zone: @zone
           end
 
-          let(:tax_address) { stub_model(Spree::Address) }
-
           context "when the tax is not a VAT" do
             it { is_expected.to eq([rate]) }
           end
@@ -115,42 +112,22 @@ describe Spree::TaxRate, :type => :model do
 
         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
+            allow(order).to receive_messages tax_zone: create(:zone, name: "Other Zone")
           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
+          context "when the tax is a VAT" do
+            let(:included_in_price) { true }
+            # The rate should NOT match in this instance because:
+            # The order has a different tax zone, and the price is
+            # henceforth a net price and will not change.
+            it 'return no tax rate' do
+              expect(subject).to be_empty
             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 }
+          context "when the tax is not VAT" do
+            it "returns no tax rate" do
+              expect(subject).to be_empty
             end
           end
         end
@@ -158,27 +135,27 @@ describe Spree::TaxRate, :type => :model do
     end
   end
 
-  context ".adjust" do
+  describe ".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) }
+    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)
+          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]
+        allow(Spree::TaxRate).to receive_messages match: [rate_1, rate_2]
       end
 
       it "should apply adjustments for two tax rates to the order" do
@@ -188,11 +165,30 @@ describe Spree::TaxRate, :type => :model do
       end
     end
 
+    context "without tax rates" do
+      let(:line_item) do
+        stub_model(Spree::LineItem,
+          :price => 10.0,
+          :quantity => 2,
+          :tax_category => nil,
+          :variant => stub_model(Spree::Variant)
+        )
+      end
+
+      let(:line_items) { [line_item] }
+
+      it "should update pre_tax_total to match line item cost if no taxes" do
+        line_item.tax_category = nil
+        Spree::TaxRate.adjust(order, line_items)
+        expect(line_item.pre_tax_amount).to eq line_item.price * line_item.quantity
+      end
+    end
+
     context "with shipments" do
-      let(:shipments) { [stub_model(Spree::Shipment, :cost => 10.0, :tax_category => tax_category_1)] }
+      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]
+        allow(Spree::TaxRate).to receive_messages match: [rate_1, rate_2]
       end
 
       it "should apply adjustments for two tax rates to the order" do
@@ -201,30 +197,208 @@ describe Spree::TaxRate, :type => :model do
         Spree::TaxRate.adjust(order, shipments)
       end
     end
+
+    context "for MOSS taxation in Europe" do
+      let(:germany) { create :country, name: "Germany" }
+      let(:india) { create :country, name: "India" }
+      let(:france) { create :country, name: "France" }
+      let(:france_zone) { create :zone_with_country, name: "France Zone" }
+      let(:germany_zone) { create :zone_with_country, name: "Germany Zone", default_tax: true }
+      let(:india_zone) { create :zone_with_country, name: "India" }
+      let(:moss_category) { Spree::TaxCategory.create(name: "Digital Goods") }
+      let(:normal_category) { Spree::TaxCategory.create(name: "Analogue Goods") }
+      let(:eu_zone) { create(:zone, name: "EU") }
+
+      let!(:german_vat) do
+        Spree::TaxRate.create(
+          name: "German VAT",
+          amount: 0.19,
+          calculator: Spree::Calculator::DefaultTax.create,
+          tax_category: moss_category,
+          zone: germany_zone,
+          included_in_price: true
+        )
+      end
+      let!(:french_vat) do
+        Spree::TaxRate.create(
+          name: "French VAT",
+          amount: 0.25,
+          calculator: Spree::Calculator::DefaultTax.create,
+          tax_category: moss_category,
+          zone: france_zone,
+          included_in_price: true
+        )
+      end
+      let!(:eu_vat) do
+        Spree::TaxRate.create(
+          name: "EU_VAT",
+          amount: 0.19,
+          calculator: Spree::Calculator::DefaultTax.create,
+          tax_category: normal_category,
+          zone: eu_zone,
+          included_in_price: true
+        )
+      end
+
+      let(:download) { create(:product, tax_category: moss_category, price: 100) }
+      let(:tshirt) { create(:product, tax_category: normal_category, price: 100) }
+      let(:order) { Spree::Order.create }
+
+      before do
+        germany_zone.zone_members.create(zoneable: germany)
+        france_zone.zone_members.create(zoneable: france)
+        india_zone.zone_members.create(zoneable: india)
+        eu_zone.zone_members.create(zoneable: germany)
+        eu_zone.zone_members.create(zoneable: france)
+      end
+
+      context "a download" do
+        before do
+          order.contents.add(download.master, 1)
+        end
+
+        it "without an adress costs 100 euros including tax" do
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.display_total).to eq(Spree::Money.new(100))
+          expect(order.included_tax_total).to eq(15.97)
+        end
+
+        it "to germany costs 100 euros including tax" do
+          allow(order).to receive(:tax_zone).and_return(germany_zone)
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.display_total).to eq(Spree::Money.new(100))
+          expect(order.included_tax_total).to eq(15.97)
+        end
+
+        it "to france costs more including tax" do
+          allow(order).to receive(:tax_zone).and_return(france_zone)
+          order.update_line_item_prices!
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.display_total).to eq(Spree::Money.new(105.04))
+          expect(order.included_tax_total).to eq(21.01)
+          expect(order.additional_tax_total).to eq(0)
+        end
+
+        it "to somewhere else costs the net amount" do
+          allow(order).to receive(:tax_zone).and_return(india_zone)
+          order.update_line_item_prices!
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.included_tax_total).to eq(0)
+          expect(order.included_tax_total).to eq(0)
+          expect(order.display_total).to eq(Spree::Money.new(84.03))
+        end
+      end
+
+      context "a t-shirt" do
+        before do
+          order.contents.add(tshirt.master, 1)
+        end
+
+        it "to germany costs 100 euros including tax" do
+          allow(order).to receive(:tax_zone).and_return(germany_zone)
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.display_total).to eq(Spree::Money.new(100))
+          expect(order.included_tax_total).to eq(15.97)
+        end
+
+        it "to france costs 100 euros including tax" do
+          allow(order).to receive(:tax_zone).and_return(france_zone)
+          order.update_line_item_prices!
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.display_total).to eq(Spree::Money.new(100.00))
+          expect(order.included_tax_total).to eq(15.97)
+          expect(order.additional_tax_total).to eq(0)
+        end
+
+        it "to somewhere else costs the net amount" do
+          allow(order).to receive(:tax_zone).and_return(india_zone)
+          order.update_line_item_prices!
+          Spree::TaxRate.adjust(order, order.line_items)
+          order.update_with_updater!
+          expect(order.included_tax_total).to eq(0)
+          expect(order.display_total).to eq(Spree::Money.new(84.03))
+        end
+      end
+    end
   end
 
-  context "#adjust" do
+  describe ".included_tax_amount_for" do
+    let!(:order) { create :order_with_line_items }
+    let!(:included_tax_rate) do
+      create :tax_rate,
+             included_in_price: true,
+             tax_category: order.line_items.first.tax_category,
+             zone: order.tax_zone,
+             amount: 0.4
+    end
+
+    let!(:other_included_tax_rate) do
+      create :tax_rate,
+             included_in_price: true,
+             tax_category: order.line_items.first.tax_category,
+             zone: order.tax_zone,
+             amount: 0.05
+    end
+
+    let!(:additional_tax_rate) do
+      create :tax_rate,
+             included_in_price: false,
+             tax_category: order.line_items.first.tax_category,
+             zone: order.tax_zone,
+             amount: 0.2
+    end
+
+    let!(:included_tax_rate_from_somewhere_else) do
+      create :tax_rate,
+             included_in_price: true,
+             tax_category: order.line_items.first.tax_category,
+             zone: create(:zone_with_country),
+             amount: 0.1
+    end
+    let(:price_options) do
+      {
+        tax_zone: order.tax_zone,
+        tax_category: line_item.tax_category
+      }
+    end
+
+
+    let(:line_item) { order.line_items.first }
+    subject(:included_tax_amount) { Spree::TaxRate.included_tax_amount_for(price_options) }
+
+    it 'will only get me tax amounts from tax_rates that match' do
+      expect(subject).to eq(included_tax_rate.amount + other_included_tax_rate.amount)
+    end
+  end
+
+  describe "#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")
+      @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
+        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
+        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)
+      @taxable     = create(:product, tax_category: @category)
+      @nontaxable  = create(:product, tax_category: @category2)
     end
 
     context "not taxable line item " do
@@ -254,7 +428,7 @@ describe Spree::TaxRate, :type => :model do
         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)
+            expect(line_item.adjustments.count).to eq(2)
           end
 
           it "should not create a tax refund" do
@@ -265,11 +439,16 @@ describe Spree::TaxRate, :type => :model do
 
         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
+            new_rate = Spree::TaxRate.create(
+              amount: 0.2,
+              included_in_price: true,
+              calculator: Spree::Calculator::DefaultTax.create,
+              tax_category: @category,
+              zone: create(:zone_with_country)
+            )
+            allow(@order).to receive(:tax_zone).and_return(new_rate.zone)
           end
+
           it "should create an adjustment" do
             Spree::TaxRate.adjust(@order, @order.line_items)
             expect(line_item.adjustments.charge.count).to eq(1)
@@ -283,10 +462,10 @@ describe Spree::TaxRate, :type => :model do
 
         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)
+            @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
@@ -296,15 +475,15 @@ describe Spree::TaxRate, :type => :model do
             expect(line_item.adjustments.charge.count).to eq(0)
           end
 
-          it "should create a tax refund for each tax rate" do
+          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(1)
+            expect(line_item.adjustments.credit.count).to eq(0)
           end
         end
 
         context "when price does not include tax" do
           before do
-            allow(@order).to receive_messages :tax_zone => @zone
+            allow(@order).to receive_messages tax_zone: @zone
             [@rate1, @rate2].each do |rate|
               rate.included_in_price = false
               rate.zone = @zone
@@ -320,7 +499,7 @@ describe Spree::TaxRate, :type => :model do
           end
 
           it "should not delete adjustments for complete order when taxrate is deleted" do
-            @order.update_column :completed_at, Time.now
+            @order.update_column :completed_at, Time.current
             @rate1.destroy!
             @rate2.destroy!
             expect(line_item.adjustments.count).to eq(2)
@@ -345,7 +524,7 @@ describe Spree::TaxRate, :type => :model do
             end
 
             describe 'when the tax zone is removed' do
-              before { allow(@order).to receive_messages :tax_zone => nil }
+              before { allow(@order).to receive_messages tax_zone: nil }
 
               it 'does not apply any adjustments' do
                 Spree::TaxRate.adjust(@order, @order.line_items)
@@ -373,7 +552,7 @@ describe Spree::TaxRate, :type => :model do
 
           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)
+            expect(@price_before_taxes + included_tax).to eq(line_item.total)
           end
         end
       end