1- import { resetStoreInOrder , storeInOrder , storeInOrderKeys } from "../storeInOrder"
1+ import { storeInOrder } from "../storeInOrder"
22
33const controllable = ( ) => {
44 const finish : Array < { resolve : ( ) => void ; reject : ( error : unknown ) => void } > = [ ]
55 const write = vi . fn ( ( ) => new Promise < void > ( ( resolve , reject ) => finish . push ( { resolve, reject } ) ) )
66 return { write, finish }
77}
88
9+ let counter = 0
10+ // Each test has a key of its own: what one leaves in line cannot reach another.
11+ let current = "key"
12+ const keyOf = ( ) => current
13+
914describe ( "storeInOrder" , ( ) => {
10- afterEach ( ( ) => resetStoreInOrder ( ) )
15+ beforeEach ( ( ) => {
16+ current = `key-${ ++ counter } `
17+ } )
1118
1219 it ( "runs a write at once when nothing of that key is in line, and keeps nothing once it is done" , async ( ) => {
1320 const { write, finish } = controllable ( )
1421
15- const stored = storeInOrder ( "key" , write )
22+ const stored = storeInOrder ( keyOf ( ) , write )
1623 await vi . waitFor ( ( ) => expect ( write ) . toHaveBeenCalledTimes ( 1 ) )
1724 finish [ 0 ] . resolve ( )
1825 await stored
1926
20- expect ( storeInOrderKeys ( ) ) . toEqual ( [ ] )
27+ // Nothing is left in line: the next write of the key starts at once.
28+ const next = controllable ( )
29+ void storeInOrder ( keyOf ( ) , next . write )
30+ await vi . waitFor ( ( ) => expect ( next . write ) . toHaveBeenCalledTimes ( 1 ) )
31+ next . finish [ 0 ] . resolve ( )
2132 } )
2233
2334 it ( "starts a write of the same key only when the one before it has settled" , async ( ) => {
2435 const first = controllable ( )
2536 const second = controllable ( )
2637
27- const a = storeInOrder ( "key" , first . write )
28- const b = storeInOrder ( "key" , second . write )
38+ const a = storeInOrder ( keyOf ( ) , first . write )
39+ const b = storeInOrder ( keyOf ( ) , second . write )
2940 await vi . waitFor ( ( ) => expect ( first . write ) . toHaveBeenCalledTimes ( 1 ) )
3041 expect ( second . write ) . not . toHaveBeenCalled ( )
3142
@@ -34,17 +45,16 @@ describe("storeInOrder", () => {
3445 await vi . waitFor ( ( ) => expect ( second . write ) . toHaveBeenCalledTimes ( 1 ) )
3546 second . finish [ 0 ] . resolve ( )
3647 await b
37- expect ( storeInOrderKeys ( ) ) . toEqual ( [ ] )
3848 } )
3949
4050 it ( "keeps one write waiting at most: a newer one replaces it, and every caller is answered by the one that runs" , async ( ) => {
4151 const running = controllable ( )
4252 const replaced = controllable ( )
4353 const latest = controllable ( )
4454
45- const a = storeInOrder ( "key" , running . write )
46- const b = storeInOrder ( "key" , replaced . write )
47- const c = storeInOrder ( "key" , latest . write )
55+ const a = storeInOrder ( keyOf ( ) , running . write )
56+ const b = storeInOrder ( keyOf ( ) , replaced . write )
57+ const c = storeInOrder ( keyOf ( ) , latest . write )
4858 expect ( c ) . toBe ( b )
4959 await vi . waitFor ( ( ) => expect ( running . write ) . toHaveBeenCalledTimes ( 1 ) )
5060 running . finish [ 0 ] . resolve ( )
@@ -60,8 +70,8 @@ describe("storeInOrder", () => {
6070 const stalled = controllable ( )
6171 const other = controllable ( )
6272
63- void storeInOrder ( "a" , stalled . write )
64- const b = storeInOrder ( "b" , other . write )
73+ void storeInOrder ( ` ${ keyOf ( ) } -a` , stalled . write )
74+ const b = storeInOrder ( ` ${ keyOf ( ) } -b` , other . write )
6575 await vi . waitFor ( ( ) => expect ( other . write ) . toHaveBeenCalledTimes ( 1 ) )
6676 other . finish [ 0 ] . resolve ( )
6777 await b
@@ -71,9 +81,9 @@ describe("storeInOrder", () => {
7181 const first = controllable ( )
7282 const second = controllable ( )
7383
74- const a = storeInOrder ( "key" , first . write )
84+ const a = storeInOrder ( keyOf ( ) , first . write )
7585 const aFailed = expect ( a ) . rejects . toThrow ( "storage unavailable" )
76- const b = storeInOrder ( "key" , second . write )
86+ const b = storeInOrder ( keyOf ( ) , second . write )
7787 await vi . waitFor ( ( ) => expect ( first . write ) . toHaveBeenCalledTimes ( 1 ) )
7888 first . finish [ 0 ] . reject ( new Error ( "storage unavailable" ) )
7989 await aFailed
@@ -86,11 +96,11 @@ describe("storeInOrder", () => {
8696 it ( "reports a write that throws before it returns a promise, and goes on" , async ( ) => {
8797 const next = controllable ( )
8898
89- const a = storeInOrder ( "key" , ( ) => {
99+ const a = storeInOrder ( keyOf ( ) , ( ) => {
90100 throw new Error ( "sync failure" )
91101 } )
92102 await expect ( a ) . rejects . toThrow ( "sync failure" )
93- const b = storeInOrder ( "key" , next . write )
103+ const b = storeInOrder ( keyOf ( ) , next . write )
94104 await vi . waitFor ( ( ) => expect ( next . write ) . toHaveBeenCalledTimes ( 1 ) )
95105 next . finish [ 0 ] . resolve ( )
96106 await b
@@ -100,7 +110,7 @@ describe("storeInOrder", () => {
100110 const unhandled = vi . fn ( )
101111 process . on ( "unhandledRejection" , unhandled )
102112 try {
103- void storeInOrder ( "key" , async ( ) => Promise . reject ( new Error ( "nobody waits" ) ) )
113+ void storeInOrder ( keyOf ( ) , async ( ) => Promise . reject ( new Error ( "nobody waits" ) ) )
104114 await new Promise ( ( resolve ) => setTimeout ( resolve , 20 ) )
105115 expect ( unhandled ) . not . toHaveBeenCalled ( )
106116 } finally {
0 commit comments