constable-rails 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb4658a48f23de1dcb97417de5bab1deda4548a334e2a198835f93b7cac656c3
-  data.tar.gz: c844e9f7ac1c8d797d60349b7b15759bbcbbb0f1b56c914d43e2511e17f75489
+  metadata.gz: 5fd3b3f867d958ed8f1306a51fb6a001145d88bd4c79839dd6d603f0b565248b
+  data.tar.gz: 1dee6cf2bece623c102744cb44e271461907d386715ed435fcc871ee131dd92c
 SHA512:
-  metadata.gz: c3e78d5c2d2ab5314ee501795a92a1017fbfe0eb4cab6889c7ab6883d1ff898b02a595a693c3bb774c8e8e26caed2132c4f0c033723e7389735386f7b6c43668
-  data.tar.gz: 9f60ad3894558087d8747a5308e39558ce03d87c1518608dff21c9ca341fc776f11ceea45b7251435f052654ead1bbf348c489086b5857cea8e1b0a845781ff8
+  metadata.gz: 1f6c418f0dd90a2e6e45733b237e8aa3c8e2e0d7c62b55d145dc7596bf047569983f243ba92558050612328f78834971cf5fef19e52efe4eb4deee0f5a751506
+  data.tar.gz: 74e6fd7f76215036de95d36ccdd84a068a71b999368e97f998e5e832c2230d3624eaf6aba4aafe0ff5edf2aa0245b15a050e85fb5784347c6407a01d72842711

data/CHANGELOG.md

@@ -5,6 +5,51 @@ All notable changes to this project are documented here. This project adheres to
 
 ## [Unreleased]
 
+## [1.4.0]
+
+Two problems from the same 1,277-file suite: a docket nobody asked for, and 110 minutes.
+
+### A flaky test is no longer jailed by itself
+
+**This is the important one, because jailed means skipped.** A first `constable test` on a
+real suite put **29 tests on a docket the user had never asked for** — each one recorded
+as *"passed, then failed with no code change"* — and every one of them was silently
+skipped from then on. A suite with order-dependent tests, which is most large suites and
+exactly what Constable is pitched at, trips that constantly.
+
+Automatic flake-jailing is now off by default:
+
+```yaml
+jail_flakes: false   # was: always on
+```
+
+`constable test --jail` still jails failures, because that is a thing you asked for.
+Turn the automatic route back on when you want it. Nothing stops being *reported* — a
+flaky test still fails, still shows up, still gets a warrant if warrants are on. It just
+does not remove itself from the suite.
+
+### Per-worker databases without a loadable schema
+
+The same suite ran **serially for 110 minutes on a 12-core machine**, because its schema
+cannot be loaded from `schema.rb` (Postgres custom types), so `worker_databases: off` was
+the only setting that worked.
+
+Postgres can copy a whole database in one statement, and that needs no schema at all:
+
+```sql
+CREATE DATABASE "caseflow_test_3" TEMPLATE "caseflow_test"
+```
+
+`worker_databases: reuse` now clones from the test database you already have, dropping a
+stale copy and disconnecting the template first. It falls back to loading the schema when
+there is nothing to clone, and to Postgres only — anything unexpected takes the old path
+rather than failing. It is also simply faster than replaying a large schema once per
+worker, so it is worth having on any Postgres app.
+
+For a suite that could only run serially, this is the difference between one core and all
+of them.
+
+
 ## [1.3.3]
 
 **1.3.2 was tagged twice.** The console fix in it was rebuilt after the gem had already
@@ -619,7 +664,8 @@ Initial release.
 - Diff-based coverage gate — only lines changed in the current diff are held to the
   threshold. `constable beat` for the full picture, `--html` for a browsable report.
 
-[Unreleased]: https://github.com/Ray-Hughes/constable/compare/v1.3.3...HEAD
+[Unreleased]: https://github.com/Ray-Hughes/constable/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/Ray-Hughes/constable/compare/v1.3.3...v1.4.0
 [1.3.3]: https://github.com/Ray-Hughes/constable/compare/v1.3.2...v1.3.3
 [1.3.2]: https://github.com/Ray-Hughes/constable/compare/v1.3.1...v1.3.2
 [1.3.1]: https://github.com/Ray-Hughes/constable/compare/v1.3.0...v1.3.1

data/README.md

@@ -7,7 +7,7 @@
 
 **A strict Rails testing framework where fast and non-flaky are structural, not disciplinary.**
 
-[![Gem Version](https://img.shields.io/gem/v/constable-rails?color=1f6feb&label=constable-rails)](https://rubygems.org/gems/constable-rails)
+[![Gem Version](https://badge.fury.io/rb/constable-rails.svg)](https://badge.fury.io/rb/constable-rails)
 [![CI](https://github.com/Ray-Hughes/constable/actions/workflows/ci.yml/badge.svg)](https://github.com/Ray-Hughes/constable/actions/workflows/ci.yml)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.1-CC342D)](https://www.ruby-lang.org)
 [![Rails](https://img.shields.io/badge/rails-%3E%3D%207.0-D30001)](https://rubyonrails.org)

data/lib/constable/config.rb

@@ -22,6 +22,7 @@ module Constable
       "output" => "concise",
       "parallel_workers" => "auto",
       "worker_databases" => "schema",
+      "jail_flakes" => false,
       "tiers" => {
         "unit" => "test/cases/models/**/*",
         "integration" => "test/cases/controllers/**/*",
@@ -76,6 +77,19 @@ module Constable
 
     def cold_cases         = Array(@raw["cold_cases"])
     def warrants?          = truthy(@raw["warrants"])
+
+    # Should a test that passed last run and failed this one be put on the docket by
+    # itself? Off by default, and the reason is what jailing *does*: a jailed test is
+    # skipped on every later run. Turning that on automatically means a suite quietly
+    # stops running tests nobody chose to stop running.
+    #
+    # Observed on a real suite: a first `constable test` put 29 tests on a docket the user
+    # had never asked for, and every one of them was skipped from then on. A suite with
+    # order-dependent tests -- which is most large suites, and exactly the kind Constable
+    # is pitched at -- trips this constantly.
+    #
+    # `constable test --jail` still jails failures, because that is a thing you asked for.
+    def jail_flakes?       = truthy(@raw["jail_flakes"])
     # Negative retries are a typo for "off", not an instruction to count backwards.
     def warrant_retries    = [@raw["warrant_retries"].to_i, 0].max
     def auto_relink?       = truthy(@raw["auto_relink"])

data/lib/constable/jail.rb

@@ -123,6 +123,13 @@ module Constable
 
     # Consecutive clean runs that earn an automatic release. Floors at 1 -- a period of
     # zero would mean "release on sight", which is not parole.
+    # Opt-in. See Config#jail_flakes? for why the default is off: jailing skips the test on
+    # every later run, and doing that to a test nobody nominated is how a suite quietly
+    # stops testing things.
+    def jail_flakes?
+      @config.respond_to?(:jail_flakes?) ? @config.jail_flakes? : false
+    end
+
     def parole_period
       period = @config.respond_to?(:parole_period) ? @config.parole_period.to_i : 0
       period.positive? ? period : 10
@@ -290,7 +297,7 @@ module Constable
 
       if jail_mode
         jail_failure(result)
-      elsif flake_flip?(result)
+      elsif flake_flip?(result) && jail_flakes?
         jail_for_flake(result)
       else
         result

data/lib/constable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Constable
-  VERSION = "1.3.3"
+  VERSION = "1.4.0"
 end

data/lib/constable/worker_databases.rb

@@ -105,6 +105,73 @@ module Constable
                           .zip(names).each { |config, name| config._database = name if name }
     end
 
+    # Postgres can copy a whole database in one statement:
+    #
+    #   CREATE DATABASE "caseflow_test_3" TEMPLATE "caseflow_test"
+    #
+    # That matters because it needs no schema.rb at all. An app whose schema cannot
+    # rebuild the database by itself -- custom types, functions, triggers -- can still get
+    # per-worker databases this way, cloned from the test database it already has. It is
+    # also far faster than replaying a large schema once per worker.
+    #
+    # Returns true when it cloned, false when this is not Postgres or the source is not
+    # there, so the caller can fall back to loading the schema.
+    def clone_database(db_config, index)
+      return false unless postgres?(db_config)
+
+      source = db_config.database.to_s.sub(/_#{index}\z/, "")
+      target = db_config.database.to_s
+      return false if source.empty? || source == target
+
+      maintenance_connection(db_config) do |connection|
+        return false unless database_exists?(connection, source)
+
+        # A template cannot be copied while anything is connected to it.
+        disconnect_everyone_from!(connection, source)
+        connection.execute(%(DROP DATABASE IF EXISTS "#{target}"))
+        connection.execute(%(CREATE DATABASE "#{target}" TEMPLATE "#{source}"))
+      end
+
+      true
+    rescue StandardError
+      # Cloning is the fast path, never the only one. Anything unexpected -- a permission,
+      # a Postgres version, a connection that will not drop -- falls back to the schema.
+      false
+    end
+
+    def postgres?(db_config)
+      db_config.respond_to?(:adapter) && db_config.adapter.to_s.include?("postgre")
+    end
+
+    # Postgres will not let you create a database while connected to the one you are
+    # copying, so the statements run against the cluster's own maintenance database.
+    def maintenance_connection(db_config)
+      previous = ::ActiveRecord::Base.connection_db_config
+      ::ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(database: "postgres"))
+      yield ::ActiveRecord::Base.connection
+    ensure
+      ::ActiveRecord::Base.establish_connection(previous)
+    end
+
+    def database_exists?(connection, name)
+      # Plain Ruby, not #present?: this runs inside a forked worker in somebody else's app,
+      # and quietly depending on ActiveSupport being loaded is how a fast path silently
+      # turns itself off.
+      value = connection.select_value("SELECT 1 FROM pg_database WHERE datname = #{connection.quote(name)}")
+      !value.nil?
+    rescue StandardError
+      false
+    end
+
+    def disconnect_everyone_from!(connection, name)
+      connection.execute(
+        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity " \
+        "WHERE datname = #{connection.quote(name)} AND pid <> pg_backend_pid()"
+      )
+    rescue StandardError
+      nil
+    end
+
     # The :reuse half. Points every database this environment declares at its `_<index>`
     # sibling, and only builds the ones that are not there yet.
     #
@@ -121,6 +188,10 @@ module Constable
       each_worker_config(index) do |db_config|
         next if populated?(db_config)
 
+        # Clone first: it needs no schema.rb, which is the only thing that works for an
+        # app whose schema cannot rebuild the database, and it is faster besides.
+        next built << "#{db_config.database} (cloned)" if clone_database(db_config, index)
+
         ::ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
         built << db_config.database
       end

data/lib/constable.rb

@@ -149,7 +149,7 @@ module Constable
     SETTINGS = %i[
       cold_cases warrants warrant_retries auto_relink parole_period
       coverage coverage_threshold coverage_html fail_on_warnings parallel_workers
-      worker_databases output tiers
+      worker_databases jail_flakes output tiers
     ].freeze
 
     # `storage` is the one setting that cannot live here, and the reason is ordering, not

data/lib/generators/constable/templates/case_helper.rb.tt

@@ -159,6 +159,7 @@ end
 #      c.worker_databases   = :schema # or :reuse (keep them between runs) / :off
 #      c.output             = :concise    # or :expanded -- a line per test, with timings
 #      c.fail_on_warnings   = false   # CI: fail when the warning count is not trending down
+#      c.jail_flakes        = false   # auto-jail a pass->fail flip (jailed = skipped)
 #      c.warrants           = false   # rerun a failure in isolation before believing it
 #      c.warrant_retries    = 5
 #      c.parole_period      = 10      # clean runs before a paroled test releases itself

data/lib/generators/constable/templates/config.yml.tt

@@ -59,6 +59,14 @@ storage:
   url:                                 # postgres/mysql only, e.g.
                                        #   postgres://user:pass@host/constable_metadata
 
+# Put a test on the docket by itself when it passed last run and failed this one, with no
+# code change in between. Off by default, and the reason is what jailing *does*: a jailed
+# test is skipped on every later run. Turning that on automatically means a suite quietly
+# stops running tests nobody chose to stop running -- and a suite with order-dependent
+# tests, which is most large ones, trips it constantly. `constable test --jail` still
+# jails failures, because that is a thing you asked for.
+jail_flakes: false
+
 warrants: false          # opt-in flaky detector -- rerun a failure in isolation before believing it
 warrant_retries: 5       # reruns before declaring a warrant (flaky) or a genuine failure
 auto_relink: false       # auto-confirm high-confidence rename detection instead of suggesting it

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: constable-rails
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - Ray Hughes
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-08 00:00:00.000000000 Z
+date: 2026-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport