funicular 0.4.0 → 0.5.0

data/minitest/picoruby_helper_test.rb

@@ -63,6 +63,242 @@ class PicorubyHelperTest < Minitest::Test
     assert_includes html, "defer"
   end
 
+  # --- page metadata (docs decisions 12/13) -----------------------------
+
+  def test_disabled_include_tag_omits_all_local_database_metadata
+    html = @view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    refute_includes html, "data-funicular-local-database"
+    refute_includes html, "data-funicular-application-id"
+    refute_includes html, "data-funicular-user-key"
+    refute_includes html, "data-funicular-anonymous-only"
+    refute_includes html, "data-funicular-epoch"
+  end
+
+  def test_disabled_include_tag_does_not_call_the_identity_resolver_or_session
+    @config.user_key = ->(_controller) { flunk "resolver was called" }
+    session = DisabledSession.new
+    view = metadata_view(user_key: "u1", session: session)
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    refute_includes html, "data-funicular-local-database"
+  end
+
+  def test_include_tag_embeds_anonymous_only
+    @config.local_database = true
+    @config.anonymous_only = true
+    html = @view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    assert_includes html, 'data-funicular-local-database="true"'
+    assert_includes html, 'data-funicular-application-id="funicular"'
+    assert_includes html, 'data-funicular-anonymous-only="true"'
+  end
+
+  def test_enabled_include_tag_requires_an_identity_declaration
+    @config.local_database = true
+    error = assert_raises(ArgumentError) do
+      @view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    end
+    assert_includes error.message, "user_key"
+  end
+
+  # A harness with the controller/request surface a real view has. The
+  # helper reads the session through request.session (the view's own
+  # session helper delegates to the controller, where an action named
+  # "session" shadows it).
+  class MetadataHarness < Harness
+    attr_accessor :controller, :request
+  end
+
+  FakeController = Struct.new(:current_user_key)
+  FakeViewRequest = Struct.new(:session)
+
+  def metadata_view(user_key: nil, session: {})
+    view = MetadataHarness.new
+    view.controller = FakeController.new(user_key)
+    view.request = FakeViewRequest.new(session)
+    view
+  end
+
+  # A view rendered by a controller that routes an action named
+  # "session": the view's session delegate would invoke that action.
+  # The helper must go through request.session and never notice.
+  class SessionShadowedHarness < MetadataHarness
+    def session
+      raise "the session delegate was invoked instead of request.session"
+    end
+  end
+
+  def test_the_helper_never_calls_the_view_session_delegate
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    view = SessionShadowedHarness.new
+    view.controller = FakeController.new("u1")
+    view.request = FakeViewRequest.new({})
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    assert_includes html, "data-funicular-epoch"
+  end
+
+  def test_include_tag_embeds_user_key_and_epoch
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    session = {}
+    view = metadata_view(user_key: "u1", session: session)
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    assert_includes html, 'data-funicular-user-key="u1"'
+    assert_includes html, 'data-funicular-user-key-configured="true"'
+    # The epoch on the page is THE session entry the response header
+    # stamps: page and responses cannot disagree at render time.
+    epoch = session["funicular_epochs"]["funicular"]["epoch"]
+    assert_includes html, %(data-funicular-epoch="#{epoch}")
+  end
+
+  # What request.session looks like in a session-less Rails API app.
+  class DisabledSession
+    def enabled?
+      false
+    end
+
+    def [](_key)
+      raise "sessions are disabled in this application"
+    end
+
+    def []=(_key, _value)
+      raise "sessions are disabled in this application"
+    end
+  end
+
+  def test_a_disabled_session_skips_the_epoch_without_breaking
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    view = metadata_view(user_key: "u1", session: DisabledSession.new)
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    refute_includes html, "data-funicular-epoch"
+    assert_includes html, 'data-funicular-user-key="u1"'
+  end
+
+  def test_the_resolver_feeds_attribute_and_epoch_from_one_evaluation
+    # A racy resolver (current_user changing between two calls) must
+    # not embed user A's namespace while stamping user B's identity
+    # into the epoch entry: the helper evaluates it exactly once.
+    @config.local_database = true
+    calls = 0
+    @config.user_key = lambda do |_controller|
+      calls += 1
+      "u#{calls}"
+    end
+    session = {}
+    view = metadata_view(user_key: "ignored", session: session)
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    assert_equal 1, calls
+    assert_includes html, 'data-funicular-user-key="u1"'
+    assert_equal '["v1","funicular","user","u1"]',
+                 session["funicular_epochs"]["funicular"]["identity"]
+  end
+
+  def test_signed_out_omits_the_user_key_attribute
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    view = metadata_view(user_key: nil)
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    refute_includes html, "data-funicular-user-key="
+    assert_includes html, 'data-funicular-user-key-configured="true"'
+  end
+
+  def test_metadata_values_are_html_escaped
+    @config.local_database = true
+    @config.application_id = %q{"><script>alert(1)</script>}
+    @config.user_key = ->(controller) { controller.current_user_key }
+    view = metadata_view(user_key: %q{"><img src=x>})
+    html = view.picoruby_include_tag(source: :local_dist, base_styles: false)
+    refute_includes html, "<script>alert(1)</script>"
+    refute_includes html, "<img src=x>"
+    assert_includes html, "&quot;&gt;"
+  end
+
+  def test_caller_data_attributes_survive_alongside_the_metadata
+    @config.local_database = true
+    @config.anonymous_only = true
+    html = @view.picoruby_include_tag(source: :local_dist, base_styles: false,
+                                      data: { turbo_track: "reload" })
+    assert_includes html, 'data-turbo-track="reload"'
+    assert_includes html, 'data-funicular-application-id="funicular"'
+  end
+
+  def test_caller_data_cannot_override_the_framework_metadata
+    # A data: override of the epoch or the user key would make the
+    # page disagree with its own responses (instant terminal) or boot
+    # the wrong namespace: the framework's values win, in every key
+    # spelling that would render as the same HTML attribute.
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    session = {}
+    view = metadata_view(user_key: "u1", session: session)
+    html = view.picoruby_include_tag(
+      source: :local_dist, base_styles: false,
+      data: { funicular_epoch: "evil-symbol",
+              "funicular_user_key" => "evil-string",
+              "funicular-application-id" => "evil-dashed",
+              turbo_track: "reload" })
+    refute_includes html, "evil-symbol"
+    refute_includes html, "evil-string"
+    refute_includes html, "evil-dashed"
+    assert_includes html, 'data-funicular-user-key="u1"'
+    assert_includes html, 'data-funicular-application-id="funicular"'
+    epoch = session["funicular_epochs"]["funicular"]["epoch"]
+    assert_includes html, %(data-funicular-epoch="#{epoch}")
+    # The caller's unrelated attribute still rides along, and no
+    # attribute is emitted twice.
+    assert_includes html, 'data-turbo-track="reload"'
+    assert_equal 1, html.scan("data-funicular-epoch=").size
+    assert_equal 1, html.scan("data-funicular-user-key=").size
+    assert_equal 1, html.scan("data-funicular-application-id=").size
+  end
+
+  def test_caller_data_cannot_enable_the_disabled_local_database
+    html = @view.picoruby_include_tag(
+      source: :local_dist, base_styles: false,
+      data: { funicular_local_database: "true",
+              "funicular-application-id" => "injected",
+              funicular_anonymous_only: "true" })
+    refute_includes html, "data-funicular-local-database"
+    refute_includes html, "data-funicular-application-id"
+    refute_includes html, "data-funicular-anonymous-only"
+  end
+
+  def test_top_level_options_cannot_override_the_framework_metadata
+    # The contract values can bypass the data: hash entirely and arrive
+    # as top-level options, in any spelling the tag builder accepts.
+    @config.local_database = true
+    @config.user_key = ->(controller) { controller.current_user_key }
+    session = {}
+    view = metadata_view(user_key: "u1", session: session)
+    html = view.picoruby_include_tag(
+      source: :local_dist, base_styles: false,
+      **{ "data-funicular-epoch" => "evil-dashed",
+          :"data-funicular-user-key" => "evil-symbol",
+          data_funicular_application_id: "evil-underscored",
+          "data-turbo-track" => "reload" })
+    refute_includes html, "evil-dashed"
+    refute_includes html, "evil-symbol"
+    refute_includes html, "evil-underscored"
+    assert_includes html, 'data-funicular-user-key="u1"'
+    assert_includes html, 'data-funicular-application-id="funicular"'
+    epoch = session["funicular_epochs"]["funicular"]["epoch"]
+    assert_includes html, %(data-funicular-epoch="#{epoch}")
+    # Unrelated top-level data attributes are the caller's business.
+    assert_includes html, 'data-turbo-track="reload"'
+    assert_equal 1, html.scan("data-funicular-epoch=").size
+    assert_equal 1, html.scan("data-funicular-user-key=").size
+    assert_equal 1, html.scan("data-funicular-application-id=").size
+  end
+
+  def test_top_level_options_cannot_enable_the_disabled_local_database
+    html = @view.picoruby_include_tag(
+      source: :local_dist, base_styles: false,
+      **{ "data-funicular-local-database" => "true",
+          data_funicular_application_id: "injected" })
+    refute_includes html, "data-funicular-local-database"
+    refute_includes html, "injected"
+  end
+
   def test_cdn_source_uses_versioned_jsdelivr_url
     @config.cdn_version = "1.2.3"
     html = @view.picoruby_include_tag(source: :cdn, base_styles: false)

data/minitest/schema_test.rb

@@ -88,6 +88,26 @@ class SchemaDerivationTest < Minitest::Test
     assert_equal({ "update" => { method: "PATCH", path: "/x/:id" } }, schema[:endpoints])
   end
 
+  def test_build_skips_validators_for_readonly_attributes
+    schema = Funicular::Schema.build(
+      Account,
+      attributes: {
+        # name has a presence validator, but a readonly (server-managed)
+        # attribute is never submitted by the client, so its validators
+        # must not be inlined at all.
+        "name" => { type: "string", readonly: true }
+      }
+    )
+    assert_equal({ type: "string", readonly: true }, schema[:attributes]["name"])
+
+    # String keys behave the same.
+    schema = Funicular::Schema.build(
+      Account,
+      attributes: { "name" => { "type" => "string", "readonly" => true } }
+    )
+    refute schema[:attributes]["name"].key?(:validations)
+  end
+
   def test_length_range_is_serialized_as_min_and_max
     klass = Class.new do
       include ActiveModel::Validations
@@ -99,6 +119,33 @@ class SchemaDerivationTest < Minitest::Test
     assert_equal({ "minimum" => 2, "maximum" => 10 }, result["bio"]["length"])
   end
 
+  def test_bare_numericality_keeps_allow_nil
+    # numericality with no constraints serializes to a bare true; the
+    # allow_nil flag must upgrade it to a Hash instead of being dropped.
+    klass = Class.new do
+      include ActiveModel::Validations
+      def self.name = "Aged"
+      attr_accessor :age
+      validates :age, numericality: true, allow_nil: true
+    end
+    result = Funicular::Schema.validations_for(klass, ["age"])
+    assert_equal({ "allow_nil" => true }, result["age"]["numericality"])
+  end
+
+  def test_format_unescapes_ruby_hash_escape
+    # Ruby regexp literals escape "#" to suppress interpolation and the escape
+    # survives in Regexp#source; JS RegExp under the u flag rejects "\#" as an
+    # invalid identity escape (URI::MailTo::EMAIL_REGEXP is the wild example).
+    klass = Class.new do
+      include ActiveModel::Validations
+      def self.name = "Mailish"
+      attr_accessor :email
+      validates :email, format: { with: /\A[a-z.!\#$%&]+\z/ }
+    end
+    result = Funicular::Schema.validations_for(klass, ["email"])
+    assert_equal "^[a-z.!#$%&]+$", result["email"]["format"]["with"]
+  end
+
   def test_format_multiline_flag_is_translated
     klass = Class.new do
       include ActiveModel::Validations

data/minitest/session_epoch_test.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Exercises Funicular::SessionEpoch, the server half of the session
+# epoch (docs decision 13): identity encoding, rotation on every
+# authentication transition, stability while the identity holds, and
+# per-application_id isolation inside one shared Rails session.
+class SessionEpochTest < Minitest::Test
+  FakeController = Struct.new(:current_user_key)
+
+  def setup
+    @config = Funicular::Configuration.new
+    Funicular.instance_variable_set(:@configuration, @config)
+    @session = {}
+  end
+
+  def teardown
+    Funicular.instance_variable_set(:@configuration, nil)
+  end
+
+  def controller_for(key)
+    FakeController.new(key)
+  end
+
+  def configure_user_key
+    @config.user_key = ->(controller) { controller&.current_user_key }
+  end
+
+  def stamp(key)
+    Funicular::SessionEpoch.stamp!(@session, controller_for(key))
+  end
+
+  # --- identity ---------------------------------------------------------
+
+  def test_identity_is_the_typed_versioned_tuple
+    configure_user_key
+    assert_equal '["v1","funicular","anonymous"]',
+                 Funicular::SessionEpoch.identity(controller_for(nil))
+    assert_equal '["v1","funicular","user","u1"]',
+                 Funicular::SessionEpoch.identity(controller_for("u1"))
+  end
+
+  def test_user_key_is_canonicalized_with_to_s
+    configure_user_key
+    assert_equal '["v1","funicular","user","42"]',
+                 Funicular::SessionEpoch.identity(controller_for(42))
+  end
+
+  def test_a_user_key_of_anonymous_cannot_collide_with_signed_out
+    configure_user_key
+    refute_equal Funicular::SessionEpoch.identity(controller_for(nil)),
+                 Funicular::SessionEpoch.identity(controller_for("anonymous"))
+  end
+
+  def test_without_a_user_key_lambda_everyone_is_anonymous
+    assert_equal '["v1","funicular","anonymous"]',
+                 Funicular::SessionEpoch.identity(controller_for("u1"))
+  end
+
+  def test_empty_resolved_user_key_fails_loud
+    configure_user_key
+    error = assert_raises(Funicular::Error) { stamp("") }
+    assert_includes error.message, "empty"
+  end
+
+  # --- rotation ---------------------------------------------------------
+
+  def test_stamp_creates_and_then_holds_an_epoch
+    configure_user_key
+    epoch = stamp("u1")
+    refute_empty epoch
+    assert_equal epoch, stamp("u1")
+    assert_equal epoch, stamp("u1")
+  end
+
+  def test_login_logout_and_switch_all_rotate
+    configure_user_key
+    anonymous = stamp(nil)
+    login = stamp("u1")
+    refute_equal anonymous, login
+    switch = stamp("u2")
+    refute_equal login, switch
+    logout = stamp(nil)
+    refute_equal switch, logout
+    # A fresh anonymous epoch, not the first one resurrected.
+    refute_equal anonymous, logout
+  end
+
+  # --- per-application isolation ----------------------------------------
+
+  def test_epochs_are_tracked_per_application_id
+    configure_user_key
+    epoch_a = stamp("u1")
+    @config.application_id = "second_app"
+    epoch_b = stamp("u1")
+    refute_equal epoch_a, epoch_b
+    # Rotating the second app's epoch leaves the first app's alone.
+    stamp("u2")
+    @config.application_id = "funicular"
+    assert_equal epoch_a, stamp("u1")
+  end
+
+  # --- session shape ------------------------------------------------------
+
+  def test_session_entry_uses_string_keys_for_json_round_trips
+    configure_user_key
+    epoch = stamp("u1")
+    entry = @session["funicular_epochs"]["funicular"]
+    assert_equal '["v1","funicular","user","u1"]', entry["identity"]
+    assert_equal epoch, entry["epoch"]
+  end
+
+  def test_a_corrupt_session_value_is_replaced_not_crashed_on
+    configure_user_key
+    @session["funicular_epochs"] = "garbage"
+    epoch = stamp("u1")
+    refute_empty epoch
+    assert_equal epoch,
+                 @session["funicular_epochs"]["funicular"]["epoch"]
+  end
+end

data/minitest/ssr_database_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# The SSR contract for the local database (docs decision 18): model
+# class bodies evaluate under CRuby -- declarations are recorded, no
+# SQLite is touched -- but booting the database or materializing a
+# local query on the server fails loud with UnavailableError, never an
+# empty result.
+class SSRDatabaseTest < Minitest::Test
+  def setup
+    # Loads the mrblib runtime under CRuby and flips Funicular.server
+    # to true, exactly like a Rails SSR render.
+    Funicular::SSR::Runtime.load_framework!
+  end
+
+  def test_boot_refuses_on_the_server
+    error = assert_raises(Funicular::DB::UnavailableError) do
+      Funicular::DB.boot(models: [], metadata: {})
+    end
+    assert_includes error.message, "SSR"
+    # The refusal is a clean raise, not a failed state: nothing to
+    # tear down, nothing latched.
+    assert_equal :unbooted, Funicular::DB.boot_state
+  end
+
+  def test_a_local_class_body_evaluates_but_materializing_raises
+    model = Class.new(Funicular::Model) do
+      table_name "ssr_drafts"
+      storage :local do
+        migrate 1 do |t|
+          t.string :title
+        end
+      end
+    end
+    # The declaration side worked: storage recorded, no SQLite touched.
+    assert_equal true, model.local?
+    # Materializing is where the server says no.
+    assert_raises(Funicular::DB::UnavailableError) { model.count }
+    assert_raises(Funicular::DB::UnavailableError) { model.local.to_a }
+    assert_raises(Funicular::DB::UnavailableError) do
+      model.local_create(title: "nope")
+    end
+  end
+
+  def test_association_declarations_evaluate_but_reading_raises
+    # Named constants, because the conventions read the class name:
+    # SsrPost -> ssr_post_id, :ssr_comment -> SsrComment.
+    Object.const_set(:SsrComment, Class.new(Funicular::Model) do
+      storage :local do
+        migrate 1 do |t|
+          t.integer :ssr_post_id
+        end
+      end
+    end)
+    Object.const_set(:SsrPost, Class.new(Funicular::Model))
+    # Declared after the constant exists, the way a `class SsrPost <
+    # Funicular::Model` body reads: has_many derives its foreign key
+    # from the declaring class name.
+    SsrPost.class_eval do
+      storage :local do
+        migrate 1 do |t|
+          t.integer :ssr_comment_id
+        end
+      end
+      belongs_to :ssr_comment
+      has_many :ssr_comments
+    end
+    # The declaration side worked: nothing resolved, no SQLite touched.
+    record = SsrPost.new(ssr_comment_id: 1)
+    # Reading one is a local query, and the server has no local database.
+    assert_raises(Funicular::DB::UnavailableError) { record.ssr_comment }
+    assert_raises(Funicular::DB::UnavailableError) { record.ssr_comments.to_a }
+  ensure
+    Object.send(:remove_const, :SsrPost) if Object.const_defined?(:SsrPost)
+    Object.send(:remove_const, :SsrComment) if Object.const_defined?(:SsrComment)
+  end
+end

data/minitest/ssr_reload_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require "test_helper"
+
+# Development-mode SSR reload: with auto_reload enabled (the railtie
+# turns it on in development), editing an app source makes the next
+# boot! re-load the sources, so server-rendered markup matches what the
+# recompiled client bundle will hydrate.
+class SSRReloadTest < Minitest::Test
+  def setup
+    Funicular::SSR::Runtime.load_framework!
+  end
+
+  def teardown
+    Funicular::SSR::Runtime.auto_reload = false
+    Funicular::SSR::Runtime.reset_app!
+  end
+
+  def write_component(dir, title)
+    File.write(File.join(dir, "components", "reload_probe_component.rb"), <<~RUBY)
+      class ReloadProbeComponent < Funicular::Component
+        def render
+          div { "#{title}" }
+        end
+      end
+    RUBY
+  end
+
+  def build_app(dir)
+    FileUtils.mkdir_p(File.join(dir, "components"))
+    write_component(dir, "before reload")
+    File.write(File.join(dir, "initializer.rb"), <<~RUBY)
+      Funicular.start(container: "app") do |router|
+        router.get("/probe", to: ReloadProbeComponent, as: "probe")
+      end
+    RUBY
+  end
+
+  def render_probe(dir)
+    Funicular::SSR.render(path: "/probe", source_dir: dir)[:html]
+  end
+
+  def quietly
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbose
+  end
+
+  def test_edited_sources_are_reloaded_when_auto_reload_is_on
+    Dir.mktmpdir do |dir|
+      build_app(dir)
+      Funicular::SSR::Runtime.reset_app!
+      assert_includes render_probe(dir), "before reload"
+
+      write_component(dir, "after reload")
+      bump_mtime(dir)
+
+      # Off (the default): still the stale markup.
+      assert_includes render_probe(dir), "before reload"
+
+      Funicular::SSR::Runtime.auto_reload = true
+      quietly do
+        assert_includes render_probe(dir), "after reload"
+      end
+    end
+  end
+
+  def test_reset_app_discards_the_snapshot
+    Dir.mktmpdir do |dir|
+      build_app(dir)
+      Funicular::SSR::Runtime.reset_app!
+      quietly { render_probe(dir) }
+      refute Funicular::SSR::Runtime.sources_changed?(dir)
+
+      Funicular::SSR::Runtime.reset_app!
+      assert Funicular::SSR::Runtime.sources_changed?(dir)
+    end
+  end
+
+  def test_unchanged_sources_are_not_reloaded
+    Dir.mktmpdir do |dir|
+      build_app(dir)
+      Funicular::SSR::Runtime.reset_app!
+      Funicular::SSR::Runtime.auto_reload = true
+      quietly { render_probe(dir) }
+
+      refute Funicular::SSR::Runtime.sources_changed?(dir)
+    end
+  end
+
+  private
+
+  # mtime comparison, not equality of content: make the edit observable
+  # even on filesystems with coarse timestamps.
+  def bump_mtime(dir)
+    future = Time.now + 2
+    Dir.glob(File.join(dir, "**", "*.rb")).each do |file|
+      File.utime(future, future, file)
+    end
+  end
+end

data/minitest/ssr_test.rb

@@ -122,6 +122,47 @@ class SSRTest < Minitest::Test
     assert_includes result[:html], "greeting"
   end
 
+  # --- Single-component render (no route lookup) ------------------------
+
+  def test_render_component_renders_by_name_without_a_route
+    html = Funicular::SSR.render_component(
+      "GreetingComponent",
+      state: { title: "Embedded" },
+      source_dir: APP_DIR
+    )
+    assert_includes html, "<h1>Embedded</h1>"
+    assert_includes html, 'class="greeting"'
+  end
+
+  def test_render_component_passes_props_and_state
+    html = Funicular::SSR.render_component(
+      "ProbeComponent",
+      props: { "label" => "From Props" },
+      state: { note: "injected note" },
+      source_dir: APP_DIR
+    )
+    assert_includes html, "<h2>From Props</h2>"
+    assert_includes html, "<p>injected note</p>"
+  end
+
+  def test_render_component_uses_initialize_state_without_injection
+    html = Funicular::SSR.render_component("GreetingComponent", source_dir: APP_DIR)
+    assert_includes html, "<h1>Default Title</h1>"
+  end
+
+  def test_render_component_raises_on_unknown_component
+    assert_raises(NameError) do
+      Funicular::SSR.render_component("NoSuchComponent", source_dir: APP_DIR)
+    end
+  end
+
+  def test_render_component_rejects_a_non_component_constant
+    error = assert_raises(ArgumentError) do
+      Funicular::SSR.render_component("String", source_dir: APP_DIR)
+    end
+    assert_match(/not a Funicular::Component/, error.message)
+  end
+
   def test_symbolize_keys_handles_nil_and_string_keys
     assert_equal({}, Funicular::SSR.symbolize_keys(nil))
     assert_equal({ a: 1, b: 2 }, Funicular::SSR.symbolize_keys("a" => 1, "b" => 2))