Function test_event_var_data

tests/units/test_event.py:462–518

()

def test_event_var_data():
    class S(BaseState):
        x: Field[int] = field(0)

        @event
        def s(self, value: int):
            pass

        @event
        def s2(self):
            pass

    # Handler doesn't have any _var_data because it's just a str
    handler_var = Var.create(S.s2)
    assert handler_var._get_all_var_data() is None

    # Ensure spec carries _var_data
    spec_var = Var.create(S.s(S.x))
    assert spec_var._get_all_var_data() == S.x._get_all_var_data()

    # Needed to instantiate the EventChain
    def _args_spec(value: Var[int]) -> tuple[Var[int]]:
        return (value,)

    # Ensure chain carries _var_data
    chain_var = Var.create(
        EventChain(
            events=[S.s(S.x)],
            args_spec=_args_spec,
            invocation=rx.vars.FunctionStringVar.create(""),
        )
    )
    assert chain_var._get_all_var_data() == S.x._get_all_var_data()

    chain_var_data = Var.create(
        EventChain(
            events=[],
            args_spec=_args_spec,
        )
    )._get_all_var_data()
    assert chain_var_data is not None

    # Imports include EVENTS (which now imports module-level ``addEvents``)
    # and the state/event-loop providers ride along as app_wraps so the
    # compiler can mount them in the app root. ``addEvents`` reaches its
    # call sites through the import, not a hoisted hook, so ``hooks`` is
    # empty here. Compare structurally — providers are fresh instances per
    # call, so identity-based VarData equality wouldn't match.
    assert dict(chain_var_data.imports) == {
        k: tuple(v) for k, v in Imports.EVENTS.items()
    }
    assert chain_var_data.hooks == ()
    assert sorted(p for p, _ in chain_var_data.app_wraps) == [90, 100]
    assert {wrapper.tag for _, wrapper in chain_var_data.app_wraps} == {
        "StateProvider",
        "EventLoopProvider",
    }