knapsack_pro 8.0.2 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6135451be036cbd75b78cb5efd31498b91b08698771c78c69dfa7b2b1d218faa
-  data.tar.gz: bd73f2525bc9b89c5faca60bf95249d06e525fb533422b8e98399b03dcf732bf
+  metadata.gz: 9392d6bfe6377c70af5278f4b527314194c5516f5693badc4255d46c989de2c6
+  data.tar.gz: 559425cde606e2dc159912dd3facf07467c5fa1ac507fced6734c0b655f246bf
 SHA512:
-  metadata.gz: 3cca977135a8795f725cd2ee73ae5c8af2df313db76892a9e29e283fc788f0c7479dff1e8aed532fb43a1ac56cb4582200dda0af1e953426c571fb177eb2ad2f
-  data.tar.gz: 00bb2a047303b2e11eb06f1f0f358dd209a1d98cb01657b4c8144a7f137efc5cb7aa44e736e6f4925642975afb83b576c2e9a0039233b389a196180ca0a194d3
+  metadata.gz: 35a9edadc691088d01e48fdde8f496d9ed1bebb49d9dff50ffe9887c0238a5bf4b5c4289fcfcc024afd9921b53a8c5a28500ae2a00d0ca860f6ad2bfdae81de4
+  data.tar.gz: edeea08e31dfe17e0d614922665f93e76e0adbbf8564e56ef0d1f751bb38355e9e3b6f2bbd98d4f2d0ffb6a3ad417318497a150087723cf193b2f4e01f215e9f

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
-### Unreleased
+### 8.1.0
+
+* Improve the performance of the [RSpec split by test examples](https://docs.knapsackpro.com/ruby/split-by-test-examples/).
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/292
+
+    * Reduce `/v1/build_distributions/last` API requests.
+    * (Queue Mode) Improve the speed of starting tests for CI nodes that are started after the queue was already initialized by another CI node.
+    * (Regular Mode) Improve the speed of starting tests for CI nodes that are started after the test suite split was already initialized by another CI node.
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v8.0.2...v8.1.0
 
 ### 8.0.2
 

data/lib/knapsack_pro/base_allocator_builder.rb

@@ -23,28 +23,8 @@ module KnapsackPro
       KnapsackPro::Config::Env.test_dir || TestFilePattern.test_dir(adapter_class)
     end
 
-    # In Fallback Mode, we always want to run whole test files (not split by
-    # test cases) to guarantee that each test will be executed at least once
-    # across parallel CI nodes.
-    def fallback_mode_test_files
-      all_test_files_to_run
-    end
-
-    # Detect test files present on the disk that should be run.
-    # This may include fast test files + slow test files split by test cases.
-    def fast_and_slow_test_files_to_run
-      test_files_to_run = all_test_files_to_run
-
-      if adapter_class.split_by_test_cases_enabled?
-        slow_test_files = get_slow_test_files
-        return test_files_to_run if slow_test_files.empty?
-
-        test_file_cases = adapter_class.test_file_cases_for(slow_test_files)
-
-        return KnapsackPro::TestFilesWithTestCasesComposer.call(test_files_to_run, slow_test_files, test_file_cases)
-      end
-
-      test_files_to_run
+    def test_suite
+      KnapsackPro::TestSuite.new(adapter_class)
     end
 
     private
@@ -58,29 +38,5 @@ module KnapsackPro
     def repository_adapter
       KnapsackPro::RepositoryAdapterInitiator.call
     end
-
-    def test_file_pattern
-      TestFilePattern.call(adapter_class)
-    end
-
-    def all_test_files_to_run
-      KnapsackPro::TestFileFinder.call(test_file_pattern)
-    end
-
-    def slow_test_file_pattern
-      KnapsackPro::Config::Env.slow_test_file_pattern
-    end
-
-    def get_slow_test_files
-      slow_test_files =
-        if slow_test_file_pattern
-          KnapsackPro::TestFileFinder.slow_test_files_by_pattern(adapter_class)
-        else
-          # get slow test files from API and ensure they exist on disk
-          KnapsackPro::SlowTestFileFinder.call(adapter_class)
-        end
-      KnapsackPro.logger.debug("Detected #{slow_test_files.size} slow test files: #{slow_test_files.inspect}")
-      slow_test_files
-    end
   end
 end

data/lib/knapsack_pro/crypto/decryptor.rb

@@ -5,13 +5,10 @@ module KnapsackPro
     class Decryptor
       class TooManyEncryptedTestFilesError < StandardError; end
 
-      def self.call(test_files, encrypted_test_files)
-        if KnapsackPro::Config::Env.test_files_encrypted?
-          new(test_files, encrypted_test_files).call
-        else
-          # those test files are not encrypted
-          encrypted_test_files
-        end
+      def self.call(test_suite, test_files)
+        return test_files unless KnapsackPro::Config::Env.test_files_encrypted?
+
+        new(test_suite.calculate_test_files.test_files, test_files).call
       end
 
       def initialize(test_files, encrypted_test_files)

data/lib/knapsack_pro/queue_allocator.rb

@@ -4,72 +4,87 @@ module KnapsackPro
   class QueueAllocator
     FallbackModeError = Class.new(StandardError)
 
+    class Batch
+      def initialize(connection, response)
+        @connection = connection
+        @response = response
+
+        raise ArgumentError.new(connection.response) if connection.errors?
+      end
+
+      def queue_exists?
+        raise "Connection failed. Please report this as a bug: #{KnapsackPro::Urls::SUPPORT}" if connection_failed?
+        return false if connection.api_code == KnapsackPro::Client::API::V1::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
+
+        true
+      end
+
+      def connection_failed?
+        !connection.success?
+      end
+
+      def test_files
+        response.fetch('test_files')
+      end
+
+      private
+
+      attr_reader :connection, :response
+    end
+
     def initialize(args)
-      @fast_and_slow_test_files_to_run = args.fetch(:fast_and_slow_test_files_to_run)
-      @fallback_mode_test_files = args.fetch(:fallback_mode_test_files)
+      @test_suite = args.fetch(:test_suite)
       @ci_node_total = args.fetch(:ci_node_total)
       @ci_node_index = args.fetch(:ci_node_index)
       @ci_node_build_id = args.fetch(:ci_node_build_id)
       @repository_adapter = args.fetch(:repository_adapter)
+      @fallback_mode = false
     end
 
     def test_file_paths(can_initialize_queue, executed_test_files)
-      return [] if @fallback_activated
-      action = build_action(can_initialize_queue, attempt_connect_to_queue: can_initialize_queue)
-      connection = KnapsackPro::Client::Connection.new(action)
-      response = connection.call
+      return [] if @fallback_mode
 
-      # when attempt to connect to existing queue on API side failed because queue does not exist yet
-      if can_initialize_queue && connection.success? && connection.api_code == KnapsackPro::Client::API::V1::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
-        # make attempt to initalize a new queue on API side
-        action = build_action(can_initialize_queue, attempt_connect_to_queue: false)
-        connection = KnapsackPro::Client::Connection.new(action)
-        response = connection.call
-      end
+      batch = pull_tests_from_queue(can_initialize_queue)
 
-      if connection.success?
-        raise ArgumentError.new(response) if connection.errors?
-        prepare_test_files(response)
-      elsif !KnapsackPro::Config::Env.fallback_mode_enabled?
-        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
-        KnapsackPro.logger.error(message)
-        raise FallbackModeError.new(message)
-      elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
-        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
-        unless KnapsackPro::Config::Env.fixed_queue_split?
-          message += " Please ensure you have set KNAPSACK_PRO_FIXED_QUEUE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}"
-        end
-        KnapsackPro.logger.error(message)
-        raise FallbackModeError.new(message)
-      else
-        @fallback_activated = true
-        KnapsackPro.logger.warn("Fallback mode started. We could not connect with Knapsack Pro API. Your tests will be executed based on directory names. If other CI nodes were able to connect with Knapsack Pro API then you may notice that some of the test files will be executed twice across CI nodes. The most important thing is to guarantee each of test files is run at least once! Read more about fallback mode at #{KnapsackPro::Urls::FALLBACK_MODE}")
-        fallback_test_files(executed_test_files)
-      end
+      return switch_to_fallback_mode(executed_test_files: executed_test_files) if batch.connection_failed?
+      return normalize_test_files(batch.test_files) if batch.queue_exists?
+
+      test_files_result = test_suite.calculate_test_files
+
+      return try_initializing_queue(test_files_result.test_files) if test_files_result.quick?
+
+      # The tests to run were found slowly. By that time, the queue could have already been initialized by another CI node.
+      # Attempt to pull tests from the queue to avoid the attempt to initialize the queue unnecessarily (queue initialization is an expensive request with a big test files payload).
+      batch = pull_tests_from_queue(can_initialize_queue)
+
+      return switch_to_fallback_mode(executed_test_files: executed_test_files) if batch.connection_failed?
+      return normalize_test_files(batch.test_files) if batch.queue_exists?
+
+      try_initializing_queue(test_files_result.test_files)
     end
 
     private
 
-    attr_reader :fast_and_slow_test_files_to_run,
-      :fallback_mode_test_files,
+    attr_reader :test_suite,
       :ci_node_total,
       :ci_node_index,
       :ci_node_build_id,
       :repository_adapter
 
-    def encrypted_test_files
-      KnapsackPro::Crypto::Encryptor.call(fast_and_slow_test_files_to_run)
-    end
-
     def encrypted_branch
       KnapsackPro::Crypto::BranchEncryptor.call(repository_adapter.branch)
     end
 
-    def build_action(can_initialize_queue, attempt_connect_to_queue:)
-      test_files =
-        if can_initialize_queue && !attempt_connect_to_queue
-          encrypted_test_files
-        end
+    def normalize_test_files(test_files)
+      decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(test_suite, test_files)
+      KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+    end
+
+    def build_action(can_initialize_queue:, attempt_connect_to_queue:, test_files: nil)
+      if can_initialize_queue && !attempt_connect_to_queue
+        raise 'Test files are required when initializing a new queue.' if test_files.nil?
+        test_files = KnapsackPro::Crypto::Encryptor.call(test_files)
+      end
 
       KnapsackPro::Client::API::V1::Queues.queue(
         can_initialize_queue: can_initialize_queue,
@@ -83,13 +98,50 @@ module KnapsackPro
       )
     end
 
-    def prepare_test_files(response)
-      decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(fast_and_slow_test_files_to_run, response['test_files'])
-      KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+    def pull_tests_from_queue(can_initialize_queue)
+      action = build_action(can_initialize_queue: can_initialize_queue, attempt_connect_to_queue: can_initialize_queue)
+      connection = KnapsackPro::Client::Connection.new(action)
+      response = connection.call
+      Batch.new(connection, response)
+    end
+
+    def initialize_queue(tests_to_run)
+      action = build_action(can_initialize_queue: true, attempt_connect_to_queue: false, test_files: tests_to_run)
+      connection = KnapsackPro::Client::Connection.new(action)
+      response = connection.call
+      Batch.new(connection, response)
+    end
+
+    def try_initializing_queue(tests)
+      result = initialize_queue(tests)
+
+      return switch_to_fallback_mode(executed_test_files: []) if result.connection_failed?
+
+      normalize_test_files(result.test_files)
+    end
+
+    def switch_to_fallback_mode(executed_test_files:)
+      @fallback_mode = true
+
+      if !KnapsackPro::Config::Env.fallback_mode_enabled?
+        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
+        KnapsackPro.logger.error(message)
+        raise FallbackModeError.new(message)
+      elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
+        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
+        unless KnapsackPro::Config::Env.fixed_queue_split?
+          message += " Please ensure you have set KNAPSACK_PRO_FIXED_QUEUE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}"
+        end
+        KnapsackPro.logger.error(message)
+        raise FallbackModeError.new(message)
+      else
+        KnapsackPro.logger.warn("Fallback mode started. We could not connect with Knapsack Pro API. Your tests will be executed based on directory names. If other CI nodes were able to connect with Knapsack Pro API then you may notice that some of the test files will be executed twice across CI nodes. The most important thing is to guarantee each of test files is run at least once! Read more about fallback mode at #{KnapsackPro::Urls::FALLBACK_MODE}")
+        fallback_test_files(executed_test_files)
+      end
     end
 
     def fallback_test_files(executed_test_files)
-      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(fallback_mode_test_files, ci_node_total)
+      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(test_suite.fallback_test_files, ci_node_total)
       test_files_for_node_index = test_flat_distributor.test_files_for_node(ci_node_index)
       KnapsackPro::TestFilePresenter.paths(test_files_for_node_index) - executed_test_files
     end

data/lib/knapsack_pro/queue_allocator_builder.rb

@@ -4,8 +4,7 @@ module KnapsackPro
   class QueueAllocatorBuilder < BaseAllocatorBuilder
     def allocator
       KnapsackPro::QueueAllocator.new(
-        fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
-        fallback_mode_test_files: fallback_mode_test_files,
+        test_suite: test_suite,
         ci_node_total: env.ci_node_total,
         ci_node_index: env.ci_node_index,
         ci_node_build_id: env.ci_node_build_id,

data/lib/knapsack_pro/{allocator.rb → regular_allocator.rb}

@@ -1,71 +1,83 @@
 # frozen_string_literal: true
 
 module KnapsackPro
-  class Allocator
+  class RegularAllocator
+    class Split
+      def initialize(connection, response)
+        @connection = connection
+        @response = response
+
+        raise ArgumentError.new(connection.response) if connection.errors?
+      end
+
+      def exists?
+        raise "Connection failed. Please report this as a bug: #{KnapsackPro::Urls::SUPPORT}" if connection_failed?
+        return false if connection.api_code == KnapsackPro::Client::API::V1::BuildDistributions::TEST_SUITE_SPLIT_CACHE_MISS_CODE
+
+        true
+      end
+
+      def connection_failed?
+        !connection.success?
+      end
+
+      def test_files
+        response.fetch('test_files')
+      end
+
+      private
+
+      attr_reader :connection, :response
+    end
+
     def initialize(args)
-      @fast_and_slow_test_files_to_run = args.fetch(:fast_and_slow_test_files_to_run)
-      @fallback_mode_test_files = args.fetch(:fallback_mode_test_files)
+      @test_suite = args.fetch(:test_suite)
       @ci_node_total = args.fetch(:ci_node_total)
       @ci_node_index = args.fetch(:ci_node_index)
       @repository_adapter = args.fetch(:repository_adapter)
     end
 
     def test_file_paths
-      action = build_action(cache_read_attempt: true)
-      connection = KnapsackPro::Client::Connection.new(action)
-      response = connection.call
+      split = pull_tests
 
-      # when a cache miss because the test suite split was not cached yet
-      if connection.success? && connection.api_code == KnapsackPro::Client::API::V1::BuildDistributions::TEST_SUITE_SPLIT_CACHE_MISS_CODE
-        # make an attempt to initalize a new test suite split on the API side
-        action = build_action(cache_read_attempt: false)
-        connection = KnapsackPro::Client::Connection.new(action)
-        response = connection.call
-      end
+      return switch_to_fallback_mode if split.connection_failed?
+      return normalize_test_files(split.test_files) if split.exists?
 
-      if connection.success?
-        raise ArgumentError.new(response) if connection.errors?
-        prepare_test_files(response)
-      elsif !KnapsackPro::Config::Env.fallback_mode_enabled?
-        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
-        KnapsackPro.logger.error(message)
-        exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
-        Kernel.exit(exit_code)
-      elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
-        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
-        unless KnapsackPro::Config::Env.fixed_test_suite_split?
-          message += " Please ensure you have set KNAPSACK_PRO_FIXED_TEST_SUITE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_TEST_SUITE_SPLIT}"
-        end
-        KnapsackPro.logger.error(message)
-        exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
-        Kernel.exit(exit_code)
-      else
-        KnapsackPro.logger.warn("Fallback mode started. We could not connect with Knapsack Pro API. Your tests will be executed based on directory names. Read more about fallback mode at #{KnapsackPro::Urls::FALLBACK_MODE}")
-        fallback_test_files
-      end
+      test_files_result = test_suite.calculate_test_files
+
+      return try_initializing_test_suite_split(test_files_result.test_files) if test_files_result.quick?
+
+      # The tests to run were found slowly. By that time, the test suite split could have already been initialized by another CI node.
+      # Attempt to pull tests to avoid the attempt to initialize the test suite split unnecessarily (test suite split initialization is an expensive request with a big test files payload).
+      split = pull_tests
+
+      return switch_to_fallback_mode if split.connection_failed?
+      return normalize_test_files(split.test_files) if split.exists?
+
+      try_initializing_test_suite_split(test_files_result.test_files)
     end
 
     private
 
-    attr_reader :fast_and_slow_test_files_to_run,
-      :fallback_mode_test_files,
+    attr_reader :test_suite,
       :ci_node_total,
       :ci_node_index,
       :repository_adapter
 
-    def encrypted_test_files
-      KnapsackPro::Crypto::Encryptor.call(fast_and_slow_test_files_to_run)
-    end
-
     def encrypted_branch
       KnapsackPro::Crypto::BranchEncryptor.call(repository_adapter.branch)
     end
 
-    def build_action(cache_read_attempt:)
-      test_files =
-        unless cache_read_attempt
-          encrypted_test_files
-        end
+    def normalize_test_files(test_files)
+      decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(test_suite, test_files)
+      KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+    end
+
+    def build_action(cache_read_attempt:, test_files: nil)
+      unless cache_read_attempt
+        raise 'Test files are required when initializing a new test suite split.' if test_files.nil?
+        test_files = KnapsackPro::Crypto::Encryptor.call(test_files)
+      end
 
       KnapsackPro::Client::API::V1::BuildDistributions.subset(
         cache_read_attempt: cache_read_attempt,
@@ -77,13 +89,50 @@ module KnapsackPro
       )
     end
 
-    def prepare_test_files(response)
-      decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(fast_and_slow_test_files_to_run, response['test_files'])
-      KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+    def pull_tests
+      action = build_action(cache_read_attempt: true)
+      connection = KnapsackPro::Client::Connection.new(action)
+      response = connection.call
+      Split.new(connection, response)
+    end
+
+    def initialize_test_suite_split(tests_to_run)
+      action = build_action(cache_read_attempt: false, test_files: tests_to_run)
+      connection = KnapsackPro::Client::Connection.new(action)
+      response = connection.call
+      Split.new(connection, response)
+    end
+
+    def try_initializing_test_suite_split(tests)
+      split = initialize_test_suite_split(tests)
+
+      return switch_to_fallback_mode if split.connection_failed?
+
+      normalize_test_files(split.test_files)
+    end
+
+    def switch_to_fallback_mode
+      if !KnapsackPro::Config::Env.fallback_mode_enabled?
+        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
+        KnapsackPro.logger.error(message)
+        exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
+        Kernel.exit(exit_code)
+      elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
+        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
+        unless KnapsackPro::Config::Env.fixed_test_suite_split?
+          message += " Please ensure you have set KNAPSACK_PRO_FIXED_TEST_SUITE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_TEST_SUITE_SPLIT}"
+        end
+        KnapsackPro.logger.error(message)
+        exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
+        Kernel.exit(exit_code)
+      else
+        KnapsackPro.logger.warn("Fallback mode started. We could not connect with Knapsack Pro API. Your tests will be executed based on directory names. Read more about fallback mode at #{KnapsackPro::Urls::FALLBACK_MODE}")
+        fallback_test_files
+      end
     end
 
     def fallback_test_files
-      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(fallback_mode_test_files, ci_node_total)
+      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(test_suite.fallback_test_files, ci_node_total)
       test_files_for_node_index = test_flat_distributor.test_files_for_node(ci_node_index)
       KnapsackPro::TestFilePresenter.paths(test_files_for_node_index)
     end

data/lib/knapsack_pro/{allocator_builder.rb → regular_allocator_builder.rb}

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 module KnapsackPro
-  class AllocatorBuilder < BaseAllocatorBuilder
+  class RegularAllocatorBuilder < BaseAllocatorBuilder
     def allocator
-      KnapsackPro::Allocator.new(
-        fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
-        fallback_mode_test_files: fallback_mode_test_files,
+      KnapsackPro::RegularAllocator.new(
+        test_suite: test_suite,
         ci_node_total: env.ci_node_total,
         ci_node_index: env.ci_node_index,
         repository_adapter: repository_adapter,

data/lib/knapsack_pro/runners/base_runner.rb

@@ -8,7 +8,7 @@ module KnapsackPro
       end
 
       def initialize(adapter_class)
-        @allocator_builder = KnapsackPro::AllocatorBuilder.new(adapter_class)
+        @allocator_builder = KnapsackPro::RegularAllocatorBuilder.new(adapter_class)
         @allocator = allocator_builder.allocator
       end
 

data/lib/knapsack_pro/test_suite.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module KnapsackPro
+  class TestSuite
+    Result = Struct.new(:test_files, :quick?)
+
+    def initialize(adapter_class)
+      @adapter_class = adapter_class
+    end
+
+    # Detect test files present on the disk that should be run.
+    # This may include fast test files + slow test files split by test cases.
+    def calculate_test_files
+      return @result if defined?(@result)
+
+      unless adapter_class.split_by_test_cases_enabled?
+        return @result = Result.new(all_test_files_to_run, true)
+      end
+
+      slow_test_files, quick =
+        if slow_test_file_pattern
+          [KnapsackPro::TestFileFinder.slow_test_files_by_pattern(adapter_class), true]
+        else
+          [KnapsackPro::SlowTestFileFinder.call(adapter_class), false]
+        end
+
+      KnapsackPro.logger.debug("Detected #{slow_test_files.size} slow test files: #{slow_test_files.inspect}")
+
+      if slow_test_files.empty?
+        return @result = Result.new(all_test_files_to_run, quick)
+      end
+
+      test_file_cases = adapter_class.test_file_cases_for(slow_test_files)
+
+      fast_files_and_cases_for_slow_tests = KnapsackPro::TestFilesWithTestCasesComposer.call(all_test_files_to_run, slow_test_files, test_file_cases)
+
+      @result = Result.new(fast_files_and_cases_for_slow_tests, false)
+    end
+
+    # In Fallback Mode, we always want to run whole test files (not split by
+    # test cases) to guarantee that each test will be executed at least once
+    # across parallel CI nodes.
+    def fallback_test_files
+      all_test_files_to_run
+    end
+
+    private
+
+    attr_reader :adapter_class
+
+    def all_test_files_to_run
+      @all_test_files_to_run ||= KnapsackPro::TestFileFinder.call(test_file_pattern)
+    end
+
+    def test_file_pattern
+      TestFilePattern.call(adapter_class)
+    end
+
+    def slow_test_file_pattern
+      KnapsackPro::Config::Env.slow_test_file_pattern
+    end
+  end
+end

data/lib/knapsack_pro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KnapsackPro
-  VERSION = '8.0.2'
+  VERSION = '8.1.0'
 end

data/lib/knapsack_pro.rb

@@ -55,9 +55,10 @@ require_relative 'knapsack_pro/adapters/cucumber_adapter'
 require_relative 'knapsack_pro/adapters/minitest_adapter'
 require_relative 'knapsack_pro/adapters/test_unit_adapter'
 require_relative 'knapsack_pro/adapters/spinach_adapter'
-require_relative 'knapsack_pro/allocator'
+require_relative 'knapsack_pro/regular_allocator'
 require_relative 'knapsack_pro/queue_allocator'
 require_relative 'knapsack_pro/mask_string'
+require_relative 'knapsack_pro/test_suite'
 require_relative 'knapsack_pro/test_case_mergers/base_merger'
 require_relative 'knapsack_pro/test_case_mergers/rspec_merger'
 require_relative 'knapsack_pro/build_distribution_fetcher'
@@ -65,7 +66,7 @@ require_relative 'knapsack_pro/slow_test_file_determiner'
 require_relative 'knapsack_pro/slow_test_file_finder'
 require_relative 'knapsack_pro/test_files_with_test_cases_composer'
 require_relative 'knapsack_pro/base_allocator_builder'
-require_relative 'knapsack_pro/allocator_builder'
+require_relative 'knapsack_pro/regular_allocator_builder'
 require_relative 'knapsack_pro/queue_allocator_builder'
 require_relative 'knapsack_pro/batch'
 require_relative 'knapsack_pro/queue'

data/spec/integration/runners/queue/rspec_runner_spec.rb

@@ -2022,8 +2022,6 @@ describe "#{KnapsackPro::Runners::Queue::RSpecRunner} - Integration tests", :cle
 
       actual = subject
 
-      expect(actual.stdout).to match(/DEBUG -- : \[knapsack_pro\] Detected 1 slow test files: \[\{"path".?=>.?"spec_integration\/a_spec\.rb"\}\]/)
-
       expect(actual.stdout).to include(
         <<~OUTPUT
         A_describe
@@ -2474,8 +2472,6 @@ describe "#{KnapsackPro::Runners::Queue::RSpecRunner} - Integration tests", :cle
 
       actual = subject
 
-      expect(actual.stdout).to include('DEBUG -- : [knapsack_pro] Detected 0 slow test files: []')
-
       expect(actual.stdout).to include(
         <<~OUTPUT
         A_describe