solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/store_credit_spec.rb

@@ -1,12 +1,10 @@
 require 'spec_helper'
 
 describe Spree::StoreCredit do
-
   let(:currency) { "TEST" }
   let(:store_credit) { build(:store_credit, store_credit_attrs) }
   let(:store_credit_attrs) { {} }
 
-
   describe "callbacks" do
     subject { store_credit.save }
 
@@ -23,7 +21,7 @@ describe Spree::StoreCredit do
 
     context "category is a non-expiring type" do
       let!(:secondary_credit_type) { create(:secondary_credit_type) }
-      let(:store_credit) { build(:store_credit, credit_type: nil)}
+      let(:store_credit) { build(:store_credit, credit_type: nil) }
 
       before do
         allow(store_credit.category).to receive(:non_expiring?).and_return(true)
@@ -47,8 +45,8 @@ describe Spree::StoreCredit do
     end
 
     context "the type is set" do
-      let!(:secondary_credit_type) { create(:secondary_credit_type)}
-      let(:store_credit) { build(:store_credit, credit_type: secondary_credit_type)}
+      let!(:secondary_credit_type) { create(:secondary_credit_type) }
+      let(:store_credit) { build(:store_credit, credit_type: secondary_credit_type) }
 
       before do
         allow(store_credit.category).to receive(:non_expiring?).and_return(false)
@@ -71,7 +69,7 @@ describe Spree::StoreCredit do
 
         it "should set the correct error message" do
           invalid_store_credit.valid?
-          expect(invalid_store_credit.errors.full_messages).to include("Amount used cannot be greater than the credited amount")
+          expect(invalid_store_credit.errors.full_messages).to include("Amount Used cannot be greater than the credited amount")
         end
       end
 
@@ -81,7 +79,6 @@ describe Spree::StoreCredit do
         it "should be valid" do
           expect(store_credit).to be_valid
         end
-
       end
     end
 
@@ -168,7 +165,7 @@ describe Spree::StoreCredit do
         before { store_credit.update_attributes(amount_authorized: authorized_amount) }
 
         it "subtracts the authorized amount from the credited amount" do
-          expect(store_credit.amount_remaining).to eq (store_credit.amount - authorized_amount)
+          expect(store_credit.amount_remaining).to eq(store_credit.amount - authorized_amount)
         end
       end
     end
@@ -180,7 +177,7 @@ describe Spree::StoreCredit do
 
       context "the authorized amount is not defined" do
         it "subtracts the amount used from the credited amount" do
-          expect(store_credit.amount_remaining).to eq (store_credit.amount - amount_used)
+          expect(store_credit.amount_remaining).to eq(store_credit.amount - amount_used)
         end
       end
 
@@ -190,7 +187,7 @@ describe Spree::StoreCredit do
         before { store_credit.update_attributes(amount_authorized: authorized_amount) }
 
         it "subtracts the amount used and the authorized amount from the credited amount" do
-          expect(store_credit.amount_remaining).to eq (store_credit.amount - amount_used - authorized_amount)
+          expect(store_credit.amount_remaining).to eq(store_credit.amount - amount_used - authorized_amount)
         end
       end
     end
@@ -203,7 +200,6 @@ describe Spree::StoreCredit do
       let(:originator) { nil }
 
       context "amount has not been authorized yet" do
-
         before { store_credit.update_attributes(amount_authorized: authorization_amount) }
 
         it "returns true" do
@@ -212,7 +208,7 @@ describe Spree::StoreCredit do
 
         it "adds the new amount to authorized amount" do
           store_credit.authorize(added_authorization_amount, store_credit.currency)
-          expect(store_credit.reload.amount_authorized).to eq (authorization_amount + added_authorization_amount)
+          expect(store_credit.reload.amount_authorized).to eq(authorization_amount + added_authorization_amount)
         end
 
         context "originator is present" do
@@ -282,7 +278,7 @@ describe Spree::StoreCredit do
 
     context 'troublesome floats' do
       # 8.21.to_d < 8.21 => true
-      let(:store_credit_attrs) { {amount: 8.21} }
+      let(:store_credit_attrs) { { amount: 8.21 } }
 
       subject { store_credit.validate_authorization(store_credit_attrs[:amount], store_credit.currency) }
 
@@ -374,7 +370,6 @@ describe Spree::StoreCredit do
     end
 
     context "no event found for auth_code" do
-
       it "returns false" do
         expect(subject).to be false
       end
@@ -387,11 +382,13 @@ describe Spree::StoreCredit do
 
     context "capture event found for auth_code" do
       let(:captured_amount) { 10.0 }
-      let!(:capture_event) { create(:store_credit_auth_event,
+      let!(:capture_event) {
+        create(:store_credit_auth_event,
                                     action: Spree::StoreCredit::CAPTURE_ACTION,
                                     authorization_code: auth_code,
                                     amount: captured_amount,
-                                    store_credit: store_credit) }
+                                    store_credit: store_credit)
+      }
 
       it "returns false" do
         expect(subject).to be false
@@ -406,10 +403,12 @@ describe Spree::StoreCredit do
       let(:auth_event) { create(:store_credit_auth_event) }
 
       let(:authorized_amount) { 10.0 }
-      let!(:auth_event) { create(:store_credit_auth_event,
+      let!(:auth_event) {
+        create(:store_credit_auth_event,
                                  authorization_code: auth_code,
                                  amount: authorized_amount,
-                                 store_credit: store_credit) }
+                                 store_credit: store_credit)
+      }
 
       it "returns true" do
         expect(subject).to be true
@@ -434,11 +433,13 @@ describe Spree::StoreCredit do
     let(:event_auth_code) { "1-SC-20141111111111" }
     let(:amount_used)     { 10.0 }
     let(:store_credit)    { create(:store_credit, amount_used: amount_used) }
-    let!(:capture_event)  { create(:store_credit_auth_event,
+    let!(:capture_event)  {
+      create(:store_credit_auth_event,
                                    action: Spree::StoreCredit::CAPTURE_ACTION,
                                    authorization_code: event_auth_code,
                                    amount: captured_amount,
-                                   store_credit: store_credit) }
+                                   store_credit: store_credit)
+    }
     let(:originator) { nil }
 
     subject { store_credit.credit(credit_amount, auth_code, currency, action_originator: originator) }
@@ -554,7 +555,7 @@ describe Spree::StoreCredit do
 
         it "credits the passed amount to the store credit amount used" do
           subject
-          expect(store_credit.reload.amount_used).to eq (amount_used - credit_amount)
+          expect(store_credit.reload.amount_used).to eq(amount_used - credit_amount)
         end
 
         it "creates a new store credit event" do
@@ -766,7 +767,7 @@ describe Spree::StoreCredit do
           subject { create(:store_credit, user: user, amount: additional_store_credit_amount) }
 
           it "saves the user's total store credit in the event" do
-            expect(subject.store_credit_events.first.user_total_amount).to eq (store_credit_amount + additional_store_credit_amount)
+            expect(subject.store_credit_events.first.user_total_amount).to eq(store_credit_amount + additional_store_credit_amount)
           end
         end
 
@@ -804,7 +805,7 @@ describe Spree::StoreCredit do
 
       it "sets the adjustment amount on the store credit event correctly" do
         subject
-        expect(store_credit.store_credit_events.find_by(action: Spree::StoreCredit::ADJUSTMENT_ACTION).amount).to eq -20
+        expect(store_credit.store_credit_events.find_by(action: Spree::StoreCredit::ADJUSTMENT_ACTION).amount).to eq(-20)
       end
 
       it "sets the originator on the store credit event correctly" do

data/spec/models/spree/store_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-describe Spree::Store, :type => :model do
+describe Spree::Store, type: :model do
+  it { is_expected.to respond_to(:cart_tax_country_iso) }
 
   describe ".by_url" do
     let!(:store)    { create(:store, url: "website1.com\nwww.subdomain.com") }
@@ -19,7 +20,7 @@ describe Spree::Store, :type => :model do
     let!(:store_1) { Spree::Store.first || create(:store) }
 
     let!(:store_2) { create(:store, default: false, url: 'www.subdomain.com') }
-    let!(:store_3) { create(:store, default: false, url: 'www.another.com', code: 'CODE')}
+    let!(:store_3) { create(:store, default: false, url: 'www.another.com', code: 'CODE') }
 
     it 'should return default when no domain' do
       expect(subject.class.current).to eql(store_1)
@@ -52,4 +53,22 @@ describe Spree::Store, :type => :model do
     end
   end
 
+  describe '#default_cart_tax_location' do
+    subject { described_class.new(cart_tax_country_iso: cart_tax_country_iso) }
+    context "when there is no cart_tax_country_iso set" do
+      let(:cart_tax_country_iso) { '' }
+      it "responds with an empty default_cart_tax_location" do
+        expect(subject.default_cart_tax_location).to be_empty
+      end
+    end
+
+    context "when there is a cart_tax_country_iso set" do
+      let(:country) { create(:country, iso: "DE") }
+      let(:cart_tax_country_iso) { country.iso }
+
+      it "responds with a default_cart_tax_location with that country" do
+        expect(subject.default_cart_tax_location).to eq(Spree::Tax::TaxLocation.new(country: country))
+      end
+    end
+  end
 end

data/spec/models/spree/tax/item_adjuster_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.describe Spree::Tax::ItemAdjuster do
+  subject(:adjuster) { described_class.new(item) }
+  let(:order) { Spree::Order.new }
+  let(:item) { Spree::LineItem.new(order: order) }
+
+  before do
+    allow(order).to receive(:tax_zone) { build(:zone) }
+  end
+
+  describe 'initialization' do
+    it 'sets order to item order' do
+      expect(adjuster.order).to eq(item.order)
+    end
+
+    it 'sets adjustable' do
+      expect(adjuster.item).to eq(item)
+    end
+  end
+
+  describe '#adjust!' do
+    before do
+      expect(order).to receive(:tax_zone).and_return(tax_zone)
+    end
+
+    context 'when the order has no tax zone' do
+      let(:tax_zone) { nil }
+
+      before do
+        allow(order).to receive(:tax_zone).and_return(nil)
+        adjuster.adjust!
+      end
+
+      it 'returns nil early' do
+        expect(adjuster.adjust!).to be_nil
+      end
+    end
+
+    context 'when the order has a tax zone' do
+      let(:item) { build_stubbed :line_item, order: order }
+      let(:tax_zone) { build_stubbed(:zone, :with_country) }
+
+      before do
+        expect(Spree::TaxRate).to receive(:for_zone).with(tax_zone).and_return(rates_for_order_zone)
+        expect(Spree::TaxRate).to receive(:for_zone).with(Spree::Zone.default_tax).and_return([])
+      end
+
+      context 'when there are no matching rates' do
+        let(:rates_for_order_zone) { [] }
+
+        it 'returns no adjustments' do
+          expect(adjuster.adjust!).to eq([])
+        end
+      end
+
+      context 'when there are matching rates for the zone' do
+        context 'and all rates have the same tax category as the item' do
+          let(:item_tax_category) { build_stubbed(:tax_category) }
+          let(:rate_1) { create :tax_rate, tax_category: item_tax_category }
+          let(:rate_2) { create :tax_rate }
+          let(:rates_for_order_zone) { [rate_1, rate_2] }
+
+          before { allow(item).to receive(:tax_category).and_return(item_tax_category) }
+
+          it 'creates an adjustment for every matching rate' do
+            expect(rate_1).to receive_message_chain(:adjustments, :create!)
+            expect(adjuster.adjust!.length).to eq(1)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/tax/order_adjuster_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe Spree::Tax::OrderAdjuster do
+  subject(:adjuster) { described_class.new(order) }
+
+  describe 'initialization' do
+    let(:order) { Spree::Order.new }
+
+    it 'sets order to adjustable' do
+      expect(adjuster.order).to eq(order)
+    end
+  end
+
+  describe '#adjust!' do
+    let(:zone) { build_stubbed(:zone) }
+    let(:line_items) { build_stubbed_list(:line_item, 2) }
+    let(:order) { build_stubbed(:order, line_items: line_items) }
+    let(:rates_for_order_zone) { [] }
+    let(:item_adjuster) { Spree::Tax::ItemAdjuster.new(line_items.first) }
+
+    before do
+      expect(order).to receive(:tax_zone).at_least(:once).and_return(zone)
+      expect(Spree::TaxRate).to receive(:for_zone).with(zone).and_return(rates_for_order_zone)
+      expect(Spree::TaxRate).to receive(:for_zone).with(Spree::Zone.default_tax).and_return([])
+    end
+
+    it 'calls the item adjuster with all line items' do
+      expect(Spree::Tax::ItemAdjuster).to receive(:new).
+                                            with(
+                                              line_items.first,
+                                              rates_for_order_zone: rates_for_order_zone,
+                                              rates_for_default_zone: [],
+                                              order_tax_zone: zone,
+                                              skip_destroy_adjustments: true
+                                            ).and_return(item_adjuster)
+      expect(Spree::Tax::ItemAdjuster).to receive(:new).
+                                            with(
+                                              line_items.second,
+                                              rates_for_order_zone: rates_for_order_zone,
+                                              rates_for_default_zone: [],
+                                              order_tax_zone: zone,
+                                              skip_destroy_adjustments: true
+                                            ).and_return(item_adjuster)
+
+      expect(item_adjuster).to receive(:adjust!).twice
+      adjuster.adjust!
+    end
+  end
+end

data/spec/models/spree/tax/shipping_rate_taxer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Spree::Tax::ShippingRateTaxer do
+  let(:shipping_rate) { build_stubbed(:shipping_rate) }
+
+  subject(:taxer) { described_class.new(shipping_rate) }
+
+  describe '#tax' do
+    subject(:taxer) { described_class.new.tax(shipping_rate) }
+
+    context 'with no matching tax rates' do
+      it 'returns the object' do
+        expect(subject).to eq(shipping_rate)
+        expect(subject.taxes).to eq([])
+      end
+    end
+
+    context 'with tax rates' do
+      let(:ship_address) { create :address }
+      let(:tax_category) { create :tax_category }
+      let(:order) { create :order, ship_address: ship_address }
+      let(:shipment) { create :shipment, order: order }
+      let!(:shipping_method) { create :shipping_method, tax_category: tax_category, zones: [zone] }
+      let(:zone) { create :zone, countries: [ship_address.country] }
+      let!(:tax_rate_one) { create :tax_rate, tax_category: tax_category, zone: zone, amount: 0.1 }
+      let!(:tax_rate_two) { create :tax_rate, tax_category: tax_category, zone: zone, amount: 0.2 }
+      let!(:non_applicable_rate) { create :tax_rate, zone: zone }
+      let(:shipping_rate) { create :shipping_rate, cost: 10, shipping_method: shipping_method }
+
+      it 'builds a shipping rate tax for every tax rate' do
+        expect(subject.taxes.length).to eq(2)
+        expect(subject.taxes.map(&:tax_rate)).to include(tax_rate_one)
+        expect(subject.taxes.map(&:tax_rate)).to include(tax_rate_two)
+        # This rate has a different tax category.
+        expect(subject.taxes.map(&:tax_rate)).not_to include(non_applicable_rate)
+      end
+
+      it 'will produce a shipping rate that, when saved, also saves the taxes' do
+        expect { subject.save }.to change(Spree::ShippingRateTax, :count).by(2)
+      end
+
+      it 'will produce a shipping rate with correct taxes' do
+        tax_one = subject.taxes.detect { |tax| tax.tax_rate == tax_rate_one }
+        tax_two = subject.taxes.detect { |tax| tax.tax_rate == tax_rate_two }
+        expect(tax_one.amount).to eq(shipping_rate.cost * tax_rate_one.amount)
+        expect(tax_two.amount).to eq(shipping_rate.cost * tax_rate_two.amount)
+      end
+    end
+  end
+end

data/spec/models/spree/tax/tax_location_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+RSpec.describe Spree::Tax::TaxLocation do
+  let(:country) { build_stubbed(:country) }
+  let(:state) { build_stubbed(:state) }
+
+  subject { described_class.new }
+
+  it { is_expected.to respond_to(:state_id) }
+  it { is_expected.to respond_to(:country_id) }
+
+  describe "default values" do
+    it "has a nil state and country id" do
+      expect(subject.state_id).to eq(nil)
+      expect(subject.country_id).to eq(nil)
+    end
+  end
+
+  describe '#==' do
+    let(:other) { described_class.new(state: nil, country: nil) }
+
+    it 'compares the values of state id and country id and does not care about object identity' do
+      expect(subject).to eq(other)
+    end
+  end
+
+  describe "initialization" do
+    subject { described_class.new(args) }
+
+    context 'with a country object' do
+      let(:args) { { country: country } }
+
+      it "will yield a location with that country's id" do
+        expect(subject.country_id).to eq(country.id)
+      end
+    end
+
+    context 'with a state object' do
+      let(:args) { { state: state } }
+
+      it "will yield a location with that state's id" do
+        expect(subject.state_id).to eq(state.id)
+      end
+    end
+  end
+
+  describe "#empty?" do
+    subject { described_class.new(args).empty? }
+
+    context 'with a country present' do
+      let(:args) { { country: country } }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with a state present' do
+      let(:args) { { state: state } }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with no region data present' do
+      let(:args) { {} }
+
+      it { is_expected.to be true }
+    end
+  end
+end