hecks 6.0.0 → 7.0.0

data/lib/hecks/quality_control/cli/qa_tick/quiesce_guard.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../adapters/qa_quiesce_marker"
+
+module Hecks
+  module QualityControlCli
+    class QaTick
+      # Keeps a tick quiet while QA is quiesced for a mint window. Before each step the tick asks
+      # whether the `quiesced` dial is on or a fresh marker (`hecks qa_quiesce.hold!`) exists;
+      # if so the step does not start: `quiesced: skipped <step>` is printed and the step counts
+      # as clean, so the tick exits 0. The marker is read again before every step, so a hold set
+      # while a tick runs stops the steps after it. A stale marker is ignored, and said once per
+      # tick.
+      module QuiesceGuard
+        private
+
+        # Runs a step unless QA is quiesced.
+        #
+        # @param name [String] the step's name, as the report prints it
+        # @yieldreturn [Array(String, Integer)] the step's output and exit status
+        # @return [Step] the step's result, or a clean skipped step
+        def guarded(name)
+          skipped = quiesced_reason
+          return Step.new(name, *yield) unless skipped
+
+          message = "quiesced: skipped #{name} (#{skipped})"
+          puts message
+          Step.new(name, message, 0)
+        end
+
+        # @return [String, nil] why QA is quiet right now, or nil when steps may run
+        def quiesced_reason
+          return "the quiesced dial is on" if dial(:QUIESCED, false)
+
+          marker = @quiesce_marker ||= Adapters::QaQuiesceMarker.new
+          report_stale(marker)
+          hold = marker.active
+          marker.describe(hold) if hold
+        end
+
+        def report_stale(marker)
+          stale = marker.stale
+          return if stale.nil? || @stale_reported
+
+          @stale_reported = true
+          puts "quiesce marker is stale and ignored: #{marker.describe(stale)}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_tick.rb

@@ -8,13 +8,17 @@ require "tempfile"
 require_relative "child"
 require_relative "qa_tick/preflight"
 require_relative "qa_tick/output"
+require_relative "qa_main_gate"
+require_relative "qa_event_pump"
+require_relative "qa_tick/event_pump_step"
+require_relative "qa_tick/quiesce_guard"
 
 module Hecks
   module QualityControlCli
     # The command behind `hecks quality_control sweep.tick`: one QA tick. It needs a clean tree,
     # rebases on `origin/main`, then runs `QaPrCheck`, `QaSweep --all`, `QaGeneratedDomains
-    # --from-dials` and `QaMutate --from-dials` and prints one report. The dials can turn the last
-    # two off.
+    # --from-dials` and `QaMutate --from-dials`, then `QaMainGate` for the quick gate on main, and prints
+    # one report. The dials can turn the last three off.
     #
     # It exits 2 if any step found something, 1 if none did but a step errored or it refused, 0 if
     # all are clean. The step order is enforced here, not in prose. `QA_REPO_DIR` picks the
@@ -23,6 +27,8 @@ module Hecks
     class QaTick
       include Preflight
       include Output
+      include EventPumpStep
+      include QuiesceGuard
 
       EXIT_OK = 0
       EXIT_ERROR = 1
@@ -112,15 +118,21 @@ module Hecks
       Step = Struct.new(:name, :output, :exit_code)
 
       def run_steps
-        steps = [
-          Step.new("check_pull_requests", *run_pr_check),
-          Step.new("ask run --all", *run_sweep),
-          Step.new("check_generated_domains --from-dials", *run_generated_domains),
-          Step.new("mutate --from-dials", *run_mutation)
-        ]
+        steps = finding_steps
         report(steps, reclaimed_holds(steps[1].output), write_tick_log!(steps))
       end
 
+      # The steps that look for findings, in the order the report prints them. The event pump is last.
+      def finding_steps
+        [
+          guarded("check_pull_requests") { run_pr_check },
+          guarded("ask run --all") { run_sweep },
+          guarded("check_generated_domains --from-dials") { run_generated_domains },
+          guarded("mutate --from-dials") { run_mutation },
+          (guarded("check_main") { run_main_check } if dial(:RED_MAIN_CHECK, false))
+        ].compact + watch_steps
+      end
+
       def run_pr_check
         banner "hecks quality_control check_pull_requests"
         output, exit_code = run_step(->(argv) { QaPrCheck.call(argv, root: @root) })
@@ -149,6 +161,22 @@ module Hecks
         [output, exit_code]
       end
 
+      # The quick gate on local main, last: each red check it finds becomes a bug and a self-contained one
+      # is fixed, landed and pushed by `QaMainGate`.
+      def run_main_check
+        banner "hecks quality_control check_main"
+        output, exit_code = run_step(->(argv) { QaMainGate.call(argv, root: @root) })
+        puts output
+        [output, exit_code]
+      end
+
+      # @return [Object] the dial's value from `qa/settings.yml`, or the fallback when it is not loaded
+      def dial(name, fallback)
+        return fallback unless defined?(::QualityControlDials) && ::QualityControlDials.const_defined?(name)
+
+        ::QualityControlDials.const_get(name)
+      end
+
       def reclaimed_holds(sweep_output)
         sweep_output.scan(RECLAIMED_HOLD).flatten
       end

data/lib/hecks/quality_control/quality_control.behaviors

@@ -0,0 +1,65 @@
+Hecks.behaviors "QualityControl" do
+  vision "A green verdict is the only one announced, and a roll is requested once for a commit."
+
+  # The quality control bluebook bound as its own hecksagon binds it, for a behaviors boot. Its
+  # ports are declared in quality_control.ports.hecksagon; no adapter is needed for these tests,
+  # which never ask.
+  loads "quality_control.bluebook", "quality_control.hecksagon", "quality_control.ports.hecksagon"
+
+  test "Green announces a green verdict on main" do
+    tests "Green", on: "Head"
+    input commit: { value: "c" * 40 }, branch: { value: "main" }, repo: { value: "heckslabs/embryonaut_platform" },
+          color: { value: "green" }
+    # The chain goes on: no adapter answers the classifier in this boot, so it refuses.
+    expect emits: ["CiGreen", "RollConsidered", "ClassifyRefused"]
+  end
+
+  test "A red verdict on embryonaut_platform's main starts no image roll" do
+    tests "Red", on: "Head"
+    input commit: { value: "c" * 40 }, repo: { value: "heckslabs/embryonaut_platform" }, color: { value: "red" },
+          failing_jobs: { value: "rspec" }
+    expect emits: ["CiRed"]
+  end
+
+  test "Green refuses a red verdict" do
+    tests "Green", on: "Head"
+    input commit: { value: "c" * 40 }, branch: { value: "main" }, repo: { value: "heckslabs/embryonaut_platform" },
+          color: { value: "red" }
+    expect refused: "only a green verdict is announced"
+  end
+
+  test "Red names the failing jobs of a red verdict" do
+    tests "Red", on: "Head"
+    input commit: { value: "c" * 40 }, repo: { value: "heckslabs/embryonaut_platform" }, color: { value: "red" },
+          failing_jobs: { value: "rspec" }
+    expect emits: ["CiRed"]
+  end
+
+  test "Request refuses a commit on a branch other than main" do
+    tests "Request", on: "Head"
+    input commit: { value: "c" * 40 }, branch: { value: "feature" }, repo: { value: "heckslabs/embryonaut_platform" }
+    expect refused: "only main is judged"
+  end
+
+  test "Request starts an idle roll once" do
+    tests "Request", on: "ImageRoll"
+    input commit: { value: "d" * 40 }, app: { value: "console" }
+    # The chain runs through the roll's ask and its finish in this boot. The commit is no real
+    # embryonaut_platform commit, so its change set is unreadable and the roll is refused before
+    # any build; the refusal still finishes the roll.
+    expect emits: ["RollRequested", "RollRefused", "RollDone"]
+  end
+
+  test "A second Request for a commit already requested does nothing" do
+    tests "Request", on: "ImageRoll"
+    setup "QualityControl::ImageRoll.Request", commit: { value: "e" * 40 }, app: { value: "console" }
+    input commit: { value: "e" * 40 }, app: { value: "console" }
+    expect refused: "already exists"
+  end
+
+  test "NeedsApproval holds a commit that reaches past the container" do
+    tests "NeedsApproval", on: "ImageRoll"
+    input commit: { value: "f" * 40 }, paths: { value: "deploy-aws/box-generated/Makefile" }
+    expect emits: ["RollNeedsApproval"]
+  end
+end