solidus_core 1.1.4 → 1.2.0.beta1

data/spec/models/spree/store_credit_event_spec.rb

@@ -28,7 +28,7 @@ describe Spree::StoreCreditEvent do
     end
 
     it "excludes invalidated store credit events" do
-      invalidated_store_credit = create(:store_credit, invalidated_at: Time.now)
+      invalidated_store_credit = create(:store_credit, invalidated_at: Time.current)
       event = create(:store_credit_event, action: Spree::StoreCredit::VOID_ACTION, store_credit: invalidated_store_credit)
       expect(described_class.exposed_events).not_to include event
     end

data/spec/models/spree/store_credit_spec.rb

@@ -837,7 +837,7 @@ describe Spree::StoreCredit do
     subject { store_credit.invalidate(invalidation_reason, invalidation_user) }
 
     it "sets the invalidated_at field to the current time" do
-      invalidated_at = Time.now
+      invalidated_at = Time.current
       Timecop.freeze(invalidated_at) do
         subject
         expect(store_credit.invalidated_at).to eq invalidated_at

data/spec/models/spree/tax_rate_spec.rb

@@ -181,7 +181,7 @@ describe Spree::TaxRate, :type => :model 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
+      it "should only apply adjustments for matching rates" do
         expect(rate_1).to receive(:adjust)
         expect(rate_2).not_to receive(:adjust)
         Spree::TaxRate.adjust(order.tax_zone, line_items)
@@ -195,7 +195,7 @@ describe Spree::TaxRate, :type => :model 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
+      it "should apply adjustments for matching rates" do
         expect(rate_1).to receive(:adjust)
         expect(rate_2).not_to receive(:adjust)
         Spree::TaxRate.adjust(order.tax_zone, shipments)
@@ -203,173 +203,434 @@ describe Spree::TaxRate, :type => :model do
     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) }
+  # While the above test is nice and fast - let me tell you a story or two here.
+  context ".adjust" do
+    let(:order) { create :order }
+    let(:book_product) { create :product, price: 20, name: "Book", tax_category: books_category }
+    let(:download_product) { create :product, price: 10, name: "Download", tax_category: digital_category }
+    let(:sweater_product) { create :product, price: 30, name: "Download", tax_category: normal_category }
+    let(:book) { book_product.master }
+    let(:download) { download_product.master }
+    let(:sweater) { sweater_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" }
+
+    context 'selling from germany' do
+      let(:germany) { create :country, iso: "DE" }
+      # The weird default_tax boolean is what makes this context one with default included taxes
+      let!(:germany_zone) { create :zone, countries: [germany], default_tax: true }
+      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,
+          included_in_price: true,
+          amount: 0.07,
+          tax_category: books_category,
+          zone: eu_zone
+        )
+      end
+      let!(:german_normal_vat) do
+        create(
+          :tax_rate,
+          included_in_price: true,
+          amount: 0.19,
+          tax_category: normal_category,
+          zone: eu_zone
+        )
+      end
+      let!(:german_digital_vat) do
+        create(
+          :tax_rate,
+          included_in_price: true,
+          amount: 0.19,
+          tax_category: digital_category,
+          zone: germany_zone
+        )
+      end
+      let!(:romanian_digital_vat) do
+        create(
+          :tax_rate,
+          included_in_price: true,
+          amount: 0.24,
+          tax_category: digital_category,
+          zone: romania_zone
+        )
+      end
 
-      it "should not create a tax adjustment" do
-        Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-        expect(line_item.adjustments.tax.charge.count).to eq(0)
+      before do
+        allow(order).to receive(:tax_zone) { tax_zone }
+        order.contents.add(variant)
+        Spree::TaxRate.adjust(order.tax_zone, order.line_items)
       end
 
-      it "should not create a refund" do
-        Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-        expect(line_item.adjustments.credit.count).to eq(0)
+      let(:line_item) { order.line_items.first }
+
+      context 'to germany' do
+        let(:tax_zone) { germany_zone }
+
+        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 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 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
       end
-    end
 
-    context "taxable line item" do
-      let!(:line_item) { @order.contents.add(@taxable.master, 1) }
+      context 'to romania' do
+        let(:tax_zone) { romania_zone }
 
-      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])
+        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.pre_tax_amount).to eq(18.69)
+          end
         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.tax_zone, @order.line_items)
-            expect(line_item.adjustments.count).to eq(1)
+        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
+
+          # This test fails intermittently - it's a matter of luck
+          xit 'has 4.79 of included tax' do
+            expect(line_item.included_tax_total).to eq(4.79)
           end
 
-          it "should not create a tax refund" do
-            Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-            expect(line_item.adjustments.credit.count).to eq(0)
+          it 'has a constant amount pre tax' do
+            expect(line_item.pre_tax_amount).to eq(25.21)
           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
+        context 'an order with a download' do
+          let(:variant) { download }
+
+          it 'still has an adjusted price for romania' do
+            pending "waiting for the MOSS refactoring"
+            expect(line_item.price).to eq(10.42)
           end
-          it "should create an adjustment" do
-            Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-            expect(line_item.adjustments.charge.count).to eq(1)
+
+          it 'has one tax adjustment' do
+            expect(line_item.adjustments.tax.count).to eq(1)
+          end
+
+          # Fails intermittently - xit'ed for the time being
+          xit 'has 2.02 of included tax' do
+            expect(line_item.included_tax_total).to eq(2.02)
           end
 
-          it "should not create a tax refund for each tax rate" do
-            Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-            expect(line_item.adjustments.credit.count).to eq(0)
+          it 'has a constant amount pre tax' do
+            pending 'but it changes to 8.06, because Spree thinks both VATs apply'
+            expect(line_item.pre_tax_amount).to eq(8.40)
           end
         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
+      # International delivery, no tax applies whatsoever
+      context 'to anywhere else in the world' do
+        let(:tax_zone) { world_zone }
+
+        context 'an order with a book' do
+          let(:variant) { book }
+
+          it 'should sell at the net price' do
+            pending "Prices have to be adjusted"
+            expect(line_item.price).to eq(18.69)
           end
 
-          it "should not create positive adjustments" do
-            Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-            expect(line_item.adjustments.charge.count).to eq(0)
+          it 'is adjusted to the net price' do
+            expect(line_item.total).to eq(18.69)
           end
 
-          it "should create a tax refund for each tax rate" do
-            Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-            expect(line_item.adjustments.credit.count).to eq(1)
+          it 'has no tax adjustments' do
+            pending "Right now it gets a refund"
+            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
+            pending 'but there is a refund, still'
+            expect(line_item.additional_tax_total).to eq(0)
+          end
+
+          it 'has a constant amount pre tax' do
+            expect(line_item.pre_tax_amount).to eq(18.69)
           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.tax_zone, @order.line_items)
+        context 'an order with a sweater' do
+          let(:variant) { sweater }
+
+          it 'should sell at the net price' do
+            pending 'but prices are not adjusted according to the zone yet'
+            expect(line_item.price).to eq(25.21)
+          end
+
+          it 'has no tax adjustments' do
+            pending 'but it has a refund'
+            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
+            pending 'but it has a refund for included taxes wtf'
+            expect(line_item.additional_tax_total).to eq(0)
+          end
+
+          it 'has a constant amount pre tax' do
+            expect(line_item.pre_tax_amount).to eq(25.21)
+          end
+        end
+
+        context 'an order with a download' do
+          let(:variant) { download }
+
+          it 'should sell at the net price' do
+            pending 'but prices are not adjusted yet'
+            expect(line_item.price).to eq(8.40)
+          end
+
+          it 'has no tax adjustments' do
+            pending 'but a refund is created'
+            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
+            pending 'but an tax refund that disguises as additional tax is created'
+            expect(line_item.additional_tax_total).to eq(0)
+          end
+
+          it 'has a constant amount pre tax' do
+            expect(line_item.pre_tax_amount).to eq(8.40)
+          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) }
+      let(:united_states) { create(:country, states: [new_york]) }
+      let(:new_york_zone) { create(:zone, states: [new_york]) }
+      let(:unites_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,
+          tax_category: books_category,
+          zone: new_york_zone,
+          included_in_price: false,
+          amount: 0.05
+        )
+      end
+
+      let!(:federal_books_tax) do
+        create(
+          :tax_rate,
+          tax_category: books_category,
+          zone: unites_states_zone,
+          included_in_price: false,
+          amount: 0.10
+        )
+      end
+
+      let!(:federal_digital_tax) do
+        create(
+          :tax_rate,
+          tax_category: digital_category,
+          zone: unites_states_zone,
+          included_in_price: false,
+          amount: 0.20
+        )
+      end
+
+      before do
+        allow(order).to receive(:tax_zone) { tax_zone }
+        order.contents.add(variant)
+        Spree::TaxRate.adjust(order.tax_zone, order.line_items)
+      end
+
+      let(:line_item) { order.line_items.first }
+
+      context 'to new york' do
+        let(:tax_zone) { new_york_zone }
+
+        # 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 deleted" do
-            @rate1.destroy!
-            @rate2.destroy!
+            new_york_books_tax.destroy!
+            federal_books_tax.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!
+            order.update_column :completed_at, Time.now
+            new_york_books_tax.destroy!
+            federal_books_tax.destroy!
             expect(line_item.adjustments.count).to eq(2)
           end
+        end
 
-          it "should create an adjustment" do
-            expect(line_item.adjustments.count).to eq(2)
-          end
+        # This is a fictional case for when no taxes apply at all.
+        context 'an order with a sweater' do
+          let(:variant) { sweater }
 
-          it "should not create a tax refund" do
-            expect(line_item.adjustments.credit.count).to eq(0)
+          it 'still has the original price' do
+            expect(line_item.price).to eq(30)
           end
 
-          describe 'tax adjustments' do
-            before { Spree::TaxRate.adjust(@order.tax_zone, @order.line_items) }
+          it 'sells for the line items amount plus additional tax' do
+            expect(line_item.total).to eq(30)
+          end
 
-            it "should apply adjustments when a tax zone is present" do
-              expect(line_item.adjustments.count).to eq(2)
-            end
+          it 'has no tax adjustments' do
+            expect(line_item.adjustments.tax.count).to eq(0)
+          end
 
-            describe 'when the tax zone is removed' do
-              before { allow(@order).to receive_messages :tax_zone => nil }
+          it 'has no included tax' do
+            expect(line_item.included_tax_total).to eq(0)
+          end
 
-              it 'does not apply any adjustments' do
-                Spree::TaxRate.adjust(@order.tax_zone, @order.line_items)
-                expect(line_item.adjustments.count).to eq(0)
-              end
-            end
+          it 'has no additional tax' do
+            expect(line_item.additional_tax_total).to eq(0)
           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.tax_zone, line_item)
-            @rate2.adjust(@order.tax_zone, line_item)
+        # 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 "should create two price adjustments" do
-            expect(@order.line_item_adjustments.count).to eq(2)
+          it 'has one tax adjustments' do
+            expect(line_item.adjustments.tax.count).to eq(1)
           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)
+          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
+      end
+
+      context 'when no tax zone is given' do
+        let(:tax_zone) { 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