super_good-solidus_taxjar 0.18.2 → 1.0.0

data/spec/super_good/solidus_taxjar/api_spec.rb

@@ -1,6 +1,9 @@
 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 }
 
@@ -31,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
@@ -57,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) }
@@ -81,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
@@ -105,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
@@ -144,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
@@ -161,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
@@ -183,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
@@ -208,9 +334,6 @@ RSpec.describe SuperGood::SolidusTaxjar::Api do
   describe "#nexus_regions" do
     subject { api.nexus_regions }
 
-    let(:api) { described_class.new(taxjar_client: dummy_client) }
-    let(:dummy_client) { instance_double ::Taxjar::Client }
-
     before do
       allow(dummy_client)
         .to receive(:nexus_regions)

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

data/spec/super_good/solidus_taxjar/reportable_spec.rb

@@ -0,0 +1,194 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::Reportable do
+  class ReportableTestClass
+    include SuperGood::SolidusTaxjar::Reportable
+
+    def initialize(order)
+      @order = order
+    end
+
+    def test_with_reportable
+      with_reportable(@order) do
+        return true
+      end
+      false
+    end
+
+    def test_with_replaceable
+      with_replaceable(@order) do
+        return true
+      end
+      false
+    end
+  end
+
+  let(:reportable_test_class) { ReportableTestClass.new(order) }
+
+  describe "#with_reportable" do
+    subject { reportable_test_class.test_with_reportable }
+
+    let!(:taxjar_configuration) { create(:taxjar_configuration, preferred_reporting_enabled_at_integer: nil) }
+
+    let(:order) { create(:order) }
+
+    it { is_expected.to be_falsey }
+
+    context "when reporting is enabled" do
+      let!(:taxjar_configuration) { create(:taxjar_configuration,   preferred_reporting_enabled_at_integer: 1.hour.ago) }
+
+      it { is_expected.to be_falsey }
+
+      context "is completed" do
+        let(:order) { create(:completed_order_with_totals) }
+
+        it { is_expected.to be_falsey }
+
+        context "is shipped" do
+          let(:order) { create(:shipped_order) }
+
+          it { is_expected.to be_truthy }
+
+          context "the order is not paid" do
+            before do
+              order.update_columns(payment_state: :balance_due)
+            end
+
+            it { is_expected.to be_falsey }
+          end
+
+          context "when the order has a failed transaction sync log and no order transactions" do
+            before do
+              create :transaction_sync_log, :error, order: order
+            end
+
+            it { is_expected.to be_truthy }
+          end
+
+          context "when the order has a failed transaction sync log, and an existing order transaction" do
+            before do
+              create :transaction_sync_log, :error, order: order
+              create :taxjar_order_transaction, order: order
+            end
+
+            it { is_expected.to be_falsey }
+          end
+
+          context "when the order was completed before reporting was enabled" do
+            before do
+              allow(SuperGood::SolidusTaxjar.exception_handler)
+                .to receive(:call)
+
+              order.update_columns(completed_at: 2.days.ago)
+            end
+
+            it { is_expected.to be_falsey }
+
+            it "creates a sync log with an error" do
+              expect { subject }
+                .to change { order.taxjar_transaction_sync_logs.count }
+                .from(0)
+                .to(1)
+
+              expect(order.taxjar_transaction_sync_logs.last).to have_attributes(
+                status: "error",
+                error_message: "Order cannot be synced because it was completed before TaxJar reporting was enabled"
+              )
+            end
+
+            it "calls the solidus taxjar exception handler with the error" do
+              subject
+
+              expect(SuperGood::SolidusTaxjar.exception_handler)
+                .to have_received(:call)
+                .with(RuntimeError.new("Order cannot be synced because it was completed before TaxJar reporting was enabled"))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#with_replaceable" do
+    subject { reportable_test_class.test_with_replaceable }
+
+    let!(:taxjar_configuration) { create(:taxjar_configuration, preferred_reporting_enabled_at_integer: nil) }
+
+    let(:order) { create(:order) }
+
+    it { is_expected.to be_falsey }
+
+    context "when reporting is enabled and the order is completed and shipped" do
+      let!(:taxjar_configuration) { create(:taxjar_configuration,   preferred_reporting_enabled_at_integer: 1.hour.ago) }
+      let(:order) do
+        order = create(:completed_order_with_pending_payment)
+        order.update_columns(shipment_state: :shipped)
+        order
+      end
+      let(:last_transaction_amount) { order.payment_total - order.additional_tax_total }
+      let(:dummy_api) { instance_double ::SuperGood::SolidusTaxjar::Api }
+
+      before do
+        allow(dummy_api)
+          .to receive(:show_latest_transaction_for)
+          .and_return(double(amount: last_transaction_amount))
+        allow(SuperGood::SolidusTaxjar)
+          .to receive(:api)
+          .and_return(dummy_api)
+      end
+
+      it { is_expected.to be_falsey }
+
+      context "when the order has a previous taxjar transaction" do
+        before do
+          create(:taxjar_order_transaction, order: order)
+        end
+
+        it { is_expected.to be_falsey }
+
+        context "when the order is paid" do
+          let(:order) { create :shipped_order }
+
+          it { is_expected.to be_falsey }
+
+          context "when the order's amount has changed" do
+            let(:last_transaction_amount) { order.payment_total - 12 }
+
+            it { is_expected.to be_truthy }
+
+            context "when the order was completed before reporting was enabled" do
+              before do
+                allow(SuperGood::SolidusTaxjar.exception_handler)
+                  .to receive(:call)
+
+                order.update_columns(completed_at: 2.days.ago)
+              end
+
+              it { is_expected.to be_falsey }
+
+              it "creates a sync log with an error" do
+                expect { subject }
+                  .to change { order.taxjar_transaction_sync_logs.count }
+                  .from(0)
+                  .to(1)
+
+                expect(order.taxjar_transaction_sync_logs.last).to have_attributes(
+                  status: "error",
+                  error_message: "Order cannot be synced because it was completed before TaxJar reporting was enabled"
+                )
+              end
+
+              it "calls the solidus taxjar exception handler with the error" do
+                subject
+
+                expect(SuperGood::SolidusTaxjar.exception_handler)
+                  .to have_received(:call)
+                  .with(RuntimeError.new("Order cannot be synced because it was completed before TaxJar reporting was enabled"))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end