unreliable 0.1.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 492ba9597605f55f1b9ee0d92a132a072a70257ef2b12bb54390f78dc6b67b7d
-  data.tar.gz: 385fe7486e4b8bf7b24ffc2657eee2d956d88a77e765582974a3bf20eb41480c
+  metadata.gz: c392da89c1547259307a12e4674e96c9aaa07e0d7b2550d508fc98b7d490b8ea
+  data.tar.gz: de874288196a3383fce382e4e35ae425547d0a8afd3fb64e5b1989e49f703b83
 SHA512:
-  metadata.gz: 7328df183703ef3aa8410eb86995558d11f5855c86c20142b046632d95110681f162db99dede9f7b75f7e1bf72d0e05e7bdad675412005d84d05d9af957acedb
-  data.tar.gz: 453b0ae1dfc15bf3354a3caf7ea421caf61dd2b5d48ec8d1c04166749db470693e0da0ec4c863aeb81f03b970e2a94addc7795860396bbf9c025e2ad2c665f1a
+  metadata.gz: d9a215c602f513619493f094994098ae4e15555b8f9d9962b0ddf3a9c15fe7d6cb0a19b3d75b064c12985383bfc2fd8d247d7a1d4400485dafd69cd63aea94e4
+  data.tar.gz: 70ae7ac42726add25f320037c57c7d42a4d28d6af1e6380f4be8c5ccbecd24deb34bd095255579645a3fc345e3ee7913b85108b7c2bcf6cd05b8fb3e3f4c0a05

data/CHANGELOG.md

@@ -1,4 +1,17 @@
-## Unreliable 0.1.2 (April xx, 2022) ##
+## Unreliable 0.9.0 (November 20, 2022) ##
+
+### Changed
+
+* Minor README, gemspec, and rubocop changes.
+* More tests, including queries generated by ActiveRecord associations.
+* Don't randomize order from ar\_internal\_metadata.
+* When a single-table query or subquery has an existing ORDER that includes all columns of that table's primary key, this is one of the few cases where we know we don't need to randomize order, so don't bother.
+
+## Unreliable 0.1.3 (August 21, 2022) ##
+
+* README and minor gemspec changes.
+
+## Unreliable 0.1.2 (April 27, 2022) ##
 
 * README and internal dependency changes.
 

data/README.md

@@ -3,9 +3,9 @@
 ![CI workflow](https://github.com/jamiemccarthy/unreliable/actions/workflows/ci.yml/badge.svg)
 ![Gem version](https://img.shields.io/gem/v/unreliable)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa)](code_of_conduct.md)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa)](CODE_OF_CONDUCT.md)
 
-**Unreliable makes your ActiveRecord scopes and test suite better, by forcing your tests to not rely on ambiguous ordering.**
+**The `unreliable` gem forces your ActiveRecord tests not to rely on ambiguous ordering. This makes your app and its tests more robust.**
 
 ## Installation
 
@@ -19,106 +19,98 @@ group :test do
 end
 ```
 
-Then `bundle install` and run your test suite repeatedly, maybe 6-8 times, looking for new failures.
+The next time your test suite runs, it may emit new errors and failures. If so, great!
 
-## The problem
+## The problem with orders
 
-Here's an open secret: relational databases do not guarantee the order results are returned in, without a well-chosen ORDER BY clause.
+Here's an [open secret](#references): **relational databases do not guarantee the order results are returned in, without a thorough `ORDER BY` clause.**
 
-Choosing a good ORDER is harder than it seems. And you can get it wrong silently. Your test suite won't help you if your database just happens to return the same order almost all the time. Which they usually do.
+If all your ActiveRecord ordering is already unambiguous, congratulations! `unreliable` will have no effect.
 
-If your Rails code relies on that accidental ordering, that's a bug in your app. Or sometimes ambiguous order is fine for your app's purposes, but your tests rely on it. Either way, your tests are passing when they should be failing.
+But sometimes we think we specified an unambiguous order, but didn't. Maybe we ordered on timestamps, which are usually unique but sometimes not. And the test suite will stay silent as long as our database just happens to return the same order.
 
-## The test
+If ambiguous ordering is fine for your app's purposes, but your tests rely on a specific order, that's a bug in your tests. Your tests are incorrectly failing -- rarely -- which can be confusing and annoying.
 
-In a Rails test environment, Unreliable patches ActiveRecord to always have a final ORDER BY clause that returns results in a random order.
+Or, if your Rails code relies on that accidental ordering, that's a bug in your app. Your tests are passing when they should be failing.
 
-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.
+In both cases, `unreliable` exposes the problem by making those tests fail most of the time.
 
-If you install Unreliable and your test suite starts failing, but only sometimes, that tells you to check your app's relations and scopes, and check your tests.
+## Fixing the new failures
 
-Even your relations with an order may have an ambiguous order. See "Ordering trivia" below.
+When `unreliable` turns up a new test failure, you fix it in one of two ways. Either relax your test so it stops relying on order, or tighten up your app to specify order rigorously. (In my company's app, it was about 50/50.)
 
-## The fixes
+### Relax a test
 
-When Unreliable turns up a new test failure, it's for one of two reasons. Either your test needs to stop relying on order, or your app needs to specify order better.
+Take a look at what your test is checking. If you're testing a method or an endpoint that returns a list whose order doesn't matter, you may have written it to expect the order that was returned the first time you ran it. This often happens with fixtures. You might:
 
-### Incorrect test
+* Make your test accept all correct answers. For example, sort an array in the method's response before comparing.
 
-Take a look at what you're testing. If you're testing a method or an endpoint that returns a list whose order doesn't matter and isn't documented, you may have written it to expect the order that was returned the first time you ran it. This often happens with fixtures. You might:
+* Help your test suite focus on what you're testing. If your fixtures' "latest" element could change because they don't specify a timestamp, that might be a distraction that's not relevant to how your app works, so you could assign timestamps to the fixtures.
 
-* Make your test accept all correct answers. For example, sort the method's response before comparing.
+This makes your test suite more robust.
 
-* Or, help your test suite focus on what you're testing. If your fixtures' "latest" element is random because they don't specify a timestamp, that may be a distraction that's not relevant to how your app works, so you could just assign them timestamps.
+If your test suite is checking generated `.to_sql` against known-good SQL text, `unreliable` isn't helpful. It's easiest to use `Unreliable::Config.disable { ... }` to turn it off for a block.
 
-Either way, you eliminate potential spurious failures in your test suite.
+### Tighten the app
 
-### Incorrect app
+If your app should be returning results in a particular order, and now with `unreliable` it sometimes does not, your test is correct and your app is wrong. Specify order rigorously in your app.
 
-If your app should be returning results in a particular order, and now with Unreliable it sometimes does not, your test is correct and your app is wrong. Specify order rigorously in your app.
-
-Maybe you've defined an ordering this way:
+Maybe you're testing `Book.reverse_chron.first`, and you've defined that ordering this way:
 
 ```
-  class Book
-    scope :reverse_chron, -> { order(year_published: :desc) }
-  end
+class Book
+  scope :reverse_chron, -> { order(year_published: :desc) }
+end
 ```
 
 When you meant to define it unambiguously:
 
 ```
-  class Book
-    scope :reverse_chron, -> { order(year_published: :desc, title: :desc) }
-  end
+  scope :reverse_chron, -> { order(year_published: :desc, title: :desc) }
 ```
 
 Or, if `title` is not unique:
 
 ```
-  class Book
-    scope :reverse_chron, -> { order(year_published: :desc, title: :desc, id: :desc) }
-  end
+  scope :reverse_chron, -> { order(year_published: :desc, title: :desc, id: :desc) }
 ```
 
-This example is obviously wrong because many books are published each year, but this error can occur at any time granularity.
+The problem in this example is easy to see because many books are published each year. But this error can occur at any time granularity.
 
 ## Requirements
 
-Unreliable is tested to support Ruby 2.6 through 3.1, and Rails 5.0 through 7.0.
+`unreliable` is tested to support Ruby 2.6 through 3.1, and Rails 5.0 through 7.0.
 
-As of April 2022, this is all released versions of both that are currently supported, plus several older releases.
+As of November 2022, this is all released versions of both that are currently supported, plus several older releases.
 
-Unreliable depends only on ActiveRecord and Railties. If you have a non-Rails app that uses ActiveRecord, you can still use it.
+`unreliable` depends only on ActiveRecord and Railties. If you have a non-Rails app that uses ActiveRecord, you can still use it.
 
 ## Implementation
 
-**Unreliable does exactly nothing outside of test environments. There is intentionally no way to enable Unreliable in production, and there never will be.**
+`unreliable` does exactly nothing outside of test environments. There is intentionally no way to enable `unreliable` in production, and there never will be.
 
-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.)
+In a Rails test environment, `unreliable` patches ActiveRecord to append a final `ORDER BY` clause, when necessary, that returns results in a random order.
 
-This means that the ORDER BY applies to not just SELECTs but e.g. delete_all and update_all. It also applies within subqueries.
+Because it's appended, the existing ordering is not affected unless it is ambiguous.
 
-The patch is only applied when `Rails.env.test?`, and that boolean is also checked on every invocation to make certain it has no effect in any other environment.
+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::Config.disable do ... end` will turn it off for a block.
+`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.
 
-## Ordering trivia
+This means that the `ORDER BY` applies to not just `SELECT` but e.g. `delete_all` and `update_all`. It also applies within subqueries.
 
-The most common ambiguous ordering is an ORDER BY one column that is not unique, like a timestamp.
+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.
 
-But there are other ways you can order a relation but still have your query be ambiguous:
+### No dual-purpose environment please
 
-* ORDER BY multiple columns, but with no subset which is unique
-* ORDER BY a column with values that differ only by [character case](https://dev.mysql.com/doc/refman/8.0/en/sorting-rows.html)
-* ORDER BY values that are identical within the [prefix length limit](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_max_sort_length) examined for sorting
-
-Unreliable correctly tests these because the random order is always appended.
+Your test environment is just for running your test suite. If you've overloaded the test environment to do any actual work, you'd be frustrated when `unreliable` slows it down and changes its behavior, so don't install it (yet).
 
 ## Contributing
 
 Thoughts and suggestions are welcome. Please read the code of conduct, then create an issue or pull request on GitHub. If you just have questions, go ahead and open an issue, I'm pretty friendly.
 
+### Run the gem's tests
+
 To test locally, against the different versions of ActiveRecord, use Ruby 2.7, the only version currently compatible with all the ActiveRecord versions supported. Install the required gems with:
 
 ```
@@ -127,13 +119,13 @@ bundle install
 bundle exec appraisal install
 ```
 
-Run Unreliable's linter with:
+Run `unreliable`'s linter with:
 
 ```
 bundle exec standardrb
 ```
 
-Then you can run Unreliable's tests with:
+Then you can run `unreliable`'s tests with:
 
 ```
 bundle exec appraisal rake
@@ -143,29 +135,59 @@ Appraisal ensures the tests run against every compatible minor version of Active
 
 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.
 
-Testing against ActiveRecord is done with [Combustion](https://github.com/pat/combustion), which stands up a local single-table SQLite database and an ActiveRecord-based model for it. This gives more reliable coverage than mocking unit tests within ActiveRecord itself.
+Testing against ActiveRecord is done with [Combustion](https://github.com/pat/combustion), which stands up a local SQLite database and ActiveRecord-based models for it. This gives more reliable coverage than mocking unit tests within ActiveRecord itself, though I do some of that too.
 
-If you'd like to see Unreliable in action on a small but real Rails app locally, you can do this:
+### Experiment
 
-1. Start with a 1-line Gemfile: `gem "rails", "~> x.y"`
-2. `bundle install`, then:
-3. `bundle exec rails new . --skip-javascript --skip-webpack-install --skip-sprockets --skip-turbolinks --skip-jbuilder --skip-spring`
-4. Add to Gemfile test block: `gem "unreliable", path: "../unreliable"`
-5. `bundle install` again
-6. `bundle exec rails generate model post title:string body:text`
-7. `RAILS_ENV=test bundle exec rails db:migrate`
-8. `RAILS_ENV=test bundle exec rails c`
-9. You should see "Loading test environment" and the Rails console prompt. Then to test:
+If you'd like to see `unreliable` in action on a small but real Rails app locally, you can do this:
+
+1. In a directory next to your `unreliable` working directory, create a `.ruby-version` of `2.7.6` and a 2-line `Gemfile`: `source "https://rubygems.org"`, `gem "rails", "~> 7.0"`
+2. `bundle install && bundle exec rails new . --force`
+3. `echo 'gem "unreliable", path: "../unreliable"' >> Gemfile`
+4. `bundle install && bundle exec rails generate model post title:string body:text`
+5. `RAILS_ENV=test bundle exec rails db:migrate`
+6. `RAILS_ENV=test bundle exec rails c`
+7. You should see SQLite's `ORDER BY RANDOM()` in ActiveRecord queries:
 
 ```
-3.0.1 :001 > puts Post.where(title: "abc").to_sql
-   (0.7ms)  SELECT sqlite_version(*)
-SELECT "posts".* FROM "posts" WHERE "posts"."title" = 'abc' ORDER BY RAND()
+irb(main):001:0> Post.where(title: "abc")
+   (2.1ms)  SELECT sqlite_version(*)
+  Post Load (0.3ms)  SELECT "posts".* FROM "posts" WHERE "posts"."title" = ? ORDER BY RANDOM()  [["title", "abc"]]
+=> []
+irb(main):002:0> Post.limit(5).delete_all
+  Post Delete All (0.2ms)  DELETE FROM "posts" WHERE "posts"."id" IN (SELECT "posts"."id" FROM "posts" ORDER BY RANDOM() LIMIT ?)  [["LIMIT", 5]]
+=> 0
 ```
 
-## Future development
+## Ordering trivia
+
+The most common ambiguous ordering is an ORDER BY one column that is not unique, like a timestamp.
+
+But there are other ways you can order a relation but still have your query be ambiguous:
+
+* ORDER BY multiple columns, but with no subset which is unique
+* ORDER BY a column with values that differ only by [character case](https://dev.mysql.com/doc/refman/8.0/en/sorting-rows.html)
+* ORDER BY values that are identical within the [prefix length limit](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_max_sort_length) examined for sorting
+
+`unreliable` ensures correct testing because it appends a random order to each of these cases.
+
+## References
+
+SQL standard ([SQL-92](https://web.archive.org/web/20220730144627/https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt)):
+
+> When the ordering of a cursor is partially determined by an _order by clause_, then the relative positions of two rows are determined only by the _order by clause_; if the two rows have equal values for the purpose of evaluating the _order by clause_, then their relative positions are implementation-dependent.
+
+MySQL ([5.6](https://dev.mysql.com/doc/refman/5.6/en/limit-optimization.html), [5.7](https://dev.mysql.com/doc/refman/5.7/en/limit-optimization.html), [8.0](https://dev.mysql.com/doc/refman/8.0/en/limit-optimization.html)):
+
+> If multiple rows have identical values in the `ORDER BY` columns, the server is free to return those rows in any order, and may do so differently depending on the overall execution plan. In other words, the sort order of those rows is nondeterministic with respect to the nonordered columns.
+
+Postgres ([12](https://www.postgresql.org/docs/12/sql-select.html#SQL-ORDERBY), [13](https://www.postgresql.org/docs/13/sql-select.html#SQL-ORDERBY), [14](https://www.postgresql.org/docs/14/sql-select.html#SQL-ORDERBY)):
+
+> If two rows are equal according to the leftmost expression, they are compared according to the next expression and so on. If they are equal according to all specified expressions, they are returned in an implementation-dependent order.
+
+SQLite ([3.39](https://www.sqlite.org/lang_select.html#the_order_by_clause)):
 
-When new minor versions of ActiveRecord or Ruby are released, I will update the Appraisals file and run `bundle exec appraisal update` as well as the install, and update the matrix in the ci.yml workflow. There will be a patch-level release for these changes, even if no Unreliable code changes are required.
+> The order in which two rows for which all ORDER BY expressions evaluate to equal values are returned is undefined.
 
 ## See also
 

data/lib/unreliable/build_order.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Override ActiveRecord::QueryMethods.build_order to always append a final ORDER(RAND())
+# Override ActiveRecord::QueryMethods.build_order to append a final ORDER(RAND()) when necessary
 
 require "active_record/connection_adapters/abstract_adapter"
 
@@ -10,6 +10,8 @@ module Unreliable
       super(arel)
 
       return unless Unreliable::Config.enabled?
+      return if from_only_internal_metadata?(arel)
+      return if from_one_table_with_ordered_pk?(arel)
 
       case Arel::Table.engine.connection.adapter_name
       when "Mysql2"
@@ -26,5 +28,37 @@ module Unreliable
 
       end
     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]
+    end
+
+    def from_one_table_with_ordered_pk?(arel)
+      # This gem isn't (yet) capable of determining if ordering is reliable when two or
+      # more tables are being joined.
+      return false if arel.ast.cores.first.source.is_a?(Arel::Nodes::JoinSource) &&
+        arel.ast.cores.first.source.right.present?
+      return false if arel.froms.count > 1
+
+      # If the single table's primary key's column(s) are covered by the order columns,
+      # return true and don't randomize the order.
+      (primary_key_columns(arel) - order_columns(arel)).empty?
+    end
+
+    def primary_key_columns(arel)
+      # primary_key returns a String if it's one column, an Array if two or more
+      [ActiveRecord::Base.connection.primary_key(arel.froms.first.name)].flatten
+    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
+        .map(&:expr)
+        .select { |expr| expr.relation.name == from_table_name }
+        .map(&:name)
+        .map(&:to_s) # In Rails < 5.2, the order column names are symbols; >= 5.2, strings
+    end
   end
 end

data/lib/unreliable/version.rb

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

data/spec/env_spec.rb

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

data/spec/examples.txt

@@ -1,14 +1,39 @@
-example_id                         | status | run_time        |
----------------------------------- | ------ | --------------- |
-./spec/env_spec.rb[1:1]            | passed | 0.00986 seconds |
-./spec/env_spec.rb[1:2]            | passed | 0.00041 seconds |
-./spec/model_select_spec.rb[1:1]   | passed | 0.00035 seconds |
-./spec/model_select_spec.rb[1:2]   | passed | 0.00044 seconds |
-./spec/model_select_spec.rb[1:3]   | passed | 0.0005 seconds  |
-./spec/model_select_spec.rb[1:4]   | passed | 0.00061 seconds |
-./spec/model_subquery_spec.rb[1:1] | passed | 0.00125 seconds |
-./spec/model_update_spec.rb[1:1]   | passed | 0.00012 seconds |
-./spec/railtie_spec.rb[1:1]        | passed | 0.00062 seconds |
-./spec/railtie_spec.rb[1:2]        | passed | 0.00018 seconds |
-./spec/version_spec.rb[1:1]        | passed | 0.00127 seconds |
-./spec/version_spec.rb[1:2]        | passed | 0.00016 seconds |
+example_id                                 | status | run_time        |
+------------------------------------------ | ------ | --------------- |
+./spec/env_spec.rb[1:1]                    | passed | 0.00346 seconds |
+./spec/env_spec.rb[1:2]                    | passed | 0.00049 seconds |
+./spec/model_cache_versioning_spec.rb[1:1] | passed | 0.03983 seconds |
+./spec/model_indexes_books_spec.rb[1:1]    | passed | 0.00152 seconds |
+./spec/model_indexes_books_spec.rb[1:2]    | passed | 0.00132 seconds |
+./spec/model_indexes_books_spec.rb[1:3]    | passed | 0.00108 seconds |
+./spec/model_indexes_cats_spec.rb[1:1]     | passed | 0.00105 seconds |
+./spec/model_indexes_cats_spec.rb[1:2]     | passed | 0.0015 seconds  |
+./spec/model_indexes_dreams_spec.rb[1:1]   | passed | 0.00313 seconds |
+./spec/model_indexes_dreams_spec.rb[1:2]   | passed | 0.00129 seconds |
+./spec/model_indexes_shelves_spec.rb[1:1]  | passed | 0.00178 seconds |
+./spec/model_indexes_shelves_spec.rb[1:2]  | passed | 0.00174 seconds |
+./spec/model_indexes_shelves_spec.rb[1:3]  | passed | 0.00076 seconds |
+./spec/model_indexes_shelves_spec.rb[1:4]  | passed | 0.00087 seconds |
+./spec/model_indexes_shelves_spec.rb[1:5]  | passed | 0.00079 seconds |
+./spec/model_indexes_shelves_spec.rb[1:6]  | passed | 0.00101 seconds |
+./spec/model_joins_spec.rb[1:1]            | passed | 0.01262 seconds |
+./spec/model_joins_spec.rb[1:2]            | passed | 0.00359 seconds |
+./spec/model_joins_spec.rb[1:3]            | passed | 0.01319 seconds |
+./spec/model_joins_spec.rb[1:4]            | passed | 0.00217 seconds |
+./spec/model_select_spec.rb[1:1]           | passed | 0.0007 seconds  |
+./spec/model_select_spec.rb[1:2]           | passed | 0.00093 seconds |
+./spec/model_select_spec.rb[1:3]           | passed | 0.00091 seconds |
+./spec/model_select_spec.rb[1:4]           | passed | 0.00127 seconds |
+./spec/model_subquery_spec.rb[1:1]         | passed | 0.00155 seconds |
+./spec/model_update_arel_10_spec.rb[1:1]   | passed | 0.00536 seconds |
+./spec/railtie_spec.rb[1:1]                | passed | 0.00013 seconds |
+./spec/railtie_spec.rb[1:2]                | passed | 0.00008 seconds |
+./spec/textual_order_spec.rb[1:1]          | passed | 0.00108 seconds |
+./spec/textual_order_spec.rb[1:2]          | passed | 0.00067 seconds |
+./spec/textual_order_spec.rb[1:3]          | passed | 0.00078 seconds |
+./spec/textual_order_spec.rb[1:4]          | passed | 0.00087 seconds |
+./spec/textual_order_spec.rb[1:5]          | passed | 0.00069 seconds |
+./spec/textual_order_spec.rb[1:6]          | passed | 0.00079 seconds |
+./spec/textual_order_spec.rb[1:7]          | passed | 0.00088 seconds |
+./spec/version_spec.rb[1:1]                | passed | 0.00151 seconds |
+./spec/version_spec.rb[1:2]                | passed | 0.0002 seconds  |

data/spec/model_cache_versioning_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# collection_cache_versioning was added in Rails 6.0. It performs a
+# SELECT COUNT(*), MAX(updated_at) which will have an unnecessary ORDER BY RANDOM()
+# applied to it. That shouldn't hurt anything. This is a simple way to both
+# cover that important code and ensure Unreliable works correctly with
+# aggregate SELECTs.
+
+RSpec.describe Cat do
+  it "in ActiveRecord >= 6, calculates cache versions",
+    skip: ((ActiveRecord::VERSION::MAJOR < 6) ? "test is for ActiveRecord >= 6 only" : false) do
+    old_setting = ActiveRecord::Base.collection_cache_versioning
+    ActiveRecord::Base.collection_cache_versioning = true
+    Cat.new(name: "spot").save!
+    Cat.new(name: "sadie").save!
+    expect(Cat.where("name LIKE 's%'").cache_version).to start_with("2-")
+    expect(Cat.where(name: "foo").cache_version).to eq("0")
+  ensure
+    Cat.delete_all
+    ActiveRecord::Base.collection_cache_versioning = old_setting
+  end
+end

data/spec/model_indexes_books_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe "model_indexes_books" do
+  it "randomly selects from books with no order" do
+    expect(Book.all.to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "randomly selects from books ordered by nonindexed column" do
+    expect(Book.all.order(:subject).to_sql).to end_with('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('ORDER BY "books"."isbn" ASC, RANDOM()')
+  end
+end

data/spec/model_indexes_cats_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe "model_indexes_cats" do
+  it "randomly selects from cats" do
+    expect(Cat.all.to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "nonrandomly selects from cats by implied primary key descending" do
+    expect(Cat.all.order(id: :desc).to_sql).to end_with('ORDER BY "cats"."id" DESC')
+  end
+end

data/spec/model_indexes_dreams_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe "model_indexes_dreams" do
+  it "randomly selects from dreams ordered by nonindexed column" do
+    expect(Dream.all.order(:subject).to_sql).to end_with('ORDER BY "dreams"."subject" ASC, RANDOM()')
+  end
+
+  it "nonrandomly selects from dreams by explicit primary key" do
+    expect(Dream.all.order(:dream_id).to_sql).to end_with('ORDER BY "dreams"."dream_id" ASC')
+  end
+end

data/spec/model_indexes_shelves_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe "model_indexes_shelves" do
+  it "randomly selects from shelves" do
+    expect(Shelf.all.to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "randomly selects from some shelves" do
+    expect(Shelf.where(contents: "foo").to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "randomly selects from shelves ordered by id" do
+    expect(Shelf.order(:shelf_id).to_sql).to end_with('ORDER BY "shelves"."shelf_id" ASC, RANDOM()')
+  end
+
+  it "randomly selects from shelves ordered by position" do
+    expect(Shelf.order(:shelf_position).to_sql).to end_with(
+      'ORDER BY "shelves"."shelf_position" ASC, RANDOM()'
+    )
+  end
+
+  it "nonrandomly selects from shelves ordered by id and position" do
+    expect(Shelf.order(:shelf_id, :shelf_position).to_sql).to end_with(
+      'ORDER BY "shelves"."shelf_id" ASC, "shelves"."shelf_position" ASC'
+    )
+  end
+
+  it "nonrandomly selects from some shelves ordered by id and position" do
+    expect(Shelf.where(contents: "bar").order(:shelf_id, :shelf_position).to_sql).to end_with(
+      'ORDER BY "shelves"."shelf_id" ASC, "shelves"."shelf_position" ASC'
+    )
+  end
+end

data/spec/model_joins_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# So far, unreliable does not try to know when it can omit the ORDER BY RANDOM()
+# when joining tables. It's unnecessary in some of the below tests and a future
+# version that's smart about joins might be able to omit it.
+
+RSpec.describe "model_indexes_joins" do
+  it "randomly selects from owner has_many cats" do
+    expect(Owner.joins(:cats).all.to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "randomly selects from owner has_many ordered cats" do
+    expect(Owner.joins(:cats).order("owners.id": :asc).all.to_sql).to end_with(", RANDOM()")
+    expect(Owner.joins(:cats).order(:"cats.id").all.to_sql).to end_with(", RANDOM()")
+    expect(Owner.joins(:cats).order(:"owners.id", "cats.id": :desc).all.to_sql).to end_with(", RANDOM()")
+    expect(Owner.joins(:cats).order(:"owners.id", :"cats.name").all.to_sql).to end_with(", RANDOM()")
+  end
+
+  it "randomly selects from dreamer has_one dream" do
+    expect(Dreamer.joins(:dream).all.to_sql).to end_with("ORDER BY RANDOM()")
+  end
+
+  it "randomly selects from dreamer has_one ordered dream" do
+    expect(Dreamer.joins(:dream).order("dreamers.id": :desc).all.to_sql).to end_with(", RANDOM()")
+    expect(Dreamer.joins(:dream).order(:"dreams.id").all.to_sql).to end_with(", RANDOM()")
+  end
+end

data/spec/model_select_spec.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-RSpec.describe Thing do
+RSpec.describe Cat do
   it "randomly selects from all" do
-    expect(Thing.all.to_sql).to end_with("ORDER BY RANDOM()")
+    expect(Cat.all.to_sql).to end_with("ORDER BY RANDOM()")
   end
 
   it "randomly selects from some" do
-    expect(Thing.where(word: "foo").to_sql).to end_with("ORDER BY RANDOM()")
+    expect(Cat.where(name: "foo").to_sql).to end_with("ORDER BY RANDOM()")
   end
 
   it "adds randomness to existing order" do
-    expect(Thing.order(:word).to_sql).to end_with('ORDER BY "things"."word" ASC, RANDOM()')
+    expect(Cat.order(:name).to_sql).to end_with('ORDER BY "cats"."name" ASC, RANDOM()')
   end
 
   it "respects a disable block" do
     Unreliable::Config.disable do
-      expect(Thing.where(word: "foo").to_sql).to_not end_with("ORDER BY RANDOM()")
-      expect(Thing.where(word: "foo").to_sql).to end_with(%q("things"."word" = 'foo'))
+      expect(Cat.where(name: "foo").to_sql).to_not end_with("ORDER BY RANDOM()")
+      expect(Cat.where(name: "foo").to_sql).to end_with(%q("cats"."name" = 'foo'))
     end
   end
 end

data/spec/model_subquery_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-RSpec.describe Thing do
+RSpec.describe Cat do
   it "randomly selects in main query and subquery" do
     # rubocop:disable Layout/SpaceInsideParens,Layout/DotPosition
-    expect( Thing.where(word: Thing.where(word: "foo")).to_sql ).
-      to end_with( %q[WHERE "things"."word" = 'foo' ORDER BY RANDOM()) ORDER BY RANDOM()] )
+    expect( Cat.where(name: Cat.where(name: "foo")).to_sql ).
+      to end_with( %q[WHERE "cats"."name" = 'foo' ORDER BY RANDOM()) ORDER BY RANDOM()] )
     # rubocop:enable Layout/SpaceInsideParens,Layout/DotPosition
   end
 end