super_good-solidus_taxjar 0.18.2 → 1.0.0

data/spec/super_good/solidus_taxjar/reporting_spec.rb

@@ -0,0 +1,243 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::Reporting do
+  let(:dummy_api) { instance_double ::SuperGood::SolidusTaxjar::Api }
+  let(:order) { build :order, completed_at: 1.days.ago }
+  let(:reporting) { described_class.new(api: dummy_api) }
+  let(:test_order_transaction_id) { "R1234-transaction" }
+  let(:test_refund_transaction_id) { "R1234-old-transaction-REFUND" }
+  let(:test_transaction_date) { Date.new(2022, 1, 1) }
+  let(:taxjar_order_response_double) {
+    double(
+      "Taxjar::Order",
+      transaction_id: test_order_transaction_id,
+      transaction_date: test_transaction_date
+    )
+  }
+  let(:taxjar_refund_response_double) {
+    double(
+      "Taxjar::Refund",
+      transaction_id: test_refund_transaction_id,
+      transaction_date: test_transaction_date
+    )
+  }
+
+  describe "#refund_and_create_transaction" do
+    subject { reporting.refund_and_create_new_transaction(order) }
+
+    let(:order) { create :order_with_totals, completed_at: 1.days.ago, number: "R1234-old-transaction" }
+    let!(:order_transaction_to_refund) {
+      create(
+        :taxjar_order_transaction,
+        transaction_id: "R1234-old-transaction",
+        transaction_date: Date.new(2021, 1, 1),
+        order: order
+      )
+    }
+
+    before do
+      allow(dummy_api)
+        .to receive(:create_refund_transaction_for)
+        .and_return(taxjar_refund_response_double)
+
+      allow(dummy_api)
+        .to receive(:create_transaction_for)
+        .and_return(taxjar_order_response_double)
+    end
+
+    it "refunds the transaction and creates a new one in TaxJar" do
+      subject
+
+      expect(dummy_api)
+        .to have_received(:create_refund_transaction_for)
+        .with(order)
+      expect(dummy_api)
+        .to have_received(:create_transaction_for)
+        .with(order)
+    end
+
+    it "creates a refund transaction record" do
+      expect { subject }
+        .to change { SuperGood::SolidusTaxjar::RefundTransaction.count }
+        .from(0)
+        .to(1)
+
+      expect(SuperGood::SolidusTaxjar::RefundTransaction.last).to have_attributes(
+        transaction_id: test_refund_transaction_id,
+        transaction_date: test_transaction_date,
+        order_transaction: order_transaction_to_refund
+      )
+    end
+
+    it "creates and returns a transaction for the order" do
+      expect(subject).to be_a(SuperGood::SolidusTaxjar::OrderTransaction)
+      expect(subject.persisted?).to be_truthy
+      expect(subject).to have_attributes(
+        transaction_id: test_order_transaction_id,
+        transaction_date: test_transaction_date
+      )
+    end
+
+    context "when the refund is for the full amount of the order" do
+      let(:order) { create :order, completed_at: 1.days.ago, number: "R1234-old-transaction" }
+
+      it "refunds the transaction" do
+        subject
+
+        expect(dummy_api)
+          .to have_received(:create_refund_transaction_for)
+          .with(order)
+      end
+
+      it "doesn't create a new transaction in taxjar" do
+        subject
+
+        expect(dummy_api)
+          .not_to have_received(:create_transaction_for)
+      end
+
+      it "creates a refund transaction record" do
+        expect { subject }
+          .to change { SuperGood::SolidusTaxjar::RefundTransaction.count }
+          .from(0)
+          .to(1)
+
+        expect(SuperGood::SolidusTaxjar::RefundTransaction.last).to have_attributes(
+          transaction_id: test_refund_transaction_id,
+          transaction_date: test_transaction_date,
+          order_transaction: order_transaction_to_refund
+        )
+      end
+
+      it "returns nil" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context "when Taxjar cannot create a refund transaction", :vcr do
+      let(:reporting) { described_class.new }
+      let(:order) { create(:completed_order_with_totals, number: "R1234-old-transaction") }
+      let!(:tax_rate) { create(:tax_rate, name: "Sales Tax") }
+
+      # We ensure that TaxJar cannot create a refund transaction refunding it
+      # *before* the test scenario.
+      before do
+        taxjar_api_client = ::SuperGood::SolidusTaxjar::Api.default_taxjar_client
+        begin
+          taxjar_api_client.show_order("R1234-old-transaction")
+        rescue Taxjar::Error::NotFound
+          taxjar_client.create_order(
+            ApiParams.transaction_params(order, "R1234-old-transaction")
+          )
+        end
+
+        begin
+          taxjar_api_client.show_refund("R1234-old-transaction-REFUND")
+        rescue Taxjar::Error::NotFound
+          taxjar_client.create_refund(
+            ApiParams.refund_transaction_params(order, order_transaction_to_refund)
+          )
+        end
+      end
+
+      it "raises an error" do
+        expect { subject }.to raise_error(
+          Taxjar::Error::UnprocessableEntity,
+          "Provider tranx already imported for your user account"
+        )
+      end
+
+      it "doesn't create a new transaction" do
+        expect(SuperGood::SolidusTaxjar.api)
+          .not_to receive(:create_transaction_for)
+
+        begin
+          subject
+        rescue Taxjar::Error::UnprocessableEntity
+          nil
+        end
+      end
+    end
+
+    context "when a partially completed refund exists in the database" do
+      before do
+        create :taxjar_refund_transaction, order_transaction: order_transaction_to_refund
+      end
+
+      it "skips creating the refund transaction and model" do
+        expect { subject }
+          .not_to change { SuperGood::SolidusTaxjar::RefundTransaction.count }
+
+        expect(dummy_api)
+          .not_to have_received(:create_refund_transaction_for)
+      end
+
+      it "creates a new order transaction" do
+        expect { subject }
+          .to change { SuperGood::SolidusTaxjar::OrderTransaction.count }
+          .from(1)
+          .to(2)
+
+        expect(dummy_api)
+          .to have_received(:create_transaction_for)
+      end
+    end
+  end
+
+  describe "#show_or_create_transaction" do
+    subject { reporting.show_or_create_transaction(order) }
+
+    context "the order has an existing transaction" do
+      before do
+        create :taxjar_order_transaction, transaction_id: test_order_transaction_id, transaction_date: test_transaction_date
+      end
+
+      it "returns the existing taxjar order transaction record" do
+        allow(dummy_api)
+          .to receive(:show_latest_transaction_for)
+          .and_return(taxjar_order_response_double)
+
+        subject
+
+        expect(dummy_api)
+          .to have_received(:show_latest_transaction_for)
+          .with(order)
+
+        expect(subject).to be_a(SuperGood::SolidusTaxjar::OrderTransaction)
+        expect(subject.persisted?).to be_truthy
+        expect(subject).to have_attributes(
+          transaction_id: test_order_transaction_id,
+          transaction_date: test_transaction_date
+        )
+      end
+    end
+
+    context "order doesn't have a transaction" do
+      let(:order) { create :order, completed_at: 1.days.ago }
+
+      context "TaxJar has no record of the transaction" do
+        it "creates a transaction for the order" do
+          allow(dummy_api)
+            .to receive(:show_latest_transaction_for)
+            .and_return(nil)
+
+          allow(dummy_api)
+            .to receive(:create_transaction_for)
+            .and_return(taxjar_order_response_double)
+
+          subject
+
+          expect(dummy_api).to have_received(:show_latest_transaction_for).with(order)
+          expect(dummy_api).to have_received(:create_transaction_for).with(order)
+
+          expect(subject).to be_a(SuperGood::SolidusTaxjar::OrderTransaction)
+          expect(subject.persisted?).to be_truthy
+          expect(subject).to have_attributes(
+            transaction_id: test_order_transaction_id,
+            transaction_date: test_transaction_date
+          )
+        end
+      end
+    end
+  end
+end

data/spec/super_good/solidus_taxjar/tax_calculator_spec.rb

@@ -77,7 +77,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
     context "when the order has an incomplete tax address" do
       let(:address) do
         ::Spree::Address.new(
-          first_name: "Ronnie James",
           zipcode: nil,
           address1: nil,
           city: "Beverly Hills",
@@ -106,7 +105,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
     context "when the order has no line items" do
       let(:address) do
         ::Spree::Address.new(
-          first_name: "Ronnie James",
           zipcode: "90210",
           address1: "9900 Wilshire Blvd",
           city: "Beverly Hills",
@@ -127,7 +125,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
     context "when the API encounters an error" do
       let(:address) do
         ::Spree::Address.new(
-          first_name: "Ronnie James",
           zipcode: "90210",
           address1: "9900 Wilshire Blvd",
           city: "Beverly Hills",
@@ -137,7 +134,13 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
       end
 
       before do
-        allow(dummy_api).to receive(:tax_for).with(order).and_raise("A bad thing happened.")
+        allow(calculator)
+          .to receive(:taxable_address?).with(address)
+          .and_return(true)
+        allow(dummy_api)
+          .to receive(:tax_for)
+          .with(order)
+          .and_raise("A bad thing happened.")
       end
 
       it "calls the configured error handler" do
@@ -159,7 +162,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
     context "when the order has a non-empty tax address" do
       let(:address) do
         ::Spree::Address.new(
-          first_name: "Ronnie James",
           zipcode: "90210",
           address1: "9900 Wilshire Blvd",
           city: "Beverly Hills",
@@ -178,14 +180,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
       end
 
       context "and there is tax" do
-        let!(:tax_rate) do
-          ::Spree::TaxRate.create!(
-            name: "Sales Tax",
-            amount: 0.5,
-            calculator: ::Spree::Calculator.new
-          )
-        end
-
         let(:breakdown) do
           instance_double ::Taxjar::Breakdown,
             line_items: [taxjar_line_item],
@@ -199,6 +193,12 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
 
         let(:shipping_tax_breakdown) { nil }
 
+        before do
+          allow(calculator)
+            .to receive(:taxable_address?).with(address)
+            .and_return(true)
+        end
+
         it "returns the taxes" do
           expect(subject.order_id).to eq order.id
           expect(subject.shipment_taxes).to be_empty
@@ -209,7 +209,7 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
           aggregate_failures do
             expect(item_tax.item_id).to eq 33
             expect(item_tax.label).to eq "Sales Tax"
-            expect(item_tax.tax_rate).to eq tax_rate
+            expect(item_tax.tax_rate).to be_a(Spree::TaxRate)
             expect(item_tax.amount).to eq 6.66
             expect(item_tax.included_in_price).to eq false
           end
@@ -231,8 +231,8 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
 
         context "but the taxable address check returns false" do
           before do
-            allow(SuperGood::SolidusTaxjar.taxable_address_check)
-              .to receive(:call).with(address)
+            allow(calculator)
+              .to receive(:taxable_address?).with(address)
               .and_return(false)
           end
 
@@ -269,19 +269,19 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxCalculator do
             aggregate_failures do
               expect(shipment_taxes[0].item_id).to eq 1
               expect(shipment_taxes[0].label).to eq "Sales Tax"
-              expect(shipment_taxes[0].tax_rate).to eq tax_rate
+              expect(shipment_taxes[0].tax_rate).to be_a(Spree::TaxRate)
               expect(shipment_taxes[0].amount).to eq 2.33
               expect(shipment_taxes[0].included_in_price).to eq false
 
               expect(shipment_taxes[1].item_id).to eq 2
               expect(shipment_taxes[1].label).to eq "Sales Tax"
-              expect(shipment_taxes[1].tax_rate).to eq tax_rate
+              expect(shipment_taxes[1].tax_rate).to be_a(Spree::TaxRate)
               expect(shipment_taxes[1].amount).to eq 4.33
               expect(shipment_taxes[1].included_in_price).to eq false
 
               expect(shipment_taxes[2].item_id).to eq 3
               expect(shipment_taxes[2].label).to eq "Sales Tax"
-              expect(shipment_taxes[2].tax_rate).to eq tax_rate
+              expect(shipment_taxes[2].tax_rate).to be_a(Spree::TaxRate)
               expect(shipment_taxes[2].amount).to eq 3.34
               expect(shipment_taxes[2].included_in_price).to eq false
             end

data/spec/super_good/solidus_taxjar/tax_rate_calculator_spec.rb

@@ -18,7 +18,6 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxRateCalculator do
 
     let(:incomplete_address) do
       ::Spree::Address.new(
-        first_name: "Ronnie James",
         zipcode: nil,
         address1: nil,
         city: "Beverly Hills",
@@ -64,8 +63,8 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxRateCalculator do
 
       context "when the address is not taxable" do
         before do
-          allow(SuperGood::SolidusTaxjar.taxable_address_check)
-            .to receive(:call).with(address)
+          allow(calculator)
+            .to receive(:taxable_address?).with(address)
             .and_return(false)
         end
 
@@ -76,6 +75,9 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxRateCalculator do
         let(:tax_rate) { 0.03 }
 
         before do
+          allow(calculator)
+            .to receive(:taxable_address?).with(address)
+            .and_return(true)
           allow(dummy_api).to receive(:tax_rate_for) { tax_rate }
         end
 
@@ -89,6 +91,9 @@ RSpec.describe ::SuperGood::SolidusTaxjar::TaxRateCalculator do
       let(:address) { complete_address }
 
       before do
+        allow(calculator)
+          .to receive(:taxable_address?).with(address)
+          .and_return(true)
         allow(dummy_api).to receive(:tax_rate_for).and_raise("A bad thing happened.")
       end
 

data/spec/super_good/solidus_taxjar/transaction_id_generator_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+RSpec.describe SuperGood::SolidusTaxjar::TransactionIdGenerator do
+  describe ".next_transaction_id" do
+    subject {
+      described_class.next_transaction_id(
+        order: order,
+        current_transaction_id: current_transaction_id
+      )
+    }
+
+    let(:order) { build :order, number: order_number }
+    let(:order_number) { "R1234567890" }
+
+    context "without a `current_transaction_id`" do
+      subject { described_class.next_transaction_id(order: order) }
+
+      it "uses the order.number as the transaction_id" do
+        expect(subject).to eq("R1234567890")
+      end
+
+      context "and there are dashes in the order number" do
+        let(:order_number) { "R123-456-7890" }
+
+        it "uses the order.number as the transaction_id" do
+          expect(subject).to eq("R123-456-7890")
+        end
+      end
+    end
+
+    context "with a `current_transaction_id`" do
+      context "when the current transaction ID does not have a suffix" do
+        let(:order_number) { "R1234567890" }
+        let(:current_transaction_id) { "R1234567890" }
+
+        it "generates the next sequential transaction_id" do
+          expect(subject).to eq("R1234567890-1")
+        end
+      end
+
+      context "when the current transaction ID has a suffix" do
+        let(:order_number) { "R1234567890" }
+        let(:current_transaction_id) { "R1234567890-2" }
+
+        it "generates the next sequential transaction_id" do
+          expect(subject).to eq("R1234567890-3")
+        end
+      end
+
+      context "when the current transaction ID contains more than one '-'" do
+        let(:order_number) { "R123-456-789-0" }
+        let(:current_transaction_id) { "R123-456-789-0-2" }
+
+        it "generates the next sequential transaction_id" do
+          expect(subject).to eq("R123-456-789-0-3")
+        end
+      end
+
+      context "when the current transaction ID suffix rolls over" do
+        let(:order_number) { "R1234567890" }
+        let(:current_transaction_id) { "R1234567890-99" }
+
+        it "generates the next sequential transaction_id" do
+          expect(subject).to eq("R1234567890-100")
+        end
+      end
+    end
+  end
+
+  describe ".refund_transaction_id" do
+    subject { described_class.refund_transaction_id(transaction_id) }
+
+    let(:transaction_id) { "R1234567890" }
+
+    it { is_expected.to eq("R1234567890-REFUND") }
+  end
+end

data/spec/super_good/solidus_taxjar_spec.rb

@@ -5,6 +5,54 @@ RSpec.describe SuperGood::SolidusTaxjar do
     expect(SuperGood::SolidusTaxjar::VERSION).not_to be nil
   end
 
+  describe ".table_name_prefix" do
+    subject { described_class.table_name_prefix }
+
+    it { is_expected.to eq("solidus_taxjar_") }
+  end
+
+  describe ".api" do
+    subject { described_class.api }
+
+    it "returns an instance of the api client" do
+      expect(subject).to be_a(SuperGood::SolidusTaxjar::Api)
+    end
+  end
+
+  describe ".reporting" do
+    subject { described_class.reporting }
+
+    it "creates a new reporting" do
+      expect(subject).to be_a(::SuperGood::SolidusTaxjar::Reporting)
+    end
+  end
+
+  describe ".logger" do
+    subject { described_class.logger }
+
+    let(:logger_double) { instance_double(Logger) }
+
+    context "logger is set" do
+      before do
+        described_class.logger = logger_double
+      end
+
+      after do
+        described_class.logger = nil
+      end
+
+      it "returns the logger" do
+        expect(subject).to be(logger_double)
+      end
+    end
+
+    context "no logger is set" do
+      it "returns the Rails logger" do
+        expect(subject).to be(Rails.logger)
+      end
+    end
+  end
+
   describe "configuration" do
     describe ".cache_key" do
       subject { described_class.cache_key.call(order) }
@@ -21,6 +69,28 @@ RSpec.describe SuperGood::SolidusTaxjar do
       end
     end
 
+    describe ".cache_duration" do
+      subject { described_class.cache_duration }
+
+      it "returns the default cache duration" do
+        expect(subject).to eq(3.hours)
+      end
+
+      context "when set to another value" do
+        before do
+          described_class.cache_duration = 1.hour
+        end
+
+        it "returns the correct cache duration" do
+          expect(subject).to eq(1.hour)
+        end
+
+        after do
+          described_class.cache_duration = 3.hours
+        end
+      end
+    end
+
     describe ".discount_calculator" do
       subject { described_class.discount_calculator }
       it { is_expected.to eq SuperGood::SolidusTaxjar::DiscountCalculator }
@@ -88,5 +158,19 @@ RSpec.describe SuperGood::SolidusTaxjar do
         expect(subject).to eq(10)
       end
     end
+
+    describe ".job_queue" do
+      subject { described_class.job_queue }
+
+      it { is_expected.to eq :default }
+    end
+
+    describe ".configuration" do
+      subject { described_class.configuration }
+
+      it "returns a Configuration instance" do
+        expect(subject).to be_instance_of(SuperGood::SolidusTaxjar::Configuration)
+      end
+    end
   end
 end

data/spec/support/checkoutable_store_shared_context.rb

@@ -0,0 +1,19 @@
+# Set up some data that a store needs to work and be realistic.
+#
+RSpec.shared_context "checkoutable store" do
+  let!(:default_store) { create :store, default: true }
+  let!(:taxjar_configuration) {
+    create :taxjar_configuration, :reporting_enabled
+  }
+
+  let!(:california) {
+    create :state,
+      country: create(:country, states_required: true),
+      state_code: "CA"
+  }
+
+  let!(:check_payment_method) { create :check_payment_method }
+  let!(:shipping_method) { create :shipping_method }
+  let!(:stock_location) { create :stock_location }
+  let!(:zone) { create :zone }
+end

data/spec/support/solidus_events_helper.rb

@@ -0,0 +1,26 @@
+module SolidusEventsHelper
+  # We can use this helper method to ensure that events are not run until after
+  # the test setup has been completed. This helps us more easily test side
+  # effects from events or control unintended side effects when attempting to
+  # test functionality that is not event-driven but would otherwise emit events.
+  #
+  # @yield Any test setup you'd like to run without events being emitted.
+  # @return The return value of the test setup in your block.
+  def with_events_disabled(&block)
+    if SolidusSupport::LegacyEventCompat.using_legacy?
+      allow(Spree::Event).to receive(:fire).and_return(nil)
+    else
+      allow(Spree::Bus).to receive(:publish).and_return(nil)
+    end
+
+    object = yield block
+
+    if SolidusSupport::LegacyEventCompat.using_legacy?
+      allow(Spree::Event).to receive(:fire).and_call_original
+    else
+      allow(Spree::Bus).to receive(:publish).and_call_original
+    end
+
+    object
+  end
+end

data/spec/taxjar/api/request_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe Taxjar::API::Request, :vcr do
+  subject { Taxjar::API::Request.new(client, :get, '/v2/summary_rates', 'summary_rates').perform }
+
+  let(:logger) { double(Logger) }
+  let(:client) { Taxjar::Client.new(api_key: ENV["TAXJAR_API_KEY"], api_url: "https://api.sandbox.taxjar.com") }
+
+  before do
+    allow(SuperGood::SolidusTaxjar).to receive(:logger).and_return(logger)
+  end
+
+
+  context "logging is enabled" do
+    before do
+      allow(SuperGood::SolidusTaxjar).to receive(:logging_enabled).and_return(true)
+    end
+
+    it "calls the logger", :aggregate_failures do
+      allow(logger).to receive(:debug)
+      allow(logger).to receive(:info)
+
+      subject
+
+      # When recording a cassette with VCR for this spec, one extra log
+      # statement is generated. In general we expect this to be called twice,
+      # but specify at least 2 times so cassettes can be re-recorded.
+      expect(logger).to have_received(:debug).at_least(2).times do |&block|
+        expect(block.call)
+          .to match("Host: api.sandbox.taxjar.com")
+          .or(match(/"summary_rates":/))
+      end
+
+      expect(logger).to have_received(:info).at_least(2).times do |&block|
+        expect(block.call)
+          .to match("> GET https://api.sandbox.taxjar.com/v2/summary_rates")
+          .or(match("< 200 OK"))
+      end
+    end
+  end
+
+  context "logging is disabled" do
+    before do
+      allow(SuperGood::SolidusTaxjar).to receive(:logging_enabled).and_return(false)
+    end
+
+    it "doesn't call the logger" do
+      expect(logger).to_not receive(:debug)
+      expect(logger).to_not receive(:info)
+
+      subject
+    end
+  end
+end

data/super_good-solidus_taxjar.gemspec

@@ -25,13 +25,14 @@ Gem::Specification.new do |spec|
   spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "deface", ">= 1"
   spec.add_dependency "solidus_core", ">= 2.4.0"
-  spec.add_dependency "solidus_support"
+  spec.add_dependency "solidus_support", ">= 0.9.0"
   spec.add_dependency "taxjar-ruby"
 
   spec.add_development_dependency "solidus_dev_support"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "vcr", "~> 4.0"