solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/address_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe Spree::Address, :type => :model do
-
+describe Spree::Address, type: :model do
   subject { Spree::Address }
 
   context "aliased attributes" do
-    let(:address) { Spree::Address.new firstname: 'Ryan', lastname: 'Bigg'}
+    let(:address) { Spree::Address.new firstname: 'Ryan', lastname: 'Bigg' }
 
     it " first_name" do
       expect(address.first_name).to eq("Ryan")
@@ -17,13 +16,12 @@ describe Spree::Address, :type => :model do
   end
 
   context "validation" do
-
-    let(:country) { mock_model(Spree::Country, :states => [state], :states_required => true) }
-    let(:state) { stub_model(Spree::State, :name => 'maryland', :abbr => 'md') }
-    let(:address) { build(:address, :country => country) }
+    let(:country) { mock_model(Spree::Country, states: [state], states_required: true) }
+    let(:state) { stub_model(Spree::State, name: 'maryland', abbr: 'md') }
+    let(:address) { build(:address, country: country) }
 
     before do
-      allow(country.states).to receive_messages :find_all_by_name_or_abbr => [state]
+      allow(country.states).to receive_messages find_all_by_name_or_abbr: [state]
     end
 
     context 'address does not require state' do
@@ -72,7 +70,7 @@ describe Spree::Address, :type => :model do
 
       it "state is entered but country does not contain that state" do
         address.state = state
-        address.country = stub_model(Spree::Country, :states_required => true)
+        address.country = stub_model(Spree::Country, states_required: true)
         address.valid?
         expect(address.errors["state"]).to eq(['is invalid'])
       end
@@ -80,7 +78,7 @@ describe Spree::Address, :type => :model do
       it "both state and state_name are entered but country does not contain the state" do
         address.state = state
         address.state_name = 'maryland'
-        address.country = stub_model(Spree::Country, :states_required => true)
+        address.country = stub_model(Spree::Country, states_required: true)
         expect(address).to be_valid
         expect(address.state_id).to be_nil
       end
@@ -167,23 +165,24 @@ describe Spree::Address, :type => :model do
 
       context 'has a default country' do
         before do
-          Spree::Config[:default_country_id] = default_country.id
+          Spree::Config[:default_country_iso] = default_country.iso
         end
 
-        it "sets up a new record with Spree::Config[:default_country_id]" do
+        it "sets up a new record with Spree::Config[:default_country_iso]" do
           expect(Spree::Address.build_default.country).to eq default_country
         end
       end
 
       # Regression test for https://github.com/spree/spree/issues/1142
-      it "uses the first available country if :default_country_id is set to an invalid value" do
-        Spree::Config[:default_country_id] = "0"
-        expect(Spree::Address.build_default.country).to eq default_country
+      it "raises ActiveRecord::RecordNotFound if :default_country_iso is set to an invalid value" do
+        Spree::Config[:default_country_iso] = "00"
+        expect {
+          Spree::Address.build_default.country
+        }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end
 
-
   context '.factory' do
     context 'with attributes that use setters defined in Address' do
       let(:address_attributes) { attributes_for(:address, country_id: nil, country_iso: country.iso) }
@@ -258,15 +257,14 @@ describe Spree::Address, :type => :model do
     end
   end
 
-
   describe '.value_attributes' do
     subject do
       Spree::Address.value_attributes(base_attributes, merge_attributes)
     end
 
     context 'with symbols and strings' do
-      let(:base_attributes) { {'address1' => '1234 way', 'address2' => 'apt 2'} }
-      let(:merge_attributes) { {:address1 => '5678 way'} }
+      let(:base_attributes) { { 'address1' => '1234 way', 'address2' => 'apt 2' } }
+      let(:merge_attributes) { { address1: '5678 way' } }
 
       it 'stringifies and merges the keys' do
         expect(subject).to eq('address1' => '5678 way', 'address2' => 'apt 2')
@@ -279,13 +277,13 @@ describe Spree::Address, :type => :model do
           'id' => 1,
           'created_at' => Time.current,
           'updated_at' => Time.current,
-          'address1' => '1234 way',
+          'address1' => '1234 way'
         }
       end
       let(:merge_attributes) do
         {
           'updated_at' => Time.current,
-          'address2' => 'apt 2',
+          'address2' => 'apt 2'
         }
       end
 
@@ -295,8 +293,8 @@ describe Spree::Address, :type => :model do
     end
 
     context 'with aliased attributes' do
-      let(:base_attributes) { {'first_name' => 'Jordan'} }
-      let(:merge_attributes) { {'last_name' => 'Brough'} }
+      let(:base_attributes) { { 'first_name' => 'Jordan' } }
+      let(:merge_attributes) { { 'last_name' => 'Brough' } }
 
       it 'renames them to the normalized value' do
         expect(subject).to eq('firstname' => 'Jordan', 'lastname' => 'Brough')
@@ -311,7 +309,7 @@ describe Spree::Address, :type => :model do
   end
 
   context '#country_iso=' do
-    let(:address) { build(:address, :country_id => nil) }
+    let(:address) { build(:address, country_id: nil) }
     let(:country) { create(:country, iso: 'ZW') }
 
     it 'sets the country to the country with the matching iso code' do
@@ -328,42 +326,41 @@ describe Spree::Address, :type => :model do
 
   context '#full_name' do
     context 'both first and last names are present' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => 'Jackson') }
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: 'Jackson') }
       specify { expect(address.full_name).to eq('Michael Jackson') }
     end
 
     context 'first name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => 'Jackson') }
+      let(:address) { stub_model(Spree::Address, firstname: nil, lastname: 'Jackson') }
       specify { expect(address.full_name).to eq('Jackson') }
     end
 
     context 'last name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => nil) }
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: nil) }
       specify { expect(address.full_name).to eq('Michael') }
     end
 
     context 'both first and last names are blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => nil) }
+      let(:address) { stub_model(Spree::Address, firstname: nil, lastname: nil) }
       specify { expect(address.full_name).to eq('') }
     end
-
   end
 
   context '#state_text' do
     context 'state is blank' do
-      let(:address) { stub_model(Spree::Address, :state => nil, :state_name => 'virginia') }
+      let(:address) { stub_model(Spree::Address, state: nil, state_name: 'virginia') }
       specify { expect(address.state_text).to eq('virginia') }
     end
 
     context 'both name and abbr is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => 'va') }
-      let(:address) { stub_model(Spree::Address, :state => state) }
+      let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
+      let(:address) { stub_model(Spree::Address, state: state) }
       specify { expect(address.state_text).to eq('va') }
     end
 
     context 'only name is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => nil) }
-      let(:address) { stub_model(Spree::Address, :state => state) }
+      let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
+      let(:address) { stub_model(Spree::Address, state: state) }
       specify { expect(address.state_text).to eq('virginia') }
     end
   end
@@ -371,6 +368,6 @@ describe Spree::Address, :type => :model do
   context '#requires_phone' do
     subject { described_class.new }
 
-    it { is_expected.to be_require_phone  }
+    it { is_expected.to be_require_phone }
   end
 end

data/spec/models/spree/adjustment_reason_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 describe Spree::AdjustmentReason do
-
   describe 'creation' do
     it 'is successful' do
       create(:adjustment_reason)
     end
   end
-
 end

data/spec/models/spree/adjustment_spec.rb

@@ -3,8 +3,8 @@
 
 require 'spec_helper'
 
-describe Spree::Adjustment, :type => :model do
-
+describe Spree::Adjustment, type: :model do
+  let!(:store) { create :store }
   let(:order) { Spree::Order.new }
   let(:line_item) { create :line_item, order: order }
 

data/spec/models/spree/app_configuration_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-describe Spree::AppConfiguration, :type => :model do
-
-  let (:prefs) { Rails.application.config.spree.preferences }
+describe Spree::AppConfiguration, type: :model do
+  let(:prefs) { Rails.application.config.spree.preferences }
 
   it "should be available from the environment" do
     prefs.layout = "my/layout"
@@ -21,8 +20,39 @@ describe Spree::AppConfiguration, :type => :model do
     expect(prefs.variant_search_class).to eq Spree::Core::Search::Variant
   end
 
+  it "uses variant pricer class by default" do
+    expect(prefs.variant_pricer_class).to eq Spree::Variant::Pricer
+  end
+
+  it "has a getter for the pricing options class provided by the variant pricer class" do
+    expect(prefs.pricing_options_class).to eq Spree::Variant::Pricer.pricing_options_class
+  end
+
+  it "has an instacached getter for the default pricing options" do
+    expect(prefs.default_pricing_options).to be_a Spree::Variant::Pricer.pricing_options_class
+    expect(prefs.default_pricing_options.object_id).to eq prefs.default_pricing_options.object_id
+  end
+
   describe '#stock' do
     subject { prefs.stock }
     it { is_expected.to be_a Spree::Core::StockConfiguration }
   end
+
+  describe '@default_country_iso_code' do
+    it 'is the USA by default' do
+      expect(prefs[:default_country_iso]).to eq("US")
+    end
+  end
+
+  describe '@admin_vat_country_iso' do
+    it 'is `nil` by default' do
+      expect(prefs[:admin_vat_country_iso]).to eq(nil)
+    end
+  end
+
+  it 'has a default admin VAT location with nil values by default' do
+    expect(prefs.admin_vat_location).to eq(Spree::Tax::TaxLocation.new)
+    expect(prefs.admin_vat_location.state_id).to eq(nil)
+    expect(prefs.admin_vat_location.country_id).to eq(nil)
+  end
 end

data/spec/models/spree/asset_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Asset, :type => :model do
+describe Spree::Asset, type: :model do
   describe "#viewable" do
     it "touches association" do
       product = build(:custom_product)
@@ -20,5 +20,4 @@ describe Spree::Asset, :type => :model do
       expect(asset2.position).to eq 1
     end
   end
-
 end

data/spec/models/spree/calculator/default_tax_spec.rb

@@ -1,30 +1,39 @@
 require 'spec_helper'
 
-describe Spree::Calculator::DefaultTax, :type => :model do
-  let!(:country) { create(:country) }
-  let!(:zone) { create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => []) }
-  let!(:tax_category) { create(:tax_category, :tax_rates => []) }
-  let!(:rate) { create(:tax_rate, :tax_category => tax_category, :amount => 0.05, :included_in_price => included_in_price) }
+describe Spree::Calculator::DefaultTax, type: :model do
+  let(:address) { create(:address) }
+  let!(:zone) { create(:zone, name: "Country Zone", default_tax: true, countries: [tax_rate_country]) }
+  let(:tax_rate_country) { address.country }
+  let(:tax_category) { create(:tax_category) }
+  let!(:rate) { create(:tax_rate, tax_category: tax_category, amount: 0.05, included_in_price: included_in_price, zone: zone) }
   let(:included_in_price) { false }
-  let!(:calculator) { Spree::Calculator::DefaultTax.new(:calculable => rate ) }
-  let!(:order) { create(:order) }
-  let!(:line_item) { create(:line_item, :price => 10, :quantity => 3, :tax_category => tax_category) }
-  let!(:shipment) { create(:shipment, :cost => 15) }
+  subject(:calculator) { Spree::Calculator::DefaultTax.new(calculable: rate ) }
 
   context "#compute" do
     context "when given an order" do
-      let!(:line_item_1) { line_item }
-      let!(:line_item_2) { create(:line_item, :price => 10, :quantity => 3, :tax_category => tax_category) }
+      let(:order) do
+        create(
+          :order_with_line_items,
+          line_items_attributes: [
+            { price: 10, quantity: 3, tax_category: tax_category }.merge(line_item_one_options),
+            { price: 10, quantity: 3, tax_category: tax_category }.merge(line_item_two_options)
+          ],
+          ship_address: address
+        )
+      end
+      let(:line_item_one_options) { {} }
+      let(:line_item_two_options) { {} }
 
-      before do
-        allow(order).to receive_messages :line_items => [line_item_1, line_item_2]
+      context "when all items matches the rate's tax category" do
+        it "should be equal to the sum of the item totals * rate" do
+          expect(calculator.compute(order)).to eq(3)
+        end
       end
 
       context "when no line items match the tax category" do
-        before do
-          line_item_1.tax_category = nil
-          line_item_2.tax_category = nil
-        end
+        let(:other_tax_category) { create(:tax_category) }
+        let(:line_item_one_options) { { tax_category: other_tax_category } }
+        let(:line_item_two_options) { { tax_category: other_tax_category } }
 
         it "should be 0" do
           expect(calculator.compute(order)).to eq(0)
@@ -32,32 +41,20 @@ describe Spree::Calculator::DefaultTax, :type => :model do
       end
 
       context "when one item matches the tax category" do
-        before do
-          line_item_1.tax_category = tax_category
-          line_item_2.tax_category = nil
-        end
+        let(:other_tax_category) { create(:tax_category) }
+        let(:line_item_two_options) { { tax_category: other_tax_category } }
 
         it "should be equal to the item total * rate" do
           expect(calculator.compute(order)).to eq(1.5)
         end
 
         context "correctly rounds to within two decimal places" do
-          before do
-            line_item_1.price = 10.333
-            line_item_1.quantity = 1
-          end
+          let(:line_item_one_options) { { price: 10.333, quantity: 1 } }
 
           specify do
             # Amount is 0.51665, which will be rounded to...
             expect(calculator.compute(order)).to eq(0.52)
           end
-
-        end
-      end
-
-      context "when more than one item matches the tax category" do
-        it "should be equal to the sum of the item totals * rate" do
-          expect(calculator.compute(order)).to eq(3)
         end
       end
 
@@ -71,57 +68,149 @@ describe Spree::Calculator::DefaultTax, :type => :model do
           # 60 - 57.14 = $2.86
           expect(calculator.compute(order).to_f).to eql 2.86
         end
+
+        context "when the order's tax address is outside the default VAT zone" do
+          let(:order_zone) { create(:zone, countries: [address.country]) }
+          let(:default_vat_country) { create(:country, iso: "DE") }
+
+          before do
+            rate.zone.update(countries: [default_vat_country])
+            # The order has to be reloaded here because of tax zone caching.
+            order.reload
+          end
+
+          it 'creates a negative amount, indicating a VAT refund' do
+            expect(subject.compute(order)).to eq(-2.86)
+          end
+        end
       end
     end
+  end
+
+  shared_examples_for 'computing any item' do
+    let(:promo_total) { 0 }
+    let(:order) { build_stubbed(:order, ship_address: address) }
 
     context "when tax is included in price" do
       let(:included_in_price) { true }
+
       context "when the variant matches the tax category" do
+        it "should be equal to the item's full price * rate" do
+          expect(calculator.compute(item)).to eql 1.43
+        end
 
         context "when line item is discounted" do
-          before do
-            line_item.promo_total = -1
-            Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
-          end
+          let(:promo_total) { -1 }
 
           it "should be equal to the item's discounted total * rate" do
-            expect(calculator.compute(line_item)).to eql 1.38
+            expect(calculator.compute(item)).to eql 1.38
           end
         end
 
-        it "should be equal to the item's full price * rate" do
-          Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
-          expect(calculator.compute(line_item)).to eql 1.43
+        context "when the order's tax address is outside the default VAT zone" do
+          let!(:order_zone) { create(:zone, countries: [address.country]) }
+          let(:default_vat_country) { create(:country, iso: "DE") }
+
+          before do
+            rate.zone.update(countries: [default_vat_country])
+          end
+
+          it 'creates a negative amount, indicating a VAT refund' do
+            expect(subject.compute(item)).to eq(-1.43)
+          end
         end
       end
     end
 
     context "when tax is not included in price" do
       context "when the line item is discounted" do
-        before { line_item.promo_total = -1 }
+        let(:promo_total) { -1 }
 
         it "should be equal to the item's pre-tax total * rate" do
-          expect(calculator.compute(line_item)).to eq(1.45)
+          expect(calculator.compute(item)).to eq(1.45)
         end
       end
 
       context "when the variant matches the tax category" do
         it "should be equal to the item pre-tax total * rate" do
-          expect(calculator.compute(line_item)).to eq(1.50)
+          expect(calculator.compute(item)).to eq(1.50)
         end
       end
     end
+  end
 
-    context "when given a shipment" do
-      it "should be 5% of 15" do
-        expect(calculator.compute(shipment)).to eq(0.75)
-      end
+  describe 'when given a line item' do
+    let(:item) do
+      build_stubbed(
+        :line_item,
+        price: 10,
+        quantity: 3,
+        promo_total: promo_total,
+        order: order,
+        tax_category: tax_category
+      )
+    end
 
-      it "takes discounts into consideration" do
-        shipment.promo_total = -1
-        # 5% of 14
-        expect(calculator.compute(shipment)).to eq(0.7)
-      end
+    it_behaves_like 'computing any item'
+  end
+
+  describe 'when given a shipment' do
+    let(:shipping_method) do
+      build_stubbed(
+        :shipping_method,
+        tax_category: tax_category
+      )
     end
+
+    let(:shipping_rate) do
+      build_stubbed(
+        :shipping_rate,
+        selected: true,
+        shipping_method: shipping_method
+      )
+    end
+
+    let(:item) do
+      build_stubbed(
+        :shipment,
+        cost: 30,
+        promo_total: promo_total,
+        order: order,
+        shipping_rates: [shipping_rate]
+      )
+    end
+
+    it_behaves_like 'computing any item'
+  end
+
+  describe 'when given a shipping rate' do
+    let(:shipping_method) do
+      build_stubbed(
+        :shipping_method,
+        tax_category: tax_category
+      )
+    end
+
+    let(:shipment) do
+      build_stubbed(
+        :shipment,
+        order: order
+      )
+    end
+
+    let(:item) do
+      # cost and discounted_amount for shipping rates are the same as they
+      # can not be discounted. for the sake of passing tests, the cost is
+      # adjusted here.
+      build_stubbed(
+        :shipping_rate,
+        cost: 30 + promo_total,
+        selected: true,
+        shipping_method: shipping_method,
+        shipment: shipment
+      )
+    end
+
+    it_behaves_like 'computing any item'
   end
 end

data/spec/models/spree/calculator/flat_percent_item_total_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::FlatPercentItemTotal, :type => :model do
+describe Spree::Calculator::FlatPercentItemTotal, type: :model do
   let(:calculator) { Spree::Calculator::FlatPercentItemTotal.new }
   let(:line_item) { mock_model Spree::LineItem }
 

data/spec/models/spree/calculator/flexi_rate_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::FlexiRate, :type => :model do
+describe Spree::Calculator::FlexiRate, type: :model do
   let(:calculator) { Spree::Calculator::FlexiRate.new }
 
   let(:order) do
@@ -15,27 +15,27 @@ describe Spree::Calculator::FlexiRate, :type => :model do
     end
 
     it "should compute amount correctly when first_item has a value" do
-      allow(calculator).to receive_messages :preferred_first_item => 1.0
+      allow(calculator).to receive_messages preferred_first_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(1.0)
     end
 
     it "should compute amount correctly when additional_items has a value" do
-      allow(calculator).to receive_messages :preferred_additional_item => 1.0
+      allow(calculator).to receive_messages preferred_additional_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(9.0)
     end
 
     it "should compute amount correctly when additional_items and first_item have values" do
-      allow(calculator).to receive_messages :preferred_first_item => 5.0, :preferred_additional_item => 1.0
+      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(14.0)
     end
 
     it "should compute amount correctly when additional_items and first_item have values AND max items has value" do
-      allow(calculator).to receive_messages :preferred_first_item => 5.0, :preferred_additional_item => 1.0, :preferred_max_items => 3
+      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0, preferred_max_items: 3
       expect(calculator.compute(order).round(2)).to eq(7.0)
     end
 
     it "should allow creation of new object with all the attributes" do
-      Spree::Calculator::FlexiRate.new(:preferred_first_item => 1, :preferred_additional_item => 1, :preferred_max_items => 1)
+      Spree::Calculator::FlexiRate.new(preferred_first_item: 1, preferred_additional_item: 1, preferred_max_items: 1)
     end
   end
 end

data/spec/models/spree/calculator/percent_on_line_item_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   class Calculator
-    describe PercentOnLineItem, :type => :model do
+    describe PercentOnLineItem, type: :model do
       let(:line_item) { double("LineItem", amount: 100) }
 
       before { subject.preferred_percent = 15 }

data/spec/models/spree/calculator/price_sack_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::PriceSack, :type => :model do
+describe Spree::Calculator::PriceSack, type: :model do
   let(:calculator) do
     calculator = Spree::Calculator::PriceSack.new
     calculator.preferred_minimal_amount = 5
@@ -10,7 +10,7 @@ describe Spree::Calculator::PriceSack, :type => :model do
   end
 
   let(:order) { stub_model(Spree::Order) }
-  let(:shipment) { stub_model(Spree::Shipment, :amount => 10) }
+  let(:shipment) { stub_model(Spree::Shipment, amount: 10) }
 
   # Regression test for https://github.com/spree/spree/issues/714 and https://github.com/spree/spree/issues/739
   it "computes with an order object" do