solidus_backtracs 2.2.0

data/spec/lib/solidus_backtracs/api/request_error_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe SolidusBacktracs::Api::RequestError do
+  describe '.from_response' do
+    it 'extracts the status code, body and headers from the response' do
+      response = instance_double(
+        'HTTParty::Response',
+        code: 500,
+        headers: { 'Key' => 'Value' },
+        body: '{ "message": "Internal Server Error" }',
+      )
+
+      error = described_class.from_response(response)
+
+      expect(error).to have_attributes(
+        response_code: 500,
+        response_headers: { 'Key' => 'Value' },
+        response_body: '{ "message": "Internal Server Error" }',
+      )
+    end
+  end
+end

data/spec/lib/solidus_backtracs/api/request_runner_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe SolidusBacktracs::Api::RequestRunner do
+  #TODO
+  describe '.from_config' do
+    it 'builds a runner using credentials from the configuration' do
+      stub_configuration(api_key: 'user', api_secret: 'pass')
+
+      request_runner = described_class.from_config
+
+      expect(request_runner).to have_attributes(
+        username: 'user',
+        password: 'pass',
+      )
+    end
+  end
+
+  describe '#call' do
+    context 'when the response code is 2xx' do
+      it 'returns the parsed response' do
+        stub_request(:post, %r{bactracstest.andlor.com}).with(
+          basic_auth: %w[user pass],
+          headers: { 'Content-Type' => 'application/json', 'Accept' => 'application/json' },
+          body: '{"request_key":"request_value"}',
+        ).to_return(
+          headers: { 'Content-Type' => 'application/json' },
+          body: '{"response_key":"response_value"}',
+        )
+        request_runner = described_class.new(username: 'user', password: 'pass')
+
+        response = request_runner.call(:post, '/test', request_key: 'request_value')
+
+        expect(response).to eq('response_key' => 'response_value')
+      end
+    end
+
+    context 'when the response code is 429' do
+      it 'raises a RateLimitedError' do
+        stub_request(:post, %r{bactracstest.andlor.com}).to_return(
+          status: 429,
+          headers: { 'Content-Type' => 'application/json', 'X-Rate-Limit-Reset' => 20 },
+          body: '{"message":"Too Many Requests"}',
+        )
+        request_runner = described_class.new(username: 'user', password: 'pass')
+
+        expect {
+          request_runner.call(:post, '/test')
+        }.to raise_error(SolidusBacktracs::Api::RateLimitedError)
+      end
+    end
+
+    context 'when the response code is not 200 or 429' do
+      it 'raises a RequestError' do
+        stub_request(:post, %r{bactracstest.andlor.com}).to_return(
+          status: 500,
+          headers: { 'Content-Type' => 'application/json' },
+          body: '{"message":"Internal Server Error"}',
+        )
+        request_runner = described_class.new(username: 'user', password: 'pass')
+
+        expect {
+          request_runner.call(:post, '/test')
+        }.to raise_error(SolidusBacktracs::Api::RequestError)
+      end
+    end
+  end
+end

data/spec/lib/solidus_backtracs/api/shipment_serializer_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe SolidusBacktracs::Api::ShipmentSerializer do
+  describe '#call' do
+    it 'serializes the shipment' do
+      shipment = create(:order_ready_to_ship).shipments.first
+
+      serializer = described_class.new(store_id: '12345678')
+      result = serializer.call(shipment)
+
+      expect(result).to be_instance_of(Hash)
+    end
+
+    it 'sets residential = false in address if company is given' do
+      order = create(:order_ready_to_ship,
+        bill_address: build(:address, company: 'ACME Co.'),
+        ship_address: build(:address, company: nil))
+      shipment = order.shipments.first
+
+      serializer = described_class.new(store_id: '12345678')
+      result = serializer.call(shipment)
+
+      expect(result[:billTo][:residential]).to be false
+      expect(result[:shipTo][:residential]).to be true
+    end
+  end
+end

data/spec/lib/solidus_backtracs/api/threshold_verifier_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe SolidusBacktracs::Api::ThresholdVerifier do
+  context "when the shipment's order was completed" do
+    context 'when the shipment was never synced with Backtracs yet' do
+      it 'returns true when the shipment was never synced with backtracs yet' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first
+
+        expect(described_class.call(shipment)).to eq(true)
+      end
+
+      it "returns false when the shipment's order was created too far in the past" do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 11.minutes.ago)
+        end
+
+        expect(described_class.call(shipment)).to eq(false)
+      end
+    end
+
+    context 'when the shipment was already synced with Backtracs' do
+      it 'returns true when the shipment is pending a Backtracs re-sync' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 4.minutes.ago)
+          s.update_columns(backtracs_synced_at: 5.minutes.ago)
+        end
+
+        expect(described_class.call(shipment)).to eq(true)
+      end
+
+      it 'returns false when the shipment is up-to-date in Backtracs' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 6.minutes.ago)
+          s.update_columns(backtracs_synced_at: 5.minutes.ago)
+        end
+
+        expect(described_class.call(shipment)).to eq(false)
+      end
+
+      it 'returns false when the order was updated too far in the past' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 11.minutes.ago)
+          s.update_columns(backtracs_synced_at: 12.minutes.ago)
+        end
+
+        expect(described_class.call(shipment)).to eq(false)
+      end
+    end
+  end
+
+  context "when the shipment's order was not completed" do
+    it 'returns false' do
+      shipment = create(:shipment)
+
+      expect(described_class.call(shipment)).to eq(false)
+    end
+  end
+end

data/spec/lib/solidus_backtracs/shipment_notice_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusBacktracs::ShipmentNotice do
+  shared_examples 'ships or updates the shipment' do
+    context 'when the order was not shipped yet' do
+      # rubocop:disable RSpec/MultipleExpectations
+      it 'ships the order successfully' do
+        shipment_notice = build_shipment_notice(order.shipments.first, shipment_tracking: '1Z1231234')
+        shipment_notice.apply
+
+        order.reload
+        expect(order.shipments.first).to be_shipped
+        expect(order.shipments.first.shipped_at).not_to be_nil
+        expect(order.shipments.first.tracking).to eq('1Z1231234')
+        expect(order.cartons.first.tracking).to eq('1Z1231234')
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    context 'when the order was already shipped' do
+      it 'updates the tracking number on the shipment' do
+        order.shipments.first.ship!
+
+        shipment_notice = build_shipment_notice(order.shipments.first, shipment_tracking: '1Z1231234')
+        shipment_notice.apply
+
+        expect(order.reload.shipments.first.tracking).to eq('1Z1231234')
+      end
+    end
+  end
+
+  context 'when capture_at_notification is true' do
+    before { stub_configuration(capture_at_notification: true) }
+
+    context 'when the order is paid' do
+      let(:order) { create_order_ready_to_ship(paid: true) }
+
+      include_examples 'ships or updates the shipment'
+    end
+
+    context 'when the order is not paid' do
+      let(:order) { create_order_ready_to_ship(paid: false) }
+
+      context 'when the payment can be captured successfully' do
+        include_examples 'ships or updates the shipment'
+
+        it 'pays the order successfully' do
+          shipment_notice = build_shipment_notice(order.shipments.first, shipment_tracking: '1Z1231234')
+          shipment_notice.apply
+
+          order.reload
+          expect(order.payments).to all(be_completed)
+          expect(order.reload).to be_paid
+        end
+      end
+
+      context 'when the payment cannot be captured' do
+        it 'raises a PaymentError' do
+          allow_any_instance_of(Spree::Payment).to receive(:capture!).and_raise(Spree::Core::GatewayError)
+
+          shipment_notice = build_shipment_notice(order.shipments.first)
+
+          expect { shipment_notice.apply }.to raise_error(SolidusBacktracs::PaymentError) do |e|
+            expect(e.cause).to be_instance_of(Spree::Core::GatewayError)
+          end
+        end
+      end
+    end
+  end
+
+  context 'when capture_at_notification is false' do
+    before { stub_configuration(capture_at_notification: false) }
+
+    context 'when the order is paid' do
+      let(:order) { create_order_ready_to_ship(paid: true) }
+
+      include_examples 'ships or updates the shipment'
+    end
+
+    context 'when the order is not paid' do
+      it 'raises an OrderNotPaidError' do
+        stub_configuration(capture_at_notification: false)
+        order = create_order_ready_to_ship(paid: false)
+
+        shipment_notice = build_shipment_notice(order.shipments.first)
+
+        expect { shipment_notice.apply }.to raise_error(SolidusBacktracs::OrderNotPaidError)
+      end
+    end
+  end
+
+  private
+
+  def create_order_ready_to_ship(paid: true)
+    order = create(:order_ready_to_ship)
+
+    unless paid
+      order.payments.update_all(state: 'pending')
+      order.recalculate
+    end
+
+    order
+  end
+
+  def build_shipment_notice(shipment, shipment_tracking: '1Z1231234')
+    SolidusBacktracs::ShipmentNotice.new(
+      shipment_number: shipment.number,
+      shipment_tracking: shipment_tracking,
+    )
+  end
+end

data/spec/lib/solidus_backtracs_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe SolidusBacktracs do
+  describe 'VERSION' do
+    it 'is defined' do
+      expect(SolidusBacktracs::VERSION).to be_present
+    end
+  end
+end

data/spec/models/spree/shipment_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Spree::Shipment do
+  describe '.between' do
+    it 'delegates to BetweenQuery' do
+      shipment = build_stubbed(:shipment)
+      allow(SolidusBacktracs::Shipment::BetweenQuery).to receive(:apply).with(
+        any_args,
+        from: Time.zone.yesterday,
+        to: Time.zone.today,
+      ).and_return([shipment])
+
+      result = Spree::Deprecation.silence do
+        described_class.between(Time.zone.yesterday, Time.zone.today)
+      end
+
+      expect(result).to eq([shipment])
+    end
+
+    it 'prints a deprecation warning' do
+      allow(Spree::Deprecation).to receive(:warn)
+
+      described_class.between(Time.zone.yesterday, Time.zone.today)
+
+      expect(Spree::Deprecation).to have_received(:warn).with(/Spree::Shipment\.between/)
+    end
+  end
+
+  describe '.exportable' do
+    it 'delegates to ExportableQuery' do
+      shipment = build_stubbed(:shipment)
+      allow(SolidusBacktracs::Shipment::ExportableQuery).to receive(:apply).and_return([shipment])
+
+      result = Spree::Deprecation.silence do
+        described_class.exportable
+      end
+
+      expect(result).to eq([shipment])
+    end
+
+    it 'prints a deprecation warning' do
+      allow(Spree::Deprecation).to receive(:warn)
+
+      described_class.exportable
+
+      expect(Spree::Deprecation).to have_received(:warn).with(/Spree::Shipment\.exportable/)
+    end
+  end
+end

data/spec/queries/solidus_backtracs/shipment/between_query_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe SolidusBacktracs::Shipment::BetweenQuery do
+  describe '.apply' do
+    it 'returns shipments whose updated_at falls within the given time range' do
+      shipment = create(:shipment) { |s| s.update_column(:updated_at, Time.zone.now) }
+
+      result = described_class.apply(
+        Spree::Shipment.all,
+        from: Time.zone.yesterday,
+        to: Time.zone.tomorrow,
+      )
+
+      expect(result).to eq([shipment])
+    end
+
+    it "returns shipments whose order's updated_at falls within the given time range" do
+      order = create(:order) { |o| o.update_column(:updated_at, Time.zone.now) }
+      shipment = create(:shipment, order: order)
+
+      result = described_class.apply(
+        Spree::Shipment.all,
+        from: Time.zone.yesterday,
+        to: Time.zone.tomorrow,
+      )
+
+      expect(result).to eq([shipment])
+    end
+
+    it 'does not return shipments whose updated_at does not fall within the given time range' do
+      create(:shipment) { |s| s.update_column(:updated_at, Time.zone.now) }
+
+      result = described_class.apply(
+        Spree::Shipment.all,
+        from: Time.zone.tomorrow,
+        to: Time.zone.tomorrow + 1.day,
+      )
+
+      expect(result).to eq([])
+    end
+
+    it "does not return shipments whose order's updated_at falls within the given time range" do
+      order = create(:order) { |o| o.update_column(:updated_at, Time.zone.now) }
+      create(:shipment, order: order)
+
+      result = described_class.apply(
+        Spree::Shipment.all,
+        from: Time.zone.tomorrow,
+        to: Time.zone.tomorrow + 1.day,
+      )
+
+      expect(result).to eq([])
+    end
+  end
+end

data/spec/queries/solidus_backtracs/shipment/exportable_query_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe SolidusBacktracs::Shipment::ExportableQuery do
+  describe '.apply' do
+    context 'when capture_at_notification is false and export_canceled_shipments is false' do
+      it 'returns ready shipments from complete orders' do
+        stub_configuration(capture_at_notification: false, export_canceled_shipments: false)
+
+        ready_shipment = create(:order_ready_to_ship).shipments.first
+        create(:order_ready_to_ship) { |o| o.shipments.first.cancel! }
+        create(:shipped_order)
+
+        expect(described_class.apply(Spree::Shipment.all)).to eq([ready_shipment])
+      end
+    end
+
+    context 'when capture_at_notification is true and export_canceled_shipments is false' do
+      it 'returns non-canceled shipments from complete orders' do
+        stub_configuration(capture_at_notification: true, export_canceled_shipments: false)
+
+        ready_shipment = create(:order_ready_to_ship).shipments.first
+        shipped_shipment = create(:shipped_order).shipments.first
+        create(:order_ready_to_ship) { |o| o.shipments.first.cancel! }
+
+        expect(described_class.apply(Spree::Shipment.all)).to eq([ready_shipment, shipped_shipment])
+      end
+    end
+
+    context 'when capture_at_notification is false and export_canceled_shipments is true' do
+      it 'returns ready and canceled shipments from complete orders' do
+        stub_configuration(capture_at_notification: false, export_canceled_shipments: true)
+
+        ready_shipment = create(:order_ready_to_ship).shipments.first
+        canceled_shipment = create(:order_ready_to_ship).shipments.first
+        canceled_shipment.cancel!
+        create(:shipped_order)
+
+        expect(described_class.apply(Spree::Shipment.all)).to eq([ready_shipment, canceled_shipment])
+      end
+    end
+
+    context 'when capture_at_notification is true and export_canceled_shipments is true' do
+      it 'returns all shipments from complete orders' do
+        stub_configuration(capture_at_notification: true, export_canceled_shipments: true)
+
+        ready_shipment = create(:order_ready_to_ship).shipments.first
+        canceled_shipment = create(:order_ready_to_ship).shipments.first
+        canceled_shipment.cancel!
+        shipped_shipment = create(:shipped_order).shipments.first
+
+        expect(described_class.apply(Spree::Shipment.all)).to eq([ready_shipment, canceled_shipment, shipped_shipment])
+      end
+    end
+  end
+end

data/spec/queries/solidus_backtracs/shipment/pending_api_sync_query_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe SolidusBacktracs::Shipment::PendingApiSyncQuery do
+  describe '.apply' do
+    context 'when dealing with shipments that were never synced' do
+      it 'returns the shipments that are within the threshold' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 9.minutes.ago)
+        end
+        create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 11.minutes.ago)
+        end
+
+        expect(described_class.apply(Spree::Shipment.all)).to match_array([shipment])
+      end
+    end
+
+    context 'when dealing with shipments that were already synced' do
+      it 'returns the shipments that are within the threshold and pending a re-sync' do
+        stub_configuration(api_sync_threshold: 10.minutes)
+        shipment = create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 7.minutes.ago)
+          s.update_columns(shipstation_synced_at: 8.minutes.ago)
+        end
+        create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 9.minutes.ago)
+          s.update_columns(shipstation_synced_at: 8.minutes.ago)
+        end
+        create(:order_ready_to_ship).shipments.first.tap do |s|
+          s.order.update_columns(updated_at: 11.minutes.ago)
+          s.update_columns(shipstation_synced_at: 10.minutes.ago)
+        end
+
+        expect(described_class.apply(Spree::Shipment.all)).to match_array([shipment])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
+
+# Create the dummy app if it's still missing.
+dummy_env = "#{__dir__}/dummy/config/environment.rb"
+system 'bin/rake extension:test_app' unless File.exist? dummy_env
+require dummy_env
+
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
+
+# Requires factories defined in lib/solidus_backtracs/testing_support/factories.rb
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusBacktracs::Engine)
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = false
+
+  if Spree.solidus_gem_version < Gem::Version.new('2.11')
+    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
+  end
+end

data/spec/support/configuration_helper.rb

@@ -0,0 +1,13 @@
+module ConfigurationHelper
+  def stub_configuration(options)
+    allow(SolidusBacktracs.configuration).to receive_messages(options)
+
+    if options[:capture_at_notification]
+      stub_spree_preferences(require_payment_to_ship: false)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ConfigurationHelper
+end

data/spec/support/controllers.rb

@@ -0,0 +1 @@
+require 'rails-controller-testing'

data/spec/support/webmock.rb

@@ -0,0 +1,3 @@
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!

data/spec/support/xsd.rb

@@ -0,0 +1,5 @@
+require 'rspec/xsd'
+
+RSpec.configure do |config|
+  config.include RSpec::XSD
+end