solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/shipping_rate_spec.rb

@@ -2,74 +2,104 @@
 
 require 'spec_helper'
 
-describe Spree::ShippingRate, :type => :model do
-  let(:shipment) { create(:shipment) }
-  let(:shipping_method) { create(:shipping_method) }
-  let(:shipping_rate) { Spree::ShippingRate.new(:shipment => shipment,
-                                                :shipping_method => shipping_method,
-                                                :cost => 10) }
+describe Spree::ShippingRate, type: :model do
+  let(:address) { create(:address) }
+  let(:foreign_address) { create :address, country_iso_code: "DE" }
+  let(:order) { create :order, ship_address: address }
+  let(:shipment) { create(:shipment, order: order) }
+  let(:shipping_method) { create(:shipping_method, tax_category: tax_category) }
+  let(:tax_category) { create :tax_category }
+
+  subject(:shipping_rate) do
+    Spree::ShippingRate.new(
+      shipment: shipment,
+      shipping_method: shipping_method,
+      cost: 10
+    )
+  end
 
   context "#display_price" do
-    context "when tax included in price" do
-      context "when the tax rate is from the default zone" do
-        before { shipment.order.update_attributes!(ship_address_id: nil) }
-        let!(:zone) { create(:zone, :default_tax => true) }
-        let(:tax_rate) do
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => zone)
-        end
+    let!(:default_zone) { create :zone, countries: [address.country], default_tax: true }
+    let!(:other_zone) { create :zone, countries: [foreign_address.country] }
 
-        before { shipping_rate.tax_rate = tax_rate }
+    before do
+      allow(order).to receive(:tax_address).and_return(order_address)
+    end
 
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (incl. $0.91 #{tax_rate.name})")
-        end
+    context 'with one included tax rate' do
+      let!(:tax_rate) do
+        create :tax_rate,
+        included_in_price: true,
+        name: "VAT",
+        zone: default_zone,
+        tax_category: tax_category
+      end
 
-        context "when cost is zero" do
-          before do
-            shipping_rate.cost = 0
-          end
+      let(:order_address) { address }
 
-          it "shows no tax amount" do
-            expect(shipping_rate.display_price.to_s).to eq("$0.00")
-          end
-        end
+      before do
+        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
       end
 
-      context "when the tax rate is from a non-default zone" do
-        let!(:default_zone) { create(:zone, :default_tax => true) }
-        let!(:non_default_zone) { create(:zone, :default_tax => false) }
-        let(:tax_rate) do
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => non_default_zone)
+      it "shows correct tax amount" do
+        expect(shipping_rate.display_price.to_s).to eq("$10.00 (incl. $0.91 #{tax_rate.name})")
+      end
+
+      context "when cost is zero" do
+        before do
+          shipping_rate.cost = 0
         end
-        before { shipping_rate.tax_rate = tax_rate }
 
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (excl. $0.91 #{tax_rate.name})")
+        it "shows no tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$0.00")
         end
+      end
+    end
 
-        context "when cost is zero" do
-          before do
-            shipping_rate.cost = 0
-          end
+    context 'with one tax rate that will be refunded' do
+      let!(:tax_rate) do
+        create :tax_rate,
+        included_in_price: true,
+        name: "VAT",
+        zone: default_zone,
+        tax_category: tax_category
+      end
+
+      let(:order_address) { foreign_address }
+
+      before do
+        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
+      end
+
+      it "shows correct tax amount" do
+        expect(shipping_rate.display_price.to_s).to eq("$10.00 (excl. $0.91 #{tax_rate.name})")
+      end
+
+      context "when cost is zero" do
+        before do
+          shipping_rate.cost = 0
+        end
 
-          it "shows no tax amount" do
-            expect(shipping_rate.display_price.to_s).to eq("$0.00")
-          end
+        it "shows no tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$0.00")
         end
       end
     end
 
-    context "when tax is additional to price" do
-      let(:tax_rate) { create(:tax_rate, :name => "Sales Tax", :amount => 0.1) }
-      before { shipping_rate.tax_rate = tax_rate }
+    context 'with one additional tax rate' do
+      let!(:tax_rate) do
+        create :tax_rate,
+        included_in_price: false,
+        name: "Sales Tax",
+        zone: default_zone,
+        tax_category: tax_category
+      end
+
+      let(:order_address) { address }
+
+      before do
+        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
+      end
 
       it "shows correct tax amount" do
         expect(shipping_rate.display_price.to_s).to eq("$10.00 (+ $1.00 #{tax_rate.name})")
@@ -86,13 +116,42 @@ describe Spree::ShippingRate, :type => :model do
       end
     end
 
-    context "when the currency is JPY" do
-      let(:shipping_rate) { shipping_rate = Spree::ShippingRate.new(:cost => 205)
-                            allow(shipping_rate).to receive_messages(:currency => "JPY")
-                            shipping_rate }
+    context 'with two additional tax rates' do
+      let!(:tax_rate) do
+        create :tax_rate,
+        included_in_price: false,
+        name: "Sales Tax",
+        zone: default_zone,
+        tax_category: tax_category
+      end
+
+      let!(:other_tax_rate) do
+        create :tax_rate,
+        included_in_price: false,
+        name: "Other Sales Tax",
+        zone: default_zone,
+        tax_category: tax_category,
+        amount: 0.05
+      end
+
+      let(:order_address) { address }
+
+      before do
+        Spree::Tax::ShippingRateTaxer.new.tax(shipping_rate)
+      end
+
+      it "shows correct tax amount" do
+        expect(shipping_rate.display_price.to_s).to eq("$10.00 (+ $1.00 Sales Tax, + $0.50 Other Sales Tax)")
+      end
+
+      context "when cost is zero" do
+        before do
+          shipping_rate.cost = 0
+        end
 
-      it "displays the price in yen" do
-        expect(shipping_rate.display_price.to_s).to eq("¥205")
+        it "shows no tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$0.00")
+        end
       end
     end
   end
@@ -111,25 +170,6 @@ describe Spree::ShippingRate, :type => :model do
     end
   end
 
-  context "#tax_rate" do
-    let!(:tax_rate) { create(:tax_rate) }
-
-    before do
-      shipping_rate.tax_rate = tax_rate
-    end
-
-    it "can be retrieved" do
-      expect(shipping_rate.tax_rate.reload).to eq(tax_rate)
-    end
-
-    it "can be retrieved even when deleted" do
-      tax_rate.update_column(:deleted_at, Time.current)
-      shipping_rate.save
-      shipping_rate.reload
-      expect(shipping_rate.tax_rate).to eq(tax_rate)
-    end
-  end
-
   context "#shipping_method_code" do
     before do
       shipping_method.code = "THE_CODE"

data/spec/models/spree/shipping_rate_tax_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module Spree
+  RSpec.describe ShippingRateTax, type: :model do
+    subject(:shipping_rate_tax) { described_class.new }
+
+    it { is_expected.to respond_to(:amount) }
+    it { is_expected.to respond_to(:tax_rate) }
+    it { is_expected.to respond_to(:shipping_rate) }
+
+    describe 'absolute_amount' do
+      subject(:shipping_rate_tax) { described_class.new(amount: amount).absolute_amount }
+
+      context 'with a negative amount' do
+        let(:amount) { -19 }
+
+        it { is_expected.to eq(19) }
+      end
+
+      context 'with a positive amount' do
+        let(:amount) { 19 }
+        it { is_expected.to eq(19) }
+      end
+    end
+
+    describe 'display_absolute_amount' do
+      subject(:shipping_rate_tax) { described_class.new(amount: 10).display_absolute_amount.to_s }
+
+      it { is_expected.to eq("$10.00") }
+    end
+
+    describe '#currency' do
+      subject(:shipping_rate_tax) { described_class.new(amount: 10, shipping_rate: shipping_rate).currency }
+
+      context 'when we have a shipping rate' do
+        let(:shipping_rate) { build_stubbed(:shipping_rate) }
+
+        it 'delegates the call to the shipment' do
+          expect(shipping_rate).to receive(:currency)
+          subject
+        end
+      end
+
+      context "when we don't have a shipping rate" do
+        let(:shipping_rate) { nil }
+
+        it 'is nil' do
+          expect(subject).to eq(nil)
+        end
+      end
+    end
+
+    describe '#label' do
+      subject(:shipping_rate_tax) { described_class.new(amount: amount, tax_rate: tax_rate).label }
+
+      context 'with an included tax rate' do
+        let(:tax_rate) { build_stubbed(:tax_rate, included_in_price: true, name: "VAT") }
+        context 'with a negative amount' do
+          let(:amount) { -2.2 }
+          it 'labels a refund' do
+            expect(subject).to eq("excl. $2.20 VAT")
+          end
+        end
+
+        context 'with a positive amount' do
+          let(:amount) { 2.2 }
+          it 'labels an included tax' do
+            expect(subject).to eq("incl. $2.20 VAT")
+          end
+        end
+      end
+
+      context 'with an additional tax rate' do
+        let(:tax_rate) { build_stubbed(:tax_rate, included_in_price: false, name: "Sales Tax") }
+        let(:amount) { 2.2 }
+
+        it 'labels an additional tax' do
+          expect(subject).to eq("+ $2.20 Sales Tax")
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/state_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Spree::State, :type => :model do
+describe Spree::State, type: :model do
   it "can find a state by name or abbr" do
-    state = create(:state, :name => "California", :abbr => "CA")
+    state = create(:state, name: "California", abbr: "CA")
     expect(Spree::State.find_all_by_name_or_abbr("California")).to include(state)
     expect(Spree::State.find_all_by_name_or_abbr("CA")).to include(state)
   end

data/spec/models/spree/stock/availability_validator_spec.rb

@@ -14,8 +14,8 @@ module Spree
 
         it "adds a validation error" do
           subject
-          display_name = "#{line_item.variant.name}"
-          display_name +=  " (#{line_item.variant.options_text})" unless line_item.variant.options_text.blank?
+          display_name = line_item.variant.name.to_s
+          display_name += " (#{line_item.variant.options_text})" unless line_item.variant.options_text.blank?
           expect(line_item.errors).to match_array ["Quantity selected of #{display_name.inspect} is not available."]
         end
       end
@@ -51,7 +51,7 @@ module Spree
       end
 
       context "line_item is part of a shipment" do
-        let!(:order)            { create(:order_with_line_items) }
+        let!(:order) { create(:order_with_line_items) }
 
         context "has stock in all stock locations" do
           let(:line_item)         { order.line_items.first }
@@ -70,7 +70,7 @@ module Spree
           let!(:stock_location_1) { create(:stock_location, name: "Test Warehouse", active: false) }
 
           before do
-            order.contents.add(variant, 1, stock_location_quantities: { stock_location_1.id => 1})
+            order.contents.add(variant, 1, stock_location_quantities: { stock_location_1.id => 1 })
             order.contents.advance
             stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
           end

data/spec/models/spree/stock/coordinator_spec.rb

@@ -2,54 +2,44 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Coordinator, :type => :model do
+    describe Coordinator, type: :model do
       let(:order) { create(:order_with_line_items, line_items_count: 2) }
 
       subject { Coordinator.new(order) }
 
-      context "packages" do
+      describe "#shipments" do
         it "builds, prioritizes and estimates" do
-          expect(subject).to receive(:build_location_configured_packages).ordered
-          expect(subject).to receive(:build_packages).ordered
-          expect(subject).to receive(:prioritize_packages).ordered
-          expect(subject).to receive(:estimate_packages).ordered
-          expect(subject).to receive(:validate_packages).ordered
-          subject.packages
+          expect(subject).to receive(:build_location_configured_packages).ordered.and_call_original
+          expect(subject).to receive(:build_packages).ordered.and_call_original
+          expect(subject).to receive(:prioritize_packages).ordered.and_call_original
+          expect(subject).to receive(:estimate_packages).ordered.and_call_original
+          expect(subject).to receive(:validate_packages).ordered.and_call_original
+          subject.shipments
         end
 
         it 'uses the pluggable estimator class' do
           expect(Spree::Config.stock).to receive(:estimator_class).and_call_original
-          subject.packages
+          subject.shipments
         end
-      end
-
-      describe "#shipments" do
-        let(:packages) { [build(:stock_package_fulfilled), build(:stock_package_fulfilled)] }
-
-        before { allow(subject).to receive(:packages).and_return(packages) }
 
-        it "turns packages into shipments" do
-          shipments = subject.shipments
-          expect(shipments.count).to eq packages.count
-          shipments.each { |shipment| expect(shipment).to be_a Shipment }
+        it 'builds shipments' do
+          expect(subject.shipments.size).to eq(1)
         end
 
         it "puts the order's ship address on the shipments" do
           shipments = subject.shipments
-          shipments.each { |shipment| expect(shipment.address).to eq order.ship_address }
+          expect(shipments.map(&:address)).to eq [order.ship_address]
         end
-      end
 
-      context "build packages" do
-        it "builds a package for all active stock locations" do
-          subject.packages.count == StockLocation.count
+        it "builds a shipment for all active stock locations" do
+          subject.shipments.count == StockLocation.count
         end
 
         context "missing stock items in active stock location" do
           let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
 
-          it "builds packages only for valid active stock locations" do
-            expect(subject.build_packages.count).to eq(StockLocation.count - 1)
+          it "builds shipments only for valid active stock locations" do
+            expect(subject.shipments.count).to eq(StockLocation.count - 1)
           end
         end
       end
@@ -77,18 +67,18 @@ module Spree
         let!(:order) { create(:order, line_items: [create(:line_item, variant: variant_1), create(:line_item, variant: variant_2)]) }
 
         it "splits the inventory units to stock locations that they have stock items for" do
-          packages = subject.packages
+          shipments = subject.shipments
 
-          expect(subject.packages.size).to eq 2
+          expect(shipments.size).to eq 2
 
-          location_1_package = packages.detect { |p| p.stock_location == stock_location_1 }
-          location_2_package = packages.detect { |p| p.stock_location == stock_location_2 }
+          location_1_shipment = shipments.detect { |p| p.stock_location == stock_location_1 }
+          location_2_shipment = shipments.detect { |p| p.stock_location == stock_location_2 }
 
-          expect(location_1_package).to be_present
-          expect(location_2_package).to be_present
+          expect(location_1_shipment).to be_present
+          expect(location_2_shipment).to be_present
 
-          expect(location_1_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_1]
-          expect(location_2_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_2]
+          expect(location_1_shipment.inventory_units.map(&:variant)).to eq [variant_1]
+          expect(location_2_shipment.inventory_units.map(&:variant)).to eq [variant_2]
         end
       end
 
@@ -105,19 +95,20 @@ module Spree
         let!(:order) { create(:order) }
         let!(:line_item) { create(:line_item, order: order, variant: variant, quantity: 5) }
         before { order.reload }
-        let(:packages) { subject.packages }
+        let(:shipments) { subject.shipments }
 
         shared_examples "a fulfillable package" do
           it "packages correctly" do
-            expect(packages).not_to be_empty
-            expect(packages.map(&:quantity).sum).to eq(5)
-            expect(packages.flat_map(&:contents).map(&:inventory_unit).uniq.size).to eq(5)
+            expect(shipments).not_to be_empty
+            inventory_units = shipments.flat_map { |s| s.inventory_units }
+            expect(inventory_units.size).to eq(5)
+            expect(inventory_units.uniq.size).to eq(5)
           end
         end
 
         shared_examples "an unfulfillable package" do
           it "raises exception" do
-            expect{ packages }.to raise_error(Spree::Order::InsufficientStock)
+            expect{ shipments }.to raise_error(Spree::Order::InsufficientStock)
           end
         end
 
@@ -214,16 +205,9 @@ module Spree
             order.order_stock_locations.create(stock_location_id: stock_location_2.id, quantity: line_item_2.quantity, variant_id: line_item_2.variant_id)
           end
 
-          it "builds a package for each associated stock location" do
-            packages = subject.build_location_configured_packages
-            expect(packages.count).to eq(2)
-            expect(packages.map(&:stock_location)).to eq([stock_location, stock_location_2])
-          end
-        end
-        context "there are no configured stock locations" do
-          it "doesn't build any packages" do
-            packages = subject.build_location_configured_packages
-            expect(packages.count).to eq(0)
+          it "builds a shipment for each associated stock location" do
+            shipments = subject.shipments
+            expect(shipments.map(&:stock_location)).to match_array([stock_location, stock_location_2])
           end
         end
       end

data/spec/models/spree/stock/differentiator_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Differentiator, :type => :model do
+    describe Differentiator, type: :model do
       let(:variant1) { mock_model(Variant) }
       let(:variant2) { mock_model(Variant) }