Hydration drops cached dependent updates from get_delta storage assignments #7571

async def test_hydrate_sends_override_mutation_dependents(
    wired_app, real_base_state_processor, emitted_deltas, token
):
    class StorageState(State):
        value: str = rx.LocalStorage("")

        @_override_base_method
        def get_delta(self) -> Delta:
            if "value" in self.dirty_vars and self.value == "stale":
                self.value = "fresh"
            return super().get_delta()

    class DependentState(State):
        @rx.var(cache=True, auto_deps=False)
        async def copy(self) -> str:
            return (await self.get_state(StorageState)).value

    DependentState.computed_vars["copy"].add_dependency(
        DependentState, StorageState.value
    )
    wired_app.add_page(
        lambda: rx.text(StorageState.value, DependentState.copy), route="/"
    )
    wired_app._compile_page("index")
    name = StorageState.get_full_name()
    key = "value" + FIELD_MARKER
    boot_name = Event.from_event_type(State.hydrate_and_load())[0].name
    payload = {"vars": {f"{name}.{key}": "stale"}}

    async with real_base_state_processor as processor:
        await (
            await processor.enqueue(token, _boot_event(boot_name, payload))
        ).wait_all()

    async with _read_back(real_base_state_processor, token) as root:
        assert (await root.get_state(StorageState)).value == "fresh"
        assert await (await root.get_state(DependentState)).copy == "fresh"

    storage_values = [
        delta[name][key]
        for _, delta in emitted_deltas
        if key in delta.get(name, {})
    ]
    dependent_values = [
        delta[DependentState.get_full_name()]["copy" + FIELD_MARKER]
        for _, delta in emitted_deltas
        if "copy" + FIELD_MARKER in delta.get(DependentState.get_full_name(), {})
    ]
    assert storage_values[-1] == "fresh"
    assert dependent_values[-1] == "fresh"  # Actual: "stale"