super_good-solidus_taxjar 0.18.1 → 1.0.0

data/spec/super_good/solidus_taxjar/api_spec.rb

@@ -1,11 +1,15 @@
 require "spec_helper"
 
 RSpec.describe SuperGood::SolidusTaxjar::Api do
+  let(:api) { described_class.new(taxjar_client: dummy_client) }
+  let(:dummy_client) { instance_double ::Taxjar::Client }
+
   describe ".new" do
     subject { described_class.new }
 
     before do
-      ENV["TAXJAR_API_KEY"] = 'taxjar_api_token'
+      allow(ENV).to receive(:fetch).and_call_original
+      allow(ENV).to receive(:fetch).with("TAXJAR_API_KEY").and_return("taxjar_api_token")
     end
 
     it "sets the correct headers" do
@@ -21,7 +25,8 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
     subject { described_class.default_taxjar_client }
 
     before do
-      ENV["TAXJAR_API_KEY"] = 'taxjar_api_token'
+      allow(ENV).to receive(:fetch).and_call_original
+      allow(ENV).to receive(:fetch).with("TAXJAR_API_KEY").and_return("taxjar_api_token")
     end
 
     it "returns an instance of the TaxJar client" do
@@ -29,12 +34,26 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
     end
   end
 
+  describe "#tax_categories" do
+    subject { api.tax_categories }
+
+    let(:tax_categories) {
+      [
+        instance_double(Taxjar::Category, name: "Clothing"),
+        instance_double(Taxjar::Category, name: "Digital Goods")
+      ]
+    }
+
+    it "responds with a list of tax categories" do
+      allow(dummy_client).to receive(:categories).and_return(tax_categories)
+
+      expect(subject).to eq(tax_categories)
+    end
+  end
 
   describe "#tax_for" do
     subject { api.tax_for order }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:order) { Spree::Order.new }
 
     before do
@@ -55,8 +74,6 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
   describe "tax_rate_for" do
     subject { api.tax_rate_for address }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:address) { Spree::Address.new }
     let(:tax_rate) { 0.04 }
     let(:response) { double(rate: tax_rate) }
@@ -79,8 +96,6 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
   describe "#tax_rates_for" do
     subject { api.tax_rates_for address }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:address) { Spree::Address.new }
 
     before do
@@ -103,28 +118,47 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
 
     let(:api) { described_class.new(taxjar_client: dummy_client) }
     let(:dummy_client) { instance_double ::Taxjar::Client }
-    let(:order) { Spree::Order.new }
+    let(:order) { create(:order_ready_to_ship, number: "R123") }
+
+    let(:dummy_response) do
+      instance_double(
+        ::Taxjar::Order,
+        transaction_id: "R123",
+        transaction_date: "2015-05-15T00:00:00Z"
+      )
+    end
 
-    before do
-      allow(SuperGood::SolidusTaxjar::ApiParams)
-        .to receive(:transaction_params)
-        .with(order)
-        .and_return({transaction: "params"})
+    context "when the latest transaction ID is nil" do
+      before do
+        allow(SuperGood::SolidusTaxjar::ApiParams)
+          .to receive(:transaction_params)
+          .with(order, "R123")
+          .and_return({transaction: "params"})
 
-      allow(dummy_client)
-        .to receive(:create_order)
-        .with({transaction: "params"})
-        .and_return({some_kind_of: "response"})
+        allow(dummy_client)
+          .to receive(:create_order)
+          .with({transaction: "params"})
+          .and_return(dummy_response)
+      end
+
+      it { is_expected.to eq(dummy_response) }
     end
 
-    it { is_expected.to eq({some_kind_of: "response"}) }
+    context "when the API call to create the transaction fails" do
+      before do
+        allow(dummy_client).to receive(:create_order).and_raise(Taxjar::Error)
+      end
+
+      it "does not create an `OrderTransaction` for the order" do
+        expect { subject }.to raise_error(Taxjar::Error)
+        expect(order.taxjar_order_transactions.count).to be_zero
+      end
+    end
   end
 
   describe "#update_transaction_for" do
     subject { api.update_transaction_for order }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:order) { Spree::Order.new }
 
     before do
@@ -142,11 +176,9 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
     it { is_expected.to eq({some_kind_of: "response"}) }
   end
 
-  describe "#update_transaction_for" do
+  describe "#delete_transaction_for" do
     subject { api.delete_transaction_for order }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:order) { Spree::Order.new(number: "R111222333") }
 
     before do
@@ -159,11 +191,49 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
     it { is_expected.to eq({some_kind_of: "response"}) }
   end
 
+  describe "#show_latest_transaction_for" do
+    subject { api.show_latest_transaction_for order }
+
+    let(:order) { Spree::Order.new(number: "R111222333") }
+
+    context "with a persisted order transaction" do
+      before do
+        create(
+          :taxjar_order_transaction,
+          order: order,
+          transaction_id: "R111222333-42"
+        )
+      end
+
+      let(:order) { create(:order, number: "R111222333") }
+
+      it "uses the persisted transaction_id to fetch the TaxJar transaction" do
+        expect(dummy_client)
+          .to receive(:show_order)
+          .with("R111222333-42")
+          .and_return({some_kind_of: "response"})
+        expect(subject).to eq({some_kind_of: "response"})
+      end
+
+      context "TaxJar does not have an order transaction persisted" do
+        before do
+          allow(dummy_client)
+            .to receive(:show_order)
+            .and_raise(Taxjar::Error::NotFound)
+        end
+
+        it { is_expected.to eq nil }
+      end
+    end
+
+    context "without a persisted order transaction" do
+      it { is_expected.to eq nil }
+    end
+  end
+
   describe "#create_refund_for" do
     subject { api.create_refund_for reimbursement }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:reimbursement) { Spree::Reimbursement.new }
 
     before do
@@ -181,11 +251,69 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
     it { is_expected.to eq({some_kind_of: "response"}) }
   end
 
+  describe "#create_refund_transaction_for" do
+    subject { api.create_refund_transaction_for order }
+
+    let(:order) { create(:order_ready_to_ship, number: "R111222333") }
+
+    let(:taxjar_order) {
+      Taxjar::Order.new(
+        amount: 20,
+        sales_tax: 2,
+        shipping: 5
+      )
+    }
+
+    before do
+      allow(dummy_client)
+        .to receive(:show_order)
+        .with("R111222333-10")
+        .and_return(taxjar_order)
+
+      allow(SuperGood::SolidusTaxjar::ApiParams)
+        .to receive(:refund_transaction_params)
+        .with(order, taxjar_order)
+        .and_return({refund_transaction: "params"})
+
+      allow(dummy_client)
+        .to receive(:create_refund)
+        .with({refund_transaction: "params"})
+        .and_return({some_kind_of: "response"})
+    end
+
+    context "when no order transaction has been persisted" do
+      it "raises an exception" do
+        expect { subject }.to raise_error(
+          NotImplementedError,
+          "No latest TaxJar order transaction for #{order.number}. "       \
+          "Backfilling TaxJar transaction orders from Solidus is not yet " \
+          "implemented."
+        )
+      end
+    end
+
+    context "when an order transaction has been persisted" do
+      before do
+        create(
+          :taxjar_order_transaction,
+          order: order,
+          transaction_id: "R111222333-10"
+        )
+      end
+
+      it "requests the latest transaction from TaxJar" do
+        expect(dummy_client).to receive(:show_order).with("R111222333-10")
+
+        subject
+      end
+
+      it { is_expected.to eq({some_kind_of: "response"}) }
+    end
+  end
+
   describe "#validate_spree_address" do
     subject { api.validate_spree_address spree_address }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
     let(:spree_address) { build :address }
 
     before do
@@ -202,4 +330,16 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
 
     it { is_expected.to eq({some_kind_of: "response"}) }
   end
+
+  describe "#nexus_regions" do
+    subject { api.nexus_regions }
+
+    before do
+      allow(dummy_client)
+        .to receive(:nexus_regions)
+        .and_return({some_kind_of: "response"})
+    end
+
+    it { is_expected.to eq({some_kind_of: "response"}) }
+  end
 end

data/spec/super_good/solidus_taxjar/backfill_transactions_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::BackfillTransactions do
+  describe "#call" do
+    subject { described_class.new.call(start_date: start_date.to_s, end_date: end_date.to_s) }
+
+    let(:start_date) { 1.day.ago.to_date }
+    let(:end_date) { Date.today }
+
+    it "returns a new transaction sync batch" do
+      expect(subject).to be_a(SuperGood::SolidusTaxjar::TransactionSyncBatch)
+    end
+
+    it "has the start and end date" do
+      expect(subject).to have_attributes({start_date: start_date, end_date: end_date})
+    end
+
+    it "queues a job to backfill the transactions in the batch" do
+      expect { subject }
+        .to have_enqueued_job(SuperGood::SolidusTaxjar::BackfillTransactionSyncBatchJob)
+        .with(kind_of(SuperGood::SolidusTaxjar::TransactionSyncBatch))
+    end
+  end
+end

data/spec/super_good/solidus_taxjar/cached_api_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::CachedApi do
+  describe ".nexus_regions" do
+    subject { instance.nexus_regions }
+
+    let(:instance) { described_class.new(api: dummy_api) }
+
+    let(:dummy_api) do
+      instance_double(SuperGood::SolidusTaxjar::Api)
+    end
+
+    let(:nexus_region) { ::Taxjar::NexusRegion.new(region: "California") }
+
+    before do
+      allow(dummy_api).to receive(:nexus_regions).and_return(
+        [nexus_region]
+      )
+    end
+
+    it "makes a request to the TaxJar API" do
+      subject
+      expect(dummy_api).to have_received(:nexus_regions)
+    end
+
+    it "returns a list of nexus regions" do
+      expect(subject).to contain_exactly(nexus_region)
+    end
+
+    context "when nexus regions cached" do
+      before do
+        Rails.cache.write(:nexus_regions, [nexus_region])
+      end
+
+      it "doesn't make a request to the TaxJar API" do
+        subject
+        expect(dummy_api).to_not have_received(:nexus_regions)
+      end
+
+      it "returns a list of nexus regions" do
+        expect(subject).to contain_exactly(nexus_region)
+      end
+
+      context "with refresh true" do
+        subject { instance.nexus_regions(refresh: true) }
+
+        it "makes a request to the TaxJar API" do
+          subject
+          expect(dummy_api).to have_received(:nexus_regions)
+        end
+
+        it "returns a list of nexus regions" do
+          expect(subject).to contain_exactly(nexus_region)
+        end
+      end
+    end
+  end
+end

data/spec/super_good/solidus_taxjar/calculator_helper_spec.rb

@@ -0,0 +1,131 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::CalculatorHelper do
+  class TestProxy
+    extend SuperGood::SolidusTaxjar::CalculatorHelper
+  end
+
+  describe "#incomplete_address?" do
+    subject { TestProxy.incomplete_address?(address) }
+
+    context "with a missing city" do
+      let(:address) { build :address, city: nil }
+      it { is_expected.to eq(true) }
+    end
+
+    context "with a missing address1" do
+      let(:address) { build :address, address1: nil }
+      it { is_expected.to eq(true) }
+    end
+
+    context "with a missing zipcode" do
+      let(:address) { build :address, zipcode: nil }
+      it { is_expected.to eq(true) }
+    end
+
+    context "with a missing state in CA" do
+      let(:address) { build :address, country_iso_code: "CA" }
+
+      before { address.state = nil }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "with a missing state in US" do
+      let(:address) { build :address, country_iso_code: "US" }
+
+      before { address.state = nil }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "with a missing state in DE" do
+      let(:address) { build :address, country_iso_code: "DE", state: nil }
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe "#state_required?" do
+    subject { TestProxy.state_required?(country) }
+
+    context "when the address' country is Canada" do
+      let(:country) { Spree::Country.new(iso: "CA") }
+      it { is_expected.to eq(true) }
+    end
+
+    context "when the address' country is the USA" do
+      let(:country) { Spree::Country.new(iso: "US") }
+      it { is_expected.to eq(true) }
+    end
+
+    context "when the address' country is neither Canada nor the USA" do
+      let(:country) { Spree::Country.new(iso: "FR") }
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe "#taxable_address?" do
+    subject { TestProxy.taxable_address?(address) }
+
+    let(:configuration_class) { double }
+
+    before do
+      allow(SuperGood::SolidusTaxjar)
+        .to receive(:taxable_address_check)
+        .and_return(configuration_class)
+      allow(configuration_class).to receive(:call)
+        .and_return(taxable_address)
+    end
+
+    context "when taxable address check returns false" do
+      let(:taxable_address) { false }
+      let(:address) do
+        create :address, name: "Canada", country_iso_code: "CA"
+      end
+
+      it { is_expected.to be_falsey }
+    end
+
+    context "when taxable address check returns true" do
+      let(:taxable_address) { true }
+
+      context "with non-US address" do
+        let(:address) do
+          create :address, name: "Canada", country_iso_code: "CA"
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context "with US address", :vcr do
+        let(:usa) { create :country, iso: "US", name: "United States" }
+
+        # This test expects a TaxJar account to have nexus in California.
+        #
+        context "when the address is within a nexus region" do
+          let(:address) {
+            create :address,
+              state: create(:state, abbr: "CA", country: usa, name: "Cali!"),
+              country: usa,
+              zipcode: "94704"
+          }
+
+          it { is_expected.to eq true }
+        end
+
+        # This test expects a TaxJar account to *not* have nexus in Alabama.
+        #
+        context "when the address is not within a nexus region" do
+          let(:address) {
+            create :address,
+              state: create(:state, abbr: "AL", country: usa, name: "Alabama"),
+              country: usa,
+              zipcode: "35006"
+          }
+
+          it { is_expected.to eq false }
+        end
+      end
+    end
+  end
+end

data/spec/super_good/solidus_taxjar/discount_calculator_spec.rb

@@ -5,9 +5,26 @@ RSpec.describe SuperGood::SolidusTaxjar::DiscountCalculator do
     subject { calculator.discount }
 
     let(:calculator) { described_class.new line_item }
+    let(:line_item) { create :line_item }
+    let!(:order) { create :completed_order_with_promotion, promotion: promotion_with_adjustment, line_items: [line_item] }
 
-    let(:line_item) { ::Spree::LineItem.new(promo_total: 12.34) }
+    let(:cancelation_adjustment_amount) { -8 }
+    let(:promotion_adjustment_amount) { -2 }
+    let(:promotion_with_adjustment) { create :promotion_with_item_adjustment, adjustment_rate: promotion_adjustment_amount }
+    let!(:unit_cancellation_adjustment) { create :adjustment, order: order, adjustable: line_item, amount: cancelation_adjustment_amount, source_type: "Spree::UnitCancel" }
 
-    it { is_expected.to eq(-12.34) }
+    let!(:tax_adjustment) { create :tax_adjustment, order: order, adjustable: line_item, amount: 2.50 }
+
+    it "sums the total of all non-tax adjustments" do
+      expect(subject).to eq(-1 * (cancelation_adjustment_amount + promotion_adjustment_amount))
+    end
+
+    context "a non-eligible adjustment exists" do
+      let!(:unit_cancellation_adjustment) { create :adjustment, order: order, adjustable: line_item, eligible: false, amount: cancelation_adjustment_amount, source_type: "Spree::UnitCancel" }
+
+      it "only sums eligible adjustments" do
+        expect(subject).to eq(-1 * promotion_adjustment_amount)
+      end
+    end
   end
 end