ruact 0.0.6 → 0.0.8

data/spec/ruact/manifest_resolver_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "net/http"
+require "tmpdir"
+
+module Ruact
+  RSpec.describe ManifestResolver do
+    # spec_helper pins resolve/resolve_soft to the boot manifest suite-wide for
+    # hermeticity; this spec is the one place that exercises the REAL paths.
+    before do
+      allow(described_class).to receive(:resolve).and_call_original
+      allow(described_class).to receive(:resolve_soft).and_call_original
+    end
+
+    let(:manifest_hash) do
+      {
+        "LikeButton" => {
+          "id" => "/LikeButton.jsx",
+          "name" => "LikeButton",
+          "chunks" => ["/LikeButton.jsx"]
+        }
+      }
+    end
+    let(:manifest_json) { JSON.generate(manifest_hash) }
+
+    # A real Net::HTTPSuccess (HTTPOK < HTTPSuccess) whose body we override, so
+    # the resolver's `response.is_a?(Net::HTTPSuccess)` branch is exercised for
+    # real without touching the network.
+    def http_ok(body)
+      response = Net::HTTPOK.new("1.1", "200", "OK")
+      response.define_singleton_method(:body) { body }
+      response
+    end
+
+    def in_dev
+      allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("development"))
+    end
+
+    describe ".resolve in development (the boot-race)" do
+      before do
+        in_dev
+        # Simulate the race: boot read the missing file, so the cached manifest is nil.
+        allow(Ruact).to receive(:manifest).and_return(nil)
+      end
+
+      it "resolves from the Vite dev server over HTTP (no 500, ref resolvable)" do
+        allow(Net::HTTP).to receive(:start).and_return(http_ok(manifest_json))
+
+        manifest = described_class.resolve
+
+        expect(manifest).to be_a(ClientManifest)
+        ref = manifest.reference_for("LikeButton")
+        expect(ref.module_id).to eq("/LikeButton.jsx")
+      end
+
+      it "fetches the manifest from the configured vite_dev_server URL" do
+        allow(Net::HTTP).to receive(:start).and_return(http_ok(manifest_json))
+
+        described_class.resolve
+
+        expect(Net::HTTP).to have_received(:start).with(
+          "localhost", 5173, hash_including(:open_timeout, :read_timeout)
+        )
+      end
+
+      it "does not double-slash the path when vite_dev_server has a trailing slash" do
+        allow(described_class).to receive(:base_url).and_return("http://localhost:5173/")
+        http = instance_double(Net::HTTP)
+        allow(http).to receive(:get).and_return(http_ok(manifest_json))
+        allow(Net::HTTP).to receive(:start).and_yield(http).and_return(http_ok(manifest_json))
+
+        described_class.resolve
+
+        expect(http).to have_received(:get).with("/__ruact/manifest")
+      end
+
+      it "speaks TLS when vite_dev_server is https" do
+        allow(described_class).to receive(:base_url).and_return("https://localhost:5173")
+        allow(Net::HTTP).to receive(:start).and_return(http_ok(manifest_json))
+
+        described_class.resolve
+
+        expect(Net::HTTP).to have_received(:start).with(
+          "localhost", 5173, hash_including(use_ssl: true)
+        )
+      end
+
+      it "falls back to the on-disk file when the dev server is unreachable" do
+        allow(Net::HTTP).to receive(:start).and_raise(Errno::ECONNREFUSED)
+
+        Dir.mktmpdir do |dir|
+          path = File.join(dir, "react-client-manifest.json")
+          File.write(path, manifest_json)
+          allow(described_class).to receive(:file_path).and_return(path)
+
+          manifest = described_class.resolve
+          expect(manifest).to be_a(ClientManifest)
+          expect(manifest.reference_for("LikeButton").module_id).to eq("/LikeButton.jsx")
+        end
+      end
+
+      it "raises a clear, actionable error (not NoMethodError) when neither HTTP nor file is available" do
+        allow(Net::HTTP).to receive(:start).and_raise(Errno::ECONNREFUSED)
+        allow(described_class).to receive(:file_path).and_return("/no/such/manifest.json")
+
+        expect { described_class.resolve }.to raise_error(ManifestError, %r{Vite dev server.*bin/dev}m)
+      end
+
+      # Story 15.0 (F8) — an error message is a prompt: agents (and humans)
+      # regex-match error text, so the ENGLISH wording and its stable tokens
+      # (`Vite dev server`, `react-client-manifest.json`, `bin/dev`) are pinned.
+      it "raises the ENGLISH message naming the dev-server URL, the manifest path and the bin/dev fix " \
+         "(Story 15.0)", :story_15_0 do
+        allow(Net::HTTP).to receive(:start).and_raise(Errno::ECONNREFUSED)
+        allow(described_class).to receive(:file_path).and_return("/no/such/manifest.json")
+
+        expect { described_class.resolve }.to raise_error(ManifestError) do |error|
+          expect(error.message).to include("[ruact] Vite dev server unreachable at http://localhost:5173")
+          expect(error.message).to include("no react-client-manifest.json found at /no/such/manifest.json")
+          expect(error.message).to include("run `bin/dev`")
+        end
+      end
+
+      it "ignores a non-2xx dev-server response and falls back" do
+        allow(Net::HTTP).to receive(:start).and_return(Net::HTTPNotFound.new("1.1", "404", "Not Found"))
+        allow(described_class).to receive(:file_path).and_return("/no/such/manifest.json")
+
+        expect { described_class.resolve }.to raise_error(ManifestError)
+      end
+    end
+
+    describe ".resolve_soft in development (fail-open for FR100)" do
+      before do
+        in_dev
+        allow(Ruact).to receive(:manifest).and_return(nil)
+      end
+
+      it "returns nil (no raise) when nothing is resolvable" do
+        allow(Net::HTTP).to receive(:start).and_raise(Errno::ECONNREFUSED)
+        allow(described_class).to receive(:file_path).and_return("/no/such/manifest.json")
+
+        expect(described_class.resolve_soft).to be_nil
+      end
+
+      it "returns the dev manifest when the server is up" do
+        allow(Net::HTTP).to receive(:start).and_return(http_ok(manifest_json))
+        expect(described_class.resolve_soft).to be_a(ClientManifest)
+      end
+    end
+
+    describe "production / non-development (untouched)" do
+      it "returns Ruact.manifest verbatim without any HTTP call" do
+        allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("production"))
+        allow(Net::HTTP).to receive(:start)
+        boot_manifest = ClientManifest.from_hash(manifest_hash)
+        allow(Ruact).to receive(:manifest).and_return(boot_manifest)
+
+        expect(described_class.resolve).to be(boot_manifest)
+        expect(Net::HTTP).not_to have_received(:start)
+      end
+
+      it "returns Ruact.manifest in the test environment too (no dev fetch)" do
+        allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("test"))
+        allow(Net::HTTP).to receive(:start)
+        boot_manifest = ClientManifest.from_hash(manifest_hash)
+        allow(Ruact).to receive(:manifest).and_return(boot_manifest)
+
+        expect(described_class.resolve).to be(boot_manifest)
+        expect(Net::HTTP).not_to have_received(:start)
+      end
+    end
+  end
+end

data/spec/ruact/serializable_spec.rb

@@ -32,6 +32,132 @@ module Ruact
       end
     end
 
+    # Story 13.7 — `ruact_props` on ActiveRecord models.
+    #
+    # ActiveRecord defines its attribute reader methods LAZILY (on first
+    # instance access), so at the moment the `ruact_props :title` macro runs,
+    # `method_defined?(:title)` is `false` even for a real column. The eager
+    # boot check used to raise there, so an AR model that included
+    # `Ruact::Serializable` crashed at class-load. Story 13.7 makes the check
+    # HYBRID: POROs are still checked eagerly at class-load (byte-identical, see
+    # the block above), while for a lazy-attribute (AR) class the loud check is
+    # DEFERRED to the first `ruact_serialize` — where the DB is up and the reader
+    # exists. Loudness is preserved: a bogus prop still raises a clean
+    # `ArgumentError`, just at first render of that model instead of at boot.
+    #
+    # Zero suite-boot DB footprint: the connection + table are built INSIDE the
+    # example (direct connection DDL, NOT `Schema.define`, so we touch nothing
+    # global — no `schema_migrations` / `ar_internal_metadata`), and only a
+    # connection we ourselves opened is torn down.
+    describe "ActiveRecord models (Story 13.7)", :story_13_7 do
+      before do
+        require "active_record"
+        @already_connected =
+          ActiveRecord::Base.respond_to?(:connected?) && ActiveRecord::Base.connected?
+        ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:") unless @already_connected
+        ActiveRecord::Base.connection.create_table(:ruact_props_probe_posts, force: true) do |t|
+          t.string :title
+          t.string :secret
+        end
+      end
+
+      after do
+        if defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+          ActiveRecord::Base.connection.drop_table(:ruact_props_probe_posts, if_exists: true)
+        end
+        ActiveRecord::Base.remove_connection unless @already_connected
+      end
+
+      let(:ar_model) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "ruact_props_probe_posts"
+          include Ruact::Serializable
+
+          ruact_props :id, :title
+        end
+      end
+
+      it "loads without raising even though readers are lazy at class-load (AC#1)" do
+        expect { ar_model }.not_to raise_error
+      end
+
+      it "ruact_serialize returns only the declared allowlist (AC#1)" do
+        row = ar_model.create!(title: "Hello", secret: "top-secret")
+
+        expect(row.ruact_serialize).to eq({ "id" => row.id, "title" => "Hello" })
+        expect(row.ruact_serialize.keys).not_to include("secret")
+      end
+
+      it "defers the loud check to first serialize for a bogus prop (AC#2)" do
+        model = nil
+
+        # Declaring a bogus prop on an AR model does NOT raise at class-load —
+        # the reader might still be defined lazily, so the check is deferred.
+        expect do
+          model = Class.new(ActiveRecord::Base) do
+            self.table_name = "ruact_props_probe_posts"
+            include Ruact::Serializable
+
+            ruact_props :ttile # typo — neither a column nor a method
+          end
+        end.not_to raise_error
+
+        # …but it fails LOUDLY (same clean ArgumentError) on first serialize.
+        expect { model.new.ruact_serialize }
+          .to raise_error(ArgumentError, /ttile.*not defined/)
+      end
+
+      it "re-validates loudly when props are re-declared after a first serialize (AC#2)" do
+        model = Class.new(ActiveRecord::Base) do
+          self.table_name = "ruact_props_probe_posts"
+          include Ruact::Serializable
+
+          ruact_props :id, :title
+        end
+
+        # First serialize succeeds and memoizes "validated"…
+        model.create!(title: "Hello").ruact_serialize
+
+        # …a re-declaration with a bogus prop must NOT be masked by the stale
+        # memo: the next serialize still raises the clean ArgumentError.
+        model.ruact_props :id, :ttile
+        expect { model.new.ruact_serialize }
+          .to raise_error(ArgumentError, /ttile.*not defined/)
+      end
+
+      it "re-validates an inherited declaration re-declared on the parent after a subclass serialize (AC#2)" do
+        parent = Class.new(ActiveRecord::Base) do
+          self.table_name = "ruact_props_probe_posts"
+          include Ruact::Serializable
+
+          ruact_props :id, :title
+        end
+        child = Class.new(parent)
+
+        # The subclass serializes first, memoizing the inherited (valid) list…
+        parent.create!(title: "Hello")
+        child.first.ruact_serialize
+
+        # …then the PARENT re-declares with a bogus prop. The subclass must not
+        # keep serving its stale memo: its next serialize re-validates loudly.
+        parent.ruact_props :id, :ttile
+        expect { child.first.ruact_serialize }
+          .to raise_error(ArgumentError, /ttile.*not defined/)
+      end
+
+      it "dispatches through serialize_serializable under strict true AND false (AC#4)" do
+        row = ar_model.create!(title: "Hello", secret: "top-secret")
+
+        [true, false].each do |strict|
+          output = Ruact::Flight::Renderer.render(
+            row, Ruact::ClientManifest.from_hash({}), strict_serialization: strict
+          )
+          expect(output).to include("Hello")
+          expect(output).not_to include("top-secret")
+        end
+      end
+    end
+
     describe "ruact_serialize (AC#1)" do
       it "returns only declared props" do
         obj = serializable_class.new

data/spec/ruact/server_bucket_request_spec.rb

@@ -138,6 +138,47 @@ module ServerBucketSpecSupport
       post.valid?
       ruact_errors(post)
     end
+
+    # Story 15.0 (F6) — the injection-BYPASS case the dev warning targets:
+    # registers errors, then renders explicitly on the same branch, so
+    # `default_render` never runs and the errors vanish from the JSON body.
+    def opt_out_render
+      post = ServerBucketSpecSupport::ValidatedPost.new(title: nil)
+      post.valid?
+      ruact_errors(post)
+      render json: { "ok" => false }
+    end
+
+    # Story 15.0 (F6 guardrail a) — the documented-correct Bucket-1 pattern:
+    # register errors, render the form page again (the template binds the
+    # `ruact_errors` reader). Requested WITHOUT the function-call Accept.
+    def failed_with_page_render
+      post = ServerBucketSpecSupport::ValidatedPost.new(title: nil)
+      post.valid?
+      ruact_errors(post)
+      render :new_form
+    end
+
+    # Story 15.0 (F6 guardrail b) — register errors, then redirect (the
+    # redirect-back round-trip). Correct on BOTH buckets, must never warn.
+    def failed_with_redirect
+      post = ServerBucketSpecSupport::ValidatedPost.new(title: nil)
+      post.valid?
+      ruact_errors(post)
+      redirect_to "/posts/new"
+    end
+
+    # Story 15.0 (F6 guardrail d) — explicit render with an UNTOUCHED collector.
+    def untouched_explicit_render
+      render json: { "ok" => true }
+    end
+
+    # Story 15.5 (FR109) — a plain Rails action on a `Ruact::Server` controller:
+    # a GET that renders plain text, so it is neither a function call nor a ruact
+    # page render. The dev shape-log must stay SILENT on it (non-negotiated).
+    def plain_rails
+      render plain: "just rails"
+    end
   end
 
   # Review round 2 — an auth-style before_action that redirects on a Bucket-2
@@ -211,6 +252,15 @@ ControllerRequestSpecSupport.write_view(
   ERB
 )
 
+# Story 15.0 (F6 guardrail a) — the re-rendered form page for the documented
+# Bucket-1 `ruact_errors(record); render :new_form` pattern. No component tags
+# on purpose (the guardrail is about the warn predicate, not the pipeline).
+ControllerRequestSpecSupport.write_view(
+  "server_bucket_spec_support/bucket_server", "new_form", <<~ERB
+    <div>the form again</div>
+  ERB
+)
+
 if defined?(ControllerRequestSpecSupport) &&
    !ControllerRequestSpecSupport.instance_variable_get(:@__ruact_server_bucket_routes_appended)
   ControllerRequestSpecSupport.instance_variable_set(:@__ruact_server_bucket_routes_appended, true)
@@ -227,6 +277,15 @@ if defined?(ControllerRequestSpecSupport) &&
     post "/bucket/validated_create_invalid", to: "server_bucket_spec_support/bucket_server#validated_create_invalid"
     post "/bucket/validated_create_valid",   to: "server_bucket_spec_support/bucket_server#validated_create_valid"
     post "/bucket/stray_errors_ivar", to: "server_bucket_spec_support/bucket_server#stray_errors_ivar"
+    # Story 15.0 (F6) — the warning truth-table routes.
+    post "/bucket/opt_out_render", to: "server_bucket_spec_support/bucket_server#opt_out_render"
+    post "/bucket/failed_with_page_render",
+         to: "server_bucket_spec_support/bucket_server#failed_with_page_render"
+    post "/bucket/failed_with_redirect", to: "server_bucket_spec_support/bucket_server#failed_with_redirect"
+    post "/bucket/untouched_explicit_render",
+         to: "server_bucket_spec_support/bucket_server#untouched_explicit_render"
+    # Story 15.5 (FR109) — a plain Rails GET on a Server controller (non-negotiated).
+    get  "/bucket/plain_rails", to: "server_bucket_spec_support/bucket_server#plain_rails"
     post "/bucket/dual_redirecting", to: "server_bucket_spec_support/bucket_dual#redirecting"
     post "/bucket/protected", to: "server_bucket_spec_support/bucket_forgery#create_protected"
     get  "/bucket/csrf_token", to: "server_bucket_spec_support/bucket_forgery#csrf_token"
@@ -472,6 +531,124 @@ RSpec.describe "Story 9.2: Ruact::Server dual-bucket response negotiation", :sto
     # NON-raised 200 path above; the two contracts stay distinct.
   end
 
+  # Story 15.0 (F6) — the dev-mode injection opt-out warning truth table.
+  # Fires ONLY on: development + function-call request + touched collector +
+  # explicit host render. Silent on every documented-correct pattern.
+  describe "Story 15.0: dev-mode ruact_errors injection opt-out warning (F6)", :story_15_0 do
+    # The distinctive fragment of the F6 message (deliberately distinct from
+    # any other `[ruact]` log line, incl. the future 15.5 bucket log).
+    let(:warning_re) { /\[ruact\] .*called `ruact_errors` and then rendered explicitly/ }
+    let(:html_form_headers) do
+      { "CONTENT_TYPE" => "application/x-www-form-urlencoded", "HTTP_ACCEPT" => "text/html" }
+    end
+
+    before do
+      allow(Rails.logger).to receive(:warn)
+    end
+
+    # NOTE: the suite's default Rails.env is "development" (RAILS_ENV unset),
+    # so the dev examples stub it EXPLICITLY anyway (they must not depend on
+    # the suite default) and the non-dev example stubs a non-dev env.
+    def stub_env(name)
+      allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new(name))
+    end
+
+    def stub_development_env
+      stub_env("development")
+    end
+
+    it "warns exactly once on an explicit render after ruact_errors on a function-call request" do
+      stub_development_env
+      post "/bucket/opt_out_render", "{}", json_headers
+
+      expect(Rails.logger).to have_received(:warn).with(
+        a_string_matching(/\[ruact\] .*BucketServerController#opt_out_render.*ruact_errors.*NOT.*injected/m)
+      ).once
+    end
+
+    it "names the fix in the message (fall through, page-render binding, or redirect)" do
+      stub_development_env
+      post "/bucket/opt_out_render", "{}", json_headers
+
+      expect(Rails.logger).to have_received(:warn).with(
+        a_string_matching(/fall.*through.*errors=\{ruact_errors\}.*redirect_to/m)
+      )
+    end
+
+    it "keeps the response byte-identical whether the warning fires or not (log-only)" do
+      stub_env("production")
+      post "/bucket/opt_out_render", "{}", json_headers
+      silent_status = last_response.status
+      silent_body   = last_response.body
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+
+      stub_development_env
+      post "/bucket/opt_out_render", "{}", json_headers
+
+      expect(Rails.logger).to have_received(:warn).with(a_string_matching(warning_re))
+      expect(last_response.status).to eq(silent_status)
+      expect(last_response.body).to eq(silent_body)
+      expect(JSON.parse(last_response.body)).to eq("ok" => false)
+    end
+
+    it "guardrail (a): silent on the documented Bucket-1 `ruact_errors(record); render :new` pattern" do
+      stub_development_env
+      post "/bucket/failed_with_page_render", "post[title]=", html_form_headers
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to include("the form again")
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "guardrail (b): silent on `ruact_errors(record); redirect_to` on a function-call request" do
+      stub_development_env
+      post "/bucket/failed_with_redirect", "{}", json_headers
+
+      expect(JSON.parse(last_response.body)).to eq("$redirect" => "/posts/new")
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "guardrail (b): silent on `ruact_errors(record); redirect_to` on a Bucket-1 request" do
+      stub_development_env
+      post "/bucket/failed_with_redirect", "post[title]=", html_form_headers
+
+      expect(last_response.status).to eq(302)
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "guardrail (c): silent on the fall-through itself (errors were injected)" do
+      stub_development_env
+      post "/bucket/validated_create_invalid", "{}", json_headers
+
+      expect(JSON.parse(last_response.body).fetch("errors")).to eq("title" => ["Title can't be blank"])
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "guardrail (d): silent on an explicit render when the collector was never touched" do
+      stub_development_env
+      post "/bucket/untouched_explicit_render", "{}", json_headers
+
+      expect(JSON.parse(last_response.body)).to eq("ok" => true)
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "never warns outside development (the bypass case in the test env stays silent)" do
+      stub_env("test")
+      post "/bucket/opt_out_render", "{}", json_headers
+
+      expect(last_response.status).to eq(200)
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+
+    it "never warns in production either" do
+      stub_env("production")
+      post "/bucket/opt_out_render", "{}", json_headers
+
+      expect(last_response.status).to eq(200)
+      expect(Rails.logger).not_to have_received(:warn).with(a_string_matching(warning_re))
+    end
+  end
+
   # Story 10.0 (AC5) — the Server-path inherits the default_render graceful
   # degradation fix. A GET is never a function call, so Server#default_render
   # delegates to super → the fixed Controller#default_render.
@@ -491,4 +668,118 @@ RSpec.describe "Story 9.2: Ruact::Server dual-bucket response negotiation", :sto
       expect(last_response.headers["Content-Type"]).to include("text/x-component")
     end
   end
+
+  # Story 15.5 (FR109) — the dev-mode response-shape legibility log. One
+  # `[ruact]` line per ruact-NEGOTIATED request naming the chosen bucket + the
+  # deciding signal. Log-only (byte-identical), dev-gated, SILENT on
+  # non-negotiated (plain Rails) responses. Mirrors the F6 warning test shape.
+  describe "Story 15.5: dev-mode response-shape log (FR109)", :story_15_5 do
+    # The distinctive fragment of the 15.5 log — deliberately distinct from the
+    # F6 warning line (which matches `called \`ruact_errors\` and then rendered`).
+    let(:shape_log_re) { /\[ruact\] .* — .* → / }
+    let(:flight_headers)   { { "HTTP_ACCEPT" => "text/x-component" } }
+    let(:html_get_headers) { { "HTTP_ACCEPT" => "*/*" } }
+
+    before do
+      # The suite default env is development (RAILS_ENV unset); dev examples
+      # still stub it explicitly so they never depend on the suite default.
+      allow(Rails.logger).to receive(:info)
+    end
+
+    def stub_env(name)
+      allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new(name))
+    end
+
+    def stub_development_env
+      stub_env("development")
+    end
+
+    it "logs the function-call JSON bucket once with the deciding signal (AC2)" do
+      stub_development_env
+      post "/bucket/with_ivars", "{}", json_headers
+
+      expect(Rails.logger).to have_received(:info).with(
+        "[ruact] ServerBucketSpecSupport::BucketServerController#with_ivars — " \
+        "Accept: application/json + POST → function-call JSON"
+      ).once
+    end
+
+    it "names the 204 (no ivars) sub-shape" do
+      stub_development_env
+      post "/bucket/empty", "{}", json_headers
+
+      expect(last_response.status).to eq(204)
+      expect(Rails.logger).to have_received(:info).with(
+        a_string_matching(%r{#empty_action — Accept: application/json \+ POST → function-call JSON \(204, no ivars\)})
+      ).once
+    end
+
+    it "names the $redirect sub-shape" do
+      stub_development_env
+      post "/bucket/redirecting", "{}", json_headers
+
+      expect(JSON.parse(last_response.body)).to eq("$redirect" => "/posts/1")
+      expect(Rails.logger).to have_received(:info).with(
+        a_string_matching(%r{#redirecting — Accept: application/json \+ POST → function-call \$redirect})
+      ).once
+    end
+
+    it "logs the Flight-page bucket on a text/x-component page render (AC2)" do
+      stub_development_env
+      get "/server-implicit/show", {}, flight_headers
+
+      expect(last_response.headers["Content-Type"]).to include("text/x-component")
+      expect(Rails.logger).to have_received(:info).with(
+        "[ruact] ServerBucketSpecSupport::ServerImplicitController#show — " \
+        "Accept: text/x-component → Flight page"
+      ).once
+    end
+
+    it "logs the HTML-shell bucket on an HTML-acceptable page GET (AC2)" do
+      stub_development_env
+      get "/server-implicit/show", {}, html_get_headers
+
+      expect(last_response.headers["Content-Type"]).to include("text/html")
+      expect(Rails.logger).to have_received(:info).with(
+        "[ruact] ServerBucketSpecSupport::ServerImplicitController#show — " \
+        "HTML-acceptable Accept, no Flight header → HTML shell"
+      ).once
+    end
+
+    it "is SILENT on a plain Rails action on the same controller (non-negotiated, AC2)" do
+      stub_development_env
+      get "/bucket/plain_rails"
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq("just rails")
+      expect(Rails.logger).not_to have_received(:info).with(a_string_matching(shape_log_re))
+    end
+
+    it "is SILENT outside development and byte-identical to the dev response (log-only, AC2)",
+       :aggregate_failures do
+      stub_env("production")
+      post "/bucket/with_ivars", "{}", json_headers
+      prod_status = last_response.status
+      prod_body   = last_response.body
+      prod_ctype  = last_response.headers["Content-Type"]
+      prod_vary   = last_response.headers["Vary"]
+      expect(Rails.logger).not_to have_received(:info).with(a_string_matching(shape_log_re))
+
+      stub_development_env
+      post "/bucket/with_ivars", "{}", json_headers
+      expect(Rails.logger).to have_received(:info).with(a_string_matching(shape_log_re))
+      expect(last_response.status).to eq(prod_status)
+      expect(last_response.body).to eq(prod_body)
+      expect(last_response.headers["Content-Type"]).to eq(prod_ctype)
+      expect(last_response.headers["Vary"]).to eq(prod_vary)
+    end
+
+    it "never logs in the test environment either" do
+      stub_env("test")
+      post "/bucket/with_ivars", "{}", json_headers
+
+      expect(last_response.status).to eq(200)
+      expect(Rails.logger).not_to have_received(:info).with(a_string_matching(shape_log_re))
+    end
+  end
 end