constable-rails 1.4.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 807163563a2d149b1f1267c2dd873ebc19e9948664b8311f4185676ac9698753
-  data.tar.gz: d7c59c367bf69908c0909b2bda248f2d5d0c320a8238bbea628ac203134105a5
+  metadata.gz: 4ee7e9d9303ba3b3e4977f529ab515059faa946e96209dae4e80dbef42d2930c
+  data.tar.gz: feadad150285bf9d68b11cc671b7c1bc13188c39a0b6c76317aef1a7a6ca9c70
 SHA512:
-  metadata.gz: 16458c866e5975ed485a03793c52c4d918b1191f8760ee45fd814d824857c943f5a848d268888e2d29334850b360d6f1df56e4cc1f619ad347f79c94a2bec0ae
-  data.tar.gz: 0e7fc08cf6105a1fea100ebbda9dc3d316444982fe5ed467b09e45c27f8d36577711f8f175dc020773724f1973f2748b9a0fd76b0d791d24f48e1afb15a31ed7
+  metadata.gz: 71adc2fab90c1ce4b1239159f7000c2b2200dc7f6becc3d365f6c935dc1702a9c012557b4602c909de880f2728433cfdfc9b4bd1524b8ec25581459c4a4f415a
+  data.tar.gz: 70fd3761fed31d90e365e1b24940025ddd14dc6f80f0761d004cdfe6c69145b4f1806f4fe49753a61af4137677cc2313c9a3f7cd0ce2f284e121ada1e75d0fdf

data/CHANGELOG.md

@@ -5,6 +5,123 @@ All notable changes to this project are documented here. This project adheres to
 
 ## [Unreleased]
 
+## [2.0.0]
+
+A tidy-up release. The API you write — `investigate`, `witness`, `briefing`, `docket`,
+`attest` — has not changed, and no case file or config key needs editing. The major
+version is for one removed accessor and for the behaviour change in 1.4.0, both below.
+
+### `constable modernize --cold`
+
+A conversion that comes back flagged is **not runnable**: the flagged constructs are left
+verbatim, so `let!` stays `let!` and the class body raises the moment it loads. That is
+deliberate — what a `let!` should become is a decision, not a rewrite — but it leaves a
+file stranded in `spec/` when the goal is one tree.
+
+```console
+$ constable modernize spec/models/tag_spec.rb --cold
+```
+
+writes `spec/models/tag_case.rb` as a cold case: one line at the top, the body byte for
+byte, run through real RSpec. Move it into `test/cases/` and the file is ported without
+being converted. Verified end to end — a `let!`-using spec that cannot convert runs 9/9
+from `test/` untouched.
+
+So a port is now: `modernize` a file, convert it if it comes back clean, `--cold` it if it
+does not, and revisit later. Nothing has to stay behind.
+
+### A case file that will not load says why
+
+A half-converted case still containing `let!` reported:
+
+```
+no tests matched test/cases/tmp
+```
+
+A file that raises while loading registers no investigations, so the selection came back
+empty and the empty-selection guard — added in 1.0.0 to catch mistyped paths — claimed
+the path was wrong. For a file that was right there and broken. It now reports the real
+error:
+
+```
+NoMethodError: undefined method `let!' for TagCase:Class
+This file never ran. Nothing in it was tested.
+```
+
+### `constable jail release --all`
+
+Emptying the docket took one command per test, which is unusable at the scale a docket
+reaches — before 1.4.0 a pass/fail flip jailed a test by itself, and one real suite put 29
+on the docket from a single run.
+
+Releasing is safe, and that is the point: a jailed test is *skipped*, so a docket full of
+tests nobody nominated is silently reducing what the suite covers. A bare `release` with
+no locator stays a usage error rather than an implicit "everything".
+
+### Removed: `Result#coverage`
+
+**Breaking, and why the major.** It was never written or read anywhere in the gem, and it
+did not survive `to_h`/`from_h` — so a value set on it vanished crossing the pipe from a
+parallel worker, silently, and only in parallel. An attribute that loses data is worse
+than no attribute. Coverage has always travelled separately and still does.
+
+### Also breaking, from 1.4.0
+
+`jail_flakes` defaults to **false**: a test that passed last run and failed this one is no
+longer jailed automatically. Jailing skips the test on every later run, and doing that to
+a test nobody nominated is how a suite quietly stops testing things. `--jail` is
+unaffected.
+
+### Test coverage
+
+The suite is now **1,025 runs**, up from 738 at 1.0.0. This release adds permanent tests
+for the three areas that had none and carried the most risk:
+
+- **`Result`** — the wire format between a worker and the parent. Every attribute is
+  asserted to survive a real `Marshal` round trip, because anything that does not is data
+  lost only in parallel runs, which is the worst way to find out. That is how the
+  `coverage` bug above was found.
+- **Cold-case shapes** — 17 real-world files run end to end through both engines: pending
+  and `xit`, `before`/`around` hooks, tags, aggregate failures, a raising hook, shared
+  examples, `RSpec.configure` inside a spec, deep nesting, the same file twice, and seven
+  Minitest arrangements. Every serious bug this project has had lived in these adapters.
+- **`Identity`** — stability under reformatting and comments, distinctness on real change,
+  unicode, cold-case keys, and the disambiguation added in 1.0.0.
+
+
+## [1.4.2]
+
+### Cold cases run inside a parallel worker
+
+The defect recorded as known in 1.4.1, now understood and fixed. Two bugs, stacked, and
+the second one hid the first.
+
+**RSpec swallows errors in required files.** `Configuration#requires=` routes through
+`load_file_handling_errors`, which rescues anything raised while loading, reports it
+through a formatter, and sets `world.wants_to_quit = true`. Every later
+`ExampleGroup.run` then returns immediately. Constable points RSpec's streams at a
+throwaway `StringIO` — stdout belongs to the reporter — so that report went nowhere: the
+file loaded, the examples registered, and none of them ran. A forked worker produced no
+results, no error and no exception, and exited 0. Requires are now loaded directly, where
+an exception carries its own message and backtrace, and the quit flag is checked and
+surfaced if anything sets it anyway.
+
+**Not every database can be sharded.** With the error visible, the real cause was one
+line: worker setup renamed *every* database config to `<database>_<index>`, including
+connections that are not per-worker test data at all. Caseflow talks to a legacy Oracle
+system (VACOLS) alongside its own Postgres databases, and appending `_3` to an Oracle TNS
+service name produces:
+
+```
+OCIError: ORA-12162: TNS:net service name is incorrectly specified
+```
+
+raised inside a `before(:suite)` hook — which is exactly what RSpec was swallowing. Only
+adapters that per-worker copies make sense for are renamed now (postgresql, postgis,
+mysql2, trilogy, sqlite3). An external system stays shared by every worker, which is what
+it is for.
+
+
 ## [1.4.1]
 
 ### A parallel run that ran nothing is no longer a pass
@@ -712,7 +829,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.4.1...HEAD
+[Unreleased]: https://github.com/Ray-Hughes/constable/compare/v1.4.3...HEAD
+[1.4.3]: https://github.com/Ray-Hughes/constable/compare/v1.4.2...v1.4.3
+[1.4.2]: https://github.com/Ray-Hughes/constable/compare/v1.4.1...v1.4.2
 [1.4.1]: https://github.com/Ray-Hughes/constable/compare/v1.4.0...v1.4.1
 [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

data/README.md

@@ -393,7 +393,7 @@ worse than one that resets.
 | `constable test PATH[:LINE]` | One file, or one investigation at that line |
 | `constable test --unsafe` | Cold cases only |
 | `constable test --jail` | The full run, in jail mode |
-| `constable jail [run\|parole\|release]` | The docket |
+| `constable jail [run\|parole\|release]` | The docket. `release --all` empties it |
 | `constable warrants [release]` | Outstanding warrants |
 | `constable watchlist` | Everything under supervision right now |
 | `constable status` | How the suite is doing over time |
@@ -402,7 +402,7 @@ worse than one that resets.
 | `constable prepare [--workers N]` | Build the per-worker test databases `worker_databases: reuse` needs |
 | `constable prune [--dry-run]` | Forget docket rows and warrants for tests that no longer exist |
 | `constable import --from=rspec` | Adopt an existing suite as cold cases |
-| `constable modernize PATH` | Opt-in AST rewrite into the native DSL |
+| `constable modernize PATH [--cold]` | Opt-in AST rewrite into the native DSL. `--cold` moves it verbatim instead |
 
 Flags: `--full --unsafe --jail --warrants --coverage --seed N --workers N --verbose --tier T\n--expanded --concise --output MODE --no-color`.
 

data/lib/constable/cli.rb

@@ -197,6 +197,8 @@ module Constable
     DESC
     option :alongside, type: :boolean, default: false, desc: "Write PATH_case.rb beside the original"
     option :"in-place", type: :boolean, default: false, desc: "Overwrite the file"
+    option :cold, type: :boolean, default: false,
+                  desc: "Move it verbatim as a cold case instead of converting"
     option :"show-source", type: :boolean, default: false, desc: "Print the rewritten source"
     def modernize(*paths)
       if paths.empty?
@@ -205,6 +207,7 @@ module Constable
       end
 
       mode = if options[:"in-place"] then :in_place
+             elsif options[:cold] then :cold
              elsif options[:alongside] then :alongside
              else :none
              end
@@ -312,13 +315,48 @@ module Constable
         say "Paroled. It runs normally now; one failure sends it straight back."
       end
 
-      desc "release PATH:LINE", "Fully release a test, no supervision"
-      def release(locator)
+      desc "release [PATH:LINE]", "Fully release a test, no supervision"
+      long_desc <<~DESC
+        Takes one test off the docket. `--all` empties it.
+
+        Emptying is the right move after a docket that filled up on its own -- before
+        1.4.0 a pass/fail flip jailed a test automatically, and a suite with
+        order-dependent tests could put dozens on it that nobody chose. Releasing is safe:
+        anything genuinely broken fails again on the next run, in the open.
+      DESC
+      option :all, type: :boolean, default: false, desc: "Release every test on the docket"
+      def release(locator = nil)
+        return release_all if options[:all]
+
+        if locator.nil?
+          CLI.complain("release needs a PATH:LINE, or --all to empty the docket")
+          exit(EXIT_USAGE)
+        end
+
         act(locator) { |jail, identity| jail.release(identity) }
         say "Released."
       end
 
       no_commands do
+        # Emptying the docket in one go. Right after a docket that filled up on its own --
+        # before 1.4.0 a pass/fail flip jailed a test automatically, and a suite with
+        # order-dependent tests could put dozens on it that nobody chose. Releasing is
+        # safe: anything genuinely broken fails again on the next run, in the open.
+        def release_all
+          jail = Jail.new(config: Constable.config, storage: Constable.storage)
+          entries = jail.entries
+
+          if entries.empty?
+            say "The docket is already empty."
+            return 0
+          end
+
+          entries.each { |entry| jail.release(entry.identity) }
+          say "Released #{entries.size} #{entries.size == 1 ? "test" : "tests"}. The docket is empty."
+          say "Anything genuinely broken will fail on the next run, where you can see it."
+          0
+        end
+
         def act(locator)
           jail = Jail.new(config: Constable.config, storage: Constable.storage)
           refuse_ambiguous(locator, jail.candidates(locator), "on the docket")

data/lib/constable/cold_case/rspec.rb

@@ -120,6 +120,7 @@ module Constable
             with_engine do
               collector  = Collector.new
               load_error = capture_load(path)
+              load_error ||= quit_flag_error(path)
               unless load_error
                 # After the file has loaded -- that load is what registers them -- and
                 # before its examples run. See #run_pending_before_suite_hooks.
@@ -306,10 +307,22 @@ module Constable
           requires = rspec_option_requires
           return if requires.empty?
 
-          # `requires=` rather than plain Kernel#require: it is RSpec's own accessor, and
-          # it puts `lib` and the default path (`spec`) on the load path first, which is
-          # what makes a bare `require "rails_helper"` resolve.
-          configuration.requires = requires
+          # Deliberately NOT `configuration.requires =`, which is RSpec's own accessor.
+          # That routes through Configuration#load_file_handling_errors, which rescues
+          # anything raised while loading, reports it through a formatter, and sets
+          # `world.wants_to_quit`. Since stdout belongs to Constable's reporter, RSpec's
+          # streams are a throwaway StringIO, so that report goes nowhere -- and every
+          # later ExampleGroup.run returns immediately. The file loads, the examples
+          # register, and none of them run. A forked worker produced no results, no error
+          # and no exception, and exited 0.
+          #
+          # So the load path is set up the same way and the requires are done here, where
+          # an exception is an exception and carries its own message and backtrace.
+          add_spec_load_paths!(configuration)
+          requires.each { |path| require path }
+          configuration.instance_variable_set(:@requires, requires)
+        rescue Constable::Error
+          raise
         rescue StandardError => e
           # A helper that will not load is the suite's problem to fix, and it will say so
           # loudly on the first file. Constable's job here is not to disappear.
@@ -317,6 +330,53 @@ module Constable
                           "Cold cases will run without it.", kind: :cold_case)
         end
 
+        # What `configuration.requires=` does before requiring anything: puts `lib` and the
+        # default path (`spec`) on the load path, which is what makes a bare
+        # `require "rails_helper"` resolve at all.
+        def add_spec_load_paths!(configuration)
+          default_path = configuration.default_path if configuration.respond_to?(:default_path)
+          ["lib", default_path].compact.uniq.each do |dir|
+            absolute = File.expand_path(dir, Constable.root)
+            $LOAD_PATH.unshift(absolute) if File.directory?(absolute) && !$LOAD_PATH.include?(absolute)
+          end
+        end
+
+        # RSpec does not let an error in a required file reach you.
+        # Configuration#load_file_handling_errors rescues anything raised while loading,
+        # reports it through `notify_non_example_exception`, and sets
+        # `world.wants_to_quit = true`. Every later ExampleGroup.run then returns
+        # immediately, so the file loads, the examples register, and none of them run.
+        #
+        # We point RSpec's output at a throwaway StringIO -- stdout belongs to the
+        # reporter -- so that report goes nowhere. The result was a forked worker that
+        # produced no results, no error and no exception, and exited 0. It took a probe
+        # inside the child to find that `wants_to_quit` was the difference.
+        #
+        # So: ask, and put the swallowed message back in front of the user.
+        def raise_if_loading_failed!(configuration, requires)
+          return unless ::RSpec.world.wants_to_quit
+
+          # Clear it, or every later file in this session inherits the flag and runs
+          # nothing either.
+          ::RSpec.world.wants_to_quit = false
+
+          raise Constable::Error,
+                "RSpec could not load #{requires.join(", ")} (from .rspec). " \
+                "#{swallowed_output(configuration)}".strip
+        end
+
+        # Whatever RSpec wrote about it before we could ask. Its streams are ours, so this
+        # is the only copy in existence.
+        def swallowed_output(configuration)
+          [configuration.error_stream, configuration.output_stream, configuration.deprecation_stream]
+            .uniq
+            .filter_map { |io| io.string.to_s.strip if io.respond_to?(:string) }
+            .reject(&:empty?)
+            .first.to_s
+        rescue StandardError
+          ""
+        end
+
         # Parsed by RSpec itself, so `.rspec`, `~/.rspec`, `.rspec-local` and SPEC_OPTS are
         # all read with its precedence rather than a guess at the format.
         def rspec_option_requires
@@ -372,6 +432,18 @@ module Constable
           configuration.start_time = ::RSpec::Core::Time.now if configuration.respond_to?(:start_time=)
         end
 
+        # Same swallowing, one level down: a `require` inside the spec file that fails is
+        # rescued by RSpec, flagged, and never surfaced. Without this the file reports as
+        # a clean run of zero tests.
+        def quit_flag_error(path)
+          return nil unless ::RSpec.world.wants_to_quit
+
+          ::RSpec.world.wants_to_quit = false
+          Constable::Error.new(
+            "RSpec stopped while loading #{path}. #{swallowed_output(::RSpec.configuration)}".strip
+          )
+        end
+
         # A file that won't even parse is news, not a crash. Report it as one errored
         # result so the run keeps going and the summary names the file.
         def capture_load(path)

data/lib/constable/importer/modernizer.rb

@@ -28,7 +28,7 @@ module Constable
       # :none      -- dry run. Report only. The default.
       # :alongside -- write foo_spec.rb's conversion to foo_case.rb, never clobbering.
       # :in_place  -- overwrite the original file.
-      WRITE_MODES = %i[none alongside in_place].freeze
+      WRITE_MODES = %i[none alongside in_place cold].freeze
 
       GROUP_METHODS       = %i[describe context xdescribe xcontext fdescribe fcontext feature].freeze
       EXAMPLE_METHODS     = %i[it specify example scenario].freeze
@@ -175,9 +175,60 @@ module Constable
           File.join(dir, "#{base}_case.rb")
         end
 
+        # `--cold`: move the file into the native tree without converting a line of it.
+        #
+        # A conversion that comes back flagged is not runnable -- the flagged constructs
+        # are left verbatim, so `let!` stays `let!` and the class body raises the moment it
+        # loads. That is deliberate: what a `let!` should become is a decision, not a
+        # rewrite. But it leaves a file stuck in spec/ when the goal is one tree.
+        #
+        # A cold case is the answer that already exists: one line at the top, the body
+        # untouched, run through real RSpec, results folded into the same report. This
+        # writes exactly that, so a port can move every file and convert the ones worth
+        # converting on its own schedule.
+        def cold_wrap(result, root)
+          target = alongside_path(result.path)
+          if File.exist?(target)
+            result.error = "refusing to overwrite #{target.delete_prefix("#{root}/")}"
+            return
+          end
+
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, cold_source(result))
+          result.written_to = target.delete_prefix("#{root}/")
+        end
+
+        # The original bytes, between a header line and a final `end`. Nothing inside is
+        # parsed, reindented or touched -- that is the whole promise of a cold case.
+        def cold_source(result)
+          <<~RUBY
+            # frozen_string_literal: true
+
+            # Moved verbatim from #{result.relative_path}. Runs through real RSpec, with its
+            # results folded into Constable's reporting, flake history and CI gate.
+            #
+            # Nothing inside has been converted, so every RSpec feature still works --
+            # `let!`, `before(:all)`, shared examples, rspec-mocks. Convert it with
+            # `constable modernize` when it is worth doing; there is no deadline.
+            class #{cold_class_name(result)} < Constable::ColdCase::RSpec
+            #{indent(result.original.to_s.rstrip)}
+            end
+          RUBY
+        end
+
+        def cold_class_name(result)
+          base = File.basename(result.path, ".rb").sub(/_(?:spec|test)\z/, "")
+          "Legacy#{base.split(%r{[_/]}).map(&:capitalize).join}Spec"
+        end
+
+        def indent(source)
+          source.lines.map { |line| line.strip.empty? ? line : "  #{line}" }.join
+        end
+
         private
 
         def persist(result, root, write)
+          return cold_wrap(result, root) if write == :cold
           return unless result.ok? && result.changed?
 
           case write

data/lib/constable/result.rb

@@ -18,7 +18,7 @@ module Constable
 
     attr_reader :identity, :case_name, :description, :file, :line, :kind, :tier
     attr_accessor :status, :duration, :failure, :warnings, :retries, :jail_reason,
-                  :parole_day, :times_jailed, :seed, :coverage
+                  :parole_day, :times_jailed, :seed
 
     def initialize(identity:, case_name:, description:, file:, line:, kind: :native, tier: nil,
                    status: :passed, duration: 0.0, failure: nil, warnings: [], retries: [])

data/lib/constable/runner.rb

@@ -231,6 +231,12 @@ module Constable
     def refuse_empty_selection!(items)
       return unless items.empty?
       return unless @selection.explicit?
+      # A file that raised while loading registers no investigations, so the selection
+      # comes back empty and this guard would report "no tests matched" -- burying the
+      # actual error, which is already captured and about to be reported as a failure.
+      # "Your path is wrong" is the wrong thing to say about a file that is right there
+      # and broken.
+      return if load_errors.any?
 
       raise Constable::Error, @selection.empty_selection_message
     end

data/lib/constable/version.rb

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

data/lib/constable/worker_databases.rb

@@ -236,13 +236,32 @@ module Constable
     # Every database config for this environment, renamed to its per-worker sibling.
     # `_database=` is exactly how Rails' own TestDatabases does the renaming, and this
     # runs in a forked child, so the mutation dies with the worker.
+    # Adapters where "give each worker its own copy" is a thing that can be done at all.
+    #
+    # An app can hold connections Constable has no business renaming. Caseflow talks to a
+    # legacy Oracle system (VACOLS) alongside its own Postgres databases; appending `_3` to
+    # an Oracle TNS service name produces `ORA-12162: TNS:net service name is incorrectly
+    # specified`, and since that surfaces inside a `before(:suite)` hook, RSpec swallowed
+    # it and the worker ran nothing at all.
+    #
+    # An external system like that is shared by every worker on purpose: it is not
+    # per-worker test data, and there is no per-worker copy of it to make.
+    SHARDABLE_ADAPTERS = %w[postgresql postgis mysql2 trilogy sqlite3].freeze
+
+    def shardable_adapter?(db_config)
+      return false unless db_config.respond_to?(:adapter)
+
+      SHARDABLE_ADAPTERS.include?(db_config.adapter.to_s)
+    end
+
     def each_worker_config(index)
       configs = ::ActiveRecord::Base.configurations.configs_for(env_name: env_name,
                                                                 include_hidden: true)
       configs.each do |db_config|
-        db_config._database = "#{db_config.database}_#{index}"
         next unless db_config.database_tasks?
+        next unless shardable_adapter?(db_config)
 
+        db_config._database = "#{db_config.database}_#{index}"
         yield db_config
       end
     end

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

@@ -180,6 +180,72 @@ end
 # -----------------------------------------------------------------------------
 
 Constable.configure do |c|
+  # --- Settings. Uncomment what you want; each is shown at its default. --------
+
+  # Workers default to `auto` -- processor count minus a little headroom, so the
+  # machine stays usable while the suite runs. Pin it when a CI container lies
+  # about its core count, or to rule parallelism out while debugging.
+  #
+  # c.parallel_workers = 4
+
+  # How a parallel worker gets a database of its own. Sharing one is not a
+  # speed/safety trade, it is a correctness bug: on SQLite the run dissolves into
+  # "database is locked", and on a client/server database tests quietly see each
+  # other's rows, which is worse because it looks like it worked.
+  #
+  #   :schema   rebuild <database>_<index> from schema.rb every run. What Rails
+  #             does for `rails test`, and correct by construction -- the
+  #             databases cannot drift, because they are thrown away each time.
+  #             The default, and the wrong choice only when it is slow or
+  #             impossible.
+  #   :reuse    keep them between runs. Faster (a big schema is not replayed per
+  #             worker), and the ONLY option that works when your schema cannot
+  #             rebuild the database by itself -- true of any app with Postgres
+  #             custom types, since CREATE TYPE has no schema.rb representation.
+  #             Run `constable prepare` once to build them, and again after a
+  #             migration; keeping them current is your job.
+  #   :off      do not shard, so do not fork. An explicit serial run: no attempt,
+  #             no warning. Correct, and as slow as one core.
+  #
+  # c.worker_databases = :reuse
+
+  # The live stream while the suite runs. The summary is identical either way.
+  #   :concise   one glyph per test, grouped per case (default)
+  #   :expanded  a line per test: glyph, description, duration -- so you can see
+  #              which test is hanging while it hangs, not afterwards
+  #
+  # c.output = :expanded
+
+  # Put a test on the docket by itself when it passed last run and failed this
+  # one. Off by default, and the reason is what jailing does: a jailed test is
+  # SKIPPED on every later run. On automatically, a suite with order-dependent
+  # tests quietly stops running things nobody chose to stop running.
+  #
+  # c.jail_flakes = true
+
+  # Rerun a failure in isolation before believing it. A test that then passes is
+  # flaky rather than broken: it gets a warrant instead of failing the build, and
+  # stays loudly visible until someone deals with it.
+  #
+  # c.warrants = true
+
+  # CI: fail the build when the warning count is not trending down. Warnings are
+  # cold-case files and `unsafe` blocks -- allowed, but visible.
+  #
+  # c.fail_on_warnings = true
+
+  # Diff-based coverage: only lines changed in the current diff are held to it.
+  #
+  # c.coverage           = true
+  # c.coverage_threshold = 90
+
+  # Your existing RSpec/Minitest files, run verbatim as cold cases through their
+  # own engine. `constable import --from=rspec` writes this for you.
+  #
+  # c.cold_cases = ["spec/**/*_spec.rb"]
+
+  # --- Code. This can only be written here. -----------------------------------
+
   # One-time global setup, run once per process before the whole suite. For
   # configuring the world -- drivers, adapters, formats -- and deliberately not
   # for creating records that tests then share. See the note at the bottom of

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: constable-rails
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Ray Hughes