ruact 0.0.10 → 0.0.12

data/spec/ruact/server_upload_request_spec.rb

@@ -1,311 +0,0 @@
-# frozen_string_literal: true
-
-# Story 9.1 — request-cycle + unit spec for the Story 8.5 upload guard
-# RE-ANCHORED on the `Ruact::Server` concern (its final, v2 home). Replaces
-# `server_functions/endpoint_controller_upload_spec.rb` (removed in the same
-# commit — AC5). Pins, against REAL host-controller routes:
-#
-#   - oversized multipart → 413 + structured `upload_limit` payload through
-#     the concern's salvaged chain (inventory A7, A14, B7, B9, B11)
-#   - guard fires BEFORE CSRF verification on correctly ordered hosts —
-#     413, not 403 (B6 / Pitfall #4)
-#   - the three carve-outs: nil limit (B2), content-type allowlist (B3),
-#     absent Content-Length (B4); off-by-one equal-passes (B5)
-#   - D1: the 413 renders structured for native form submits too (no
-#     function-call Accept header) — the documented UploadTooLargeError
-#     exception to the re-raise rule
-#   - D2: GET/HEAD requests skip the guard entirely (C5)
-#   - small uploads reach the action as ActionDispatch::Http::UploadedFile
-#     with metadata + mixed non-file fields intact (transplant sanity)
-#
-# Mounts on the shared Story-7.9 Rails app; deliberately independent of the
-# v1 `server_functions/dispatch_request_spec.rb` (demolished in Story 9.9).
-
-require "action_controller/railtie"
-require "action_view/railtie"
-
-require "spec_helper"
-require "rack/test"
-require "tempfile"
-
-require "ruact/server"
-
-require_relative "controller_request_spec" unless defined?(ControllerRequestSpecSupport)
-
-SERVER_UPLOAD_SPEC_PNG_PATH =
-  File.expand_path("../support/fixtures/pixel.png", __dir__).freeze
-SERVER_UPLOAD_SPEC_PNG_BYTES = File.binread(SERVER_UPLOAD_SPEC_PNG_PATH).freeze
-
-module ServerUploadSpecSupport
-  class UploadsServerController < ActionController::Base
-    include Ruact::Server
-
-    def create_upload
-      uploaded = params[:cover]
-      render json: {
-        "title" => params[:title].to_s,
-        "uploaded_class" => uploaded.class.name,
-        "original_filename" => uploaded.respond_to?(:original_filename) ? uploaded.original_filename : nil,
-        "byte_size" => uploaded.respond_to?(:read) ? uploaded.read.bytesize : nil
-      }
-    end
-  end
-
-  # CSRF-enforcing host for the Pitfall #4 ordering proof (B6) — forgery is
-  # flipped on per-example via the class-level `allow_forgery_protection`.
-  class ForgeryUploadsServerController < ActionController::Base
-    include Ruact::Server
-
-    protect_from_forgery with: :exception
-
-    def create_protected_upload
-      render json: { "ok" => true }
-    end
-  end
-end
-
-if defined?(ControllerRequestSpecSupport) &&
-   !ControllerRequestSpecSupport.instance_variable_get(:@__ruact_server_upload_routes_appended)
-  ControllerRequestSpecSupport.instance_variable_set(:@__ruact_server_upload_routes_appended, true)
-  ControllerRequestSpecSupport.app_class.routes.append do
-    post "/server_upload",           to: "server_upload_spec_support/uploads_server#create_upload"
-    post "/server_upload/protected", to: "server_upload_spec_support/forgery_uploads_server#create_protected_upload"
-  end
-end
-
-RSpec.describe "Story 9.1: Ruact::Server concern — salvaged upload guard", :story_9_1 do
-  include Rack::Test::Methods
-
-  let(:app_class) { ControllerRequestSpecSupport.app_class }
-  let(:app)       { app_class.instance }
-
-  let(:function_call_accept) { { "HTTP_ACCEPT" => "application/json" } }
-
-  before do
-    Rails.logger = Logger.new(IO::NULL)
-    ControllerRequestSpecSupport.boot!
-  end
-
-  def with_oversized_tempfile
-    large = Tempfile.new(["big", ".bin"])
-    large.binmode
-    large.write("x" * 4096) # 4 KB > the 1 KB caps below
-    large.rewind
-    yield large
-  ensure
-    large.close
-    large.unlink
-  end
-
-  def cap_max_upload_bytes(value)
-    # spec_helper's global before-hook resets @config; re-prime AFTER it so
-    # the tight cap sticks for the example body (same dance as the v1 spec).
-    Ruact.instance_variable_set(:@config, nil)
-    Ruact.instance_variable_set(:@configured_at_least_once, false)
-    Ruact.configure { |c| c.max_upload_bytes = value }
-  end
-
-  describe "transplant sanity — small multipart upload reaches the action" do
-    it "params[:cover] arrives as ActionDispatch::Http::UploadedFile with metadata; mixed fields intact" do
-      post "/server_upload",
-           {
-             "title" => "My Post",
-             "cover" => Rack::Test::UploadedFile.new(SERVER_UPLOAD_SPEC_PNG_PATH, "image/png")
-           },
-           function_call_accept
-      expect(last_response.status).to eq(200)
-      body = JSON.parse(last_response.body)
-      expect(body.fetch("uploaded_class")).to eq("ActionDispatch::Http::UploadedFile")
-      expect(body.fetch("original_filename")).to eq("pixel.png")
-      expect(body.fetch("byte_size")).to eq(SERVER_UPLOAD_SPEC_PNG_BYTES.bytesize)
-      expect(body.fetch("title")).to eq("My Post")
-    end
-  end
-
-  describe "oversized multipart → 413 + structured upload_limit payload (A7/A14/B7/B9/B11)" do
-    before { cap_max_upload_bytes(1024) }
-
-    it "function-call request: 413 with discriminator, real action_name, and the dev-only upload_limit block" do
-      with_oversized_tempfile do |large|
-        post "/server_upload",
-             {
-               "title" => "Too big",
-               "cover" => Rack::Test::UploadedFile.new(large.path, "application/octet-stream")
-             },
-             function_call_accept
-        expect(last_response.status).to eq(413)
-        body = JSON.parse(last_response.body)
-        expect(body).to include(
-          "_ruact_server_action_error" => true,
-          "error_class" => "Ruact::UploadTooLargeError",
-          # A14 — the controller's REAL action name, no registry-symbol
-          # fallback dance (the v1 path_parameters[:name] fallback is gone).
-          "action_name" => "create_upload"
-        )
-        expect(body.fetch("upload_limit")).to include("limit_bytes" => 1024)
-        # B7 — received_bytes is the WIRE Content-Length: file bytes PLUS
-        # multipart boundary + field overhead.
-        expect(body.fetch("upload_limit").fetch("received_bytes")).to be > 4096
-      end
-    end
-
-    it "D1 — a native form submit (no function-call Accept) ALSO gets the structured 413" do
-      # UploadTooLargeError is the documented exception to the re-raise rule:
-      # the guard only exists on requests that opted into the concern, and a
-      # meaningful 413 beats a re-raised 500 for every caller shape.
-      with_oversized_tempfile do |large|
-        post "/server_upload",
-             {
-               "title" => "Too big, browser shape",
-               "cover" => Rack::Test::UploadedFile.new(large.path, "application/octet-stream")
-             }
-        expect(last_response.status).to eq(413)
-        body = JSON.parse(last_response.body)
-        expect(body.fetch("_ruact_server_action_error")).to be(true)
-        expect(body.fetch("error_class")).to eq("Ruact::UploadTooLargeError")
-      end
-    end
-  end
-
-  describe "guard fires BEFORE CSRF verification (B6 / Pitfall #4)" do
-    around do |example|
-      previous = ServerUploadSpecSupport::ForgeryUploadsServerController.allow_forgery_protection
-      ServerUploadSpecSupport::ForgeryUploadsServerController.allow_forgery_protection = true
-      example.run
-    ensure
-      ServerUploadSpecSupport::ForgeryUploadsServerController.allow_forgery_protection = previous
-    end
-
-    before { cap_max_upload_bytes(1024) }
-
-    it "oversized request WITHOUT a CSRF token returns 413, not 403" do
-      with_oversized_tempfile do |large|
-        post "/server_upload/protected",
-             {
-               "title" => "Too big, no token",
-               "cover" => Rack::Test::UploadedFile.new(large.path, "application/octet-stream")
-             },
-             function_call_accept
-        expect(last_response.status).to eq(413)
-        expect(JSON.parse(last_response.body).fetch("error_class")).to eq("Ruact::UploadTooLargeError")
-      end
-    end
-  end
-
-  describe "carve-out — max_upload_bytes = nil disables the gem-side guard (B2)" do
-    before { cap_max_upload_bytes(nil) }
-
-    it "a body of any size flows through to the action" do
-      with_oversized_tempfile do |large|
-        post "/server_upload",
-             {
-               "title" => "no cap",
-               "cover" => Rack::Test::UploadedFile.new(large.path, "application/octet-stream")
-             },
-             function_call_accept
-        expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body).fetch("uploaded_class")).to eq("ActionDispatch::Http::UploadedFile")
-      end
-    end
-  end
-
-  describe "carve-out — application/json bypasses the guard (B3, request-cycle)" do
-    before { cap_max_upload_bytes(1024) }
-
-    it "a 4 KB JSON body passes the guard and reaches the action" do
-      payload = { "title" => "big json", "blob" => "x" * 4096 }
-      post "/server_upload", payload.to_json,
-           { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json" }
-      expect(last_response.status).to eq(200)
-      # No file in a JSON body — the action reports the params leaf class.
-      expect(JSON.parse(last_response.body).fetch("uploaded_class")).to eq("NilClass")
-    end
-  end
-
-  # Unit-level coverage of the short-circuit branches — directly against a
-  # host controller instance, mirroring the v1 unit block but with the
-  # concern's D2 verb gate in play (request.get? / request.head?).
-  describe "Unit — __ruact_enforce_upload_limit! short-circuits (B2–B5, C5/D2)" do
-    let(:controller) { ServerUploadSpecSupport::UploadsServerController.new }
-
-    def with_max_upload_bytes(value)
-      cap_max_upload_bytes(value)
-      yield
-    ensure
-      Ruact.instance_variable_set(:@config, nil)
-      Ruact.instance_variable_set(:@configured_at_least_once, false)
-    end
-
-    def stub_request(content_type:, content_length:, http_method: "POST")
-      request = instance_double(
-        ActionDispatch::Request,
-        content_length: content_length,
-        get?: http_method == "GET",
-        head?: http_method == "HEAD"
-      )
-      allow(request).to receive(:content_mime_type)
-        .and_return(content_type ? Mime::Type.lookup(content_type) : nil)
-      allow(controller).to receive(:request).and_return(request)
-    end
-
-    it "B4 — nil Content-Length (chunked transfer) bypasses the guard" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "multipart/form-data", content_length: nil)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "B2 — max_upload_bytes = nil bypasses the guard even with oversized Content-Length" do
-      with_max_upload_bytes(nil) do
-        stub_request(content_type: "multipart/form-data", content_length: 10 * 1024 * 1024)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "B3 — application/json content type bypasses the guard" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "application/json", content_length: 10 * 1024 * 1024)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "B3 — missing content type (nil) bypasses the guard" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: nil, content_length: 10_000)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "B3/B8 — application/x-www-form-urlencoded is subject to the guard" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "application/x-www-form-urlencoded", content_length: 2048)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }
-          .to raise_error(Ruact::UploadTooLargeError) do |error|
-            expect(error.received_bytes).to eq(2048)
-            expect(error.limit_bytes).to eq(1024)
-          end
-      end
-    end
-
-    it "B5 — Content-Length exactly equal to the limit passes the guard (off-by-one)" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "multipart/form-data", content_length: 1024)
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "C5/D2 — a GET request skips the guard even with an oversized multipart body" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "multipart/form-data", content_length: 10 * 1024 * 1024, http_method: "GET")
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-
-    it "C5/D2 — a HEAD request skips the guard" do
-      with_max_upload_bytes(1024) do
-        stub_request(content_type: "multipart/form-data", content_length: 10 * 1024 * 1024, http_method: "HEAD")
-        expect { controller.send(:__ruact_enforce_upload_limit!) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/ruact/signed_references_spec.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-# Story 13.2 (FR96) — unit specs for the signed-reference primitive:
-# Ruact.signed_global_id (outbound) + Ruact.locate_signed (inbound). Covers the
-# four epic AC cases (round-trip / tampered / expired / wrong-purpose) plus the
-# loud-omission guards that keep an unscoped or silently-non-expiring token
-# unconstructible.
-
-require "spec_helper"
-require "global_id"
-require "active_support"
-require "active_support/core_ext/integer/time"
-require "active_support/core_ext/numeric/time"
-require "active_support/message_verifier"
-
-# A GlobalID-locatable test record: globalid keys off `class.name` + `#id` and
-# resolves via `class.find(id)`. Top-level + constantizable so the locator can
-# reach it (mirrors how query_request_spec defines its host classes top-level).
-class SignedRefSpecPost
-  include GlobalID::Identification
-
-  attr_reader :id
-
-  def initialize(id)
-    @id = id.to_s
-    self.class.store[@id] = self
-  end
-
-  def self.store
-    @store ||= {}
-  end
-
-  def self.find(id)
-    store.fetch(id.to_s)
-  end
-end
-
-module Ruact # rubocop:disable Style/OneClassPerFile
-  RSpec.describe SignedReferences, :story_13_2 do
-    let(:record) { SignedRefSpecPost.new("7") }
-
-    before do
-      # globalid signing needs an app name + a verifier secret. Set both as
-      # test infrastructure (no other spec uses globalid, so the global state
-      # is inert elsewhere).
-      GlobalID.app = "ruact-test"
-      SignedGlobalID.verifier = ActiveSupport::MessageVerifier.new("a" * 64)
-    end
-
-    describe ".signed_global_id + .locate_signed round-trip (AC: round-trip)" do
-      it "mints a token that resolves back to the same record for a matching purpose" do
-        token = Ruact.signed_global_id(record, for: :post_edit, expires_in: 1.hour)
-
-        expect(token).to be_a(String)
-        expect(token).not_to eq("7")    # a signed token, not the raw id
-        expect(token).to include("--")  # MessageVerifier signature separator
-        located = Ruact.locate_signed(token, for: :post_edit)
-        expect(located.id).to eq("7")
-      end
-    end
-
-    describe ".locate_signed rejection cases" do
-      let(:token) { Ruact.signed_global_id(record, for: :post_edit, expires_in: 1.hour) }
-
-      it "rejects a tampered token (AC: tampered)" do
-        expect { Ruact.locate_signed("#{token}tamper", for: :post_edit) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-      end
-
-      it "rejects an expired token (AC: expired)" do
-        expired = Ruact.signed_global_id(record, for: :post_edit, expires_in: -1.hour)
-        expect { Ruact.locate_signed(expired, for: :post_edit) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-      end
-
-      it "rejects a wrong-purpose token (AC: wrong-for)" do
-        expect { Ruact.locate_signed(token, for: :post_delete) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-      end
-
-      it "rejects a nil / garbage token" do
-        expect { Ruact.locate_signed(nil, for: :post_edit) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-        expect { Ruact.locate_signed("not-a-token", for: :post_edit) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-      end
-
-      it "does not echo the raw token in the rejection message (no leak)" do
-        Ruact.locate_signed("#{token}tamper", for: :post_edit)
-      rescue Ruact::InvalidSignedGlobalIDError => e
-        expect(e.message).not_to include(token)
-      end
-    end
-
-    describe "loud-omission guards (never a silent insecure default)" do
-      it "raises when no purpose is given and none is configured" do
-        expect { Ruact.signed_global_id(record, expires_in: 1.hour) }
-          .to raise_error(Ruact::Error, /purpose/)
-      end
-
-      it "raises on an explicit for: nil (an unscoped token is never allowed)" do
-        expect { Ruact.signed_global_id(record, for: nil, expires_in: 1.hour) }
-          .to raise_error(Ruact::Error, /purpose/)
-      end
-
-      it "raises when expiry is omitted and none is configured" do
-        expect { Ruact.signed_global_id(record, for: :post_edit) }
-          .to raise_error(Ruact::Error, /expir/i)
-      end
-
-      it "honors an explicit expires_in: nil as a deliberate non-expiring token" do
-        token = Ruact.signed_global_id(record, for: :post_edit, expires_in: nil)
-        expect(Ruact.locate_signed(token, for: :post_edit).id).to eq("7")
-      end
-
-      it "rejects expires_in: false (globalid would silently treat it as non-expiring)" do
-        expect { Ruact.signed_global_id(record, for: :post_edit, expires_in: false) }
-          .to raise_error(Ruact::Error, /expiry must be/)
-      end
-
-      it "rejects a bare Integer expires_in (globalid would crash on #from_now)" do
-        expect { Ruact.signed_global_id(record, for: :post_edit, expires_in: 3600) }
-          .to raise_error(Ruact::Error, /expiry must be/)
-      end
-
-      it "rejects a configured default of false (the second silent non-expiring path)" do
-        Ruact.configure { |c| c.signed_global_id_default_expires_in = false }
-        expect { Ruact.signed_global_id(record, for: :post_edit) }
-          .to raise_error(Ruact::Error, /expiry must be/)
-      end
-
-      it "raises a clear error for a non-GlobalID-locatable value" do
-        expect { Ruact.signed_global_id("plain-string", for: :post_edit, expires_in: 1.hour) }
-          .to raise_error(Ruact::Error, /GlobalID-locatable/)
-      end
-
-      it "does NOT convert a valid token to a deleted record into InvalidSignedGlobalIDError " \
-         "(contract: a gone record is the host's normal finder concern, not a forged token)" do
-        token = Ruact.signed_global_id(record, for: :post_edit, expires_in: 1.hour)
-        SignedRefSpecPost.store.delete(record.id) # the row is gone, the token is still valid
-
-        # the underlying finder raises (KeyError here; ActiveRecord::RecordNotFound in a real app),
-        # NOT Ruact::InvalidSignedGlobalIDError — the primitive only owns signature/expiry/purpose.
-        expect { Ruact.locate_signed(token, for: :post_edit) }
-          .to raise_error(KeyError)
-      end
-    end
-
-    describe "configured defaults" do
-      it "falls back to signed_global_id_default_purpose / _expires_in when the call omits them" do
-        Ruact.configure do |c|
-          c.signed_global_id_default_purpose = :app_default
-          c.signed_global_id_default_expires_in = 1.hour
-        end
-
-        token = Ruact.signed_global_id(record)
-        expect(Ruact.locate_signed(token).id).to eq("7")
-        # a token minted under the default purpose must not resolve under another
-        expect { Ruact.locate_signed(token, for: :something_else) }
-          .to raise_error(Ruact::InvalidSignedGlobalIDError)
-      end
-    end
-  end
-end

data/spec/ruact/string_distance_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Ruact
-  RSpec.describe StringDistance, :story_13_5 do
-    describe ".damerau_levenshtein" do
-      it "returns 0 for identical strings" do
-        expect(described_class.damerau_levenshtein("postId", "postId")).to eq(0)
-      end
-
-      it "counts an adjacent transposition as a single edit" do
-        expect(described_class.damerau_levenshtein("postId", "postdI")).to eq(1)
-      end
-
-      it "handles empty strings" do
-        expect(described_class.damerau_levenshtein("", "abc")).to eq(3)
-        expect(described_class.damerau_levenshtein("abc", "")).to eq(3)
-      end
-    end
-
-    describe ".closest_match" do
-      let(:pool) { %w[postId initialCount title] }
-
-      it "finds the nearest candidate within the threshold (case-insensitive)" do
-        expect(described_class.closest_match("postID", pool)).to eq("postId")
-      end
-
-      it "returns nil when nothing is within distance" do
-        expect(described_class.closest_match("zzzzzzzz", pool)).to be_nil
-      end
-
-      it "prefers the smallest distance" do
-        expect(described_class.closest_match("titel", pool)).to eq("title")
-      end
-    end
-  end
-end

data/spec/ruact/tasks_json_introspection_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "rake"
-require "json"
-require "tmpdir"
-require "action_controller"
-require "ruact/server"
-require "ruact/doctor"
-require "ruact/server_functions"
-
-# Story 15.3 (FR107) — end-to-end coverage of the `--json` Rake glue itself:
-# the `-- --json` ARGV scan, JSON-only stdout (no human prose), and — for
-# `ruact:doctor` — the preserved process exit code (0 pass/warn, 1 on fail).
-# The `Doctor#as_json` / `Introspection.as_json` shapes are unit-tested
-# elsewhere; THIS proves the task wiring around them (Codex R1, Acceptance
-# Auditor). Mirrors the isolated-Rake harness in
-# spec/ruact/server_functions/rake_spec.rb.
-module Ruact
-  RSpec.describe "rake --json introspection tasks", :story_15_3 do
-    around do |example|
-      Dir.mktmpdir do |dir|
-        original_root = Rails.root
-        Rails.root = Pathname.new(dir)
-
-        prev = Rake.application
-        Rake.application = Rake::Application.new
-        Rake.application.define_task(Rake::Task, :environment)
-        load File.expand_path("../../lib/tasks/ruact.rake", __dir__)
-
-        example.run
-      ensure
-        Rake.application = prev
-        Rails.root = original_root
-      end
-    end
-
-    def invoke!(task_name)
-      Rake::Task[task_name].reenable
-      Rake::Task[task_name].invoke
-    end
-
-    # ---- ruact:doctor -- --json (AC1: JSON-only stdout + preserved exit) ----
-
-    describe "ruact:doctor -- --json" do
-      before { stub_const("ARGV", %w[ruact:doctor -- --json]) }
-
-      def stub_doctor(status:)
-        report = {
-          "schema_version" => 0,
-          "status" => status,
-          "checks" => [{ "name" => "manifest", "status" => status, "message" => "m", "remediation" => nil }]
-        }
-        allow(Ruact::Doctor).to receive(:new).and_return(instance_double(Ruact::Doctor, as_json: report))
-      end
-
-      it "prints ONLY the JSON document (no prose) and does not exit when all pass", :aggregate_failures do
-        stub_doctor(status: "pass")
-
-        out = nil
-        expect { out = capture_stdout_string { invoke!("ruact:doctor") } }.not_to raise_error
-        parsed = JSON.parse(out)
-        expect(parsed["schema_version"]).to eq(0)
-        expect(parsed["status"]).to eq("pass")
-        expect(out).not_to include("[ruact] Health check")
-        expect(out).not_to include("Run rails generate")
-      end
-
-      it "exits 1 (SystemExit) when a check fails, still emitting the JSON", :aggregate_failures do
-        stub_doctor(status: "fail")
-
-        expect do
-          expect { invoke!("ruact:doctor") }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
-        end.to output(/"status": "fail"/).to_stdout
-      end
-    end
-
-    it "ruact:doctor WITHOUT --json runs the human path (no JSON), returns 0 when healthy" do
-      stub_const("ARGV", %w[ruact:doctor])
-      allow(Ruact::Doctor).to receive(:run).and_return(true)
-
-      expect { expect { invoke!("ruact:doctor") }.not_to raise_error }.not_to output(/schema_version/).to_stdout
-      expect(Ruact::Doctor).to have_received(:run)
-    end
-
-    # ---- ruact:routes (AC2: JSON via -- --json, human table bare) ----
-
-    describe "ruact:routes" do
-      before do
-        stub_const("RakeRoutesPostsController", Class.new(ActionController::Base) { include Ruact::Server })
-        reloader = Object.new
-        def reloader.execute_unless_loaded; end
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw { resources :rake_routes_posts, only: %i[create] }
-        app = Object.new
-        app.define_singleton_method(:routes) { rs }
-        app.define_singleton_method(:routes_reloader) { reloader }
-        allow(Rails).to receive(:application).and_return(app)
-      end
-
-      it "emits the EXPERIMENTAL JSON document under -- --json (end-to-end, real resolvers)", :aggregate_failures do
-        stub_const("ARGV", %w[ruact:routes -- --json])
-
-        out = capture_stdout_string { invoke!("ruact:routes") }
-        parsed = JSON.parse(out)
-        expect(parsed["schema_version"]).to eq(0)
-        create = parsed["accessors"].find { |a| a["accessor"] == "createRakeRoutesPost" }
-        expect(create).to include("kind" => "action", "verb" => "POST", "path" => "/rake_routes_posts")
-      end
-
-      it "prints a compact human table (no JSON) when invoked bare", :aggregate_failures do
-        stub_const("ARGV", %w[ruact:routes])
-
-        out = capture_stdout_string { invoke!("ruact:routes") }
-        expect(out).to include("server-function accessors:")
-        expect(out).to include("createRakeRoutesPost")
-        expect(out).not_to include("schema_version")
-      end
-
-      it "exits 1 with a `[ruact] error:` line on a naming collision" do
-        stub_const("ARGV", %w[ruact:routes -- --json])
-        allow(Ruact::ServerFunctions).to receive(:introspect)
-          .and_raise(Ruact::ConfigurationError, "server-function naming collision: A#x and B#x ...")
-
-        expect { invoke!("ruact:routes") }
-          .to raise_error(SystemExit)
-          .and output(/\[ruact\] error:.*naming collision/).to_stderr
-      end
-    end
-
-    # Captures $stdout into a String (the harness has no shared helper).
-    def capture_stdout_string
-      original = $stdout
-      $stdout = StringIO.new
-      yield
-      $stdout.string
-    ensure
-      $stdout = original
-    end
-  end
-end