ruact 0.0.6 → 0.0.8

data/spec/ruact/server_functions/introspection_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "active_support/all"
+require "action_dispatch"
+require "ruact/server_functions"
+
+module Ruact
+  module ServerFunctions
+    # Plain query class — only `instance_method(...).parameters` (kwargs) and
+    # `.name` (collision origin) are read; no Rails boot needed. Defined at module
+    # level (mirrors query_source_spec) so it is not an example-group-leaky
+    # constant.
+    class CatalogIntrospectQ
+      def categories; end
+
+      def search_users(term:, limit: 10); end
+    end
+
+    # Story 15.3 (FR107) — `ruact:routes --json` introspection. Exercised through
+    # a REAL RouteSet carrying both a mutation action and mounted query routes,
+    # with the host/query resolvers injected (no controller boot), so the document
+    # is proven byte-derived from RouteSource + QuerySource (the same single
+    # source of truth codegen consumes) and side-effect-free.
+    RSpec.describe Introspection, :story_15_3 do
+      let(:query_prefix) { QuerySource::QUERY_CONTROLLER_PREFIX }
+
+      # A real RouteSet with a mutation action (createPost, updatePost) AND two
+      # mounted query GET routes under the query dispatch controller prefix.
+      def combined_route_set
+        prefix = query_prefix
+        rs = ActionDispatch::Routing::RouteSet.new
+        rs.draw do
+          resources :posts, only: %i[create update]
+          get "/q/categories", to: "#{prefix}catalog_introspect_q#categories"
+          get "/q/search_users", to: "#{prefix}catalog_introspect_q#search_users"
+        end
+        rs
+      end
+
+      def as_json(route_set)
+        described_class.as_json(
+          route_set: route_set,
+          host_predicate: ->(_controller) { true },
+          query_class_for: lambda { |controller|
+            controller.start_with?(query_prefix) ? CatalogIntrospectQ : nil
+          }
+        )
+      end
+
+      describe ".as_json" do
+        subject(:document) { as_json(combined_route_set) }
+
+        it "gates the document with the EXPERIMENTAL schema_version (0)", :aggregate_failures do
+          expect(document["schema_version"]).to eq(0)
+          expect(document["schema_version"]).to eq(described_class::SCHEMA_VERSION)
+        end
+
+        it "round-trips through JSON.parse" do
+          expect(JSON.parse(JSON.generate(document))).to eq(document)
+        end
+
+        it "reports BOTH action and query accessors sorted by name", :aggregate_failures do
+          names = document["accessors"].map { |a| a["accessor"] }
+          expect(names).to include("createPost", "updatePost", "categories", "searchUsers")
+          expect(names).to eq(names.sort)
+        end
+
+        it "shapes an action with its required path segments as declared params", :aggregate_failures do
+          update = document["accessors"].find { |a| a["accessor"] == "updatePost" }
+          expect(update["kind"]).to eq("action")
+          expect(update["verb"]).to eq("PATCH")
+          expect(update["path"]).to eq("/posts/:id")
+          expect(update["segments"]).to eq(["id"])
+          expect(update["params"]).to eq([{ "name" => "id", "required" => true }])
+        end
+
+        it "shapes a query with its declared kwargs as params (Story 13.4)", :aggregate_failures do
+          search = document["accessors"].find { |a| a["accessor"] == "searchUsers" }
+          expect(search["kind"]).to eq("query")
+          expect(search["verb"]).to eq("GET")
+          expect(search["path"]).to eq("/q/search_users")
+          expect(search["segments"]).to eq([])
+          expect(search["params"]).to eq(
+            [{ "name" => "term", "required" => true }, { "name" => "limit", "required" => false }]
+          )
+        end
+
+        it "carries exactly the AC2 keys per accessor" do
+          document["accessors"].each do |accessor|
+            expect(accessor.keys).to contain_exactly("accessor", "kind", "verb", "path", "segments", "params")
+          end
+        end
+
+        it "does NOT include a per-accessor component-contract link (D3 = report accessors faithfully)" do
+          document["accessors"].each do |accessor|
+            expect(accessor).not_to have_key("contract")
+            expect(accessor).not_to have_key("has_contract")
+            expect(accessor).not_to have_key("contract_exists")
+          end
+        end
+      end
+
+      describe "side-effect-free (AC2 / AC4d — writes NO bridge or TS)" do
+        it "never writes the codegen bridge / TS module", :aggregate_failures do
+          allow(SnapshotWriter).to receive(:write_if_changed!)
+          allow(Snapshot).to receive(:generate_v2!)
+          allow(Codegen).to receive(:generate_ts!)
+          allow(File).to receive(:write).and_call_original
+
+          as_json(combined_route_set)
+
+          expect(SnapshotWriter).not_to have_received(:write_if_changed!)
+          expect(Snapshot).not_to have_received(:generate_v2!)
+          expect(Codegen).not_to have_received(:generate_ts!)
+          expect(File).not_to have_received(:write)
+        end
+      end
+
+      describe "single source of truth (AC2)" do
+        it "is byte-derived from ServerFunctions.introspect (same collectors as codegen)" do
+          # Both introspection and write_v2_snapshot! flow through .introspect;
+          # the document's accessors mirror those entries' identifiers exactly.
+          entries = ServerFunctions.introspect(
+            route_set: combined_route_set,
+            host_predicate: ->(_c) { true },
+            query_class_for: ->(c) { c.start_with?(query_prefix) ? CatalogIntrospectQ : nil }
+          )
+          expect(as_json(combined_route_set)["accessors"].map { |a| a["accessor"] })
+            .to eq(entries.map { |e| e["js_identifier"] })
+        end
+      end
+    end
+  end
+end

data/spec/ruact/tasks_json_introspection_spec.rb

@@ -0,0 +1,141 @@
+# 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

data/spec/ruact/testing/have_ruact_component_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "ruact/testing"
+
+# Story 15.4 (FR108) — end-to-end specs for the PUBLIC render-assertion matcher
+# `have_ruact_component`. Every example asserts against a REAL Flight wire body
+# produced by `Ruact::RenderPipeline` (the same serializer the controller runs),
+# not a hand-authored fixture — so import rows, `$L<id>` references, and the
+# serialized props hash are exactly what a host would receive.
+module Ruact
+  RSpec.describe "have_ruact_component matcher", :story_15_4 do
+    let(:manifest) do
+      ClientManifest.from_hash({
+                                 "LikeButton" => {
+                                   "id" => "/assets/LikeButton-abc.js",
+                                   "name" => "LikeButton",
+                                   "chunks" => ["/assets/LikeButton-abc.js"]
+                                 },
+                                 "PostCard" => {
+                                   "id" => "/components/PostCard.jsx",
+                                   "name" => "PostCard",
+                                   "chunks" => ["/components/PostCard.jsx"]
+                                 }
+                               })
+    end
+
+    let(:pipeline) { RenderPipeline.new(manifest) }
+
+    # Renders an ERB snippet to a REAL Flight wire string.
+    def render_wire(erb_source, **ivars)
+      ctx = Object.new
+      ivars.each { |k, v| ctx.instance_variable_set("@#{k}", v) }
+      pipeline.render({ erb: erb_source, binding: ctx.instance_eval { binding } }, mode: :string)
+    end
+
+    # Wraps a wire in the REAL HTML shell the gem emits (`__FLIGHT_DATA` push),
+    # via the shipped `Ruact::ViewHelper#ruact_flight_data_script`.
+    def html_shell(wire)
+      emitter = Object.new.extend(Ruact::ViewHelper)
+      script = emitter.send(:ruact_flight_data_script, wire)
+      "<!DOCTYPE html><html><body><div id=\"root\"></div>#{script}</body></html>"
+    end
+
+    # A minimal duck-typed response object exposing `.body` (+ optional
+    # `.content_type`), like an ActionDispatch/Rack response.
+    def response_double(body, content_type: nil)
+      Struct.new(:body, :content_type).new(body, content_type)
+    end
+
+    describe "presence (raw text/x-component body)" do
+      it "passes when the named component was rendered" do
+        wire = render_wire("<LikeButton postId={42} />")
+        expect(wire).to have_ruact_component("LikeButton")
+      end
+
+      it "resolves the name by module basename too (D3)" do
+        wire = render_wire("<PostCard title={\"Hi\"} />")
+        # Manifest module path is /components/PostCard.jsx → basename PostCard.
+        expect(wire).to have_ruact_component("PostCard")
+      end
+
+      it "fails with a legible message naming what was found when absent" do
+        wire = render_wire("<LikeButton />")
+        expect do
+          expect(wire).to have_ruact_component("Missing")
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError,
+                           /component named "Missing".*found.*LikeButton/m)
+      end
+
+      it "supports negation for an absent component" do
+        wire = render_wire("<LikeButton />")
+        expect(wire).not_to have_ruact_component("Missing")
+      end
+
+      it "negation fails legibly when the component IS present" do
+        wire = render_wire("<LikeButton />")
+        expect do
+          expect(wire).not_to have_ruact_component("LikeButton")
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /NOT to have rendered.*"LikeButton"/m)
+      end
+    end
+
+    describe ".with_props (serialized wire form, D4)" do
+      it "passes when props satisfy a hash_including matcher" do
+        wire = render_wire("<LikeButton postId={42} />")
+        expect(wire).to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 42))
+      end
+
+      it "passes with a bare key-presence include matcher" do
+        wire = render_wire("<LikeButton postId={42} />")
+        expect(wire).to have_ruact_component("LikeButton").with_props(including("postId"))
+      end
+
+      it "fails with a legible message when props mismatch" do
+        wire = render_wire("<LikeButton postId={42} />")
+        expect do
+          expect(wire).to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 99))
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError,
+                           /props matching.*serialized wire form.*"postId".*42/m)
+      end
+
+      it "supports negation with props" do
+        wire = render_wire("<LikeButton postId={42} />")
+        expect(wire).not_to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 99))
+      end
+    end
+
+    describe "input shapes (D2)" do
+      it "accepts a response object exposing #body (raw wire)" do
+        wire = render_wire("<LikeButton postId={7} />")
+        response = response_double(wire, content_type: "text/x-component")
+        expect(response).to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 7))
+      end
+
+      it "extracts Flight from an HTML shell embedding __FLIGHT_DATA" do
+        wire = render_wire("<LikeButton postId={5} />")
+        html = html_shell(wire)
+        expect(html).to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 5))
+      end
+
+      it "ignores an unrelated earlier .push and anchors to __FLIGHT_DATA" do
+        wire = render_wire("<LikeButton postId={5} />")
+        shell = html_shell(wire)
+        # A realistic layout has other scripts BEFORE the ruact bootstrap.
+        noise = %(<script>window.dataLayer=window.dataLayer||[];dataLayer.push("not flight");</script>)
+        html = shell.sub("<div id=\"root\"></div>", "<div id=\"root\"></div>#{noise}")
+        expect(html).to have_ruact_component("LikeButton").with_props(a_hash_including("postId" => 5))
+      end
+
+      it "extracts Flight from an HTML-response object (content_type text/html)" do
+        wire = render_wire("<LikeButton postId={5} />")
+        response = response_double(html_shell(wire), content_type: "text/html; charset=utf-8")
+        expect(response).to have_ruact_component("LikeButton")
+      end
+
+      it "raises a clear error on a plain-JSON function-call body" do
+        json = response_double(%({"id":1,"title":"Hi"}), content_type: "application/json")
+        expect do
+          expect(json).to have_ruact_component("PostCard")
+        end.to raise_error(Ruact::Testing::NotAFlightResponseError, /plain-JSON response.*JSON\.parse/m)
+      end
+
+      it "raises a clear error on an empty (204) body" do
+        empty = response_double("", content_type: nil)
+        expect do
+          expect(empty).to have_ruact_component("PostCard")
+        end.to raise_error(Ruact::Testing::NotAFlightResponseError, /empty response body/m)
+      end
+
+      it "raises a clear error when handed an HTML doc with no Flight payload" do
+        html = "<!DOCTYPE html><html><body><h1>Nothing here</h1></body></html>"
+        expect do
+          expect(html).to have_ruact_component("PostCard")
+        end.to raise_error(Ruact::Testing::NotAFlightResponseError, /no `__FLIGHT_DATA` payload/m)
+      end
+    end
+
+    describe "escape round-trip through the HTML shell" do
+      it "recovers a payload containing quotes and interpolation-like sequences" do
+        # Props whose serialized form contains characters Ruby's #inspect
+        # escapes (`"`, `#{`, newlines) must survive extraction from the shell.
+        wire = render_wire("<LikeButton label={@label} />", label: %(a "quoted" \#{literal}\nvalue))
+        html = html_shell(wire)
+        expect(html).to have_ruact_component("LikeButton")
+          .with_props(a_hash_including("label" => a_string_matching(/quoted/)))
+      end
+    end
+  end
+end

data/spec/ruact/testing/no_production_load_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "English"
+require "shellwords"
+
+# Story 15.4 (FR108), AC4c + AC2 — the public test surface must not load in a
+# production boot, and the promoted parser/diff must be the SINGLE shipped
+# implementation the internal `Ruact::Spec` matchers share (wrap, not fork).
+module Ruact
+  RSpec.describe "Ruact::Testing load boundary", :story_15_4 do
+    it "a bare `require \"ruact\"` does NOT define the public test surface" do
+      # Shell out to a pristine Ruby process so nothing this suite already
+      # loaded (spec/support requires `ruact/testing/*`) pollutes the check.
+      lib = File.expand_path("../../../lib", __dir__)
+      script = <<~RUBY
+        $LOAD_PATH.unshift(#{lib.inspect})
+        require "ruact"
+        defined = Ruact.const_defined?(:Testing, false)
+        # `have_ruact_component` must not be registered on the RSpec matcher surface either.
+        rspec_loaded = $LOADED_FEATURES.any? { |f| f.include?("rspec/expectations") }
+        print [defined, rspec_loaded].inspect
+      RUBY
+
+      output = `#{RbConfig.ruby} -e #{Shellwords.escape(script)} 2>&1`
+      expect($CHILD_STATUS).to be_success, "subprocess failed: #{output}"
+      expect(output).to eq("[false, false]"),
+                        "expected `require \"ruact\"` to leave Ruact::Testing undefined and " \
+                        "RSpec unloaded, got: #{output}"
+    end
+
+    it "shares ONE implementation with the internal matchers (no fork)" do
+      require "ruact/testing"
+      require_relative "../../support/flight_wire_parser"
+      require_relative "../../support/matchers/flight_fixture_matcher"
+
+      expect(Ruact::Spec::FlightWireParser).to equal(Ruact::Testing::FlightWireParser)
+      expect(Ruact::Spec::FlightStructureDiff).to equal(Ruact::Testing::FlightStructureDiff)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -58,5 +58,20 @@ RSpec.configure do |config|
     # before every example so no leaked double survives — examples that need a
     # specific logger set their own in their own `before` (which runs after this).
     Rails.logger = Logger.new(IO::NULL) if defined?(Rails) && Rails.respond_to?(:logger=)
+
+    # Manifest-over-HTTP fix: the gem suite runs with `Rails.env == development`
+    # by default, where `Ruact::ManifestResolver` would otherwise fetch the live
+    # manifest from the Vite dev server (localhost:5173) on every ActionView
+    # render — making the suite hit the network and go flaky on a dev machine
+    # that happens to run a foreign Vite there. Pin the pre-fix behaviour (return
+    # the boot-loaded `Ruact.manifest`) so the whole suite is hermetic. The
+    # resolver's own spec re-stubs these `.and_call_original` to exercise the real
+    # HTTP/fallback paths with `Net::HTTP` mocked. (The programmatic
+    # `RenderPipeline#render({erb:})` path passes `registry: nil` and never
+    # touches the resolver, so the benchmark measures the real render cost.)
+    if defined?(Ruact::ManifestResolver)
+      allow(Ruact::ManifestResolver).to receive(:resolve) { Ruact.manifest }
+      allow(Ruact::ManifestResolver).to receive(:resolve_soft) { Ruact.manifest }
+    end
   end
 end

data/spec/support/flight_wire_parser.rb

@@ -1,135 +1,21 @@
 # frozen_string_literal: true
 
-require "strscan"
-require "json"
+# Story 15.4 (FR108) — the pure Flight wire parser was PROMOTED onto the gem's
+# `lib/` load path as `Ruact::Testing::FlightWireParser` so the new public
+# `have_ruact_component` matcher and the gem's own internal matchers share ONE
+# implementation (wrap, not fork). This file is now a thin shim: it loads the
+# promoted implementation and re-exports it under the historical test-only
+# `Ruact::Spec` namespace so the existing internal matcher wrappers and their
+# self-tests keep working unchanged.
+require "ruact/testing/flight_wire_parser"
 
 module Ruact
   # Test-support utilities. Code under `Ruact::Spec` is consumed only by the
   # gem's own RSpec suite; it is not part of the public API and may change
-  # shape across stories without a deprecation cycle.
+  # shape across stories without a deprecation cycle. The parser/diff it names
+  # are aliases for the shipped `Ruact::Testing::*` implementation.
   module Spec
-    # Raised when {FlightWireParser.parse} encounters input it cannot decode.
-    # The message names the byte offset of the unparseable row so the spec
-    # author can locate the problem in a printed wire string.
-    class FlightWireParseError < StandardError; end
-
-    # Parses a Flight wire byte string into an ordered array of row records.
-    #
-    # Used by the structural Flight RSpec matchers
-    # (`match_flight_structure` / `include_flight_row`) to assert on parsed
-    # semantics rather than literal bytes. Pure function — no I/O, no global
-    # state, no `Thread.current`.
-    #
-    # @example
-    #   wire = "1:I[\"/L.jsx\",\"L\",[\"/L.jsx\"]]\n0:[\"$\",\"$L1\",null,{}]\n"
-    #   Ruact::Spec::FlightWireParser.parse(wire)
-    #   # => [
-    #   #      { id: 1, class: :import, payload: ["/L.jsx", "L", ["/L.jsx"]], raw: "1:I...\n" },
-    #   #      { id: 0, class: :model,  payload: ["$", "$L1", nil, {}],       raw: "0:[\"$\"...\n" }
-    #   #    ]
-    class FlightWireParser
-      # Parse a complete Flight wire byte string.
-      #
-      # @param wire [String] the raw bytes emitted by `Ruact::Flight::Renderer`.
-      # @return [Array<Hash>] one hash per row, in wire order. See class docs
-      #   for the hash shape (`:id`, `:class`, `:payload`, `:raw`).
-      # @raise [Ruact::Spec::FlightWireParseError] when a row is malformed.
-      def self.parse(wire)
-        rows = []
-        scanner = StringScanner.new(wire)
-
-        until scanner.eos?
-          start_offset = scanner.pos
-          rows << parse_row(scanner, start_offset)
-        end
-
-        rows
-      end
-
-      def self.parse_row(scanner, start_offset)
-        # Hint rows have no ID: ":H<code><json>\n"
-        if scanner.peek(2) == ":H"
-          scanner.pos += 2
-          code = scanner.getch
-          raise_parse_error(start_offset, "missing hint code char") if code.nil?
-
-          json = read_to_newline(scanner, start_offset)
-          return {
-            id: nil,
-            class: :hint,
-            payload: [code, parse_json(json, start_offset)],
-            raw: scanner.string.byteslice(start_offset, scanner.pos - start_offset)
-          }
-        end
-
-        hex = scanner.scan(/\h+/) || raise_parse_error(start_offset, "expected hex id")
-        scanner.skip(":") || raise_parse_error(start_offset, "expected ':' after id")
-        id = hex.to_i(16)
-
-        case scanner.peek(1)
-        when "I" then parse_tagged(:import, scanner, id, start_offset)
-        when "T" then parse_text_row(scanner, id, start_offset)
-        when "E" then parse_tagged(:error, scanner, id, start_offset)
-        else          parse_model_row(scanner, id, start_offset)
-        end
-      end
-
-      def self.parse_tagged(klass, scanner, id, start_offset)
-        scanner.getch # consume the tag byte (I or E)
-        json = read_to_newline(scanner, start_offset)
-        {
-          id: id,
-          class: klass,
-          payload: parse_json(json, start_offset),
-          raw: scanner.string.byteslice(start_offset, scanner.pos - start_offset)
-        }
-      end
-
-      def self.parse_model_row(scanner, id, start_offset)
-        json = read_to_newline(scanner, start_offset)
-        {
-          id: id,
-          class: :model,
-          payload: parse_json(json, start_offset),
-          raw: scanner.string.byteslice(start_offset, scanner.pos - start_offset)
-        }
-      end
-
-      def self.parse_text_row(scanner, id, start_offset)
-        scanner.getch # consume "T"
-        len_hex = scanner.scan(/\h+/) || raise_parse_error(start_offset, "expected hex length after T")
-        scanner.skip(",") || raise_parse_error(start_offset, "expected ',' after T<len>")
-        len = len_hex.to_i(16)
-
-        text = scanner.peek(len)
-        raise_parse_error(start_offset, "T row truncated") if text.nil? || text.bytesize < len
-
-        scanner.pos += len
-        {
-          id: id,
-          class: :text,
-          payload: text,
-          raw: scanner.string.byteslice(start_offset, scanner.pos - start_offset)
-        }
-      end
-
-      def self.read_to_newline(scanner, start_offset)
-        line = scanner.scan_until(/\n/) || raise_parse_error(start_offset, "missing trailing newline")
-        line.chomp
-      end
-
-      def self.parse_json(str, offset)
-        JSON.parse(str)
-      rescue JSON::ParserError => e
-        raise_parse_error(offset, "invalid JSON: #{e.message}")
-      end
-
-      def self.raise_parse_error(offset, reason)
-        raise FlightWireParseError, "FlightWireParser: cannot parse row at offset #{offset}: #{reason}"
-      end
-
-      private_class_method :parse_row, :parse_tagged, :parse_model_row, :parse_text_row,
-                           :read_to_newline, :parse_json, :raise_parse_error
-    end
+    FlightWireParser = Ruact::Testing::FlightWireParser
+    FlightWireParseError = Ruact::Testing::FlightWireParseError
   end
 end