solidus_backtracs 2.2.0

data/spec/fixtures/backtracs_xml_schema.xsd

@@ -0,0 +1,171 @@
+<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="Orders">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="Order" maxOccurs="unbounded" minOccurs="0">
+          <xs:complexType>
+            <xs:all>
+              <xs:element type="String50" name="OrderID" minOccurs="0"/>
+              <xs:element type="String50" name="OrderNumber"/>
+              <xs:element type="DateTime" name="OrderDate"/>
+              <xs:element type="String50" name="OrderStatus"/>
+              <xs:element type="DateTime" name="LastModified"/>
+              <xs:element type="String100" name="ShippingMethod" minOccurs="0"/>
+              <xs:element type="String50" name="PaymentMethod" minOccurs="0"/>
+              <xs:element type="xs:float" name="OrderTotal"/>
+              <xs:element type="xs:float" name="TaxAmount" minOccurs="0"/>
+              <xs:element type="xs:float" name="ShippingAmount" minOccurs="0"/>
+              <xs:element type="String1000" name="CustomerNotes" minOccurs="0"/>
+              <xs:element type="String1000" name="InternalNotes" minOccurs="0"/>
+              <xs:element type="xs:boolean" name="Gift" minOccurs="0"/>
+              <xs:element type="String1000" name="GiftMessage" minOccurs="0"/>
+              <xs:element type="String100" name="CustomField1" minOccurs="0"/>
+              <xs:element type="String100" name="CustomField2" minOccurs="0"/>
+              <xs:element type="String100" name="CustomField3" minOccurs="0"/>
+              <xs:element type="String100" name="RequestedWarehouse" minOccurs="0"/>
+              <xs:element type="String50" name="Source" minOccurs="0" />
+              <xs:element name="Customer">
+                <xs:complexType>
+                  <xs:all>
+                    <xs:element type="String100" name="CustomerCode"/>
+                    <xs:element name="BillTo">
+                      <xs:complexType>
+                        <xs:all>
+                           <xs:element type="String100" name="Name"/>
+                           <xs:element type="String100" name="Company" minOccurs="0"/>
+                           <xs:element type="String50" name="Phone" minOccurs="0"/>
+                           <xs:element type="Email" name="Email" minOccurs="0"/>
+                            <xs:element type="String200" name="Address1" minOccurs="0"/>
+                           <xs:element type="String200" name="Address2" minOccurs="0"/>
+                           <xs:element type="String100" name="City" minOccurs="0"/>
+                           <xs:element type="String100" name="State" minOccurs="0"/>
+                           <xs:element type="String50" name="PostalCode" minOccurs="0"/>
+<xs:element type="StringExactly2" name="Country" minOccurs="0"/>
+                        </xs:all>
+                      </xs:complexType>
+                    </xs:element>
+                    <xs:element name="ShipTo">
+                      <xs:complexType>
+                        <xs:all>
+                          <xs:element type="String100" name="Name"/>
+                          <xs:element type="String100" name="Company" minOccurs="0"/>
+                          <xs:element type="String200" name="Address1"/>
+                          <xs:element type="String200" name="Address2" minOccurs="0"/>
+                          <xs:element type="String100" name="City"/>
+                          <xs:element type="String100" name="State" minOccurs="0"/>
+                          <xs:element type="String50" name="PostalCode" minOccurs="1"/>
+                          <xs:element type="StringExactly2" name="Country"/>
+                          <xs:element type="String50" name="Phone" minOccurs="0"/>
+                        </xs:all>
+                      </xs:complexType>
+                    </xs:element>
+                  </xs:all>
+                </xs:complexType>
+              </xs:element>
+              <xs:element name="Items">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:element name="Item" maxOccurs="unbounded" minOccurs="0">
+                      <xs:complexType>
+                        <xs:all>
+                          <xs:element type="String50" name="LineItemID" minOccurs="0"/>
+                          <xs:element type="String100" name="SKU"/>
+                          <xs:element type="String200" name="Name"/>
+                          <xs:element type="xs:boolean" name="Adjustment" minOccurs="0"/>
+                          <xs:element type="xs:anyURI" name="ImageUrl" minOccurs="0"/>
+                          <xs:element type="xs:float" name="Weight" minOccurs="0"/>
+                          <xs:element name="WeightUnits" minOccurs="0">
+                            <xs:simpleType>
+                              <xs:restriction base="xs:string">
+                                <xs:pattern value="|pound|pounds|lb|lbs|gram|grams|gm|oz|ounces|Pound|Pounds|Lb|Lbs|Gram|Grams|Gm|Oz|Ounces|POUND|POUNDS|LB|LBS|GRAM|GRAMS|GM|OZ|OUNCES"/>
+                              </xs:restriction>
+                            </xs:simpleType>
+                          </xs:element>
+                          <xs:element name="Dimensions" minOccurs="0">
+                            <xs:complexType>
+                              <xs:all>
+                                <xs:element name="DimensionUnits" minOccurs="0">
+                                  <xs:simpleType>
+                                    <xs:restriction base="xs:string">
+                                      <xs:pattern value="|inch|inches|in|centimeter|centimeters|cm|INCH|INCHES|IN|CENTIMETER|CENTIMETERS|CM"/>
+                                    </xs:restriction>
+                                  </xs:simpleType>
+                                </xs:element>
+                                <xs:element type="xs:float" name="Length"/>
+                                <xs:element type="xs:float" name="Width"/>
+                                <xs:element type="xs:float" name="Height"/>
+                              </xs:all>
+                            </xs:complexType>
+                          </xs:element>
+                          <xs:element type="xs:int" name="Quantity"/>
+                          <xs:element type="xs:float" name="UnitPrice"/>
+                          <xs:element type="String100" name="Location" minOccurs="0"/>
+                          <xs:element name="Options" minOccurs="0">
+                            <xs:complexType>
+                              <xs:sequence>
+                                <xs:element name="Option" maxOccurs="100" minOccurs="0">
+                                  <xs:complexType>
+                                    <xs:all>
+                                      <xs:element type="String100" name="Name"/>
+                                      <xs:element type="String100" name="Value"/>
+                                      <xs:element type="xs:float" name="Weight" minOccurs="0"/>
+                                    </xs:all>
+                                  </xs:complexType>
+                                </xs:element>
+                              </xs:sequence>
+                            </xs:complexType>
+                          </xs:element>
+                        </xs:all>
+                      </xs:complexType>
+                    </xs:element>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+            </xs:all>
+          </xs:complexType>
+        </xs:element>
+      </xs:sequence>
+      <xs:attribute type="xs:short" name="pages"/>
+    </xs:complexType>
+  </xs:element>
+  <xs:simpleType name="DateTime">
+    <xs:restriction base="xs:string">
+      <xs:pattern value="[0-9][0-9]?/[0-9][0-9]?/[0-9][0-9][0-9]?[0-9]? [0-9][0-9]?:[0-9][0-9]?:?[0-9]?[0-9]?. ?[aApP]?[mM]?"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="Email">
+    <xs:restriction base="xs:string">
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="StringExactly2">
+    <xs:restriction base="xs:string">
+      <xs:minLength value="2"/>
+      <xs:maxLength value="2"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="String30">
+    <xs:restriction base="xs:string">
+      <xs:maxLength value="30"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="String50">
+    <xs:restriction base="xs:string">
+      <xs:maxLength value="50"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="String100">
+    <xs:restriction base="xs:string">
+      <xs:maxLength value="100"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="String200">
+    <xs:restriction base="xs:string">
+      <xs:maxLength value="200"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:simpleType name="String1000">
+    <xs:restriction base="xs:string">
+      <xs:maxLength value="1000"/>
+    </xs:restriction>
+  </xs:simpleType>
+</xs:schema>

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusBacktracs::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(SolidusBacktracs::Shipment::PendingApiSyncQuery).to receive(:apply)
+      .and_return(relation)
+
+    described_class.perform_now
+
+    expect(SolidusBacktracs::Api::SyncShipmentsJob).to have_been_enqueued.with(shipments[0..1])
+    expect(SolidusBacktracs::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(SolidusBacktracs::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_backtracs/api/sync_shipments_job_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusBacktracs::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(SolidusBacktracs::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 = SolidusBacktracs::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_backtracs.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_backtracs.api.sync_skipped',
+        shipment: shipment,
+      )
+    end
+  end
+
+  private
+
+  def stub_successful_batch_syncer
+    instance_spy(SolidusBacktracs::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusBacktracs::Api::BatchSyncer).to receive(:from_config).and_return(batch_syncer)
+    end
+  end
+
+  def stub_failing_batch_syncer(error)
+    instance_double(SolidusBacktracs::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusBacktracs::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(SolidusBacktracs::Api::ThresholdVerifier).to receive(:call)
+      .with(shipment)
+      .and_return(result)
+  end
+end

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

@@ -0,0 +1,228 @@
+RSpec.describe SolidusBacktracs::Api::BatchSyncer do
+  include ActiveSupport::Testing::TimeHelpers
+
+  describe '.from_config' do
+    it 'creates a syncer with the configured API client' do
+      client = instance_double(SolidusBacktracs::Api::Client)
+      allow(SolidusBacktracs::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 backtracs data on the shipment' do
+          freeze_time do
+            shipment = instance_spy('Spree::Shipment', number: 'H123456')
+            api_client = instance_double(SolidusBacktracs::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(
+              backtracs_synced_at: Time.zone.now,
+            )
+          end
+        end
+
+        it 'emits a solidus_backtracs.api.sync_completed event' do
+          stub_const('Spree::Event', class_spy(Spree::Event))
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusBacktracs::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_backtracs.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 backtracs data on the shipment' do
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusBacktracs::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_backtracs.api.sync_failed event' do
+          stub_const('Spree::Event', class_spy(Spree::Event))
+          shipment = instance_spy('Spree::Shipment', number: 'H123456')
+          api_client = instance_double(SolidusBacktracs::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_backtracs.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_backtracs.api.rate_limited event' do
+        stub_const('Spree::Event', class_spy(Spree::Event))
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusBacktracs::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(SolidusBacktracs::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 SolidusBacktracs::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_backtracs.api.rate_limited',
+          shipments: [shipment],
+          error: error,
+        )
+      end
+
+      it 're-raises the error' do
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusBacktracs::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(SolidusBacktracs::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_backtracs.api.sync_errored event' do
+        stub_const('Spree::Event', class_spy(Spree::Event))
+        shipment = instance_double('Spree::Shipment')
+        error = SolidusBacktracs::Api::RequestError.new(
+          response_headers: {},
+          response_body: '{"message":"Internal Server Error"}',
+          response_code: 500,
+        )
+        api_client = instance_double(SolidusBacktracs::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 SolidusBacktracs::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_backtracs.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 = SolidusBacktracs::Api::RequestError.new(
+          response_headers: {},
+          response_body: '{"message":"Internal Server Error"}',
+          response_code: 500,
+        )
+        api_client = instance_double(SolidusBacktracs::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_backtracs/api/client_spec.rb

@@ -0,0 +1,120 @@
+RSpec.describe SolidusBacktracs::Api::Client do
+  describe '.from_config' do
+    it 'generates a client from the configuration' do
+      request_runner = instance_double('SolidusBacktracs::Api::RequestRunner')
+      error_handler = instance_spy('Proc')
+      shipment_serializer = instance_spy('SolidusBacktracs::Api::Serializer')
+      allow(SolidusBacktracs::Api::RequestRunner).to receive(:from_config).and_return(request_runner)
+      allow(SolidusBacktracs.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('SolidusBacktracs::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('SolidusBacktracs::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('SolidusBacktracs::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('SolidusBacktracs::Api::RequestRunner'),
+      error_handler: instance_spy('Proc'),
+      shipment_serializer: stub_shipment_serializer,
+    }.merge(options))
+  end
+
+  def stub_shipment_serializer(results_map = {})
+    serializer = class_spy('SolidusBacktracs::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

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

@@ -0,0 +1,21 @@
+RSpec.describe SolidusBacktracs::Api::RateLimitedError do
+  describe '.from_response' do
+    it 'extracts the status code, body, headers and retry time from the response' do
+      response = instance_double(
+        'HTTParty::Response',
+        code: 429,
+        headers: { 'X-Rate-Limit-Reset' => 20 },
+        body: '{ "message": "Too Many Requests" }',
+      )
+
+      error = described_class.from_response(response)
+
+      expect(error).to have_attributes(
+        response_code: 429,
+        response_headers: { 'X-Rate-Limit-Reset' => 20 },
+        response_body: '{ "message": "Too Many Requests" }',
+        retry_in: 20.seconds,
+      )
+    end
+  end
+end