solidus_shipstation 1.0.0

data/spec/jobs/solidus_shipstation/api/schedule_shipment_syncs_job_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusShipstation::Api::ScheduleShipmentSyncsJob do
+  it 'schedules the shipment sync in batches' do
+    stub_configuration(api_batch_size: 2)
+    shipments = create_list(:shipment, 3)
+    relation = instance_double('ActiveRecord::Relation').tap do |r|
+      allow(r).to receive(:find_in_batches)
+        .with(batch_size: 2)
+        .and_yield(shipments[0..1])
+        .and_yield([shipments.last])
+    end
+    allow(SolidusShipstation::Shipment::PendingApiSyncQuery).to receive(:apply)
+      .and_return(relation)
+
+    described_class.perform_now
+
+    expect(SolidusShipstation::Api::SyncShipmentsJob).to have_been_enqueued.with(shipments[0..1])
+    expect(SolidusShipstation::Api::SyncShipmentsJob).to have_been_enqueued.with([shipments.last])
+  end
+
+  it 'reports any errors to the handler' do
+    error_handler = instance_spy('Proc')
+    stub_configuration(error_handler: error_handler)
+    error = RuntimeError.new('Something went wrong')
+    allow(SolidusShipstation::Shipment::PendingApiSyncQuery).to receive(:apply).and_raise(error)
+
+    described_class.perform_now
+
+    expect(error_handler).to have_received(:call).with(error, {})
+  end
+end

data/spec/jobs/solidus_shipstation/api/sync_shipments_job_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusShipstation::Api::SyncShipmentsJob do
+  include ActiveSupport::Testing::TimeHelpers
+
+  context 'when a shipment is syncable' do
+    context 'when the sync can be completed successfully' do
+      it 'syncs the provided shipments in batch' do
+        shipment = build_stubbed(:shipment) { |s| stub_syncability(s, true) }
+        batch_syncer = stub_successful_batch_syncer
+
+        described_class.perform_now([shipment])
+
+        expect(batch_syncer).to have_received(:call).with([shipment])
+      end
+    end
+
+    context 'when the sync cannot be completed' do
+      context 'when the error is a rate limit' do
+        it 'retries intelligently when hitting a rate limit' do
+          freeze_time do
+            shipment = build_stubbed(:shipment) { |s| stub_syncability(s, true) }
+            stub_failing_batch_syncer(SolidusShipstation::Api::RateLimitedError.new(
+              response_code: 429,
+              response_headers: { 'X-Rate-Limit-Reset' => 30 },
+              response_body: '{"message":"Too Many Requests"}',
+              retry_in: 30.seconds,
+            ))
+
+            described_class.perform_now([shipment])
+
+            expect(described_class).to have_been_enqueued.at(30.seconds.from_now)
+          end
+        end
+      end
+
+      context 'when the error is a server error' do
+        it 'calls the error handler' do
+          error_handler = instance_spy('Proc')
+          stub_configuration(error_handler: error_handler)
+          shipment = build_stubbed(:shipment) { |s| stub_syncability(s, true) }
+          error = SolidusShipstation::Api::RequestError.new(
+            response_code: 500,
+            response_headers: {},
+            response_body: '{"message":"Internal Server Error"}',
+          )
+          stub_failing_batch_syncer(error)
+
+          described_class.perform_now([shipment])
+
+          expect(error_handler).to have_received(:call).with(error, {})
+        end
+      end
+    end
+  end
+
+  context 'when a shipment is not syncable' do
+    it 'skips shipments that are not pending sync' do
+      shipment = build_stubbed(:shipment) { |s| stub_syncability(s, false) }
+      batch_syncer = stub_successful_batch_syncer
+
+      described_class.perform_now([shipment])
+
+      expect(batch_syncer).not_to have_received(:call)
+    end
+
+    it 'fires a solidus_shipstation.api.sync_skipped event' do
+      stub_const('Spree::Event', class_spy(Spree::Event))
+      shipment = build_stubbed(:shipment) { |s| stub_syncability(s, false) }
+      stub_successful_batch_syncer
+
+      described_class.perform_now([shipment])
+
+      expect(Spree::Event).to have_received(:fire).with(
+        'solidus_shipstation.api.sync_skipped',
+        shipment: shipment,
+      )
+    end
+  end
+
+  private
+
+  def stub_successful_batch_syncer
+    instance_spy(SolidusShipstation::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusShipstation::Api::BatchSyncer).to receive(:from_config).and_return(batch_syncer)
+    end
+  end
+
+  def stub_failing_batch_syncer(error)
+    instance_double(SolidusShipstation::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusShipstation::Api::BatchSyncer).to receive(:from_config).and_return(batch_syncer)
+
+      allow(batch_syncer).to receive(:call).and_raise(error)
+    end
+  end
+
+  def stub_syncability(shipment, result)
+    allow(SolidusShipstation::Api::ThresholdVerifier).to receive(:call)
+      .with(shipment)
+      .and_return(result)
+  end
+end

data/spec/lib/solidus_shipstation/api/batch_syncer_spec.rb

@@ -0,0 +1,229 @@
+RSpec.describe SolidusShipstation::Api::BatchSyncer do
+  include ActiveSupport::Testing::TimeHelpers
+
+  describe '.from_config' do
+    it 'creates a syncer with the configured API client' do
+      client = instance_double(SolidusShipstation::Api::Client)
+      allow(SolidusShipstation::Api::Client).to receive(:from_config).and_return(client)
+      shipment_matcher = -> {}
+      stub_configuration(api_shipment_matcher: shipment_matcher)
+
+      batch_syncer = described_class.from_config
+
+      expect(batch_syncer).to have_attributes(
+        client: client,
+        shipment_matcher: shipment_matcher,
+      )
+    end
+  end
+
+  describe '#call' do
+    context 'when the API call is successful' do
+      context 'when the sync operation succeeded' do
+        it 'updates the ShipStation data on the shipment' do
+          freeze_time do
+            shipment = instance_spy('Spree::Shipment', number: 'H123456')
+            api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+              allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
+                {
+                  'results' => [
+                    {
+                      'orderNumber' => shipment.number,
+                      'success' => true,
+                      'orderId' => '123456',
+                    }
+                  ]
+                }
+              )
+            end
+
+            build_batch_syncer(client: api_client).call([shipment])
+
+            expect(shipment).to have_received(:update_columns).with(
+              shipstation_order_id: '123456',
+              shipstation_synced_at: Time.zone.now,
+            )
+          end
+        end
+
+        it 'emits a solidus_shipstation.api.sync_completed event' do
+          stub_const('Spree::Event', class_spy(Spree::Event))
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+            allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
+              {
+                'results' => [
+                  {
+                    'orderNumber' => shipment.number,
+                    'success' => true,
+                    'orderId' => '123456',
+                  }
+                ]
+              }
+            )
+          end
+
+          build_batch_syncer(client: api_client).call([shipment])
+
+          expect(Spree::Event).to have_received(:fire).with(
+            'solidus_shipstation.api.sync_completed',
+            shipment: shipment,
+            payload: {
+              'orderNumber' => shipment.number,
+              'success' => true,
+              'orderId' => '123456',
+            },
+          )
+        end
+      end
+
+      context 'when the sync operation failed' do
+        it 'does not update the ShipStation data on the shipment' do
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+            allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
+              {
+                'results' => [
+                  {
+                    'orderNumber' => shipment.number,
+                    'success' => false,
+                    'orderId' => '123456',
+                  }
+                ]
+              }
+            )
+          end
+
+          build_batch_syncer(client: api_client).call([shipment])
+
+          expect(shipment).not_to have_received(:update_columns)
+        end
+
+        it 'emits a solidus_shipstation.api.sync_failed event' do
+          stub_const('Spree::Event', class_spy(Spree::Event))
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+            allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
+              {
+                'results' => [
+                  {
+                    'orderNumber' => shipment.number,
+                    'success' => false,
+                    'orderId' => '123456',
+                  }
+                ]
+              }
+            )
+          end
+
+          build_batch_syncer(client: api_client).call([shipment])
+
+          expect(Spree::Event).to have_received(:fire).with(
+            'solidus_shipstation.api.sync_failed',
+            shipment: shipment,
+            payload: {
+              'orderNumber' => shipment.number,
+              'success' => false,
+              'orderId' => '123456',
+            },
+          )
+        end
+      end
+    end
+
+    context 'when the API call hits a rate limit' do
+      it 'emits a solidus_shipstation.api.rate_limited event' do
+        stub_const('Spree::Event', class_spy(Spree::Event))
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusShipstation::Api::RateLimitedError.new(
+          response_headers: { 'X-Rate-Limit-Reset' => 20 },
+          response_body: '{"message":"Too Many Requests"}',
+          response_code: 429,
+          retry_in: 20.seconds,
+        )
+        api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+          allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
+        end
+
+        begin
+          build_batch_syncer(client: api_client).call([shipment])
+        rescue SolidusShipstation::Api::RateLimitedError
+          # We want to ignore the error here, since we're testing for the event.
+        end
+
+        expect(Spree::Event).to have_received(:fire).with(
+          'solidus_shipstation.api.rate_limited',
+          shipments: [shipment],
+          error: error,
+        )
+      end
+
+      it 're-raises the error' do
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusShipstation::Api::RateLimitedError.new(
+          response_headers: { 'X-Rate-Limit-Reset' => 20 },
+          response_body: '{"message":"Too Many Requests"}',
+          response_code: 429,
+          retry_in: 20.seconds,
+        )
+        api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+          allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
+        end
+
+        expect {
+          build_batch_syncer(client: api_client).call([shipment])
+        }.to raise_error(error)
+      end
+    end
+
+    context 'when the API call results in a server error' do
+      it 'emits a solidus_shipstation.api.sync_errored event' do
+        stub_const('Spree::Event', class_spy(Spree::Event))
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusShipstation::Api::RequestError.new(
+          response_headers: {},
+          response_body: '{"message":"Internal Server Error"}',
+          response_code: 500,
+        )
+        api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+          allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
+        end
+
+        begin
+          build_batch_syncer(client: api_client).call([shipment])
+        rescue SolidusShipstation::Api::RequestError
+          # We want to ignore the error here, since we're testing for the event.
+        end
+
+        expect(Spree::Event).to have_received(:fire).with(
+          'solidus_shipstation.api.sync_errored',
+          shipments: [shipment],
+          error: error,
+        )
+      end
+
+      it 're-raises the error' do
+        stub_const('Spree::Event', class_spy(Spree::Event))
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusShipstation::Api::RequestError.new(
+          response_headers: {},
+          response_body: '{"message":"Internal Server Error"}',
+          response_code: 500,
+        )
+        api_client = instance_double(SolidusShipstation::Api::Client).tap do |client|
+          allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
+        end
+
+        expect {
+          build_batch_syncer(client: api_client).call([shipment])
+        }.to raise_error(error)
+      end
+    end
+  end
+
+  private
+
+  def build_batch_syncer(client:, shipment_matcher: ->(_, shipments) { shipments.first })
+    described_class.new(client: client, shipment_matcher: shipment_matcher)
+  end
+end

data/spec/lib/solidus_shipstation/api/client_spec.rb

@@ -0,0 +1,120 @@
+RSpec.describe SolidusShipstation::Api::Client do
+  describe '.from_config' do
+    it 'generates a client from the configuration' do
+      request_runner = instance_double('SolidusShipstation::Api::RequestRunner')
+      error_handler = instance_spy('Proc')
+      shipment_serializer = instance_spy('SolidusShipstation::Api::Serializer')
+      allow(SolidusShipstation::Api::RequestRunner).to receive(:from_config).and_return(request_runner)
+      allow(SolidusShipstation.config).to receive_messages(
+        error_handler: error_handler,
+        api_shipment_serializer: shipment_serializer,
+      )
+
+      client = described_class.from_config
+
+      expect(client).to have_attributes(
+        request_runner: request_runner,
+        error_handler: error_handler,
+        shipment_serializer: shipment_serializer,
+      )
+    end
+  end
+
+  describe '#bulk_create_orders' do
+    it 'calls the bulk order creation endpoint' do
+      request_runner = instance_spy('SolidusShipstation::Api::RequestRunner')
+      shipment = build_stubbed(:shipment)
+      serialized_shipment = { 'key' => 'value' }
+
+      client = build_client(
+        request_runner: request_runner,
+        shipment_serializer: stub_shipment_serializer(shipment => serialized_shipment),
+      )
+      client.bulk_create_orders([shipment])
+
+      expect(request_runner).to have_received(:call).with(
+        :post,
+        '/orders/createorders',
+        [serialized_shipment],
+      )
+    end
+
+    it 'does not fail for serialization errors' do
+      request_runner = instance_spy('SolidusShipstation::Api::RequestRunner')
+      successful_shipment = build_stubbed(:shipment)
+      serialized_shipment = { 'key' => 'value' }
+      failing_shipment = build_stubbed(:shipment)
+      error = RuntimeError.new('Failed to serialize shipment!')
+
+      client = build_client(
+        request_runner: request_runner,
+        shipment_serializer: stub_shipment_serializer(
+          successful_shipment => serialized_shipment,
+          failing_shipment => error,
+        )
+      )
+      client.bulk_create_orders([failing_shipment, successful_shipment])
+
+      expect(request_runner).to have_received(:call).with(
+        :post,
+        '/orders/createorders',
+        [serialized_shipment],
+      )
+    end
+
+    it 'reports any serialization errors to the error handler' do
+      error_handler = instance_spy('Proc')
+      shipment = build_stubbed(:shipment)
+      error = RuntimeError.new('Failed to serialize shipment!')
+
+      client = build_client(
+        shipment_serializer: stub_shipment_serializer(shipment => error),
+        error_handler: error_handler,
+      )
+      client.bulk_create_orders([shipment])
+
+      expect(error_handler).to have_received(:call).with(error, shipment: shipment)
+    end
+
+    it 'skips the API call if all shipments failed serialization' do
+      request_runner = instance_spy('SolidusShipstation::Api::RequestRunner')
+      failing_shipment = build_stubbed(:shipment)
+
+      client = build_client(
+        shipment_serializer: stub_shipment_serializer(
+          failing_shipment => RuntimeError.new('Failed to serialize shipment!'),
+        ),
+        request_runner: request_runner,
+      )
+      client.bulk_create_orders([failing_shipment])
+
+      expect(request_runner).not_to have_received(:call)
+    end
+  end
+
+  private
+
+  def build_client(options = {})
+    described_class.new({
+      request_runner: instance_spy('SolidusShipstation::Api::RequestRunner'),
+      error_handler: instance_spy('Proc'),
+      shipment_serializer: stub_shipment_serializer,
+    }.merge(options))
+  end
+
+  def stub_shipment_serializer(results_map = {})
+    serializer = class_spy('SolidusShipstation::Api::Serializer')
+
+    results_map.each_pair do |shipment, result_or_error|
+      stub = allow(serializer).to receive(:call).with(shipment)
+
+      if result_or_error.is_a?(Hash)
+        stub.and_return(result_or_error)
+      else
+        stub.and_raise(result_or_error)
+      end
+    end
+
+    serializer
+  end
+end