Skip to content
Source
Sign inSign up
TanStack/db
Open History to see the last commit

deferred.test.ts

112 lines3.7 KB

1import { describe, expect, it } from "vitest"
2import { createDeferred } from "../src/deferred"
3import type { Deferred } from "../src/deferred"
4​
5describe(`Deferred`, () => {
6 it(`should create a deferred object with the correct shape`, () => {
7 const deferred = createDeferred<number>()
8 expect(deferred).toHaveProperty(`promise`)
9 expect(deferred).toHaveProperty(`resolve`)
10 expect(deferred).toHaveProperty(`reject`)
11 expect(deferred).toHaveProperty(`isPending`)
12 expect(typeof deferred.resolve).toBe(`function`)
13 expect(typeof deferred.reject).toBe(`function`)
14 expect(typeof deferred.isPending).toBe(`function`)
15 })
16​
17 it(`should resolve with the correct value`, async () => {
18 const deferred = createDeferred<number>()
19 deferred.resolve(42)
20 const result = await deferred.promise
21 expect(result).toBe(42)
22 })
23​
24 it(`should reject with the correct error`, async () => {
25 const deferred = createDeferred<number>()
26 const error = new Error(`test error`)
27 deferred.reject(error)
28 await expect(deferred.promise).rejects.toThrow(error)
29 })
30​
31 it(`should track pending state correctly`, () => {
32 const deferred = createDeferred<number>()
33 expect(deferred.isPending()).toBe(true)
34 deferred.resolve(42)
35 expect(deferred.isPending()).toBe(false)
36 })
37​
38 it(`should track pending state after rejection`, async () => {
39 const deferred = createDeferred<number>()
40 expect(deferred.isPending()).toBe(true)
41​
42 const error = new Error(`test error`)
43 deferred.reject(error)
44 await expect(deferred.promise).rejects.toThrow(error)
45 expect(deferred.isPending()).toBe(false)
46 })
47​
48 it(`should work with different types`, async () => {
49 // String type
50 const stringDeferred = createDeferred<string>()
51 stringDeferred.resolve(`hello`)
52 expect(await stringDeferred.promise).toBe(`hello`)
53​
54 // Object type
55 interface TestObject {
56 foo: string
57 bar: number
58 }
59 const objectDeferred = createDeferred<TestObject>()
60 const testObj = { foo: `test`, bar: 123 }
61 objectDeferred.resolve(testObj)
62 expect(await objectDeferred.promise).toEqual(testObj)
63​
64 // Array type
65 const arrayDeferred = createDeferred<Array<number>>()
66 arrayDeferred.resolve([1, 2, 3])
67 expect(await arrayDeferred.promise).toEqual([1, 2, 3])
68​
69 // Union type
70 const unionDeferred = createDeferred<string | number>()
71 unionDeferred.resolve(42)
72 expect(await unionDeferred.promise).toBe(42)
73 })
74​
75 it(`should handle promise chaining`, async () => {
76 const deferred = createDeferred<number>()
77 const chainedPromise = deferred.promise
78 .then((x) => x * 2)
79 .then((x) => x.toString())
80​
81 deferred.resolve(21)
82 const result = await chainedPromise
83 expect(result).toBe(`42`)
84 })
85​
86 it(`should handle async resolution`, async () => {
87 const deferred = createDeferred<number>()
88 const asyncValue = Promise.resolve(42)
89 deferred.resolve(asyncValue)
90 const result = await deferred.promise
91 expect(result).toBe(42)
92 })
93​
94 // Type tests - these will fail at compile time if types are wrong
95 it(`type tests`, () => {
96 const numberDeferred: Deferred<number> = createDeferred<number>()
97 numberDeferred.resolve(42) // Should compile
98 // @ts-expect-error - wrong type
99 numberDeferred.resolve(`42`) // Should not compile
100​
101 const stringDeferred: Deferred<string> = createDeferred<string>()
102 stringDeferred.resolve(`hello`) // Should compile
103 // @ts-expect-error - wrong type
104 stringDeferred.resolve(42) // Should not compile
105​
106 const promiseDeferred: Deferred<Promise<number>> =
107 createDeferred<Promise<number>>()
108 promiseDeferred.resolve(Promise.resolve(42)) // Should compile
109 // @ts-expect-error - wrong type
110 promiseDeferred.resolve(42) // Should not compile
111 })
112})