solidus_avatax_certified 1.0.0

data/spec/models/spree/address_decorator_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Spree::Address, type: :model do
+  let(:address) { build(:address) }
+
+  describe '#validation_enabled?' do
+    it 'returns true if preference is true and country validation is enabled' do
+      Spree::AvalaraPreference.address_validation.update_attributes(value: 'true')
+      Spree::AvalaraPreference.validation_enabled_countries.update_attributes(value: 'United States,Canada')
+
+      expect(address.validation_enabled?).to be_truthy
+    end
+
+    it 'returns false if address validation preference is false' do
+      Spree::AvalaraPreference.address_validation.update_attributes(value: 'false')
+
+      expect(address.validation_enabled?).to be_falsey
+    end
+
+    it 'returns false if enabled country is not present' do
+      Spree::AvalaraPreference.validation_enabled_countries.update_attributes(value: 'Canada')
+
+      expect(address.validation_enabled?).to be_falsey
+    end
+  end
+
+  describe '#country_validation_enabled?' do
+    it 'returns true if the current country is enabled' do
+      expect(address.country_validation_enabled?).to be_truthy
+    end
+  end
+
+  describe '#validation_enabled_countries' do
+    it 'returns an array' do
+      expect(Spree::Address.validation_enabled_countries).to be_kind_of(Array)
+    end
+
+    it 'includes United States' do
+      Spree::AvalaraPreference.validation_enabled_countries.update_attributes(value: 'United States,Canada')
+
+      expect(Spree::Address.validation_enabled_countries).to include('United States')
+    end
+  end
+end

data/spec/models/spree/adjustment_decorator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Spree::Adjustment, type: :model do
+  let(:order) { build(:avalara_order) }
+
+  describe 'not_tax' do
+    it 'does not include adjustments with source_type of Spree::TaxRate' do
+      tax_adjustment = create(:adjustment, source_type: 'Spree::TaxRate', order: order)
+      non_tax_adjustment = create(:adjustment, source_type: 'Spree::Promotion', order: order)
+
+      expect(Spree::Adjustment.not_tax).to_not include(tax_adjustment)
+      expect(Spree::Adjustment.not_tax).to include(non_tax_adjustment)
+    end
+  end
+
+  describe '#avatax_cache_key' do
+    it 'should respond with a cache key' do
+      adjustment = build(:adjustment, id: 1, amount: 20.0, order: order)
+
+      expected_response = 'Spree::Adjustment-1-20.0'
+
+      expect(adjustment.avatax_cache_key).to eq(expected_response)
+    end
+  end
+end

data/spec/models/spree/avalara_entity_use_code_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Spree::AvalaraEntityUseCode, type: :model do
+  it { should have_many :users }
+end

data/spec/models/spree/avalara_preference_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Spree::AvalaraPreference, type: :model do
+  it { should validate_uniqueness_of :name }
+  it { should validate_presence_of :name }
+  it { should validate_presence_of :object_type }
+
+  describe '#booleans' do
+    it 'should return records with object_type of boolean' do
+      boolean_pref = create(:avalara_preference, object_type: 'boolean')
+      other_pref = create(:avalara_preference, object_type: 'string')
+
+      expect(Spree::AvalaraPreference.booleans).to include(boolean_pref)
+      expect(Spree::AvalaraPreference.booleans).to_not include(other_pref)
+    end
+  end
+
+  describe '#strings' do
+    it 'should return records with object_type of string' do
+      string_pref = create(:avalara_preference, object_type: 'string')
+      other_pref = create(:avalara_preference, object_type: 'boolean')
+
+      expect(Spree::AvalaraPreference.strings).to include(string_pref)
+      expect(Spree::AvalaraPreference.strings).to_not include(other_pref)
+    end
+  end
+
+  describe '#arrays' do
+    it 'should return records with object_type of array' do
+      array_pref = create(:avalara_preference, object_type: 'array')
+      other_pref = create(:avalara_preference, object_type: 'boolean')
+
+      expect(Spree::AvalaraPreference.arrays).to include(array_pref)
+      expect(Spree::AvalaraPreference.arrays).to_not include(other_pref)
+    end
+  end
+
+  describe '#jsons' do
+    it 'should return records with object_type of json' do
+      json_pref = create(:avalara_preference, object_type: 'json')
+      other_pref = create(:avalara_preference, object_type: 'boolean')
+
+      expect(Spree::AvalaraPreference.jsons).to include(json_pref)
+      expect(Spree::AvalaraPreference.jsons).to_not include(other_pref)
+    end
+  end
+
+  describe '#storeable_env' do
+    it 'should return records with that have name is either company_code, license_key, account and endpoint' do
+      storable_pref = Spree::AvalaraPreference.company_code
+      other_pref = create(:avalara_preference, name: 'other')
+
+      expect(Spree::AvalaraPreference.storable_envs).to include(storable_pref)
+      expect(Spree::AvalaraPreference.storable_envs).to_not include(other_pref)
+    end
+  end
+
+  describe '#company_code' do
+    it 'should return object with the same name' do
+      company_code = Spree::AvalaraPreference.find_by(name: 'company_code')
+
+      expect(Spree::AvalaraPreference.company_code).to eq(company_code)
+    end
+  end
+
+  describe '#license_key' do
+    it 'should return object with same name' do
+      license_key = Spree::AvalaraPreference.find_by(name: 'license_key')
+
+      expect(Spree::AvalaraPreference.license_key).to eq(license_key)
+    end
+  end
+
+  describe '#account' do
+    it 'should return object with same name' do
+      account = Spree::AvalaraPreference.find_by(name: 'account')
+
+      expect(Spree::AvalaraPreference.account).to eq(account)
+    end
+  end
+
+  describe '#endpoint' do
+    it 'should return object with same name' do
+      endpoint = Spree::AvalaraPreference.find_by(name: 'endpoint')
+
+      expect(Spree::AvalaraPreference.endpoint).to eq(endpoint)
+    end
+  end
+
+  describe '#origin_address' do
+    it 'should return object with same name' do
+      origin_address = Spree::AvalaraPreference.find_by(name: 'origin_address')
+
+      expect(Spree::AvalaraPreference.origin_address).to eq(origin_address)
+    end
+  end
+
+  describe '#log' do
+    it 'should return object with same name' do
+      log = Spree::AvalaraPreference.find_by(name: 'log')
+
+      expect(Spree::AvalaraPreference.log).to eq(log)
+    end
+  end
+
+  describe '#log_to_stdout' do
+    it 'should return object with same name' do
+      log_to_stdout = Spree::AvalaraPreference.find_by(name: 'log_to_stdout')
+
+      expect(Spree::AvalaraPreference.log_to_stdout).to eq(log_to_stdout)
+    end
+  end
+
+  describe '#address_validation' do
+    it 'should return object with same name' do
+      address_validation = Spree::AvalaraPreference.find_by(name: 'address_validation')
+
+      expect(Spree::AvalaraPreference.address_validation).to eq(address_validation)
+    end
+  end
+
+  describe '#refuse_checkout_address_validation_error' do
+    it 'should return object with same name' do
+      pref = Spree::AvalaraPreference.find_by(name: 'refuse_checkout_address_validation_error')
+
+      expect(Spree::AvalaraPreference.refuse_checkout_address_validation_error).to eq(pref)
+    end
+  end
+
+  describe '#tax_calculation' do
+    it 'should return object with same name' do
+      tax_calculation = Spree::AvalaraPreference.find_by(name: 'tax_calculation')
+
+      expect(Spree::AvalaraPreference.tax_calculation).to eq(tax_calculation)
+    end
+  end
+
+  describe '#document_commit' do
+    it 'should return object with same name' do
+      document_commit = Spree::AvalaraPreference.find_by(name: 'document_commit')
+
+      expect(Spree::AvalaraPreference.document_commit).to eq(document_commit)
+    end
+  end
+
+  describe '#validation_enabled_countries' do
+    it 'should return object with name address_validation_enabled_countries' do
+      validation_enabled_countries = Spree::AvalaraPreference.find_by(name: 'address_validation_enabled_countries')
+
+      expect(Spree::AvalaraPreference.validation_enabled_countries).to eq(validation_enabled_countries)
+    end
+  end
+
+  describe '#validation_enabled_countries_array' do
+    it 'should return the objects value as an array' do
+      value = ['United States', 'Canada']
+
+      expect(Spree::AvalaraPreference.validation_enabled_countries_array).to eq(value)
+    end
+  end
+
+  describe '#is_true?' do
+    it 'should return true if value is a string of true or false' do
+      expect(Spree::AvalaraPreference.tax_calculation.is_true?).to be_in([true, false])
+    end
+
+    it 'should return false if value is an empty string' do
+      Spree::AvalaraPreference.origin_address.update_attributes(value: "")
+
+      expect(Spree::AvalaraPreference.origin_address.is_true?).to be_falsey
+    end
+  end
+end

data/spec/models/spree/avalara_transaction_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Spree::AvalaraTransaction, :vcr do
+
+  it { should belong_to :order }
+  it { should validate_presence_of :order }
+  it { should validate_uniqueness_of :order_id }
+  it { should have_db_index :order_id }
+
+  let(:included_in_price) { false }
+  let(:order) { create(:avalara_order, tax_included: included_in_price) }
+
+  context 'captured orders' do
+
+    before do
+      VCR.use_cassette("order_capture") do
+        order.avalara_capture
+      end
+    end
+
+    describe '#lookup_avatax' do
+      subject do
+        VCR.use_cassette("order_capture") do
+          order.avalara_transaction.lookup_avatax
+        end
+      end
+
+      it 'should look up avatax' do
+        expect(subject['TotalTax']).to eq('0.6')
+      end
+    end
+
+    describe '#commit_avatax' do
+      subject do
+        VCR.use_cassette("order_capture") do
+          order.avalara_transaction.commit_avatax('SalesOrder')
+        end
+      end
+
+      it 'should commit avatax' do
+        expect(subject['TotalTax']).to eq('0.6')
+      end
+
+      context 'tax calculation disabled' do
+        it 'should respond with total tax of 0' do
+          Spree::AvalaraPreference.tax_calculation.update_attributes(value: 'false')
+          expect(order.avalara_transaction.commit_avatax('SalesOrder')[:TotalTax]).to eq('0.00')
+        end
+      end
+    end
+
+    context 'promo' do
+      let(:promotion) { create(:promotion, :with_order_adjustment) }
+
+      before do
+        create(:adjustment, order: order, source: promotion.promotion_actions.first, adjustable: order)
+        order.update!
+      end
+
+      subject do
+        VCR.use_cassette('order_capture_with_promo', allow_playback_repeats: true) do
+          order.avalara_transaction.commit_avatax('SalesOrder')
+        end
+      end
+
+      it 'applies discount' do
+        expect(subject['TotalDiscount']).to eq('10')
+      end
+    end
+
+    context 'included_in_price' do
+      let(:included_in_price) { true }
+
+      subject do
+        VCR.use_cassette("tax_included_order") do
+          order.avalara_transaction.commit_avatax('SalesOrder')
+        end
+      end
+
+      it 'calculates the included tax amount from item total' do
+        expect(subject['TotalTax']).to eq('0.57')
+      end
+    end
+
+    describe '#commit_avatax_final' do
+      subject do
+        VCR.use_cassette("order_capture_finalize", allow_playback_repeats: true) do
+          order.avalara_transaction.commit_avatax_final('SalesInvoice')
+        end
+      end
+
+      it 'should commit avatax final' do
+        expect(subject['TotalTax']).to eq('0.6')
+      end
+
+      it 'should fail to commit to avatax if settings are false' do
+        Spree::AvalaraPreference.document_commit.update_attributes(value: 'false')
+
+        expect(subject).to eq('avalara document committing disabled')
+      end
+
+      context 'tax calculation disabled' do
+        it 'should respond with total tax of 0' do
+          Spree::AvalaraPreference.tax_calculation.update_attributes(value: 'false')
+          expect(subject[:TotalTax]).to eq('0.00')
+        end
+      end
+
+      context 'with CustomerUsageType' do
+        let(:use_code) { create(:avalara_entity_use_code) }
+
+        before do
+          order.user.update_attributes(avalara_entity_use_code: use_code)
+        end
+
+        subject do
+          VCR.use_cassette('capture_with_customer_usage_type') do
+            order.avalara_transaction.commit_avatax('SalesInvoice')
+          end
+        end
+
+        it 'does not add additional tax' do
+          expect(subject['TotalTax']).to eq('0')
+        end
+      end
+    end
+
+
+    describe '#cancel_order' do
+
+      describe 'when successful' do
+        let(:order) { create(:completed_avalara_order) }
+        subject do
+          VCR.use_cassette("order_cancel") do
+            order.avalara_capture_finalize
+            order.avalara_transaction.cancel_order
+          end
+        end
+
+        it 'should receive ResultCode of Success' do
+          expect(subject['ResultCode']).to eq('Success')
+        end
+      end
+
+      context 'error' do
+        it 'should receive error' do
+          order = create(:order)
+          order.avalara_transaction = Spree::AvalaraTransaction.create
+          expect(order.avalara_transaction).to receive(:cancel_order_to_avalara).and_return('Error in Tax')
+          order.avalara_transaction.cancel_order
+        end
+      end
+    end
+  end
+
+  context 'return orders' do
+    let(:order) { create(:completed_avalara_order) }
+    let(:reimbursement) { create(:reimbursement, order: order) }
+    let(:refund) { build(:refund, payment: order.payments.first, amount: order.total.to_f) }
+
+    before do
+      VCR.use_cassette("order_capture_finalize") do
+        order.avalara_capture_finalize
+        order.reload
+      end
+    end
+
+    describe '#commit_avatax' do
+      subject do
+        VCR.use_cassette("order_return_capture") do
+          order.avalara_transaction.commit_avatax('ReturnOrder', refund)
+        end
+      end
+
+      it 'should receive a ResultCode of Success' do
+        expect(subject['ResultCode']).to eq('Success')
+      end
+
+      it 'should have a TotalTax equal to additional_tax_total' do
+        expect(subject['TotalTax']).to eq("#{-order.additional_tax_total.to_f}")
+      end
+    end
+
+    describe '#commit_avatax_final' do
+      subject do
+        VCR.use_cassette("order_return_capture") do
+          order.avalara_transaction.commit_avatax_final('ReturnOrder', refund)
+        end
+      end
+
+      it 'should commit avatax final' do
+        expect(subject).to be_kind_of(Hash)
+        expect(subject['ResultCode']).to eq('Success')
+        expect(subject['TotalTax']).to eq("#{-order.additional_tax_total.to_f}")
+      end
+
+      it 'should receive post_order_to_avalara' do
+        expect(order.avalara_transaction).to receive(:post_return_to_avalara)
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Spree::Calculator::AvalaraTransaction do
+  let(:included_in_price) { false }
+  let!(:order) { create(:avalara_order, line_items_price: 10, shipment_cost: 100, tax_included: included_in_price) }
+  let(:tax_category) { Spree::TaxCategory.find_or_create_by(name: 'Clothing', tax_code: 'P0000000') }
+  let(:calculator) { Spree::TaxRate.find_by(name: 'Tax').calculator }
+  let(:line_item) { order.line_items.first }
+
+  describe '#description' do
+    it 'responds with avalara_transaction' do
+      expect(calculator.description).to eq('Avalara Transaction Calculator')
+    end
+  end
+
+  context '#compute', :vcr do
+    context 'when given an order' do
+      before do
+        allow(order).to receive_messages :line_items => [line_item]
+      end
+
+      context 'when computing an order' do
+        it 'should raise error' do
+          expect{calculator.compute(order)}.to raise_error(RuntimeError)
+        end
+      end
+    end
+    context 'when computing a line item' do
+      context 'when tax is included in price' do
+        let(:included_in_price) { true }
+        it 'should be equal to the item pre-tax total * rate' do
+          expect(calculator.compute(line_item)).to eq(0.38)
+        end
+
+        it 'should be equal to the previous included_tax_total is order is at cart' do
+          order.state = 'cart'
+          line_item.included_tax_total = 0.1
+          expect(calculator.compute(line_item)).to eq(0.1)
+        end
+
+        it 'should be equal to the previous included_tax_total is order is at address' do
+          order.state = 'address'
+          line_item.included_tax_total = 0.1
+          expect(calculator.compute(line_item)).to eq(0.1)
+        end
+      end
+
+      context 'when tax is not included in price' do
+
+        it 'should be equal to the item pre-tax total * rate' do
+          expect(calculator.compute(line_item)).to eq(0.4)
+        end
+
+        it 'should be equal to the previous additional_tax_total if order is at cart' do
+          order.state = 'cart'
+          line_item.additional_tax_total = 0.1
+          expect(calculator.compute(line_item)).to eq(0.1)
+        end
+
+        it 'should be equal to the previous additional_tax_total if order is at address' do
+          order.state = 'address'
+          line_item.additional_tax_total = 0.1
+          expect(calculator.compute(line_item)).to eq(0.1)
+        end
+
+        it 'should be equal to the previous tax total if preference tax_calculation is false' do
+          Spree::AvalaraPreference.tax_calculation.update_attributes(value: 'false')
+
+          line_item.additional_tax_total = 0.1
+          expect(calculator.compute(line_item)).to eq(0.1)
+        end
+
+        context 'when the order is discounted' do
+          let(:promotion) { create(:promotion, :with_order_adjustment, weighted_order_adjustment_amount: 2) }
+
+          before do
+            create(:adjustment, order: order, source: promotion.promotion_actions.first, adjustable: order)
+            order.update!
+          end
+
+          it 'should be equal to the items pre-tax total * rate' do
+            expect(calculator.compute(line_item)).to eq(0.32)
+          end
+        end
+
+        context 'when the line item is discounted' do
+          let!(:promotion) { create(:promotion_with_item_adjustment, adjustment_rate: 2) }
+
+          before do
+            create(:adjustment, order: order, source: promotion.promotion_actions.first, adjustable: line_item)
+            line_item.reload
+            order.reload.update!
+          end
+
+          it 'should be equal to the items pre-tax total * rate' do
+            expect(calculator.compute(line_item)).to eq(0.32)
+          end
+        end
+      end
+    end
+
+    context 'when given a shipment' do
+      let(:shipping_rate) { Spree::TaxRate.find_by(name: 'Shipping Tax') }
+      let(:shipping_calculator) { Spree::Calculator::AvalaraTransaction.new(calculable: shipping_rate) }
+      let!(:shipment) { order.shipments.first }
+
+      describe 'computing normal shipment' do
+        it 'should be equal 4.0' do
+          expect(shipping_calculator.compute(shipment)).to eq(4.0)
+        end
+      end
+
+      describe 'with promotion' do
+        it 'should equal 3.96' do
+          shipment.update_attributes(promo_total: -1)
+          expect(shipping_calculator.compute(shipment)).to eq(3.96)
+        end
+      end
+
+      describe 'when tax is included in price' do
+        let(:included_in_price) { true }
+
+        it 'should be equal to 3.85' do
+          expect(shipping_calculator.compute(shipment)).to eq(3.85)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/line_item_decorator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Spree::LineItem, type: :model do
+
+  let(:order) { create :order_with_line_items, line_items_count: 1 }
+  let(:line_item) { order.line_items.first }
+
+  describe '#to_hash' do
+    it 'should create hash of line item information' do
+      expect(line_item.to_hash).to be_kind_of(Hash)
+    end
+    it 'should have index of 1' do
+      response = line_item.to_hash
+      expect(response['Index']).to eq(1)
+    end
+  end
+
+  describe '#avatax_cache_key' do
+    it 'should respond with a cache key' do
+      line_item = Spree::LineItem.new(price: 10, id: 1, quantity: 1)
+
+      expected_response = 'Spree::LineItem-1-1-10.0-0.0'
+
+      expect(line_item.avatax_cache_key).to eq(expected_response)
+    end
+  end
+
+  describe '#avatax_line_code' do
+    it 'should equal LI' do
+      expect(line_item.avatax_line_code).to eq('LI')
+    end
+  end
+end