Julien Valverdé
130 lines
4.9 KiB
TypeScript
130 lines
4.9 KiB
TypeScript
import { render, screen, waitFor } from "@testing-library/react"
|
|
import { Effect, Fiber, Layer, Stream, SubscriptionRef } from "effect"
|
|
import { Lens } from "effect-lens"
|
|
import { describe, expect, it } from "vitest"
|
|
import * as Component from "../src/Component.js"
|
|
import * as ReactRuntime from "../src/ReactRuntime.js"
|
|
import * as Subscribable from "../src/Subscribable.js"
|
|
|
|
|
|
const makeRuntime = async () => {
|
|
const runtime = ReactRuntime.make(Layer.empty)
|
|
const effectRuntime = await runtime.runtime.context()
|
|
|
|
return {
|
|
runtime,
|
|
effectRuntime,
|
|
dispose: () => runtime.runtime.dispose(),
|
|
}
|
|
}
|
|
|
|
describe("Subscribable", () => {
|
|
it("zipLatestAll reads current values from all inputs", async () => {
|
|
const leftRef = await Effect.runPromise(SubscriptionRef.make(1))
|
|
const rightRef = await Effect.runPromise(SubscriptionRef.make("a"))
|
|
const left = Lens.fromSubscriptionRef(leftRef)
|
|
const right = Lens.fromSubscriptionRef(rightRef)
|
|
|
|
const zipped = Subscribable.zipLatestAll(left, right)
|
|
|
|
expect(await Effect.runPromise(zipped.get)).toEqual([1, "a"])
|
|
})
|
|
|
|
it("zipLatestAll emits updates when any input changes", async () => {
|
|
const leftRef = await Effect.runPromise(SubscriptionRef.make(1))
|
|
const rightRef = await Effect.runPromise(SubscriptionRef.make("a"))
|
|
const left = Lens.fromSubscriptionRef(leftRef)
|
|
const right = Lens.fromSubscriptionRef(rightRef)
|
|
|
|
const zipped = Subscribable.zipLatestAll(left, right)
|
|
const values: Array<readonly [number, string]> = []
|
|
|
|
const collector = Effect.runFork(Effect.scoped(zipped.changes.pipe(
|
|
Stream.runForEach(value => Effect.sync(() => {
|
|
values.push(value as readonly [number, string])
|
|
})),
|
|
)))
|
|
|
|
await Effect.runPromise(Lens.set(left, 2))
|
|
await waitFor(() => expect(values).toContainEqual([2, "a"]))
|
|
|
|
await Effect.runPromise(Lens.set(right, "b"))
|
|
await waitFor(() => expect(values).toContainEqual([2, "b"]))
|
|
|
|
await Effect.runPromise(Fiber.interrupt(collector))
|
|
})
|
|
|
|
it("useAll returns the latest values and rerenders when any input changes", async () => {
|
|
const { runtime, effectRuntime, dispose } = await makeRuntime()
|
|
const countRef = await Effect.runPromise(SubscriptionRef.make(1))
|
|
const labelRef = await Effect.runPromise(SubscriptionRef.make("a"))
|
|
const count = Lens.fromSubscriptionRef(countRef)
|
|
const label = Lens.fromSubscriptionRef(labelRef)
|
|
|
|
const Probe = Component.makeUntraced("SubscribableUseAllProbe")(function*() {
|
|
const [currentCount, currentLabel] = yield* Subscribable.useAll([count, label])
|
|
|
|
return <div>{`${currentCount}:${currentLabel}`}</div>
|
|
}).pipe(
|
|
Component.withRuntime(runtime.context)
|
|
)
|
|
|
|
const view = render(
|
|
<runtime.context.Provider value={effectRuntime}>
|
|
<Probe />
|
|
</runtime.context.Provider>
|
|
)
|
|
|
|
await screen.findByText("1:a")
|
|
|
|
await Effect.runPromise(Lens.set(count, 2))
|
|
await screen.findByText("2:a")
|
|
|
|
await Effect.runPromise(Lens.set(label, "b"))
|
|
await screen.findByText("2:b")
|
|
|
|
view.unmount()
|
|
await dispose()
|
|
})
|
|
|
|
it("useAll respects the provided equivalence when processing updates", async () => {
|
|
const { runtime, effectRuntime, dispose } = await makeRuntime()
|
|
const itemRef = await Effect.runPromise(SubscriptionRef.make({ id: 1, label: "first" }))
|
|
const flagRef = await Effect.runPromise(SubscriptionRef.make(true))
|
|
const item = Lens.fromSubscriptionRef(itemRef)
|
|
const flag = Lens.fromSubscriptionRef(flagRef)
|
|
|
|
const Probe = Component.makeUntraced("SubscribableUseAllEquivalenceProbe")(function*() {
|
|
const [currentItem, currentFlag] = yield* Subscribable.useAll([item, flag], {
|
|
equivalence: ([selfItem, selfFlag], [thatItem, thatFlag]) =>
|
|
selfItem.id === thatItem.id && selfFlag === thatFlag,
|
|
})
|
|
|
|
return <div>{`${currentItem.label}:${currentFlag ? "on" : "off"}`}</div>
|
|
}).pipe(
|
|
Component.withRuntime(runtime.context)
|
|
)
|
|
|
|
const view = render(
|
|
<runtime.context.Provider value={effectRuntime}>
|
|
<Probe />
|
|
</runtime.context.Provider>
|
|
)
|
|
|
|
await screen.findByText("first:on")
|
|
|
|
await Effect.runPromise(Lens.set(item, { id: 1, label: "ignored" }))
|
|
await waitFor(() => expect(screen.getByText("first:on")).toBeTruthy())
|
|
expect(screen.queryByText("ignored:on")).toBeNull()
|
|
|
|
await Effect.runPromise(Lens.set(flag, false))
|
|
await screen.findByText("ignored:off")
|
|
|
|
await Effect.runPromise(Lens.set(item, { id: 2, label: "updated" }))
|
|
await screen.findByText("updated:off")
|
|
|
|
view.unmount()
|
|
await dispose()
|
|
})
|
|
})
|