unreliable 0.10.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3cf18102610d7a8a8c380f39bad81db77ed33392ecc8dffcdc99ef7c60d222e
-  data.tar.gz: b99100338674b31fbb11036b56ce1443006d1281e5641a0b4f200bbe7a22e832
+  metadata.gz: 17d0865e8524f14bc5d1ddc01106ccf63adb25f044a7ea3ca9109d44c6f31f3f
+  data.tar.gz: c3b5ff4213d9fb54bd3a48838ad0642c4a132e80715e45500ecf3c6884cd6f47
 SHA512:
-  metadata.gz: 96139a8994cdb3badf0f80e3bc96c94c375864f9973d9b85b56fa6ad97486001dbaa56e24b42cdb2d4ba7d051a22877851fac26a5a993b07773984521cb456e2
-  data.tar.gz: 890b786b597e60b980937d792555a3666082f7d38ab6e6b1113acdfb01adc5ec6596ef59ed2041a89215526c2ca8dacccef1184967db68356f178155617d3aaa
+  metadata.gz: 461eb8a9445d48f09ff0b6e89f097fba52685f55e93637c1e2c6bc582104af44d3e30d8c503f10e145f1a3ef052f9fdaf2b4c9cb2544f3e71080f87ea2d9854a
+  data.tar.gz: 892d721b2ff0b45430625c1feae890ce0dbdc194dcab3118f8d20251af0eb0ee2c2d45bc4550bfd5ddbff334524c42c67b2d642a53709efa9c289e27a866f956

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## Unreliable 1.0.0 (April 18, 2026) ##
+
+### Fixed
+
+* Fixed crash on Rails 7.2+ caused by removal of `Arel::Table.engine` — replaced with `lease_connection` helper.
+* `Config.disable` is now thread-safe — uses `Thread.current` instead of toggling a global flag, so parallel test runners don't interfere with each other.
+
+### Added
+
+* SQL Server support — queries get `ORDER BY NEWID()`; DISTINCT queries are skipped (same rationale as PostgreSQL).
+* Trilogy MySQL client support alongside `mysql2`.
+* Rails 7.2, 8.0, and 8.1 compatibility; upper version bound raised to `< 9.0`.
+* Ruby 3.4 and 4.0 added to the CI matrix.
+* Many new specs: eager loading, `first`/`last`, `limit`, `reorder`, `group`/`having`, `or` queries, `pluck`/`exists?`/aggregates, `find_each`, and thread safety.
+
+### Changed
+
+* Development dependencies moved from gemspec to Gemfile.
+* Suppressed C-extension deprecation warnings from sqlite3 1.3.x on Ruby 2.7 (#4).
+
 ## Unreliable 0.10.0 (January 15, 2024) ##
 
 ### Changed

data/Gemfile

@@ -3,3 +3,15 @@
 source "https://rubygems.org"
 
 gemspec
+
+gem "appraisal", "~> 2.4"
+gem "bundler", "~> 2.1"
+gem "combustion", "~> 1.5"
+gem "mysql2", "~> 0.5"
+gem "ostruct"
+gem "pg", "~> 1.5"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "sqlite3", (RUBY_VERSION >= "3.2") ? "~> 1.6.9" : "~> 1.5.4"
+gem "standard", "~> 1.17"
+gem "yamllint", "~> 0.0.9"

data/README.md

@@ -19,7 +19,7 @@ group :test do
 end
 ```
 
-The next time your test suite runs, it may emit new errors and failures. If so, great!
+And run `bundle install`. Then try running your test suite. If it emits new errors and failures, great!
 
 ## The problem with orders
 
@@ -94,9 +94,11 @@ But this error can occur at any granularity, in time or other data types.
 
 `unreliable` is tested on every valid combination of:
 
- * sqlite, postgresql, and mysql2 adapters
- * Ruby 2.6 through 3.3
- * Rails 5.2 through 7.1
+ * sqlite, postgresql, mysql2, trilogy, and sqlserver adapters
+ * Ruby 2.6 through 4.0
+ * Rails 5.2 through 8.1
+
+SQL Server tests run in CI (x86\_64) only; the SQL Server 2022 Docker image has no arm64 variant and is unstable under QEMU on Apple Silicon.
 
 `unreliable` depends only on ActiveRecord and Railties. If you have a non-Rails app that uses ActiveRecord, you can still use it.
 
@@ -110,11 +112,11 @@ Because it's appended, the existing ordering is not affected unless it is ambigu
 
 With `unreliable` installed, every ActiveRecord relation invoked by the test suite will have any ambiguity replaced with randomness. Tests that rely on the ordering of two records will break half the time. Tests with three or more break most of the time.
 
-`unreliable` patches `ActiveRecord::QueryMethods#build_arel`, the point where an Arel is converted for use, to append an order to the existing order chain. (The patch is applied after ActiveRecord loads, using `ActiveSupport.on_load`, the standard interface since Rails 4.0.) It works with MySQL, Postgres, and SQLite.
+`unreliable` patches `ActiveRecord::Relation#build_order`, the point where ordering is assembled, to append a random-order term to the existing order chain. (The patch is applied after ActiveRecord loads, using `ActiveSupport.on_load`, the standard interface since Rails 4.0.) It works with MySQL, PostgreSQL, SQLite, and SQL Server.
 
-This means that the `ORDER BY` applies to not just `SELECT` but e.g. `delete_all` and `update_all`. It also applies within subqueries.
+Patching `build_order` ensures that the `ORDER BY` applies to not just `SELECT` but e.g. `delete_all` and `update_all`. It also applies within subqueries.
 
-The patch is only applied when `Rails.env.test?`, and that boolean is also checked on every invocation, just to make certain it has no effect in any other environment.
+The patch is only applied when `Rails.env.test?`, so it has zero effect on production. Just to be sure, the environment is also checked on every invocation, to make absolutely certain this code can run only in `test`.
 
 The gem has a large test suite that checks for correctness at several abstraction layers inside ActiveRecord. It ensures the correct SQL is generated and that it executes correctly.
 
@@ -136,15 +138,19 @@ After you spin up the containers and open a shell in the app container, run `unr
 standardrb
 ```
 
-Run its tests in three separate passes:
+Run its tests in separate passes:
 
 ```
 RSPEC_ADAPTER=sqlite bundle exec rake
 RSPEC_ADAPTER=postgresql bundle exec rake
 RSPEC_ADAPTER=mysql2 bundle exec rake
+RSPEC_ADAPTER=trilogy bundle exec rake
+RSPEC_ADAPTER=sqlserver bundle exec rake
 ```
 
-The GitHub CI workflow in `.github/` ensures those tests are also run against against every compatible minor version of Ruby. Your PR won't trigger my GitHub project's workflow, but you're welcome to run your own, or ask me to run mine manually.
+The SQL Server pass requires an x86\_64 host; the SQL Server 2022 Docker image does not run on Apple Silicon.
+
+The GitHub CI workflow in `.github/` ensures those tests are also run against every compatible minor version of Ruby. Your PR won't trigger my GitHub project's workflow, but you're welcome to run your own, or ask me to run mine manually.
 
 ### Experiment
 

data/lib/unreliable/build_order.rb

@@ -7,26 +7,31 @@ require "active_record/connection_adapters/abstract_adapter"
 module Unreliable
   module BuildOrder
     def build_order(arel)
-      super(arel)
+      super
 
-      adapter_name = Arel::Table.engine.connection.adapter_name
+      adapter_name = unreliable_connection.adapter_name
       return unless Unreliable::Config.enabled?
       return if distinct_on_postgres?(adapter_name)
+      return if distinct_on_sqlserver?(adapter_name)
       return if from_only_internal_metadata?(arel)
       return if from_one_table_with_ordered_pk?(arel)
 
       case adapter_name
-      when "Mysql2"
+      when "Mysql2", "Trilogy"
         # https://dev.mysql.com/doc/refman/8.0/en/mathematical-functions.html#function_rand
         arel.order("RAND()")
 
+      when "SQLServer"
+        # https://learn.microsoft.com/en-us/sql/t-sql/functions/newid-transact-sql
+        arel.order("NEWID()")
+
       when "PostgreSQL", "SQLite"
         # https://www.postgresql.org/docs/16/functions-math.html#FUNCTIONS-MATH-RANDOM-TABLE
         # https://www.sqlite.org/lang_corefunc.html#random
         arel.order("RANDOM()")
 
       else
-        raise ArgumentError, "unknown Arel::Table.engine"
+        raise ArgumentError, "unreliable: unknown adapter #{adapter_name.inspect}"
 
       end
     end
@@ -35,6 +40,12 @@ module Unreliable
       distinct_value && adapter_name == "PostgreSQL"
     end
 
+    def distinct_on_sqlserver?(adapter_name)
+      # SQL Server rejects ORDER BY expressions not in the select list when
+      # DISTINCT is used, so we don't append NEWID() to DISTINCT queries.
+      distinct_value && adapter_name == "SQLServer"
+    end
+
     def from_only_internal_metadata?(arel)
       # No need to randomize queries on ar_internal_metadata
       arel.froms.map(&:name) == [ActiveRecord::Base.internal_metadata_table_name]
@@ -57,13 +68,20 @@ module Unreliable
       # Using the SchemaCache minimizes the number of times we have to, e.g. in MySQL,
       # SELECT column_name FROM information_schema.statistics
       # (or in Rails < 6, SELECT column_name FROM information_schema.key_column_usage)
-      [ActiveRecord::Base.connection.schema_cache.primary_keys(arel.froms.first.name)].flatten
+      [unreliable_connection.schema_cache.primary_keys(arel.froms.first.name)].flatten
+    end
+
+    def unreliable_connection
+      # Rails 7.2+ soft-deprecated `connection` in favor of `lease_connection`.
+      # We check for it with klass (not self) because it works on Rails 7.2+ due to
+      # delegation, and it doesn't break Rails 5.2 due to a respond_to_missing bug.
+      klass.respond_to?(:lease_connection) ? lease_connection : connection
     end
 
     def order_columns(arel)
       from_table_name = arel.froms.first.name
       arel.orders
-        .select { |order| order.is_a? Arel::Nodes::Ordering } # Don't try to parse textual orders
+        .grep(Arel::Nodes::Ordering) # Don't try to parse textual orders
         .map(&:expr)
         .select { |expr| expr.relation.name == from_table_name }
         .map(&:name)

data/lib/unreliable/config.rb

@@ -7,15 +7,15 @@ module Unreliable
     end
 
     def self.enabled?
-      @enabled && Rails.env.test?
+      @enabled && !Thread.current[:unreliable_disabled] && Rails.env.test?
     end
 
     def self.disable
-      prev_enabled = @enabled
-      @enabled = false
+      was_disabled = Thread.current[:unreliable_disabled]
+      Thread.current[:unreliable_disabled] = true
       yield
     ensure
-      @enabled = prev_enabled
+      Thread.current[:unreliable_disabled] = was_disabled
     end
   end
 end

data/lib/unreliable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Unreliable
-  VERSION = "0.10.0"
+  VERSION = "1.0.0"
 end

data/spec/config_disable_nesting_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Unreliable::Config do
+  it "restores state after nested disable blocks" do
+    expect(Cat.all.to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+
+    Unreliable::Config.disable do
+      expect(Cat.all.to_sql).to_not include("RANDOM()")
+      expect(Cat.all.to_sql).to_not include("RAND()")
+
+      Unreliable::Config.disable do
+        expect(Cat.all.to_sql).to_not include("RANDOM()")
+        expect(Cat.all.to_sql).to_not include("RAND()")
+      end
+
+      # Still disabled after inner block
+      expect(Cat.all.to_sql).to_not include("RANDOM()")
+      expect(Cat.all.to_sql).to_not include("RAND()")
+    end
+
+    # Re-enabled after outer block
+    expect(Cat.all.to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+end

data/spec/config_thread_safety_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Config.disable must only suppress randomization in the calling thread.
+# Before the fix, @enabled was a class-level variable shared across threads,
+# so one thread's disable block would suppress randomization in all threads.
+
+RSpec.describe Unreliable::Config, "thread safety" do
+  it "does not affect other threads when disabled" do
+    other_thread_sql = nil
+    barrier = Queue.new
+
+    Unreliable::Config.disable do
+      # Our thread has randomization disabled
+      expect(Cat.all.to_sql).to_not include("RANDOM()")
+      expect(Cat.all.to_sql).to_not include("RAND()")
+
+      Thread.new do
+        other_thread_sql = Cat.all.to_sql
+        barrier.push(:done)
+      end
+
+      barrier.pop # wait for the other thread
+    end
+
+    expect(other_thread_sql).to include(adapter_rand("RANDOM()"))
+  end
+end

data/spec/env_spec.rb

@@ -3,14 +3,14 @@
 RSpec.describe Unreliable do
   it "does nothing in prod" do
     Rails.env = "production"
-    expect(Cat.where(word: "foo").to_sql).to end_with(adapter_text(%q(WHERE "cats"."word" = 'foo')))
+    expect(Cat.where(word: "foo").to_sql).to end_with(adapter_rand(%q(WHERE "cats"."word" = 'foo')))
   ensure
     Rails.env = "test"
   end
 
   it "does nothing in dev" do
     Rails.env = "development"
-    expect(Cat.where(word: "foo").to_sql).to end_with(adapter_text(%q(WHERE "cats"."word" = 'foo')))
+    expect(Cat.where(word: "foo").to_sql).to end_with(adapter_rand(%q(WHERE "cats"."word" = 'foo')))
   ensure
     Rails.env = "test"
   end

data/spec/examples.txt

@@ -0,0 +1,62 @@
+example_id                                 | status  | run_time        |
+------------------------------------------ | ------- | --------------- |
+./spec/adapter_option_spec.rb[1:1]         | passed  | 0.00045 seconds |
+./spec/env_spec.rb[1:1]                    | passed  | 0.00516 seconds |
+./spec/env_spec.rb[1:2]                    | passed  | 0.00012 seconds |
+./spec/execute_queries_spec.rb[1:1]        | passed  | 0.00479 seconds |
+./spec/execute_queries_spec.rb[1:2]        | passed  | 0.00774 seconds |
+./spec/execute_queries_spec.rb[1:3]        | passed  | 0.00722 seconds |
+./spec/execute_queries_spec.rb[1:4]        | passed  | 0.00989 seconds |
+./spec/execute_queries_spec.rb[1:5]        | passed  | 0.01507 seconds |
+./spec/execute_queries_spec.rb[1:6]        | passed  | 0.006 seconds   |
+./spec/execute_queries_spec.rb[1:7]        | passed  | 0.00368 seconds |
+./spec/execute_queries_spec.rb[1:8]        | passed  | 0.00372 seconds |
+./spec/execute_queries_spec.rb[1:9]        | passed  | 0.00329 seconds |
+./spec/execute_subqueries_spec.rb[1:1]     | passed  | 0.00974 seconds |
+./spec/execute_subqueries_spec.rb[1:2]     | passed  | 0.00419 seconds |
+./spec/model_cache_versioning_spec.rb[1:1] | passed  | 0.00092 seconds |
+./spec/model_indexes_books_spec.rb[1:1]    | passed  | 0.00058 seconds |
+./spec/model_indexes_books_spec.rb[1:2]    | passed  | 0.0002 seconds  |
+./spec/model_indexes_books_spec.rb[1:3]    | passed  | 0.00007 seconds |
+./spec/model_indexes_cats_spec.rb[1:1]     | passed  | 0.00006 seconds |
+./spec/model_indexes_cats_spec.rb[1:2]     | passed  | 0.00009 seconds |
+./spec/model_indexes_dreams_spec.rb[1:1]   | passed  | 0.00008 seconds |
+./spec/model_indexes_dreams_spec.rb[1:2]   | passed  | 0.00007 seconds |
+./spec/model_indexes_shelves_spec.rb[1:1]  | passed  | 0.00053 seconds |
+./spec/model_indexes_shelves_spec.rb[1:2]  | passed  | 0.00022 seconds |
+./spec/model_indexes_shelves_spec.rb[1:3]  | passed  | 0.00008 seconds |
+./spec/model_indexes_shelves_spec.rb[1:4]  | passed  | 0.00006 seconds |
+./spec/model_indexes_shelves_spec.rb[1:5]  | passed  | 0.00007 seconds |
+./spec/model_indexes_shelves_spec.rb[1:6]  | passed  | 0.0001 seconds  |
+./spec/model_joins_spec.rb[1:1]            | passed  | 0.00405 seconds |
+./spec/model_joins_spec.rb[1:2]            | passed  | 0.0006 seconds  |
+./spec/model_joins_spec.rb[1:3]            | passed  | 0.00015 seconds |
+./spec/model_joins_spec.rb[1:4]            | passed  | 0.00024 seconds |
+./spec/model_select_distinct_spec.rb[1:1]  | passed  | 0.0001 seconds  |
+./spec/model_select_distinct_spec.rb[1:2]  | passed  | 0.00009 seconds |
+./spec/model_select_distinct_spec.rb[1:3]  | passed  | 0.00007 seconds |
+./spec/model_select_distinct_spec.rb[1:4]  | passed  | 0.00123 seconds |
+./spec/model_select_spec.rb[1:1]           | passed  | 0.00007 seconds |
+./spec/model_select_spec.rb[1:2]           | passed  | 0.00008 seconds |
+./spec/model_select_spec.rb[1:3]           | passed  | 0.00007 seconds |
+./spec/model_select_spec.rb[1:4]           | passed  | 0.00013 seconds |
+./spec/model_subquery_spec.rb[1:1]         | passed  | 0.00014 seconds |
+./spec/model_update_arel_10_spec.rb[1:1]   | passed  | 0.00123 seconds |
+./spec/railtie_spec.rb[1:1]                | passed  | 0.00003 seconds |
+./spec/railtie_spec.rb[1:2]                | passed  | 0.00003 seconds |
+./spec/textual_order_raw_spec.rb[1:1]      | passed  | 0.00009 seconds |
+./spec/textual_order_raw_spec.rb[1:2]      | passed  | 0.00007 seconds |
+./spec/textual_order_raw_spec.rb[1:3]      | pending | 0.00001 seconds |
+./spec/textual_order_raw_spec.rb[1:4]      | pending | 0 seconds       |
+./spec/textual_order_raw_spec.rb[1:5]      | passed  | 0.00007 seconds |
+./spec/textual_order_raw_spec.rb[1:6]      | passed  | 0.00006 seconds |
+./spec/textual_order_raw_spec.rb[1:7]      | passed  | 0.00006 seconds |
+./spec/textual_order_raw_spec.rb[1:8]      | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:1]          | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:2]          | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:3]          | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:4]          | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:5]          | passed  | 0.00006 seconds |
+./spec/textual_order_spec.rb[1:6]          | passed  | 0.00007 seconds |
+./spec/version_spec.rb[1:1]                | passed  | 0.00054 seconds |
+./spec/version_spec.rb[1:2]                | passed  | 0.00004 seconds |

data/spec/execute_eager_load_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# eager_load fires a single LEFT OUTER JOIN query that goes through build_order
+# and gets ORDER BY RANDOM() appended.
+#
+# preload fires the main query (ORDER BY RANDOM()) then a separate IN-list query
+# for the association (also ORDER BY RANDOM(), since it's its own build_order call).
+#
+# includes delegates to preload when no association conditions are present, and
+# to eager_load when conditions reference the association table.
+#
+# All three strategies are tested for correct SQL shape (via to_sql) and correct
+# association loading (via execution).
+
+RSpec.describe "eager_load, preload, includes" do
+  # SQL shape — eager_load produces a single joinable query; to_sql reflects it fully.
+  # preload/includes (no conditions) to_sql shows only the main query.
+
+  it "eager_load appends random order on has_one" do
+    expect(Dreamer.eager_load(:dream).to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "eager_load appends random order on has_many" do
+    expect(Owner.eager_load(:cats).to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "preload main query appends random order" do
+    expect(Dreamer.preload(:dream).to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "preload main query does not append random order when ordered by primary key" do
+    expect(Dreamer.preload(:dream).order(:dreamer_id).to_sql).to end_with(
+      adapter_rand('ORDER BY "dreamers"."dreamer_id" ASC')
+    )
+  end
+
+  it "includes (no conditions) main query appends random order" do
+    expect(Owner.includes(:cats).to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "includes (no conditions) main query does not append random order when ordered by primary key" do
+    expect(Owner.includes(:cats).order(:id).to_sql).to end_with(
+      adapter_rand('ORDER BY "owners"."id" ASC')
+    )
+  end
+
+  it "includes (with association conditions) appends random order" do
+    expect(Owner.includes(:cats).where(cats: {name: "foo"}).to_sql).to end_with(
+      adapter_rand("ORDER BY RANDOM()")
+    )
+  end
+
+  # Execution — verify associations load correctly despite the appended ORDER BY.
+
+  context "with data" do
+    before do
+      @chuangmu = Owner.create!(name: "Chuangmu")
+      @oisin = Owner.create!(name: "Oisin")
+      Cat.create!(name: "Baku", owner: @chuangmu)
+      Cat.create!(name: "Mara", owner: @chuangmu)
+      Cat.create!(name: "Khidr", owner: @oisin)
+
+      @gilgamesh = Dreamer.create!(name: "Gilgamesh")
+      @penelope = Dreamer.create!(name: "Penelope")
+      Dream.create!(subject: "cedar forest", dreamer: @gilgamesh)
+      Dream.create!(subject: "eagle and goose", dreamer: @penelope)
+    end
+
+    after do
+      Dream.delete_all
+      Dreamer.delete_all
+      Cat.delete_all
+      Owner.delete_all
+    end
+
+    it "eager_load loads has_many associations correctly" do
+      owners = Owner.eager_load(:cats).order(:name).to_a
+      chuangmu = owners.find { |o| o.name == "Chuangmu" }
+      oisin = owners.find { |o| o.name == "Oisin" }
+      expect(chuangmu.cats.map(&:name).sort).to eq(%w[Baku Mara])
+      expect(oisin.cats.map(&:name)).to eq(["Khidr"])
+    end
+
+    it "eager_load loads has_one associations correctly" do
+      dreamers = Dreamer.eager_load(:dream).order(:name).to_a
+      gilgamesh = dreamers.find { |d| d.name == "Gilgamesh" }
+      penelope = dreamers.find { |d| d.name == "Penelope" }
+      expect(gilgamesh.dream.subject).to eq("cedar forest")
+      expect(penelope.dream.subject).to eq("eagle and goose")
+    end
+
+    it "preload loads associations correctly" do
+      owners = Owner.preload(:cats).order(:name).to_a
+      chuangmu = owners.find { |o| o.name == "Chuangmu" }
+      expect(chuangmu.cats.map(&:name).sort).to eq(%w[Baku Mara])
+    end
+
+    it "includes loads associations correctly" do
+      dreamers = Dreamer.includes(:dream).order(:name).to_a
+      penelope = dreamers.find { |d| d.name == "Penelope" }
+      expect(penelope.dream.subject).to eq("eagle and goose")
+    end
+
+    it "includes with association conditions filters and loads correctly" do
+      owners = Owner.includes(:cats).where(cats: {name: "Baku"}).to_a
+      expect(owners.map(&:name)).to eq(["Chuangmu"])
+    end
+  end
+end

data/spec/execute_find_each_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# find_each and in_batches add ORDER BY id ASC internally for cursor-based
+# iteration. The gem detects that the primary key is fully covered and correctly
+# suppresses ORDER BY RANDOM(), leaving the batch queries intact.
+
+RSpec.describe "find_each and in_batches" do
+  before do
+    %w[Baku Caer Chuangmu Gilgamesh Penelope].each { |name| Cat.create!(name: name) }
+  end
+
+  after { Cat.delete_all }
+
+  it "find_each yields all records without error" do
+    names = []
+    Cat.find_each(batch_size: 2) { |cat| names << cat.name }
+    expect(names.sort).to eq(%w[Baku Caer Chuangmu Gilgamesh Penelope])
+  end
+
+  it "in_batches iterates all records without error" do
+    names = []
+    Cat.in_batches(of: 2) { |batch| names.concat(batch.pluck(:name)) }
+    expect(names.sort).to eq(%w[Baku Caer Chuangmu Gilgamesh Penelope])
+  end
+
+  it "find_each does not append random order" do
+    sqls = []
+    subscription = ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+      sqls << payload[:sql] if payload[:sql].include?("cats")
+    end
+    Cat.find_each(batch_size: 100) { next }
+    ActiveSupport::Notifications.unsubscribe(subscription)
+    expect(sqls).to all(satisfy do |sql|
+      !sql.include?("RANDOM()") && !sql.include?("RAND()") && !sql.include?("NEWID()")
+    end)
+  end
+
+  it "in_batches does not append random order" do
+    sqls = []
+    subscription = ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+      sqls << payload[:sql] if payload[:sql].include?("cats")
+    end
+    Cat.in_batches(of: 100) { next }
+    ActiveSupport::Notifications.unsubscribe(subscription)
+    expect(sqls).to all(satisfy do |sql|
+      !sql.include?("RANDOM()") && !sql.include?("RAND()") && !sql.include?("NEWID()")
+    end)
+  end
+end

data/spec/execute_pluck_exists_aggregate_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# pluck, exists?, and aggregate methods (count, sum, minimum, maximum) all go
+# through build_arel and get ORDER BY RANDOM() appended. The ordering is harmless
+# for aggregates (result is the same regardless) and silently discarded for pluck.
+# These tests verify the methods return correct values despite the appended ORDER BY.
+
+RSpec.describe "pluck, exists?, and aggregates" do
+  before do
+    Cat.new(name: "Alfie").save!
+    Cat.new(name: "Bella").save!
+    Cat.new(name: "Cleo").save!
+  end
+
+  after { Cat.delete_all }
+
+  it "pluck returns correct values" do
+    expect(Cat.pluck(:name).sort).to eq(%w[Alfie Bella Cleo])
+  end
+
+  it "pluck with where returns correct values" do
+    expect(Cat.where(name: %w[Alfie Bella]).pluck(:name).sort).to eq(%w[Alfie Bella])
+  end
+
+  it "exists? returns true when matching rows exist" do
+    expect(Cat.where(name: "Alfie").exists?).to be true
+  end
+
+  it "exists? returns false when no matching rows exist" do
+    expect(Cat.where(name: "Nobody").exists?).to be false
+  end
+
+  it "count returns correct value" do
+    expect(Cat.count).to eq(3)
+    expect(Cat.where(name: %w[Alfie Bella]).count).to eq(2)
+  end
+
+  it "sum returns correct value" do
+    ids = Cat.pluck(:id)
+    expect(Cat.sum(:id)).to eq(ids.sum)
+  end
+
+  it "minimum and maximum return correct values" do
+    ids = Cat.pluck(:id).sort
+    expect(Cat.minimum(:id)).to eq(ids.first)
+    expect(Cat.maximum(:id)).to eq(ids.last)
+  end
+end

data/spec/execute_subqueries_spec.rb

@@ -2,7 +2,7 @@
 
 class DreamTest < UnreliableTest
   SUBJECTS = %w[fire air water earth life death].freeze
-  DREAMER_NAMES = %w[Morpheus Cluracan Mervyn Gilbert Nuala].freeze
+  DREAMER_NAMES = %w[Baku Caer Chuangmu Penelope Zhuangzi].freeze
   raise ArgumentError, "DreamTest needs at least as many subjects as dreamers" if SUBJECTS.size < DREAMER_NAMES.size
 end
 

data/spec/model_first_last_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Cat.first internally does order(:id).limit(1). Since the PK is fully covered
+# by the order, unreliable should NOT add RANDOM(). We can't call .to_sql on
+# first/last (they return records), so we test the equivalent Relation.
+
+RSpec.describe "first and last" do
+  it "does not randomize the query equivalent to .first" do
+    expect(Cat.order(:id).limit(1).to_sql).to end_with(
+      "#{adapter_rand('ORDER BY "cats"."id" ASC')} #{adapter_limit(1)}"
+    )
+  end
+
+  it "does not randomize the query equivalent to .last" do
+    expect(Cat.order(id: :desc).limit(1).to_sql).to end_with(
+      "#{adapter_rand('ORDER BY "cats"."id" DESC')} #{adapter_limit(1)}"
+    )
+  end
+
+  it "executes first and last without error" do
+    Cat.new(name: "Alfa").save!
+    Cat.new(name: "Bravo").save!
+    expect(Cat.first.name).to be_a(String)
+    expect(Cat.last.name).to be_a(String)
+  ensure
+    Cat.delete_all
+  end
+end

data/spec/model_group_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# GROUP BY queries get ORDER BY RANDOM() appended after the HAVING clause.
+# This is semantically harmless -- the DB groups first, then sorts.
+# Aggregate queries like .count use a separate code path and don't get ORDER BY.
+
+RSpec.describe "group and having" do
+  it "randomly selects with group" do
+    expect(Cat.group(:name).to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "randomly selects with group and having" do
+    expect(Cat.group(:name).having("count(*) > 0").to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
+  end
+
+  it "executes group with count correctly" do
+    Cat.new(name: "Jinx").save!
+    Cat.new(name: "Jinx").save!
+    Cat.new(name: "Pixel").save!
+    result = Cat.group(:name).count
+    expect(result).to eq({"Jinx" => 2, "Pixel" => 1})
+  ensure
+    Cat.delete_all
+  end
+
+  it "executes group with having correctly" do
+    Cat.new(name: "Jinx").save!
+    Cat.new(name: "Jinx").save!
+    Cat.new(name: "Pixel").save!
+    result = Cat.group(:name).having("count(*) > 1").count
+    expect(result).to eq({"Jinx" => 2})
+  ensure
+    Cat.delete_all
+  end
+end

data/spec/model_indexes_books_spec.rb

@@ -2,14 +2,14 @@
 
 RSpec.describe "model_indexes_books" do
   it "randomly selects from books with no order" do
-    expect(Book.all.to_sql).to end_with(adapter_text("ORDER BY RANDOM()"))
+    expect(Book.all.to_sql).to end_with(adapter_rand("ORDER BY RANDOM()"))
   end
 
   it "randomly selects from books ordered by nonindexed column" do
-    expect(Book.all.order(:subject).to_sql).to end_with(adapter_text('ORDER BY "books"."subject" ASC, RANDOM()'))
+    expect(Book.all.order(:subject).to_sql).to end_with(adapter_rand('ORDER BY "books"."subject" ASC, RANDOM()'))
   end
 
   it "randomly selects from books ordered by unique column" do
-    expect(Book.all.order(:isbn).to_sql).to end_with(adapter_text('ORDER BY "books"."isbn" ASC, RANDOM()'))
+    expect(Book.all.order(:isbn).to_sql).to end_with(adapter_rand('ORDER BY "books"."isbn" ASC, RANDOM()'))
   end
 end