solidus_bactracs 3.0.0 → 3.1.0

data/spec/jobs/{solidus_backtracs → solidus_bactracs}/api/schedule_shipment_syncs_job_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe SolidusBacktracs::Api::ScheduleShipmentSyncsJob do
+RSpec.describe SolidusBactracs::Api::ScheduleShipmentSyncsJob do
   it 'schedules the shipment sync in batches' do
     stub_configuration(api_batch_size: 2)
     shipments = create_list(:shipment, 3)
@@ -10,20 +10,20 @@ RSpec.describe SolidusBacktracs::Api::ScheduleShipmentSyncsJob do
         .and_yield(shipments[0..1])
         .and_yield([shipments.last])
     end
-    allow(SolidusBacktracs::Shipment::PendingApiSyncQuery).to receive(:apply)
+    allow(SolidusBactracs::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])
+    expect(SolidusBactracs::Api::SyncShipmentsJob).to have_been_enqueued.with(shipments[0..1])
+    expect(SolidusBactracs::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)
+    allow(SolidusBactracs::Shipment::PendingApiSyncQuery).to receive(:apply).and_raise(error)
 
     described_class.perform_now
 

data/spec/jobs/{solidus_backtracs → solidus_bactracs}/api/sync_shipments_job_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob do
+RSpec.describe SolidusBactracs::Api::SyncShipmentsJob do
   include ActiveSupport::Testing::TimeHelpers
 
   context 'when a shipment is syncable' do
@@ -20,7 +20,7 @@ RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob 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(
+            stub_failing_batch_syncer(SolidusBactracs::Api::RateLimitedError.new(
               response_code: 429,
               response_headers: { 'X-Rate-Limit-Reset' => 30 },
               response_body: '{"message":"Too Many Requests"}',
@@ -39,7 +39,7 @@ RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob 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(
+          error = SolidusBactracs::Api::RequestError.new(
             response_code: 500,
             response_headers: {},
             response_body: '{"message":"Internal Server Error"}',
@@ -64,7 +64,7 @@ RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob do
       expect(batch_syncer).not_to have_received(:call)
     end
 
-    it 'fires a solidus_backtracs.api.sync_skipped event' do
+    it 'fires a solidus_bactracs.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
@@ -72,7 +72,7 @@ RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob do
       described_class.perform_now([shipment])
 
       expect(Spree::Event).to have_received(:fire).with(
-        'solidus_backtracs.api.sync_skipped',
+        'solidus_bactracs.api.sync_skipped',
         shipment: shipment,
       )
     end
@@ -81,21 +81,21 @@ RSpec.describe SolidusBacktracs::Api::SyncShipmentsJob do
   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)
+    instance_spy(SolidusBactracs::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusBactracs::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)
+    instance_double(SolidusBactracs::Api::BatchSyncer).tap do |batch_syncer|
+      allow(SolidusBactracs::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)
+    allow(SolidusBactracs::Api::ThresholdVerifier).to receive(:call)
       .with(shipment)
       .and_return(result)
   end

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/batch_syncer_spec.rb

@@ -1,10 +1,10 @@
-RSpec.describe SolidusBacktracs::Api::BatchSyncer do
+RSpec.describe SolidusBactracs::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)
+      client = instance_double(SolidusBactracs::Api::Client)
+      allow(SolidusBactracs::Api::Client).to receive(:from_config).and_return(client)
       shipment_matcher = -> {}
       stub_configuration(api_shipment_matcher: shipment_matcher)
 
@@ -20,10 +20,10 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
   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
+        it 'updates the bactracs 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|
+            api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
               allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
                 {
                   'results' => [
@@ -40,15 +40,15 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
             build_batch_syncer(client: api_client).call([shipment])
 
             expect(shipment).to have_received(:update_columns).with(
-              backtracs_synced_at: Time.zone.now,
+              bactracs_synced_at: Time.zone.now,
             )
           end
         end
 
-        it 'emits a solidus_backtracs.api.sync_completed event' do
+        it 'emits a solidus_bactracs.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|
+          api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
             allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
               {
                 'results' => [
@@ -65,7 +65,7 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
           build_batch_syncer(client: api_client).call([shipment])
 
           expect(Spree::Event).to have_received(:fire).with(
-            'solidus_backtracs.api.sync_completed',
+            'solidus_bactracs.api.sync_completed',
             shipment: shipment,
             payload: {
               'orderNumber' => shipment.number,
@@ -77,9 +77,9 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
       end
 
       context 'when the sync operation failed' do
-        it 'does not update the backtracs data on the shipment' do
+        it 'does not update the bactracs data on the shipment' do
           shipment = instance_spy('Spree::Shipment', number: 'H123456')
-          api_client = instance_double(SolidusBacktracs::Api::Client).tap do |client|
+          api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
             allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
               {
                 'results' => [
@@ -98,10 +98,10 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
           expect(shipment).not_to have_received(:update_columns)
         end
 
-        it 'emits a solidus_backtracs.api.sync_failed event' do
+        it 'emits a solidus_bactracs.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|
+          api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
             allow(client).to receive(:bulk_create_orders).with([shipment]).and_return(
               {
                 'results' => [
@@ -118,7 +118,7 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
           build_batch_syncer(client: api_client).call([shipment])
 
           expect(Spree::Event).to have_received(:fire).with(
-            'solidus_backtracs.api.sync_failed',
+            'solidus_bactracs.api.sync_failed',
             shipment: shipment,
             payload: {
               'orderNumber' => shipment.number,
@@ -131,27 +131,27 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
     end
 
     context 'when the API call hits a rate limit' do
-      it 'emits a solidus_backtracs.api.rate_limited event' do
+      it 'emits a solidus_bactracs.api.rate_limited event' do
         stub_const('Spree::Event', class_spy(Spree::Event))
         shipment = instance_double('Spree::Shipment')
-        error = SolidusBacktracs::Api::RateLimitedError.new(
+        error = SolidusBactracs::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|
+        api_client = instance_double(SolidusBactracs::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
+        rescue SolidusBactracs::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',
+          'solidus_bactracs.api.rate_limited',
           shipments: [shipment],
           error: error,
         )
@@ -159,13 +159,13 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
 
       it 're-raises the error' do
         shipment = instance_double('Spree::Shipment')
-        error = SolidusBacktracs::Api::RateLimitedError.new(
+        error = SolidusBactracs::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|
+        api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
           allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
         end
 
@@ -176,26 +176,26 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
     end
 
     context 'when the API call results in a server error' do
-      it 'emits a solidus_backtracs.api.sync_errored event' do
+      it 'emits a solidus_bactracs.api.sync_errored event' do
         stub_const('Spree::Event', class_spy(Spree::Event))
         shipment = instance_double('Spree::Shipment')
-        error = SolidusBacktracs::Api::RequestError.new(
+        error = SolidusBactracs::Api::RequestError.new(
           response_headers: {},
           response_body: '{"message":"Internal Server Error"}',
           response_code: 500,
         )
-        api_client = instance_double(SolidusBacktracs::Api::Client).tap do |client|
+        api_client = instance_double(SolidusBactracs::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
+        rescue SolidusBactracs::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',
+          'solidus_bactracs.api.sync_errored',
           shipments: [shipment],
           error: error,
         )
@@ -204,12 +204,12 @@ RSpec.describe SolidusBacktracs::Api::BatchSyncer do
       it 're-raises the error' do
         stub_const('Spree::Event', class_spy(Spree::Event))
         shipment = instance_double('Spree::Shipment')
-        error = SolidusBacktracs::Api::RequestError.new(
+        error = SolidusBactracs::Api::RequestError.new(
           response_headers: {},
           response_body: '{"message":"Internal Server Error"}',
           response_code: 500,
         )
-        api_client = instance_double(SolidusBacktracs::Api::Client).tap do |client|
+        api_client = instance_double(SolidusBactracs::Api::Client).tap do |client|
           allow(client).to receive(:bulk_create_orders).with([shipment]).and_raise(error)
         end
 

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/client_spec.rb

@@ -1,11 +1,11 @@
-RSpec.describe SolidusBacktracs::Api::Client do
+RSpec.describe SolidusBactracs::Api::Client do
   describe '.from_config' do
     it 'generates a client from the configuration' do
-      request_runner = instance_double('SolidusBacktracs::Api::RequestRunner')
+      request_runner = instance_double('SolidusBactracs::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(
+      shipment_serializer = instance_spy('SolidusBactracs::Api::Serializer')
+      allow(SolidusBactracs::Api::RequestRunner).to receive(:from_config).and_return(request_runner)
+      allow(SolidusBactracs.config).to receive_messages(
         error_handler: error_handler,
         api_shipment_serializer: shipment_serializer,
       )
@@ -22,7 +22,7 @@ RSpec.describe SolidusBacktracs::Api::Client do
 
   describe '#bulk_create_orders' do
     it 'calls the bulk order creation endpoint' do
-      request_runner = instance_spy('SolidusBacktracs::Api::RequestRunner')
+      request_runner = instance_spy('SolidusBactracs::Api::RequestRunner')
       shipment = build_stubbed(:shipment)
       serialized_shipment = { 'key' => 'value' }
 
@@ -40,7 +40,7 @@ RSpec.describe SolidusBacktracs::Api::Client do
     end
 
     it 'does not fail for serialization errors' do
-      request_runner = instance_spy('SolidusBacktracs::Api::RequestRunner')
+      request_runner = instance_spy('SolidusBactracs::Api::RequestRunner')
       successful_shipment = build_stubbed(:shipment)
       serialized_shipment = { 'key' => 'value' }
       failing_shipment = build_stubbed(:shipment)
@@ -77,7 +77,7 @@ RSpec.describe SolidusBacktracs::Api::Client do
     end
 
     it 'skips the API call if all shipments failed serialization' do
-      request_runner = instance_spy('SolidusBacktracs::Api::RequestRunner')
+      request_runner = instance_spy('SolidusBactracs::Api::RequestRunner')
       failing_shipment = build_stubbed(:shipment)
 
       client = build_client(
@@ -96,14 +96,14 @@ RSpec.describe SolidusBacktracs::Api::Client do
 
   def build_client(options = {})
     described_class.new(**{
-      request_runner: instance_spy('SolidusBacktracs::Api::RequestRunner'),
+      request_runner: instance_spy('SolidusBactracs::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')
+    serializer = class_spy('SolidusBactracs::Api::Serializer')
 
     results_map.each_pair do |shipment, result_or_error|
       stub = allow(serializer).to receive(:call).with(shipment)

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/rate_limited_error_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Api::RateLimitedError do
+RSpec.describe SolidusBactracs::Api::RateLimitedError do
   describe '.from_response' do
     it 'extracts the status code, body, headers and retry time from the response' do
       response = instance_double(

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/request_error_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Api::RequestError do
+RSpec.describe SolidusBactracs::Api::RequestError do
   describe '.from_response' do
     it 'extracts the status code, body and headers from the response' do
       response = instance_double(

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/request_runner_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Api::RequestRunner do
+RSpec.describe SolidusBactracs::Api::RequestRunner do
   #TODO
   describe '.from_config' do
     it 'builds a runner using credentials from the configuration' do
@@ -43,7 +43,7 @@ RSpec.describe SolidusBacktracs::Api::RequestRunner do
 
         expect {
           request_runner.call(:post, '/test')
-        }.to raise_error(SolidusBacktracs::Api::RateLimitedError)
+        }.to raise_error(SolidusBactracs::Api::RateLimitedError)
       end
     end
 
@@ -58,7 +58,7 @@ RSpec.describe SolidusBacktracs::Api::RequestRunner do
 
         expect {
           request_runner.call(:post, '/test')
-        }.to raise_error(SolidusBacktracs::Api::RequestError)
+        }.to raise_error(SolidusBactracs::Api::RequestError)
       end
     end
   end

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/shipment_serializer_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Api::ShipmentSerializer do
+RSpec.describe SolidusBactracs::Api::ShipmentSerializer do
   describe '#call' do
     it 'serializes the shipment' do
       shipment = create(:order_ready_to_ship).shipments.first

data/spec/lib/{solidus_backtracs → solidus_bactracs}/api/threshold_verifier_spec.rb

@@ -1,7 +1,7 @@
-RSpec.describe SolidusBacktracs::Api::ThresholdVerifier do
+RSpec.describe SolidusBactracs::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
+    context 'when the shipment was never synced with Bactracs yet' do
+      it 'returns true when the shipment was never synced with bactracs yet' do
         stub_configuration(api_sync_threshold: 10.minutes)
         shipment = create(:order_ready_to_ship).shipments.first
 
@@ -18,22 +18,22 @@ RSpec.describe SolidusBacktracs::Api::ThresholdVerifier do
       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
+    context 'when the shipment was already synced with Bactracs' do
+      it 'returns true when the shipment is pending a Bactracs 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)
+          s.update_columns(bactracs_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
+      it 'returns false when the shipment is up-to-date in Bactracs' 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)
+          s.update_columns(bactracs_synced_at: 5.minutes.ago)
         end
 
         expect(described_class.call(shipment)).to eq(false)
@@ -43,7 +43,7 @@ RSpec.describe SolidusBacktracs::Api::ThresholdVerifier 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)
+          s.update_columns(bactracs_synced_at: 12.minutes.ago)
         end
 
         expect(described_class.call(shipment)).to eq(false)

data/spec/lib/{solidus_backtracs → solidus_bactracs}/shipment_notice_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe SolidusBacktracs::ShipmentNotice do
+RSpec.describe SolidusBactracs::ShipmentNotice do
   shared_examples 'ships or updates the shipment' do
     context 'when the order was not shipped yet' do
       # rubocop:disable RSpec/MultipleExpectations
@@ -60,7 +60,7 @@ RSpec.describe SolidusBacktracs::ShipmentNotice do
 
           shipment_notice = build_shipment_notice(order.shipments.first)
 
-          expect { shipment_notice.apply }.to raise_error(SolidusBacktracs::PaymentError) do |e|
+          expect { shipment_notice.apply }.to raise_error(SolidusBactracs::PaymentError) do |e|
             expect(e.cause).to be_instance_of(Spree::Core::GatewayError)
           end
         end
@@ -84,7 +84,7 @@ RSpec.describe SolidusBacktracs::ShipmentNotice do
 
         shipment_notice = build_shipment_notice(order.shipments.first)
 
-        expect { shipment_notice.apply }.to raise_error(SolidusBacktracs::OrderNotPaidError)
+        expect { shipment_notice.apply }.to raise_error(SolidusBactracs::OrderNotPaidError)
       end
     end
   end
@@ -103,7 +103,7 @@ RSpec.describe SolidusBacktracs::ShipmentNotice do
   end
 
   def build_shipment_notice(shipment, shipment_tracking: '1Z1231234')
-    SolidusBacktracs::ShipmentNotice.new(
+    SolidusBactracs::ShipmentNotice.new(
       shipment_number: shipment.number,
       shipment_tracking: shipment_tracking,
     )

data/spec/lib/solidus_bactracs_spec.rb

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

data/spec/models/spree/shipment_spec.rb

@@ -4,7 +4,7 @@ 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(
+      allow(SolidusBactracs::Shipment::BetweenQuery).to receive(:apply).with(
         any_args,
         from: Time.zone.yesterday,
         to: Time.zone.today,
@@ -29,7 +29,7 @@ RSpec.describe Spree::Shipment do
   describe '.exportable' do
     it 'delegates to ExportableQuery' do
       shipment = build_stubbed(:shipment)
-      allow(SolidusBacktracs::Shipment::ExportableQuery).to receive(:apply).and_return([shipment])
+      allow(SolidusBactracs::Shipment::ExportableQuery).to receive(:apply).and_return([shipment])
 
       result = Spree::Deprecation.silence do
         described_class.exportable

data/spec/queries/{solidus_backtracs → solidus_bactracs}/shipment/between_query_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Shipment::BetweenQuery do
+RSpec.describe SolidusBactracs::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) }

data/spec/queries/{solidus_backtracs → solidus_bactracs}/shipment/exportable_query_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Shipment::ExportableQuery do
+RSpec.describe SolidusBactracs::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

data/spec/queries/{solidus_backtracs → solidus_bactracs}/shipment/pending_api_sync_query_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe SolidusBacktracs::Shipment::PendingApiSyncQuery do
+RSpec.describe SolidusBactracs::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
@@ -19,15 +19,15 @@ RSpec.describe SolidusBacktracs::Shipment::PendingApiSyncQuery 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(backtracs_synced_at: 8.minutes.ago)
+          s.update_columns(bactracs_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(backtracs_synced_at: 8.minutes.ago)
+          s.update_columns(bactracs_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(backtracs_synced_at: 10.minutes.ago)
+          s.update_columns(bactracs_synced_at: 10.minutes.ago)
         end
 
         expect(described_class.apply(Spree::Shipment.all)).to match_array([shipment])

data/spec/spec_helper.rb

@@ -18,8 +18,8 @@ require 'solidus_dev_support/rspec/feature_helper'
 # 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)
+# Requires factories defined in lib/solidus_bactracs/testing_support/factories.rb
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusBactracs::Engine)
 
 RSpec.configure do |config|
   config.infer_spec_type_from_file_location!

data/spec/support/configuration_helper.rb

@@ -1,6 +1,6 @@
 module ConfigurationHelper
   def stub_configuration(options)
-    allow(SolidusBacktracs.configuration).to receive_messages(options)
+    allow(SolidusBactracs.configuration).to receive_messages(options)
 
     if options[:capture_at_notification]
       stub_spree_preferences(require_payment_to_ship: false)