constable-rails 1.3.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9f421fcc02a9f1c30aae54819a543cf548bdd997f8e638899ac6e448d093907
-  data.tar.gz: 506be0d669595b7e3f965f81f6449b4c074f4ade3a98c15d9283d78eca1cd584
+  metadata.gz: 5fd3b3f867d958ed8f1306a51fb6a001145d88bd4c79839dd6d603f0b565248b
+  data.tar.gz: 1dee6cf2bece623c102744cb44e271461907d386715ed435fcc871ee131dd92c
 SHA512:
-  metadata.gz: bf1762345ec78b7e7133e724fc9e525d2b037013eb940d49c1fdb6de2940a56284fa67c476e93c229840410e344a92e342bd344f9d21ba7c18c3a6217c3e7a2c
-  data.tar.gz: 74b67cd3a65966adc81147e272d08a3b5f092e8602dc3b543c6b2aa878f1bbead4eaabf555d072cc66b97c2137d4bf9593658478235730f3229f15cac0ef1096
+  metadata.gz: 1f6c418f0dd90a2e6e45733b237e8aa3c8e2e0d7c62b55d145dc7596bf047569983f243ba92558050612328f78834971cf5fef19e52efe4eb4deee0f5a751506
+  data.tar.gz: 74e6fd7f76215036de95d36ccdd84a068a71b999368e97f998e5e832c2230d3624eaf6aba4aafe0ff5edf2aa0245b15a050e85fb5784347c6407a01d72842711

data/CHANGELOG.md

@@ -5,6 +5,100 @@ 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
+been pushed, and RubyGems will not accept a second push of the same version — so the
+published 1.3.2 does not contain it. That fix is here, along with two more found on a
+1,277-file suite.
+
+### Shared examples survive across cold-case files
+
+A suite that keeps shared examples in a plain file beside its specs —
+`require_relative "appeal_shared_examples"` at the top of `appeal_spec.rb` — registers
+them the first time that file loads. `require` never fires again, so every later file
+that shares them died on load:
+
+```
+✗ spec/models/legacy_appeal_spec.rb  "failed to load"
+  ArgumentError: Could not find shared examples "toggle overtime"
+```
+
+Twelve files in one run, every one of which passes in isolation. RSpec never hits this
+because it loads every spec file and *then* runs them; Constable loads one at a time,
+which is what makes a cold case cheap, so the registry has to be carried across by hand.
+
+Same two files, before and after: 12 files failing to load → `458 passed, 0 failed`.
+
+### Rename suggestions are a section, not a wall
+
+They were printed unlabelled after SLOWEST, one long line per suggestion, each carrying
+two full test descriptions and two hashes. A real suite produced two hundred of them —
+several hundred lines with no heading, burying every section above.
+
+Now a `RENAMED?` section: eight at a time, three short lines each, with the rest counted.
+Descriptions are truncated to the frame, because an RSpec description built from a matcher
+carries the entire inspected object — every column of a record, ids and timestamps
+included.
+
+### The app's stdout, again (from 1.3.2, unpublished)
+
+Reassigning the `$stdout` object was not enough: a gem writing through the `STDERR`
+constant, or anything already holding the descriptor, goes straight past it, and in a
+terminal both streams land in the same place. The descriptors are now redirected with
+`IO#reopen`, with an `at_exit` guard so a crash still prints where it can be seen.
+
+CLI errors no longer use `Kernel#warn`. Rails apps routinely override `Warning.warn` to
+funnel Ruby warnings into `Rails.logger`, and a real one did: `no tests matched ...`
+arrived in `log/test.log` tagged `[RUBY WARNING]` while the terminal showed nothing at
+all, so the command looked like it had silently done nothing.
+
+
 ## [1.3.2]
 
 ### stdout is results only — the app's stdout too, not just Constable's
@@ -27,8 +121,24 @@ noise is emitted *by* booting it. And colour detection was asking `$stdout.tty?`
 by then is a file, and a file is never a tty, so colour would have silently switched off
 for everybody.
 
-Not intercepted: a write straight to file descriptor 2. Capturing that would also swallow
-a real crash and break `binding.pry`, so `2>/dev/null` stays the user's decision.
+Reassigning the `$stdout` *object* turned out not to be enough — a gem writing through
+the `STDERR` constant, or anything already holding the descriptor, goes straight past it,
+and in a terminal both streams land in the same place. So the **descriptors** are
+redirected with `IO#reopen`, which is the only thing that catches every writer, and the
+reporter is handed a dup of the real terminal taken beforehand. An `at_exit` guard puts
+them back, so an uncaught exception still prints its backtrace where you can see it.
+
+Two things that fell out of doing it properly:
+
+- **CLI errors no longer use `Kernel#warn`.** With the descriptors redirected an error
+  would have gone into the log — and `warn` would not have reached the terminal even
+  without that, because Rails apps routinely override `Warning.warn` to funnel Ruby
+  warnings into `Rails.logger`. A real one did: `no tests matched ...` arrived in
+  `log/test.log` tagged `[RUBY WARNING]` while the terminal showed nothing at all. Errors
+  now go to the console the reporter kept, on stderr.
+- **Colour detection was asking the wrong stream.** `$stdout.tty?`, when `$stdout` is by
+  then a log file and a file is never a tty — colour would have silently switched off for
+  everybody.
 
 
 ## [1.3.1]
@@ -554,7 +664,9 @@ 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.2...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
 [1.3.0]: https://github.com/Ray-Hughes/constable/compare/v1.2.0...v1.3.0

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/cli.rb

@@ -21,13 +21,29 @@ module Constable
     # tier, an unreadable config. Both are the user's mistake rather than a crash, and
     # both deserve one sentence and a usage status instead of a backtrace.
     rescue Thor::Error, Constable::Error => e
-      warn e.message
+      complain(e.message)
       exit(EXIT_USAGE)
     rescue Interrupt
-      warn "\ninterrupted"
+      complain("\ninterrupted")
       exit(EXIT_FAILED)
     end
 
+    # Anything the user has to see, written where they will see it.
+    #
+    # Not Kernel#warn. A run points stdout and stderr at log/test.log, so an error has to
+    # go to the console the reporter kept -- and `warn` would not reach it even without
+    # that: Rails apps routinely override Warning.warn to funnel Ruby warnings into
+    # Rails.logger, and a real one did. The message arrived in log/test.log tagged
+    # "[RUBY WARNING]" while the terminal showed nothing at all.
+    def self.complain(message)
+      LogRouter.restore!
+      io = LogRouter.console_err
+      io.puts(message)
+      io.flush if io.respond_to?(:flush)
+    rescue StandardError
+      $stderr.puts(message) # rubocop:disable Style/StderrPuts
+    end
+
     class_option :"no-color", type: :boolean, default: false, desc: "Disable ANSI color"
 
     desc "test [PATH[:LINE]]", "Run the suite -- native and cold cases side by side"
@@ -184,7 +200,7 @@ module Constable
     option :"show-source", type: :boolean, default: false, desc: "Print the rewritten source"
     def modernize(*paths)
       if paths.empty?
-        warn "modernize needs at least one path"
+        CLI.complain("modernize needs at least one path")
         exit(EXIT_USAGE)
       end
 
@@ -309,7 +325,7 @@ module Constable
 
           identity = jail.resolve(locator)
           unless identity
-            warn "Nothing on the docket at #{locator}"
+            CLI.complain("Nothing on the docket at #{locator}")
             exit(EXIT_USAGE)
           end
           yield jail, identity
@@ -320,9 +336,9 @@ module Constable
         def refuse_ambiguous(locator, candidates, noun)
           return if candidates.size <= 1
 
-          warn "#{locator} matches #{candidates.size} tests #{noun}. Name one:"
+          CLI.complain("#{locator} matches #{candidates.size} tests #{noun}. Name one:")
           candidates.sort_by { |entry| entry.line.to_i }.each do |entry|
-            warn "  #{entry.location}  #{entry.label}"
+            CLI.complain("  #{entry.location}  #{entry.label}")
           end
           exit(EXIT_USAGE)
         end
@@ -368,7 +384,7 @@ module Constable
 
         identity = warrants.resolve(locator)
         unless identity
-          warn "No warrant at #{locator}"
+          CLI.complain("No warrant at #{locator}")
           exit(EXIT_USAGE)
         end
         warrants.release(identity)
@@ -413,7 +429,7 @@ module Constable
     def prepare
       config = load_config
       unless WorkerDatabases.shardable?
-        warn "This app has no ActiveRecord test databases to prepare."
+        CLI.complain("This app has no ActiveRecord test databases to prepare.")
         exit(EXIT_USAGE)
       end
 
@@ -429,7 +445,7 @@ module Constable
           "rebuilding them."
       0
     rescue Constable::Error => e
-      warn e.message
+      CLI.complain(e.message)
       exit(EXIT_FAILED)
     end
 

data/lib/constable/cold_case/rspec.rb

@@ -149,6 +149,7 @@ module Constable
           @session_configuration = nil
           @session_prepared = false
           @ran_before_suite_hooks = nil
+          @shared_examples = nil
           nil
         end
 
@@ -252,9 +253,11 @@ module Constable
           ::RSpec.instance_variable_set(:@configuration, @session_configuration)
           prepare_session_configuration(::RSpec.configuration)
           clear_examples
+          restore_shared_examples!
 
           yield
         ensure
+          remember_shared_examples!
           @session_world         = ::RSpec.instance_variable_get(:@world)
           @session_configuration = ::RSpec.instance_variable_get(:@configuration)
           clear_examples
@@ -325,6 +328,38 @@ module Constable
           []
         end
 
+        # Shared examples are registered on the world, by `require`, once per process.
+        #
+        # A suite that keeps them in a plain file next to its specs -- `require_relative
+        # "appeal_shared_examples"` at the top of appeal_spec.rb -- registers them while
+        # the first file runs. `require` never fires again, so if the registry does not
+        # survive into the next file, every later file that shares them dies on load with
+        # `Could not find shared examples "toggle overtime"`.
+        #
+        # Under RSpec that never happens: it loads every spec file first, then runs them.
+        # Constable loads one file at a time, which is what makes a cold case cheap, so
+        # the registry has to be carried across by hand. Observed on a real suite: twelve
+        # files failing to load, all of which pass in isolation.
+        def remember_shared_examples!
+          world = ::RSpec.instance_variable_get(:@world)
+          return unless world.respond_to?(:shared_example_group_registry)
+
+          @shared_examples = world.shared_example_group_registry
+        rescue StandardError
+          nil
+        end
+
+        def restore_shared_examples!
+          return if @shared_examples.nil?
+
+          world = ::RSpec.world
+          return unless world.respond_to?(:shared_example_group_registry)
+
+          world.instance_variable_set(:@shared_example_group_registry, @shared_examples)
+        rescue StandardError
+          nil
+        end
+
         def clear_examples
           world = ::RSpec.instance_variable_get(:@world)
           world.reset if world.respond_to?(:reset)

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/log_router.rb

@@ -121,6 +121,10 @@ module Constable
       # else writes to the log.
       def console = @console_out || $stdout
 
+      # The same, for the stream errors belong on. Convention puts them on stderr, and a
+      # run has pointed the real one at the log.
+      def console_err = @console_err || $stderr
+
       # Rails loggers are not the only thing that writes to a terminal. A gem warning --
       # Faraday's "install the faraday-retry gem", say -- goes straight to $stderr, once
       # per file that triggers it, and lands in the middle of the live stream:
@@ -132,19 +136,74 @@ module Constable
       # terminal it captured beforehand. `--verbose` tees both back, which is the whole
       # point of that flag.
       def capture_console!(file, tee_to)
-        @console_out = $stdout
-        @console_err = $stderr
+        # Reassigning the $stdout *object* is not enough. A gem that writes through the
+        # STDERR constant, a C extension, or anything that already holds file descriptor 2
+        # goes straight past it -- and in a terminal both streams land in the same place,
+        # so "it was only on stderr" is no comfort at all when it lands mid-glyph.
+        #
+        # So the descriptors themselves are pointed at the log, and the reporter is handed
+        # a dup of the real terminal taken beforehand. #reopen changes where fd 1 and 2
+        # write for the whole process, which is the only thing that catches every writer.
+        @console_out = $stdout.dup
+        @console_err = $stderr.dup
+        @reopened    = false
+
+        # --verbose means "show me everything", so nothing is redirected; the object swap
+        # is enough to tee. The same fallback covers anything that is not a real IO on
+        # both sides -- a StringIO standing in for the terminal in a test, most obviously,
+        # where IO#reopen has nothing to reopen onto.
+        if tee_to || !redirectable?(file)
+          @swapped_out = $stdout
+          @swapped_err = $stderr
+          replacement  = tee_to ? Tee.new(file, tee_to) : file
+          $stdout = replacement
+          $stderr = replacement
+          return
+        end
+
+        $stdout.reopen(file)
+        $stderr.reopen(file)
+        $stdout.sync = true
+        $stderr.sync = true
+        @reopened = true
+
+        # Whatever happens next -- a clean exit, a raise, an interrupt -- the descriptors
+        # go back. Without this an uncaught exception prints its backtrace into
+        # log/test.log and the terminal shows nothing at all, which is a far worse bug
+        # than the one being fixed.
+        install_exit_guard!
+      end
+
+      def install_exit_guard!
+        return if @exit_guard_installed
 
-        replacement = tee_to ? Tee.new(file, tee_to) : file
-        $stdout = replacement
-        $stderr = replacement
+        @exit_guard_installed = true
+        at_exit { restore_console! }
+      end
+
+      # Every party has to be a real IO: the log we are redirecting to, and the two streams
+      # we are redirecting away from and will later have to put back.
+      def redirectable?(file)
+        [file, $stdout, $stderr].all? { |io| io.is_a?(::IO) && io.respond_to?(:fileno) }
+      rescue StandardError
+        false
       end
 
       def restore_console!
-        $stdout = @console_out if @console_out
-        $stderr = @console_err if @console_err
+        if @reopened
+          $stdout.reopen(@console_out)
+          $stderr.reopen(@console_err)
+        elsif @swapped_out
+          $stdout = @swapped_out
+          $stderr = @swapped_err
+        end
+
+        [@console_out, @console_err].each { |io| io&.close unless io&.closed? } if @reopened
         @console_out = nil
         @console_err = nil
+        @swapped_out = nil
+        @swapped_err = nil
+        @reopened = false
       end
 
       # Puts back whatever the app had before route!. Only useful in-process (our own

data/lib/constable/reporter.rb

@@ -50,6 +50,10 @@ module Constable
     # thousand lines that say the same thing.
     COLD_CASE_LIST_LIMIT = 10
 
+    # How many rename suggestions are listed before the rest are counted instead. A real
+    # suite produced two hundred, several hundred lines of output, unlabelled.
+    RENAME_LIST_LIMIT = 8
+
     DEFAULT_SLOWEST = 5
 
     # Column the expanded stream right-aligns durations into. Descriptions are never
@@ -679,27 +683,58 @@ module Constable
 
     # Rename detection is the Runner's job; the reporter only says it out loud. Never
     # its own section -- it is a suggestion, not a finding.
+    # Renames get a section of their own, a cap, and one line each.
+    #
+    # They used to be dumped unlabelled after SLOWEST, one long line per suggestion,
+    # every line carrying both full test descriptions and two hashes. A real suite
+    # produced two hundred of them and several hundred lines of output -- read as a wall
+    # of text with no heading, and buried the sections above it. A suggestion nobody can
+    # read is not a suggestion.
     def rename_suggestions(suggestions)
-      suggestions = Array(suggestions).map { |s| suggestion_line(s) }.compact
+      suggestions = Array(suggestions).map { |s| suggestion(s) }.compact
       return if suggestions.empty?
 
-      writeln
-      suggestions.each { |line| writeln(INDENT + paint(line, :dim)) }
+      section("RENAMED?")
+      shown = suggestions.first(RENAME_LIST_LIMIT)
+
+      each_entry(shown) do |item|
+        writeln(INDENT + paint(item[:from].to_s, :dim))
+        writeln(ENTRY_INDENT + paint("→ #{item[:to]}", :dim))
+        writeln(ENTRY_INDENT + paint("constable history relink #{item[:old_hash]} #{item[:new_hash]}", :dim))
+      end
+
+      remaining = suggestions.size - shown.size
+      hint(if remaining.positive?
+             "...and #{remaining} more. A test's history is keyed on its body, so a test " \
+               "that was reworded and edited in one commit looks like a new one. Relink the " \
+               "ones you recognise; ignore the rest and they age out."
+           else
+             "A test's history is keyed on its body, so one that was reworded and edited " \
+               "in the same commit looks like a new test. Relink it to carry the history over."
+           end)
     end
 
-    def suggestion_line(suggestion)
-      return suggestion.to_s if suggestion.is_a?(String)
-      return nil unless suggestion.respond_to?(:to_h)
+    def suggestion(raw)
+      return { from: raw.to_s, to: nil, old_hash: nil, new_hash: nil } if raw.is_a?(String)
+      return nil unless raw.respond_to?(:to_h)
 
-      s = suggestion.to_h.transform_keys(&:to_sym)
+      s = raw.to_h.transform_keys(&:to_sym)
       from = s[:old_label] || s[:from] || label_for(s[:old_case], s[:old_description])
       to   = s[:new_label] || s[:to]   || label_for(s[:new_case], s[:new_description])
-      old_hash = s[:old_hash] || s[:old_identity]
-      new_hash = s[:new_hash] || s[:new_identity]
       return nil if from.nil? || to.nil?
 
-      "possible rename: #{from} → #{to}, " \
-        "run constable history relink #{old_hash} #{new_hash} to confirm"
+      { from: truncate_label(from), to: truncate_label(to),
+        old_hash: s[:old_hash] || s[:old_identity], new_hash: s[:new_hash] || s[:new_identity] }
+    end
+
+    # A description built by RSpec from a matcher carries the whole inspected object --
+    # ids, timestamps, every column of a record. Printed in full it is unreadable, and it
+    # is the same test either way.
+    def truncate_label(label)
+      text = label.to_s.tr("\n", " ").squeeze(" ")
+      return text if text.length <= RULE_WIDTH - INDENT.length
+
+      "#{text[0, RULE_WIDTH - INDENT.length - 1]}…"
     end
 
     def label_for(case_name, description)

data/lib/constable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Constable
-  VERSION = "1.3.2"
+  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.2
+  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