ruact 0.0.1 → 0.0.3

data/spec/ruact/doctor_spec.rb

@@ -198,6 +198,84 @@ RSpec.describe Ruact::Doctor do
     end
   end
 
+  # --- check_legacy_constant ---
+
+  describe "#check_legacy_constant (Story 5.1)" do
+    subject(:doctor) { described_class.new }
+
+    # Built via Array#join so this spec file passes the gem-CI
+    # `name-propagation` guard without an exclusion (Story 5.1 review F4).
+    let(:legacy_const) { %w[Rails Rsc].join }
+    let(:legacy_gem)   { %w[rails rsc].join("_") }
+
+    def make_initializer(content, filename: "ruact.rb")
+      dir = tmpdir.join("config", "initializers")
+      FileUtils.mkdir_p(dir)
+      File.write(dir.join(filename), content)
+    end
+
+    def make_app_file(content, path:)
+      dir = tmpdir.join("app", File.dirname(path))
+      FileUtils.mkdir_p(dir)
+      File.write(tmpdir.join("app", path), content)
+    end
+
+    context "when no legacy references exist" do
+      it "returns :pass" do
+        status, = doctor.send(:check_legacy_constant)
+        expect(status).to eq(:pass)
+      end
+    end
+
+    context "when an initializer references the legacy constant" do
+      before { make_initializer("#{legacy_const}.configure do |c|\n  c.foo = 1\nend\n") }
+
+      it "returns :fail" do
+        status, = doctor.send(:check_legacy_constant)
+        expect(status).to eq(:fail)
+      end
+
+      it "message names the file:line and instructs the rename" do
+        _, msg = doctor.send(:check_legacy_constant)
+        expect(msg).to include("ruact.rb:1")
+        expect(msg).to include("Replace `#{legacy_const}` with `Ruact`")
+      end
+
+      it "message includes the rename documentation link (AC5)" do
+        _, msg = doctor.send(:check_legacy_constant)
+        expect(msg).to include("https://github.com/luizcg/ruact/blob/main/CHANGELOG.md#renamed")
+      end
+    end
+
+    context "when an app file requires the legacy gem name" do
+      before { make_app_file("require \"#{legacy_gem}\"\n", path: "models/foo.rb") }
+
+      it "returns :fail" do
+        status, = doctor.send(:check_legacy_constant)
+        expect(status).to eq(:fail)
+      end
+    end
+
+    context "when only the modern Ruact constant is referenced" do
+      before { make_initializer("Ruact.configure { |c| c.foo = 1 }\n") }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_legacy_constant)
+        expect(status).to eq(:pass)
+      end
+    end
+
+    context "when a word coincidentally contains the legacy substring" do
+      # e.g. "TrailsRsce" should not trigger the regex (boundary check).
+      before { make_initializer("# documenting TrailsRsce_engine here\n") }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_legacy_constant)
+        expect(status).to eq(:pass)
+      end
+    end
+  end
+
   # --- run / .run ---
 
   describe ".run / #run (AC#1, #7)" do
@@ -231,4 +309,44 @@ RSpec.describe Ruact::Doctor do
       end
     end
   end
+
+  describe "Rake task definition (Story 5.12)", :story_5_12 do
+    # Loads gem/lib/tasks/ruact.rake into a fresh Rake::Application so the
+    # task table is isolated from any other spec that may have loaded tasks.
+    # Asserts the new namespace is discoverable AND the legacy namespace is
+    # gone — guards against a partial rename (e.g. file renamed but the
+    # namespace inside left as :rsc, or vice-versa).
+    around do |example|
+      require "rake"
+      prev = Rake.application
+      Rake.application = Rake::Application.new
+      Rake.application.add_loader("rake", Rake::DefaultLoader.new)
+      Rake.application.add_loader("rb",   Rake::DefaultLoader.new)
+      load File.expand_path("../../lib/tasks/ruact.rake", __dir__)
+      example.run
+    ensure
+      Rake.application = prev
+    end
+
+    let(:rake_app) { Rake.application }
+
+    it "defines Rake::Task['ruact:doctor']" do
+      expect(rake_app.lookup("ruact:doctor")).not_to be_nil
+    end
+
+    it "does NOT define the legacy Rake task under the pre-Story-5.12 namespace" do
+      # Build the legacy task name from fragments so this spec file stays
+      # grep-clean under the Story 5.12 CI guard (which rejects the literal
+      # `<legacy>:doctor` substring anywhere in tracked files).
+      legacy_task = %w[rsc doctor].join(":")
+      expect(rake_app.lookup(legacy_task)).to be_nil
+    end
+
+    it "the ruact:doctor task action invokes Ruact::Doctor.run" do
+      task = rake_app.lookup("ruact:doctor")
+      expect(task).not_to be_nil
+      # actions is a list of Procs; just assert at least one is attached
+      expect(task.actions).not_to be_empty
+    end
+  end
 end

data/spec/ruact/erb_preprocessor_hook_spec.rb

@@ -24,13 +24,13 @@ module Ruact
       it "applies ErbPreprocessor.transform to source before calling super" do
         source = "<LikeButton postId={1} />"
         result = handler.call(fake_template, source)
-        expect(result).to include("__rsc_component__")
+        expect(result).to include("__ruact_component__")
         expect(result).to include('"LikeButton"')
         expect(result).not_to include("<LikeButton")
       end
 
       it "passes source unchanged when no PascalCase tags present (fast-path)" do
-        source = "<div class=\"hello\"><p>No RSC here</p></div>"
+        source = "<div class=\"hello\"><p>No ruact here</p></div>"
         result = handler.call(fake_template, source)
         expect(result).to eq(source)
       end
@@ -45,7 +45,7 @@ module Ruact
       it "transforms Suspense tags correctly" do
         source = "<Suspense fallback=\"Loading\"><PostCard /></Suspense>"
         result = handler.call(fake_template, source)
-        expect(result).to include("__rsc_component__")
+        expect(result).to include("__ruact_component__")
       end
     end
   end

data/spec/ruact/erb_preprocessor_spec.rb

@@ -8,19 +8,19 @@ module Ruact
 
     describe "self-closing tags" do
       it "transforms a self-closing tag with no props" do
-        expect(transform.call("<Button />")).to eq(%(<%= __rsc_component__("Button", {}) %>))
+        expect(transform.call("<Button />")).to eq(%(<%= __ruact_component__("Button", {}) %>))
       end
 
       it "transforms a self-closing tag with props" do
         result = transform.call("<LikeButton postId={@post.id} initialCount={5} />")
-        expect(result).to eq(%(<%= __rsc_component__("LikeButton", { "postId" => @post.id, "initialCount" => 5 }) %>))
+        expect(result).to eq(%(<%= __ruact_component__("LikeButton", { "postId" => @post.id, "initialCount" => 5 }) %>))
       end
     end
 
     describe "opening tags" do
       it "transforms an opening tag with props" do
         result = transform.call("<Dialog open={true}>")
-        expect(result).to eq(%(<%= __rsc_component__("Dialog", { "open" => true }) %>))
+        expect(result).to eq(%(<%= __ruact_component__("Dialog", { "open" => true }) %>))
       end
     end
 
@@ -39,7 +39,7 @@ module Ruact
     describe "complex prop expressions" do
       it "handles nested braces in a prop value" do
         result = transform.call("<Select options={Category.all.map { |c| c.id }} />")
-        expect(result).to eq(%(<%= __rsc_component__("Select", { "options" => Category.all.map { |c| c.id } }) %>))
+        expect(result).to eq(%(<%= __ruact_component__("Select", { "options" => Category.all.map { |c| c.id } }) %>))
       end
     end
 
@@ -65,8 +65,8 @@ module Ruact
       it "transforms multiple components in the same string" do
         source = '<Button /> and <Badge label={"hello"} />'
         result = transform.call(source)
-        expect(result).to match(/__rsc_component__\("Button"/)
-        expect(result).to match(/__rsc_component__\("Badge"/)
+        expect(result).to match(/__ruact_component__\("Button"/)
+        expect(result).to match(/__ruact_component__\("Badge"/)
         expect(result).to match(/"hello"/)
       end
     end
@@ -82,7 +82,7 @@ module Ruact
         result = transform.call(source)
         expect(result).to match(/<div class="container">/)
         expect(result).to match(%r{<h1>Hello</h1>})
-        expect(result).to match(/__rsc_component__\("LikeButton"/)
+        expect(result).to match(/__ruact_component__\("LikeButton"/)
       end
     end
   end

data/spec/ruact/errors_spec.rb

@@ -39,5 +39,100 @@ module Ruact
         expect { raise PreprocessorError, "test" }.to raise_error(Error)
       end
     end
+
+    describe "Ruact::ConfigurationError" do
+      it "is a subclass of Ruact::Error" do
+        expect(ConfigurationError.ancestors).to include(Error)
+      end
+
+      it "can be raised and rescued as Ruact::Error" do
+        expect { raise ConfigurationError, "test" }.to raise_error(Error)
+      end
+    end
+
+    describe "Ruact::HtmlConverterError" do
+      it "is a subclass of Ruact::Error" do
+        expect(HtmlConverterError.ancestors).to include(Error)
+      end
+
+      it "can be raised and rescued as Ruact::Error" do
+        expect { raise HtmlConverterError, "test" }.to raise_error(Error)
+      end
+    end
+
+    describe "Ruact::CurrentUserNotConfiguredError", :story_8_3 do
+      it "is a subclass of Ruact::Error" do
+        expect(CurrentUserNotConfiguredError.ancestors).to include(Error)
+      end
+
+      it "carries a default message that names BOTH Devise and hand-rolled-session worked examples" do
+        message = CurrentUserNotConfiguredError.new.message
+        expect(message).to include("Ruact.current_user requires Ruact.config.current_user_resolver to be set")
+        expect(message).to include("Devise")
+        expect(message).to include("env['warden']")
+        expect(message).to include("hand-rolled session")
+        expect(message).to include("rack.session")
+      end
+
+      it "accepts a custom message" do
+        expect(CurrentUserNotConfiguredError.new("explicit").message).to eq("explicit")
+      end
+    end
+
+    describe "Ruact::UploadTooLargeError", :story_8_5 do
+      it "is a subclass of Ruact::Error (so Story 8.4 rescue_from StandardError catches it)" do
+        expect(UploadTooLargeError.ancestors).to include(Error)
+      end
+
+      it "carries received_bytes and limit_bytes attr_readers" do
+        error = UploadTooLargeError.new(received_bytes: 11_534_336, limit_bytes: 10_485_760)
+        expect(error.received_bytes).to eq(11_534_336)
+        expect(error.limit_bytes).to eq(10_485_760)
+      end
+
+      it "synthesises a default message that includes both numbers" do
+        error = UploadTooLargeError.new(received_bytes: 11_534_336, limit_bytes: 10_485_760)
+        expect(error.message).to include("received_bytes=11534336")
+        expect(error.message).to include("limit_bytes=10485760")
+      end
+
+      it "honours an explicit custom message" do
+        error = UploadTooLargeError.new(received_bytes: 1, limit_bytes: 2, message: "custom")
+        expect(error.message).to eq("custom")
+      end
+
+      it "can be rescued as Ruact::Error and StandardError" do
+        expect { raise UploadTooLargeError.new(received_bytes: 1, limit_bytes: 0) }
+          .to raise_error(Error)
+        expect { raise UploadTooLargeError.new(received_bytes: 1, limit_bytes: 0) }
+          .to raise_error(StandardError)
+      end
+    end
+
+    describe "Ruact::ActionError", :story_8_3 do
+      it "is a subclass of Ruact::Error" do
+        expect(ActionError.ancestors).to include(Error)
+      end
+
+      it "carries status + body so the dispatcher can render without `render` access" do
+        error = ActionError.new(status: 422, body: { error: "invalid" })
+        expect(error.status).to eq(422)
+        expect(error.body).to eq(error: "invalid")
+      end
+
+      it "accepts a Symbol status" do
+        error = ActionError.new(status: :unprocessable_entity, body: nil)
+        expect(error.status).to eq(:unprocessable_entity)
+        expect(error.body).to be_nil
+      end
+
+      it "synthesises a legible message when none is given" do
+        expect(ActionError.new(status: 401, body: nil).message).to include("status=401")
+      end
+
+      it "honours an explicit custom message" do
+        expect(ActionError.new(status: 500, body: {}, message: "explicit").message).to eq("explicit")
+      end
+    end
   end
 end

data/spec/ruact/flight/renderer_spec.rb

@@ -31,7 +31,7 @@ module Ruact
         it "root row always has id 0" do
           element = ReactElement.new(type: "p")
           output  = described_class.render(element, empty_manifest)
-          expect(output.lines.last).to start_with("0:")
+          expect(Ruact::Spec::FlightWireParser.parse(output).last).to include(id: 0, class: :model)
         end
       end
 
@@ -61,9 +61,19 @@ module Ruact
         let(:fallback)  { ReactElement.new(type: "span") }
         let(:inner)     { ReactElement.new(type: "div") }
 
+        # Configuration is frozen post-Story 7.3, so RSpec mocks cannot proxy it.
+        # Configure via Ruact.configure and reset around each example.
+        around do |example|
+          Ruact.instance_variable_set(:@config, nil)
+          Ruact.instance_variable_set(:@configured_at_least_once, false)
+          example.run
+          Ruact.instance_variable_set(:@config, nil)
+          Ruact.instance_variable_set(:@configured_at_least_once, false)
+        end
+
         context "when deferred delay exceeds suspense_timeout (streaming: true)" do
           before do
-            allow(Ruact.config).to receive(:suspense_timeout).and_return(1.0)
+            Ruact.configure { |c| c.suspense_timeout = 1.0 }
           end
 
           it "emits an E-type error row instead of the model row" do
@@ -76,6 +86,7 @@ module Ruact
             suspense = SuspenseElement.new(fallback: fallback, children: inner, delay: 5.0)
             rows = described_class.each(suspense, empty_manifest, streaming: true).to_a
             error_row = rows.find { |r| r.include?(":E") }
+            # Error message string is the contract — see Story 7.6 Decision E.
             expect(error_row).to include("Suspense timeout exceeded")
           end
 
@@ -90,7 +101,7 @@ module Ruact
 
         context "when deferred delay is within suspense_timeout (streaming: true)" do
           before do
-            allow(Ruact.config).to receive(:suspense_timeout).and_return(10.0)
+            Ruact.configure { |c| c.suspense_timeout = 10.0 }
           end
 
           it "emits a model row (not an error row) and no E row" do

data/spec/ruact/flight/serializer_spec.rb

@@ -16,87 +16,32 @@ module Ruact
 
       let(:bundler) { StubBundlerConfig.new }
 
-      # --- Primitives ---
-
-      describe "strings" do
-        it "serializes a plain string" do
-          expect(render.call("hello")).to eq("0:\"hello\"\n")
-        end
-
-        it "escapes strings starting with $" do
-          expect(render.call("$danger")).to eq("0:\"$$danger\"\n")
-        end
-      end
-
-      describe "numbers" do
-        it "serializes an integer" do
-          expect(render.call(42)).to eq("0:42\n")
-        end
-
-        it "serializes a bigint (> MAX_SAFE_INTEGER) as $n<decimal>" do
-          big = 9_007_199_254_740_992
-          expect(render.call(big)).to eq("0:\"$n#{big}\"\n")
-        end
-
-        it "serializes Float::NAN" do
-          expect(render.call(Float::NAN)).to eq("0:\"$NaN\"\n")
-        end
-
-        it "serializes Float::INFINITY" do
-          expect(render.call(Float::INFINITY)).to eq("0:\"$Infinity\"\n")
-        end
-
-        it "serializes -Float::INFINITY" do
-          expect(render.call(-Float::INFINITY)).to eq("0:\"$-Infinity\"\n")
-        end
-      end
-
-      describe "nil/boolean" do
-        it "serializes nil as null" do
-          expect(render.call(nil)).to eq("0:null\n")
-        end
-
-        it "serializes true" do
-          expect(render.call(true)).to eq("0:true\n")
-        end
-
-        it "serializes false" do
-          expect(render.call(false)).to eq("0:false\n")
-        end
-      end
-
-      describe "special symbols" do
-        it "serializes :undefined as $undefined" do
-          expect(render.call(:undefined)).to eq("0:\"$undefined\"\n")
-        end
-      end
-
-      # --- Collections ---
-
-      describe "hash" do
-        it "serializes a hash with symbol keys" do
-          out = render.call({ greeting: "hello", count: 42 })
-          expect(out).to eq("0:{\"greeting\":\"hello\",\"count\":42}\n")
-        end
-      end
-
-      describe "array" do
-        it "serializes a plain array" do
-          expect(render.call([1, 2, 3])).to eq("0:[1,2,3]\n")
-        end
-      end
-
       # --- React Element (DOM) ---
+      #
+      # Primitive scalar/collection inputs (nil, booleans, integer, float, string,
+      # `$`-escaped string, hash, array) are guarded by the fixture-mode block at
+      # the bottom of this file. The cases below assert on the *parsed shape* of
+      # ReactElement payloads — fixture mode is overkill for them since the
+      # invariant under test is "the parsed tuple is `["$", <type>, <key>, <props>]`",
+      # not the literal byte sequence.
 
       describe "ReactElement" do
         it "serializes a DOM element" do
           el = ReactElement.new(type: "div", props: { className: "box", children: "hi" })
-          expect(render.call(el)).to eq("0:[\"$\",\"div\",null,{\"className\":\"box\",\"children\":\"hi\"}]\n")
+          expected = [
+            { id: 0, class: :model,
+              payload: ["$", "div", nil, { "className" => "box", "children" => "hi" }] }
+          ]
+          expect(render.call(el)).to match_flight_structure(expected)
         end
 
         it "serializes a DOM element with a key" do
           el = ReactElement.new(type: "li", key: "item-1", props: { children: "one" })
-          expect(render.call(el)).to eq("0:[\"$\",\"li\",\"item-1\",{\"children\":\"one\"}]\n")
+          expected = [
+            { id: 0, class: :model,
+              payload: ["$", "li", "item-1", { "children" => "one" }] }
+          ]
+          expect(render.call(el)).to match_flight_structure(expected)
         end
       end
 
@@ -106,11 +51,18 @@ module Ruact
         it "emits an I row for the import and references $L1 in root" do
           ref = ClientReference.new(module_id: "./LikeButton", export_name: "LikeButton")
           el  = ReactElement.new(type: ref, props: { postId: 1, initialCount: 5 })
-          out = render.call(el)
 
-          expect(out).to match(%r{1:I\["\./LikeButton","LikeButton"\]})
-          expect(out).to match(/0:\["\$","\$L1"/)
-          expect(out.index("1:I")).to be < out.index("0:["), "import row must precede model row"
+          # Story 7.6 Decision B: collapse the original sibling regex pair plus
+          # the `out.index("1:I") < out.index("0:[")` ordering check into a
+          # single structural assertion. Non-import rows compare positionally,
+          # so the import row in expected position 0 + the model row in
+          # expected position 1 encode the ordering invariant.
+          expected = [
+            { id: 1, class: :import, payload: ["./LikeButton", "LikeButton"] },
+            { id: 0, class: :model,
+              payload: ["$", "$L1", nil, { "postId" => 1, "initialCount" => 5 }] }
+          ]
+          expect(render.call(el)).to match_flight_structure(expected)
         end
 
         it "deduplicates: same ClientReference object emits only one I row" do
@@ -127,10 +79,23 @@ module Ruact
       # --- Error handling ---
 
       describe "unsupported type (AC#2)" do
+        # Build a class with no `as_json` method. ActiveSupport adds Object#as_json
+        # when Rails is loaded (Story 7.9), so Object.new no longer triggers the
+        # "no as_json" branch; this class explicitly undefines it.
+        let(:no_as_json_class) do
+          Class.new do
+            undef_method :as_json if method_defined?(:as_json) || private_method_defined?(:as_json)
+
+            def self.name
+              "UnsupportedType"
+            end
+          end
+        end
+
         it "raises SerializationError with class name and Serializable hint" do
-          expect { render.call(Object.new) }
-            .to raise_error(Ruact::SerializationError, /Object/)
-          expect { render.call(Object.new) }
+          expect { render.call(no_as_json_class.new) }
+            .to raise_error(Ruact::SerializationError, /UnsupportedType/)
+          expect { render.call(no_as_json_class.new) }
             .to raise_error(Ruact::SerializationError, /include Ruact::Serializable/)
         end
       end
@@ -150,7 +115,18 @@ module Ruact
           end.new
         end
 
-        let(:model_without_as_json) { Object.new }
+        let(:model_without_as_json) do
+          # ActiveSupport adds Object#as_json when Rails is loaded (Story 7.9), so
+          # Object.new no longer represents "no as_json defined". Use a class that
+          # explicitly undefines it instead.
+          Class.new do
+            undef_method :as_json if method_defined?(:as_json) || private_method_defined?(:as_json)
+
+            def self.name
+              "ModelWithoutAsJson"
+            end
+          end.new
+        end
 
         context "with strict_serialization: false (default)" do
           let(:render_loose) do
@@ -159,8 +135,10 @@ module Ruact
           end
 
           it "serializes via as_json, returning a hash (AC#3)" do
-            expect(render_loose.call(model_with_as_json)).to include('"id":1')
-            expect(render_loose.call(model_with_as_json)).to include('"name":"Alice"')
+            expect(render_loose.call(model_with_as_json)).to include_flight_row(
+              class: :model,
+              payload: hash_including("id" => 1, "name" => "Alice")
+            )
           end
 
           it "calls on_as_json_warning with class name and attribute list (AC#1, #3)" do
@@ -208,7 +186,7 @@ module Ruact
           it "serializes the array without crashing" do
             b = StubBundlerConfig.new
             output = Renderer.render(model_returning_array, b, strict_serialization: false)
-            expect(output).to include("[1,2,3]")
+            expect(output).to include_flight_row(class: :model, payload: [1, 2, 3])
           end
         end
 
@@ -232,6 +210,40 @@ module Ruact
           end
         end
 
+        # --- Story 7.7 regression suite — as_json returning self message shape ---
+        #
+        # The "with as_json returning self" context at :169 above asserts the error
+        # class plus the substring "infinite recursion". That gate passes if the
+        # message drifts to e.g. "infinite recursion detected" with no class name
+        # and no actionable hint — the user reading a Sentry issue would not learn
+        # which model misbehaved or how to fix it. The block below gates the full
+        # message shape from gem/lib/ruact/flight/serializer.rb#serialize_as_json:
+        # the offending class name + "Ruact::Serializable" + "ruact_props" must all
+        # appear so the message remains debuggable in production.
+        describe "edge cases (Story 7.7) — as_json returning self message shape", :story_7_7 do
+          let(:self_returning_model) do
+            Class.new do
+              def as_json
+                self
+              end
+
+              def self.name
+                "SelfModel"
+              end
+            end.new
+          end
+
+          it "names the offending class and points the user at Ruact::Serializable + ruact_props" do
+            b = StubBundlerConfig.new
+            expect { Renderer.render(self_returning_model, b, strict_serialization: false) }
+              .to raise_error(Ruact::SerializationError) do |error|
+                expect(error.message).to include("SelfModel")
+                expect(error.message).to include("Ruact::Serializable")
+                expect(error.message).to include("ruact_props")
+              end
+          end
+        end
+
         context "with as_json raising an exception" do
           let(:model_raising_error) do
             Class.new do
@@ -281,18 +293,21 @@ module Ruact
               "FakeSerializable"
             end
 
-            rsc_props :id, :title
+            ruact_props :id, :title
           end.new
         end
 
-        it "serializes via rsc_serialize — only declared props (AC#1)" do
-          expect(render.call(serializable_obj)).to include('"id":1', '"title":"Hello"')
+        it "serializes via ruact_serialize — only declared props (AC#1)" do
+          expect(render.call(serializable_obj)).to include_flight_row(
+            class: :model,
+            payload: hash_including("id" => 1, "title" => "Hello")
+          )
         end
 
         it "works with strict_serialization: true — Serializable bypasses strict gate (AC#1)" do
           b = StubBundlerConfig.new
           output = Renderer.render(serializable_obj, b, strict_serialization: true)
-          expect(output).to include('"id":1')
+          expect(output).to include_flight_row(class: :model, payload: hash_including("id" => 1))
         end
 
         it "does NOT call on_as_json_warning (AC#3)" do
@@ -306,6 +321,12 @@ module Ruact
       end
 
       # --- Fixture Contracts (AC#9) ---
+      #
+      # Fixture mode is the canonical guard for the Flight wire-format invariants
+      # of every primitive type: byte-exact escape rules, scalar canonical bytes,
+      # ordering. Story 7.6 deleted the duplicate literal-`eq` blocks that lived
+      # at the top of this file; these fixture-mode blocks are now the single
+      # source of truth for those invariants.
 
       describe "fixture contracts (AC#9)" do
         let(:fixture_render) { ->(model) { Renderer.render(model, ClientManifest.from_hash({})) } }
@@ -338,6 +359,26 @@ module Ruact
           expect(fixture_render.call(3.14)).to match_flight_fixture("number_float")
         end
 
+        it "bigint (> MAX_SAFE_INTEGER) serializes to fixture as $n<decimal>" do
+          expect(fixture_render.call(9_007_199_254_740_992)).to match_flight_fixture("bigint")
+        end
+
+        it "Float::NAN serializes to fixture as $NaN" do
+          expect(fixture_render.call(Float::NAN)).to match_flight_fixture("nan")
+        end
+
+        it "Float::INFINITY serializes to fixture as $Infinity" do
+          expect(fixture_render.call(Float::INFINITY)).to match_flight_fixture("infinity")
+        end
+
+        it "-Float::INFINITY serializes to fixture as $-Infinity" do
+          expect(fixture_render.call(-Float::INFINITY)).to match_flight_fixture("negative_infinity")
+        end
+
+        it ":undefined serializes to fixture as $undefined" do
+          expect(fixture_render.call(:undefined)).to match_flight_fixture("undefined")
+        end
+
         it "mixed array serializes to fixture" do
           expect(fixture_render.call([1, "a", true, nil])).to match_flight_fixture("array")
         end
@@ -420,7 +461,7 @@ module Ruact
               "Post"
             end
 
-            rsc_props :id, :title
+            ruact_props :id, :title
           end.new
         end