constable-rails 0.1.0

data/lib/generators/constable/model/model_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate model Post title:string` (and by anything else that ends
+    # up at active_record:model -- `rails generate resource`, `rails generate scaffold`).
+    #
+    #   test/cases/models/post_case.rb   class PostCase < UnitCase
+    class ModelGenerator < Base
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      # Accepted and ignored, so `rails generate model --fixture` still runs for an app
+      # that passes it out of habit. Constable has no fixtures: a witness builds exactly
+      # what one investigation needs and throws it away with it, which is the same reason
+      # there is no before(:all).
+      class_option :fixture, type: :boolean
+
+      check_class_collision suffix: "Case"
+
+      def create_case_file
+        template "model_case.rb.tt", case_path("models", class_path, "#{file_name}_case.rb")
+      end
+
+      # A factory gem registered as the fixture replacement still gets its turn -- factories
+      # are a witness's business, not a fixture's, and Constable has no quarrel with them.
+      hook_for :fixture_replacement
+    end
+  end
+end

data/lib/generators/constable/model/templates/model_case.rb.tt

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+# Generated by `rails generate model <%= name %>`.
+#
+# :unit is the fastest tier Constable has, and the one thing it deliberately does not do
+# is wrap each investigation in a transaction that gets rolled back afterwards. So build
+# records here, don't save them -- anything that has to persist belongs in an
+# :integration-tier case, where the rollback exists to clean up after it.
+class <%= class_name %>Case < UnitCase
+  # Memoized per investigation and thrown away with it. Name it five times in one test
+  # and pay for it once; the next test builds its own.
+  witness(:<%= singular_name %>) { <%= new_record_expression %> }
+
+<% if case_attributes.any? -%>
+  # The honest first assertion, and the one that earns its keep: the class loads, the
+  # table is there, and every column this generator just declared reads back. That is
+  # what catches a migration written but never run.
+  investigate "reads back the attributes it was generated with" do
+<% case_attributes.each do |attribute| -%>
+    attest(<%= singular_name %>.<%= attribute.column_name %>).to eq(<%= attribute_value(attribute) %>)
+<% end -%>
+  end
+
+<% end -%>
+  # Then the first real one -- a validation, an association, a method this model owns:
+  #
+  #   investigate "requires a <%= case_attributes.first&.column_name || "name" %>" do
+  #     <%= singular_name %>.<%= case_attributes.first&.column_name || "name" %> = nil
+  #
+  #     refute <%= singular_name %>.valid?
+  #     attest(<%= singular_name %>.errors[:<%= case_attributes.first&.column_name || "name" %>]).to include("can't be blank")
+  #   end
+end
+<% end -%>

data/lib/generators/constable/resource/resource_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "generators/constable/model/model_generator"
+
+module Constable
+  module Generators
+    # `rails generate resource Post title:string` is a model plus a routed controller, and
+    # Rails builds it that way: Rails::Generators::ResourceGenerator inherits from the
+    # model generator and hooks the controller separately. So the test-framework side of a
+    # resource is the model case -- the controller half arrives through constable:controller,
+    # invoked by the resource_controller hook.
+    #
+    # This subclass exists so that lookup resolves rather than printing
+    # "constable:resource [not found]" for anything that asks for the resource generator by
+    # name, and so it delegates exactly the way Rails' own does: same superclass, same
+    # output, no second copy of the template.
+    class ResourceGenerator < ModelGenerator
+      # generator_name is "resource", which would send the inherited source_root looking in
+      # a templates directory this generator does not have and does not need.
+      def self.source_root(path = nil)
+        return super if path
+
+        ModelGenerator.source_root
+      end
+    end
+  end
+end

data/lib/generators/constable/scaffold/scaffold_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+require "rails/generators/resource_helpers"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate scaffold Post title:string`, via rails:scaffold_controller,
+    # which hooks :test_framework as :scaffold.
+    #
+    #   test/cases/controllers/posts_controller_case.rb   class PostsControllerCase < IntegrationCase
+    #   test/cases/system/posts_case.rb                   class PostsCase < SystemCase
+    #
+    # The system case is written only when Rails asks for one (`--system-tests=true`),
+    # matching test_unit exactly: a browser test that nobody asked for is the slowest
+    # possible way to find that out.
+    class ScaffoldGenerator < Base
+      include ::Rails::Generators::ResourceHelpers
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      class_option :api, type: :boolean,
+                         desc: "Generate cases for an API-only controller"
+      class_option :system_tests, type: :string,
+                                  desc: "Generate a system case (set to 'true' to enable)"
+
+      check_class_collision suffix: "ControllerCase"
+
+      def create_controller_case
+        template options.api? ? "api_controller_case.rb.tt" : "controller_case.rb.tt",
+                 case_path("controllers", controller_class_path, "#{controller_file_name}_controller_case.rb")
+      end
+
+      def create_system_case
+        return if options.api?
+        return unless options[:system_tests] == "true"
+
+        template "system_case.rb.tt", case_path("system", class_path, "#{plural_file_name}_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/scaffold/templates/api_controller_case.rb.tt

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+# Generated by `rails generate scaffold <%= name %> --api`. One investigation per action,
+# every request and response in JSON -- no form pages, so no new/edit.
+class <%= controller_class_name %>ControllerCase < IntegrationCase
+<% if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+<% end -%>
+  witness(:valid_attributes) { <%= attributes_literal %> }
+  witness(:existing_<%= singular_table_name %>) { <%= class_name %>.create!(valid_attributes) }
+
+  investigate "index responds successfully" do
+    get <%= index_helper(type: :url) %>, as: :json
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "create saves a <%= human_name.downcase %>" do
+    assert_difference("<%= class_name %>.count", 1) do
+      post <%= index_helper(type: :url) %>, params: { <%= singular_table_name %>: valid_attributes }, as: :json
+    end
+
+    attest(response).to have_http_status(:created)
+  end
+
+  investigate "show responds successfully" do
+    get <%= show_helper("existing_#{singular_table_name}") %>, as: :json
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "update responds successfully" do
+    patch <%= show_helper("existing_#{singular_table_name}") %>, params: { <%= singular_table_name %>: valid_attributes }, as: :json
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "destroy removes the <%= human_name.downcase %>" do
+    # Named before the block on purpose: a witness is built the first time it is used, so
+    # creating it inside assert_difference would net out to zero.
+    record = existing_<%= singular_table_name %>
+
+    assert_difference("<%= class_name %>.count", -1) do
+      delete <%= show_helper("record") %>, as: :json
+    end
+
+    attest(response).to have_http_status(:no_content)
+  end
+end
+<% end -%>

data/lib/generators/constable/scaffold/templates/controller_case.rb.tt

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+# Generated by `rails generate scaffold <%= name %>`. One investigation per action the
+# scaffold just wrote, which is a floor rather than a suite: the case worth writing is the
+# one about behavior this controller has that no scaffold does.
+class <%= controller_class_name %>ControllerCase < IntegrationCase
+<% if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+<% end -%>
+  # :integration wraps every investigation in a transaction that is rolled back
+  # afterwards, so a witness may persist a record. It is still built fresh for each one --
+  # nothing here survives into the next investigation.
+  witness(:valid_attributes) { <%= attributes_literal %> }
+  witness(:existing_<%= singular_table_name %>) { <%= class_name %>.create!(valid_attributes) }
+
+  investigate "index responds successfully" do
+    get <%= index_helper(type: :url) %>
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "new renders the form" do
+    get <%= new_helper %>
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "create saves a <%= human_name.downcase %> and redirects to it" do
+    assert_difference("<%= class_name %>.count", 1) do
+      post <%= index_helper(type: :url) %>, params: { <%= singular_table_name %>: valid_attributes }
+    end
+
+    attest(response).to redirect_to(<%= show_helper("#{class_name}.last") %>)
+  end
+
+  investigate "show responds successfully" do
+    get <%= show_helper("existing_#{singular_table_name}") %>
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "edit renders the form" do
+    get <%= edit_helper("existing_#{singular_table_name}") %>
+
+    attest(response).to have_http_status(:ok)
+  end
+
+  investigate "update redirects to the <%= human_name.downcase %>" do
+    patch <%= show_helper("existing_#{singular_table_name}") %>, params: { <%= singular_table_name %>: valid_attributes }
+
+    attest(response).to redirect_to(<%= show_helper("existing_#{singular_table_name}") %>)
+  end
+
+  investigate "destroy removes the <%= human_name.downcase %> and redirects to the index" do
+    # Named before the block on purpose: a witness is built the first time it is used, so
+    # creating it inside assert_difference would net out to zero.
+    record = existing_<%= singular_table_name %>
+
+    assert_difference("<%= class_name %>.count", -1) do
+      delete <%= show_helper("record") %>
+    end
+
+    attest(response).to redirect_to(<%= index_helper(type: :url) %>)
+  end
+end
+<% end -%>

data/lib/generators/constable/scaffold/templates/system_case.rb.tt

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+# Generated by `rails generate scaffold <%= name %> --system-tests=true`.
+#
+# System cases drive a real browser, so they are the slowest thing Constable runs and the
+# easiest place in a suite to write a flaky test. Two rules cover most of it: never sleep
+# (Capybara's finders already wait, and a bare sleep is a lint error anyway), and assert
+# on what the page shows rather than on how long it took to show it.
+class <%= class_name.pluralize %>Case < SystemCase
+  witness(:valid_attributes) { <%= attributes_literal %> }
+  witness(:existing_<%= singular_table_name %>) { <%= class_name %>.create!(valid_attributes) }
+
+  investigate "visiting the index" do
+    visit <%= index_helper(type: :url) %>
+
+    assert page.has_selector?("h1", text: "<%= human_name.pluralize %>")
+  end
+
+  investigate "creating a <%= human_name.downcase %>" do
+    visit <%= index_helper(type: :url) %>
+    click_on "New <%= human_name.downcase %>"
+
+<% case_attributes.each do |attribute| -%>
+<% if attribute.type == :boolean -%>
+    check "<%= attribute.human_name %>"
+<% else -%>
+    fill_in "<%= attribute.human_name %>", with: <%= attribute_value(attribute) %>
+<% end -%>
+<% end -%>
+    click_on "Create <%= human_name %>"
+
+    attest(page.text).to include("<%= human_name %> was successfully created")
+  end
+
+  investigate "updating a <%= human_name.downcase %>" do
+    visit <%= show_helper("existing_#{singular_table_name}") %>
+    click_on "Edit this <%= human_name.downcase %>", match: :first
+    click_on "Update <%= human_name %>"
+
+    attest(page.text).to include("<%= human_name %> was successfully updated")
+  end
+
+  investigate "destroying a <%= human_name.downcase %>" do
+    visit <%= show_helper("existing_#{singular_table_name}") %>
+    click_on "Destroy this <%= human_name.downcase %>", match: :first
+
+    attest(page.text).to include("<%= human_name %> was successfully destroyed")
+  end
+end
+<% end -%>

data/lib/generators/constable/system/system_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate system_test Posts`, which hooks :system_tests as :system.
+    #
+    #   test/cases/system/posts_case.rb   class PostsCase < SystemCase
+    class SystemGenerator < Base
+      check_class_collision suffix: "Case"
+
+      strips_suffix(/_test\z/i)
+
+      def create_case_file
+        template "system_case.rb.tt", case_path("system", class_path, "#{plural_file_name}_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/system/templates/system_case.rb.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name.pluralize %>Case < SystemCase
+  # System cases drive a real browser, so they are the slowest thing Constable runs and
+  # the easiest place in a suite to write a flaky test. Two rules cover most of it: never
+  # sleep (Capybara's finders already wait, and a bare sleep is a lint error anyway), and
+  # assert on what the page shows rather than on how long it took to show it.
+  #
+  #   investigate "visiting the index" do
+  #     visit <%= plural_table_name %>_url
+  #
+  #     assert page.has_selector?("h1", text: "<%= class_name.pluralize %>")
+  #   end
+end
+<% end -%>

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Shared behavior is just a module.
+#
+# There is deliberately no shared-examples DSL in Constable. `include` already
+# does that job: it composes, it respects ancestry, it shows up in `.ancestors`,
+# your editor can jump to the definition, and there is no second set of scoping
+# rules to learn on top of Ruby's own.
+#
+# Any case can pick this up directly:
+#
+#   class SessionsCase < IntegrationCase
+#     include Authenticatable
+#
+#     investigate "signs a user in" do
+#       sign_in(witnessed_user)
+#       attest(response).to redirect_to(root_path)
+#     end
+#   end
+#
+# Or a whole tier can, by adding `include Authenticatable` to IntegrationCase in
+# test/case_helper.rb.
+#
+# One rule applies here exactly as it does inside a case: a support module must
+# not hold mutable state across tests. Methods and constants, not @@class_vars.
+
+module Authenticatable
+  def sign_in(user)
+    post session_path, params: { email: user.email, password: "password" }
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# =============================================================================
+#  test/case_helper.rb
+#
+#  Constable's equivalent of RSpec's spec_helper.rb + rails_helper.rb, or of
+#  Minitest's test_helper.rb. `constable test` loads this file once, before any
+#  case file -- individual cases never require it themselves.
+#
+#  Three things live here:
+#
+#    1. Booting the Rails test environment.
+#    2. The per-tier base classes your cases inherit from.
+#    3. Constable.configure -- configuration that is *code*.
+#
+#  Configuration that is merely a *setting* (a number, a flag, a glob) lives in
+#  .constable/config.yml instead, so it can be overridden by a CLI flag for one
+#  run without editing Ruby.
+# =============================================================================
+
+ENV["RAILS_ENV"] ||= "test"
+
+require_relative "../config/environment"
+require "constable"
+
+# A test suite that can reach production data is a suite that will eventually
+# destroy some. This costs one string comparison per run.
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+# Loads db/schema.rb into the test database when it has drifted behind your
+# migrations -- the same thing `rails test` does before it runs anything. Without
+# it the first case to touch the database fails with "no such table", which tells
+# you nothing about the test you actually wrote.
+if defined?(ActiveRecord::Migration)
+  begin
+    ActiveRecord::Migration.maintain_test_schema!
+  rescue ActiveRecord::PendingMigrationError => e
+    abort("#{e.message}\n\nRun: bin/rails db:migrate RAILS_ENV=test")
+  end
+end
+
+# -----------------------------------------------------------------------------
+#  Tiers are base classes, not magic.
+#
+#  A tier says how much of the stack a case needs: :unit skips the database and
+#  the request stack entirely and is the fastest thing Constable can run,
+#  :integration gets a transactional database plus request helpers, :system
+#  additionally drives a browser.
+#
+#  Rather than infer that from a file path, declare it once on a base class and
+#  let ordinary Ruby inheritance carry it down:
+#
+#      class UsersController::CreatesUserCase < IntegrationCase
+#
+#  Path-based inference (the `tiers:` section of .constable/config.yml) still
+#  works as a fallback for cases that don't inherit from one of these, but
+#  inheritance is the recommended pattern -- there is nothing to infer, nothing
+#  to surprise you, and no rule to learn that Ruby didn't already teach you.
+#
+#  These are plain classes. Anything a whole tier needs belongs here: an
+#  ActiveJob test adapter, a factory module, `include Authenticatable` for every
+#  integration case.
+#
+#  The two Constable::RailsSupport modules below are the bridge to Rails' own
+#  testing code. Constable does not reimplement `post users_path` or
+#  `click_on "Save"` -- Rails ships both as ordinary modules, and every
+#  reimplementation of them would be a slightly wrong one.
+# -----------------------------------------------------------------------------
+
+# No database, no request stack, no browser -- just Ruby. The fastest thing
+# Constable can run, and where most of a suite should live.
+class UnitCase < Constable::Case
+  tier :unit
+end
+
+# get/post/patch/delete, `response`, `follow_redirect!`, cookies, and every URL
+# helper your routes define (`users_path`, `article_url(article)`). Each
+# investigation runs inside a transaction that is rolled back afterwards.
+class IntegrationCase < Constable::Case
+  include Constable::RailsSupport::Integration
+
+  tier :integration
+end
+
+# The browser instead of the request stack: Capybara's `visit`/`click_on`/
+# `fill_in`/`page`, its assertions, your URL helpers pointed at the test server,
+# and Rails' own `driven_by`. There is no `response` here -- a system case looks
+# at the rendered page, which is the whole reason to pay for a browser.
+class SystemCase < Constable::Case
+  # Capybara is not a Constable dependency. System cases are opt-in, and a suite
+  # with no browser tests shouldn't be made to install a browser driver to boot.
+  include Constable::RailsSupport::System if defined?(Capybara)
+
+  tier :system
+
+  # The default is Selenium driving Chrome, exactly as Rails' own system tests
+  # default. Change it here and every system case follows:
+  #
+  # driven_by :selenium, using: :headless_chrome, screen_size: [1400, 1400]
+end
+
+# -----------------------------------------------------------------------------
+#  Support files -- shared modules and custom matchers.
+#
+#  Same role RSpec's spec/support/**/*.rb plays. Shared behavior *across* files
+#  is a plain module you `include`; there is deliberately no shared-examples DSL
+#  here, because Ruby's own composition tools already do that job with fewer
+#  rules to learn and more flexibility once the reuse stops being simple.
+#
+#  Sorted on purpose: Dir[] returns filesystem order, which differs between your
+#  laptop and CI. A suite that loads its own support files in an unpredictable
+#  order has already lost the argument about determinism.
+# -----------------------------------------------------------------------------
+
+Dir[Rails.root.join("test/support/**/*.rb")].sort.each { |f| require f }
+
+# -----------------------------------------------------------------------------
+#  Code-level configuration.
+# -----------------------------------------------------------------------------
+
+Constable.configure do |c|
+  # Workers default to `auto` -- processor count minus a little headroom, so the
+  # machine stays usable while the suite runs. Pin it only when a CI container
+  # lies about its core count.
+  # c.parallel_workers = 4
+
+  # One-time global setup, run once per process before the whole suite. This is
+  # for configuring the world -- drivers, adapters, formats -- and deliberately
+  # not for creating records that tests then share. See the note at the bottom
+  # of this file about why that distinction is the whole ballgame.
+  #
+  # c.before_suite do
+  #   Capybara.default_driver    = :rack_test
+  #   Capybara.javascript_driver = :headless_chrome
+  # end
+  #
+  # c.after_suite do
+  #   SomeExternalHarness.shut_down
+  # end
+
+  # Custom matchers can be defined here too, though test/support/matchers.rb is
+  # the better home once there is more than one of them:
+  #
+  # Constable::Matchers.define(:be_created) { |response| response.status == 201 }
+end
+
+# =============================================================================
+#  Two things are missing from this file on purpose.
+#
+#  1. There is no before(:all), no setup_once, no one-time fixture hook.
+#
+#     A before(:all) block builds state once and hands the same objects to many
+#     tests. That is faster right up until one test mutates one of them -- and
+#     then you have a bug that appears only in a particular order, on a
+#     particular machine, in CI, roughly once a week. The ordering that produced
+#     it isn't written down anywhere, so it isn't reproducible, so it doesn't get
+#     fixed: it gets a retry, and the retry gets copied to the next test.
+#
+#     Constable doesn't have the hook, so it can't have the bug. `briefing` runs
+#     before *every* investigation, against a fresh instance, inside a
+#     transaction that is rolled back afterwards. When that is genuinely too
+#     slow, the fix is a cheaper fixture -- build_stubbed instead of create, one
+#     record instead of five -- not state shared across tests.
+#
+#     `c.before_suite` above is not a loophole. It runs once per process to
+#     configure the world, not to populate it.
+#
+#  2. `witness` memoizes per test, and never per process.
+#
+#     witness(:user) { create(:user) } is memoized within a single
+#     investigation, so naming `user` five times in one test hits the database
+#     once. The moment that investigation finishes the memo is gone, and the
+#     next one builds its own.
+#
+#     Caching across tests would be faster, and would reintroduce exactly the
+#     shared, mutable, order-dependent state that (1) exists to prevent. So the
+#     cache is scoped to the one place it is provably safe: inside a single test
+#     that owns the object outright.
+# =============================================================================

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

@@ -0,0 +1,67 @@
+# .constable/config.yml
+#
+# Settings, as opposed to code. Everything here is a number, a flag or a glob;
+# anything that is Ruby -- custom matchers, tier base classes, one-time global
+# setup -- lives in test/case_helper.rb instead.
+#
+# Every key Constable understands is present below at its default value, so this
+# file doubles as the complete reference. Delete anything you haven't changed;
+# the behavior is identical either way. CLI flags win over this file for the
+# duration of a single run.
+
+# Glob paths to run as cold cases: original RSpec/Minitest files, driven verbatim
+# through their own real engine, with pass/fail/timing fed into Constable's
+# reporting, flake history and CI gate alongside native cases.
+#
+# This is the zero-file-change adoption route. The alternative is one line per
+# file -- inheriting from Constable::ColdCase::RSpec or ::Minitest -- which is
+# more explicit but touches source. Either way nothing gets rewritten.
+#
+# Every cold-case file is reported as a warning on every run: one per file, not
+# one per test. Not to nag, but so "12 tests not yet under native rules" is never
+# something the suite quietly forgets to mention.
+cold_cases: []
+# cold_cases:
+#   - spec/controllers/**/*_spec.rb
+#   - test/legacy/**/*_test.rb
+
+# The blotter: flake history, the jail docket, warrants.
+#
+# Constable owns this store outright. It is deliberately not the app's own
+# database, for two reasons. Native cases run inside a transaction that gets
+# rolled back, so writing "this test just failed" through that connection would
+# roll the record back too. And :unit-tier runs skip booting the database
+# entirely for speed -- requiring a live server to record a pass would undo that.
+#
+# SQLite in WAL mode handles the real workload (a handful of tables, one row per
+# test per run) comfortably. Point it at Postgres or MySQL only if you genuinely
+# need one queryable store shared across many CI machines -- and always at a
+# separate database from the app's own, never its test connection.
+storage:
+  adapter: sqlite                      # sqlite (default) | postgres | mysql
+  path: .constable/constable.sqlite3   # sqlite only
+  url:                                 # postgres/mysql only, e.g.
+                                       #   postgres://user:pass@host/constable_metadata
+
+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
+
+parole_period: 10        # consecutive clean runs before a paroled test is auto-released
+
+coverage: false          # record coverage during test runs
+coverage_threshold: 90   # diff-based -- only lines changed in the current diff are held to it
+coverage_html: false     # generate a browsable report by default
+
+fail_on_warnings: false  # CI: fail the build when the warning count doesn't trend down
+
+parallel_workers: auto   # or an explicit integer
+
+# Fallback path-based tier inference, used only when a case doesn't inherit from
+# a tiered base class. The base classes in test/case_helper.rb are the primary
+# mechanism and always win -- this is here so an un-migrated file still lands in
+# a sensible tier rather than the slowest one.
+tiers:
+  unit:        "test/cases/models/**/*"
+  integration: "test/cases/controllers/**/*"
+  system:      "test/cases/system/**/*"