constable-rails 0.1.0

data/lib/constable/version.rb

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

data/lib/constable/warrants.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module Constable
+  # Warrants -- automatic flaky detection.
+  #
+  # Jail asks "does this block the build?". A warrant asks the question underneath it:
+  # *is this failure even real?* The two are deliberately separate mechanisms, and a test
+  # can be subject to both.
+  #
+  # Opt in with `warrants: true` in config, or `constable test --warrants` for one run.
+  # Once a warrant exists it stands on its own: a warranted test gets the full retry
+  # treatment on **every** future run whether or not the flag is passed, because the
+  # blotter entry carries the rule, not the command line.
+  #
+  # Issuing one:
+  #
+  #   A test fails its normal attempt while warrants are active. Constable reruns that one
+  #   test, in isolation, `warrant_retries` more times (default 5).
+  #     * fails every retry  -> a genuine failure. No warrant. Handled like any other
+  #       failure, jail included if `--jail` is also on.
+  #     * passes at least once -> flaky, not broken. A warrant goes on the blotter, the
+  #       result stops blocking the build, and it gets its own section in the summary.
+  #
+  # Living under one:
+  #
+  #     * all retries pass -> warrant cleared, entry removed, reported as cleared.
+  #     * any retry fails  -> warrant stands, "still under warrant", still non-blocking.
+  #
+  # The blotter is the only record. Nothing here ever writes to a source file, and there
+  # is deliberately no companion command that annotates specs -- same reasoning as jail:
+  # one source of truth, nothing to drift out of sync. `constable warrants release
+  # PATH:LINE` is the manual clear.
+  class Warrants
+    # What a run's adjudication concluded about one test.
+    #
+    #   :issued   a fresh warrant -- failed, then passed under retry
+    #   :genuine  no warrant -- failed every retry, this is a real failure
+    #   :upheld   standing warrant, still flaky
+    #   :cleared  standing warrant, clean sweep -- lifted
+    #   :none     the machinery did not apply
+    VERDICTS = %i[none issued genuine upheld cleared].freeze
+
+    # One row of the warrants table, normalized. Tolerant of string keys for the same
+    # reason Jail::Entry is: the storage layer is pluggable.
+    class Entry
+      attr_reader :identity, :label, :file, :line, :reason, :issued_at, :last_seen_at,
+                  :times_seen, :clean_runs, :failed_runs, :row
+
+      def self.wrap(row)
+        return nil if row.nil?
+        return row if row.is_a?(Entry)
+        return nil unless row.respond_to?(:to_h)
+
+        hash = row.to_h
+        hash.empty? ? nil : new(hash)
+      end
+
+      def initialize(row)
+        @row          = row.each_with_object({}) { |(k, v), out| out[k.to_sym] = v }
+        @identity     = @row[:identity].to_s
+        @label        = @row[:label]
+        @file         = @row[:file].to_s
+        @line         = @row[:line]&.to_i
+        @reason       = @row[:reason]
+        @issued_at    = @row[:issued_at]
+        @last_seen_at = @row[:last_seen_at]
+        @times_seen   = (@row[:times_seen] || 0).to_i
+        @clean_runs   = (@row[:clean_runs] || 0).to_i
+        @failed_runs  = (@row[:failed_runs] || 0).to_i
+      end
+
+      # A cleared entry is handed back by storage as it was at the moment the row went
+      # away -- the only chance the reporter gets to name its final counters.
+      def cleared? = @row[:cleared] == true || @row[:state].to_s == "cleared"
+
+      def location = "#{@file}:#{@line}"
+      def to_h     = @row.dup
+    end
+
+    attr_reader :config, :storage, :issued, :cleared, :upheld, :genuine, :verdicts
+
+    def initialize(config: Constable.config, storage: Constable.storage)
+      @config   = config
+      @storage  = storage
+      @issued   = []
+      @cleared  = []
+      @upheld   = []
+      @genuine  = []
+      @verdicts = {}
+    end
+
+    # How many isolated reruns one adjudication costs. Zero disables the mechanism
+    # outright -- there is nothing to learn from retrying a test no times.
+    def warrant_retries
+      retries = @config.respond_to?(:warrant_retries) ? @config.warrant_retries.to_i : 0
+      retries.negative? ? 0 : retries
+    end
+
+    # The flag, not the blotter.
+    def enabled? = @config.respond_to?(:warrants?) ? @config.warrants? : false
+
+    def active?(requested: false) = requested || enabled?
+
+    # The blotter, not the flag. A standing warrant outranks the flag in both directions:
+    # it applies without `--warrants`, and no flag is needed to clear it.
+    def standing?(identity) = !entry(identity).nil?
+    alias warranted? standing?
+
+    # "Is this identity subject to the warrant machinery this run?" -- either because
+    # somebody asked for warrants, or because this test already has one.
+    def applies_to?(identity, requested: false)
+      return false if warrant_retries.zero?
+
+      standing?(identity) || active?(requested: requested)
+    end
+
+    # "Should I actually spend retries on this result?" A standing warrant is retried
+    # however the normal attempt went; an ordinary test only earns retries by failing.
+    def retry?(result, requested: false)
+      return false if warrant_retries.zero?
+      return false if result.nil? || result.jailed? || result.skipped?
+      return true  if standing?(result.identity)
+
+      active?(requested: requested) && result.failed?
+    end
+
+    # --- queries ---------------------------------------------------------------
+
+    def entries            = Array(@storage.warrants).filter_map { |row| Entry.wrap(row) }
+    def entry(identity)    = Entry.wrap(@storage.warrant_entry(identity.to_s))
+    def any?               = !entries.empty?
+
+    # A warranted result never fails the build. That is the whole point of establishing
+    # that the failure was not real.
+    def blocks_build?(result) = result.failed?
+
+    # --- adjudication ----------------------------------------------------------
+
+    # The Runner's single entry point. Hands back the same Result, decided.
+    #
+    #   warrants.adjudicate(result, requested: cli_flag, subject: investigation) do |subject, attempt|
+    #     runner.run_one_in_isolation(subject)   # => a Constable::Result
+    #   end
+    #
+    # The block reruns exactly one test in isolation and returns its outcome -- a Result,
+    # a status Symbol, or a boolean. It is called `warrant_retries` times, always the full
+    # count: a partial sample is a worse answer than a slower one, and the retry statuses
+    # end up on `Result#retries` for the reporter.
+    #
+    # Order matters at the call site: adjudicate first, then hand the result to Jail. A
+    # warranted result is not a failure, so it must never reach the docket; a genuine one
+    # should, jail mode included.
+    def adjudicate(result, requested: false, subject: nil, &rerun)
+      decide(result, requested: requested, subject: subject, &rerun)
+      persist(result)
+      result
+    end
+
+    # The half that runs tests and decides, with no writes -- safe inside a fork worker,
+    # where the architecture's "only the parent writes" rule applies. The parent calls
+    # #persist on the Result that comes back over the pipe.
+    def decide(result, requested: false, subject: nil, &rerun)
+      return result unless retry?(result, requested: requested)
+      raise ArgumentError, "Warrants#decide needs a block that reruns one test in isolation" unless rerun
+
+      statuses = run_retries(result, subject, rerun)
+      result.retries = statuses
+      result.status  = decided_status(result, statuses)
+      result
+    end
+
+    # The half that writes. Derives the verdict from the blotter plus the retry statuses
+    # already on the Result, so it works equally on a locally decided result and on one
+    # that arrived from a worker as a hash.
+    def persist(result, verdict = verdict_for(result))
+      @verdicts[result.identity] = verdict unless verdict == :none
+
+      case verdict
+      when :issued
+        @storage.issue_warrant(result.identity, label: result.display_label, file: result.file,
+                                                line: result.line, reason: issue_reason(result))
+        @issued << result
+      when :upheld
+        @storage.touch_warrant(result.identity, cleared: false)
+        @upheld << result
+      when :cleared
+        # touch_warrant(cleared: true) lifts the warrant and hands back the final row.
+        # clear_warrant stays the manual path; calling both would just be noise.
+        @storage.touch_warrant(result.identity, cleared: true)
+        @cleared << result
+      when :genuine
+        @genuine << result
+      end
+
+      verdict
+    end
+
+    # Fully derivable from (does a warrant stand?, how did the retries go?), which is why
+    # a worker never has to ship a verdict back alongside the result.
+    def verdict_for(result)
+      statuses = Array(result&.retries).map { |status| normalize_status(status) }
+      return :none if statuses.empty?
+
+      if standing?(result.identity)
+        statuses.all?(:passed) ? :cleared : :upheld
+      else
+        statuses.any?(:passed) ? :issued : :genuine
+      end
+    end
+
+    # --- human operations ------------------------------------------------------
+
+    # `constable warrants release PATH:LINE`.
+    def release(identity) = @storage.clear_warrant(identity.to_s) ? true : false
+
+    # Counts for the summary line and its own section.
+    def summary_counts
+      { issued: @issued.size, cleared: @cleared.size, upheld: @upheld.size, standing: entries.size }
+    end
+
+    # --- PATH:LINE resolution ---------------------------------------------------
+
+    # The CLI speaks in file:line, the blotter is keyed by content hash. Warrant rows
+    # carry both; loaded investigations are the fallback.
+    def resolve(target)
+      text = target.to_s.strip
+      return nil if text.empty?
+      return text if text.match?(/\A[0-9a-f]{8,64}\z/) && entry(text)
+
+      file, line = Jail.split_target(text)
+      return nil if file.empty?
+
+      matches = entries.select { |e| Jail.same_path?(e.file, file) }
+      matches = matches.select { |e| e.line == line } if line
+      return matches.first.identity if matches.any?
+
+      Jail.registry_identity(file, line)
+    end
+
+    def resolve!(target)
+      resolve(target) || raise(Constable::Error, "no test found for #{target.inspect} " \
+                                                 "(expected PATH:LINE, e.g. test/cases/users_case.rb:12)")
+    end
+
+    private
+
+    def run_retries(result, subject, rerun)
+      Array.new(warrant_retries) do |index|
+        normalize_status(call_rerun(rerun, subject || result, index + 1))
+      end
+    end
+
+    # Blocks are lenient about extra arguments; lambdas are not, and somebody will pass one.
+    def call_rerun(rerun, subject, attempt)
+      return rerun.call(subject, attempt) unless rerun.lambda?
+
+      case rerun.arity
+      when 0 then rerun.call
+      when 1 then rerun.call(subject)
+      else rerun.call(subject, attempt)
+      end
+    end
+
+    def decided_status(result, statuses)
+      if standing?(result.identity)
+        # A standing warrant is judged on the retries alone -- a clean sweep lifts it,
+        # anything else keeps it standing and non-blocking.
+        statuses.all?(:passed) ? :passed : :warranted
+      elsif statuses.any?(:passed)
+        :warranted
+      else
+        result.status # a genuine failure keeps whatever kind of failure it was
+      end
+    end
+
+    def normalize_status(value)
+      return value.passed? ? :passed : :failed if value.respond_to?(:passed?)
+      return :passed if value == true
+      return :failed if value == false || value.nil?
+
+      value.to_s == "passed" ? :passed : :failed
+    end
+
+    def issue_reason(result)
+      statuses = Array(result.retries).map { |status| normalize_status(status) }
+      passes   = statuses.count(:passed)
+      "failed its normal attempt, then passed #{passes} of #{statuses.size} isolated retries"
+    end
+  end
+end

data/lib/constable-rails.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The gem is published as "constable-rails" because the name "constable" was claimed on
+# RubyGems in 2011 by an unrelated, long-abandoned gem.
+#
+# Bundler.require requires each gem by its *gem* name, so an app writing the ordinary
+#
+#   gem "constable-rails"
+#
+# gets `require "constable-rails"` and nothing else. Without this file that raises
+# LoadError, and Bundler's only fallback is "constable/rails", which does not exist
+# either -- so the gem would never be loaded into the app at all. Everything would still
+# appear to work, because the `constable` executable requires "constable" itself, right
+# up until the moment something needed the Railtie: `rails generate scaffold` would
+# quietly keep emitting Minitest files, for the framework the app had just replaced.
+require "constable"

data/lib/constable.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "constable/version"
+
+# Constable -- an opinionated, strict Rails testing framework.
+#
+# Published on RubyGems as "constable-rails"; everything inside is simply Constable.
+#
+# Five ideas hold the whole thing up:
+#
+#   1. Isolation is non-negotiable in native code. No class-level shared state, no
+#      before(:all) equivalent. Every native test gets a clean transaction and a clean
+#      object graph.
+#   2. Nondeterminism is caught by the linter, not discovered in CI.
+#   3. Adoption never requires a rewrite. A whole existing RSpec/Minitest file runs
+#      untouched from day one.
+#   4. Every escape hatch is visible. Nothing that bends the rules is ever silent.
+#   5. Fast is the default, not an opt-in.
+module Constable
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+
+  # Raised by assertion primitives. Distinct from Error so a genuine bug in a test never
+  # gets mistaken for an assertion failure.
+  class AssertionFailed < Error
+    attr_reader :context
+
+    def initialize(message, context: nil)
+      @context = context
+      super(message)
+    end
+  end
+
+  autoload :Backtrace,     "constable/result"
+  autoload :CLI,           "constable/cli"
+  autoload :Case,          "constable/case"
+  autoload :ColdCase,      "constable/cold_case"
+  autoload :Config,        "constable/config"
+  autoload :Coverage,      "constable/coverage"
+  autoload :DSL,           "constable/dsl"
+  autoload :Diff,          "constable/diff"
+  autoload :Failure,       "constable/result"
+  autoload :Identity,      "constable/identity"
+  autoload :Importer,      "constable/importer"
+  autoload :Investigation, "constable/investigation"
+  autoload :Isolation,     "constable/isolation"
+  autoload :Jail,          "constable/jail"
+  autoload :LogRouter,     "constable/log_router"
+  autoload :Matchers,      "constable/matchers"
+  autoload :OrderAudit,    "constable/order_audit"
+  autoload :RailsSupport,  "constable/rails_support"
+  autoload :Registry,      "constable/registry"
+  autoload :Reporter,      "constable/reporter"
+  autoload :Result,        "constable/result"
+  autoload :Runner,        "constable/runner"
+  autoload :Selection,     "constable/selection"
+  autoload :Storage,       "constable/storage"
+  autoload :Warrants,      "constable/warrants"
+
+  class << self
+    attr_writer :root, :config, :storage
+
+    # The application root. Rails.root when Rails is booted, otherwise the nearest
+    # directory that looks like a project (has .constable/, Gemfile, or .git).
+    def root
+      @root ||= detect_root
+    end
+
+    def config
+      @config ||= Config.load(root: root)
+    end
+
+    # Code-level configuration -- matchers, tier base classes, one-time global setup.
+    # Settings that are merely settings belong in .constable/config.yml instead.
+    #
+    #   Constable.configure do |c|
+    #     c.parallel_workers = 4
+    #     c.before_suite { Capybara.default_driver = :rack_test }
+    #   end
+    def configure
+      yield configuration if block_given?
+      configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def storage
+      @storage ||= Storage::Adapter.build(config).tap(&:setup!)
+    end
+
+    def registry
+      @registry ||= Registry.new
+    end
+
+    # Warnings are never silent and never fatal by default. They accumulate through a run
+    # and always get their own section in the summary.
+    def warn!(message, location: nil, kind: :unsafe)
+      warnings << { message: message, location: location, kind: kind }
+    end
+
+    def warnings
+      @warnings ||= []
+    end
+
+    def reset!
+      @config = nil
+      @storage = nil
+      @registry = nil
+      @warnings = []
+    end
+
+    private
+
+    def detect_root
+      return Rails.root.to_s if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+      dir = Dir.pwd
+      until dir == "/"
+        return dir if File.exist?(File.join(dir, ".constable")) ||
+                      File.exist?(File.join(dir, "Gemfile")) ||
+                      File.directory?(File.join(dir, ".git"))
+
+        dir = File.dirname(dir)
+      end
+      Dir.pwd
+    end
+  end
+
+  # Code-level configuration set from test/case_helper.rb.
+  class Configuration
+    attr_accessor :parallel_workers, :seed, :coverage, :warrants
+
+    def initialize
+      @before_suite_hooks = []
+      @after_suite_hooks  = []
+    end
+
+    def before_suite(&block) = @before_suite_hooks << block
+    def after_suite(&block)  = @after_suite_hooks << block
+
+    def run_before_suite! = @before_suite_hooks.each(&:call)
+    def run_after_suite!  = @after_suite_hooks.each(&:call)
+  end
+end
+
+# Registers Constable as the app's generator test framework, so `rails generate model`
+# writes a case instead of a Minitest file. Conditional on purpose: everything above this
+# line must load in a process with no Rails at all, which is what the :unit tier is for.
+require "constable/railtie" if defined?(Rails::Railtie)

data/lib/generators/constable/base.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Rails generator machinery is required *here*, not from lib/constable.rb.
+# `require "constable"` has to work in a process with no Rails app at all --
+# that is the entire point of the :unit tier -- so railties is only ever pulled
+# in by the files that genuinely cannot exist without it.
+require "rails/generators/named_base"
+require "constable"
+
+# Rails' own generators get these for free because a booted app has loaded all of
+# ActiveSupport by the time anything generates. Ours can be loaded by a bare
+# `rails generate` in a half-booted process, and GeneratedAttribute#parse reaches for
+# String#remove, so name what we actually depend on rather than hoping.
+require "active_support/core_ext/string/filters"
+require "active_support/core_ext/string/inflections"
+
+module Constable
+  module Generators
+    # Shared ground for the generators Rails invokes on Constable's behalf.
+    #
+    # Once Constable::Railtie has registered the app's test framework, every
+    # `rails generate` command that hooks :test_framework goes looking for a generator
+    # called constable:<something>. Rails resolves that by namespace, the namespace comes
+    # from the class name, and the file is found by converting the namespace back into a
+    # path -- so the layout is not a matter of taste. Each generator lives at
+    # generators/constable/<name>/<name>_generator.rb and is called <Name>Generator.
+    # rspec-rails is arranged the same way, for the same reason.
+    #
+    # Named Base deliberately: Rails::Generators::Base.inherited skips registering any
+    # class whose name ends in "Base", so this never turns up in `rails generate` output
+    # as a generator of its own.
+    class Base < ::Rails::Generators::NamedBase
+      # Each generator keeps its templates beside itself. Rails' default looks for them
+      # under railties' own directory, which is no use to a gem that isn't railties.
+      def self.source_root(path = nil)
+        return @source_root = path if path
+
+        @source_root ||= File.expand_path(File.join(__dir__, generator_name, "templates"))
+      end
+
+      # `rails generate job CleanUpJob` and `rails generate job CleanUp` have to land in
+      # the same file, so the generators Rails hooks strip their own suffix off the name
+      # first. Declared here once rather than written out six times, and with one thing
+      # worth knowing: the memo has to be @_file_name and not @file_name, because
+      # NamedBase's own reader is backed by @file_name -- memoizing into it would make
+      # `super` hand back the already-stripped value and the suffix would never come off.
+      # The no_commands wrapper is not decoration: Thor turns every public instance method
+      # on a generator into a runnable step, and a generator whose first step is
+      # "file_name" writes no files at all.
+      def self.strips_suffix(pattern)
+        no_commands do
+          # rubocop:disable-next Naming/MemoizedInstanceVariableName -- @file_name is taken, see above
+          define_method(:file_name) { @_file_name ||= super().sub(pattern, "") }
+        end
+        private :file_name
+      end
+
+      private
+
+      # Where a generated case file goes. `test/cases/<area>/...` is the shape the `tiers:`
+      # globs in Constable::Config::DEFAULTS already use, so the path-based tier fallback
+      # and the tier base class the file inherits from agree with each other instead of
+      # quietly disagreeing. The base class still wins; agreeing just means nobody has to
+      # work out which one applied.
+      def case_path(area, *parts)
+        File.join("test/cases", area, *parts)
+      end
+
+      # The attributes worth putting in a witness. References and virtual attributes
+      # (rich text, attachments) are dropped: their value is another record or an
+      # uploaded file, and inventing one would generate a test that fails for a reason
+      # nobody wrote.
+      def case_attributes
+        @case_attributes ||= attributes.reject { |attribute| attribute.reference? || attribute.virtual? }
+      end
+
+      # `title: "MyString", published: false` -- the body of the witness a case starts from.
+      def attributes_arguments
+        case_attributes.map { |attribute| "#{attribute.column_name}: #{attribute_value(attribute)}" }.join(", ")
+      end
+
+      def attributes_literal
+        case_attributes.empty? ? "{}" : "{ #{attributes_arguments} }"
+      end
+
+      # `Post.new(title: "MyString")`, or a bare `Post.new` for a model generated with
+      # nothing to fill in.
+      def new_record_expression(klass = class_name)
+        case_attributes.empty? ? "#{klass}.new" : "#{klass}.new(#{attributes_arguments})"
+      end
+
+      def attribute_value(attribute)
+        return '"secret"' if %w[password password_confirmation].include?(attribute.name)
+
+        attribute.default.inspect
+      end
+    end
+  end
+end

data/lib/generators/constable/channel/channel_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate channel Room`.
+    #
+    #   test/cases/channels/room_channel_case.rb   class RoomChannelCase < IntegrationCase
+    class ChannelGenerator < Base
+      check_class_collision suffix: "ChannelCase"
+
+      strips_suffix(/_channel\z/i)
+
+      def create_case_file
+        template "channel_case.rb.tt", case_path("channels", class_path, "#{file_name}_channel_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/channel/templates/channel_case.rb.tt

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>ChannelCase < IntegrationCase
+  # ActionCable ships its own harness -- `subscribe`, `subscription`, `perform` -- as a
+  # module, so it composes into a case the same way any shared behavior does. One line,
+  # here or in the IntegrationCase base class in test/case_helper.rb:
+  #
+  #   include ActionCable::Channel::TestCase::Behavior
+  #
+  #   self.channel_class = <%= class_name %>Channel
+  #
+  # With that in place, the first two investigations write themselves:
+  #
+  #   investigate "subscribes" do
+  #     subscribe
+  #
+  #     attest(subscription).to be_confirmed
+  #   end
+  #
+  #   investigate "streams from its own room" do
+  #     subscribe(room: "1")
+  #
+  #     attest(streams).to include("<%= file_name %>_1")
+  #   end
+end
+<% end -%>

data/lib/generators/constable/controller/controller_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate controller Posts index show`.
+    #
+    #   test/cases/controllers/posts_controller_case.rb   class PostsControllerCase < IntegrationCase
+    class ControllerGenerator < Base
+      argument :actions, type: :array, default: [], banner: "action action"
+
+      # Rails passes this through when it skipped writing routes. Without a route there is
+      # nothing to drive, so the template says so instead of generating a request that
+      # cannot resolve.
+      class_option :skip_routes, type: :boolean
+
+      check_class_collision suffix: "ControllerCase"
+
+      def create_case_file
+        template "controller_case.rb.tt", case_path("controllers", class_path, "#{file_name}_controller_case.rb")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>ControllerCase < IntegrationCase
+<% if mountable_engine? -%>
+  include Engine.routes.url_helpers
+
+<% end -%>
+<% if actions.empty? || options[:skip_routes] -%>
+  # `rails generate controller <%= name %>` ran <%= actions.empty? ? "without any actions" : "with --skip-routes" %>, so there is no route to
+  # drive yet. When there is, an investigation reads like this -- one request, one
+  # assertion about the response, nothing shared with the next one:
+  #
+  #   investigate "index responds successfully" do
+  #     get <%= url_helper_prefix %>_index_url
+  #
+  #     attest(response).to have_http_status(:ok)
+  #   end
+<% else -%>
+<% actions.each do |action| -%>
+  investigate "<%= action %> responds successfully" do
+    get <%= url_helper_prefix %>_<%= action %>_url
+
+    attest(response).to have_http_status(:ok)
+  end
+<%= "\n" unless action == actions.last -%>
+<% end -%>
+<% end -%>
+end
+<% end -%>