chore: test cleanup

Author: Akolyte01

test/async-stores/index.test.ts

@@ -11,6 +11,7 @@ import {
   writable,
   safeLoad,
 } from '../../src';
+import { delayValue, delayFunction } from '../helpers';
 
 describe('asyncWritable', () => {
   const writableParent = writable('writable');
@@ -83,7 +84,7 @@ describe('asyncWritable', () => {
   });
 
   describe('one parent asyncDerived', () => {
-    it('loads expected value NOMERGE', async () => {
+    it('loads expected value', async () => {
       const myAsyncDerived = asyncDerived(writableParent, (storeValue) =>
         Promise.resolve(`derived from ${storeValue}`)
       );
@@ -242,7 +243,7 @@ describe('asyncWritable', () => {
 
       // this sucks but I can't figure out a better way to wait for the
       // subscribe callbacks to get called without generating a new subscription
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await delayValue(null, 100);
 
       expect(firstValue).toBe('initial first');
       expect(secondValue).toBe('initial second');
@@ -252,7 +253,7 @@ describe('asyncWritable', () => {
       firstUnsubscribe();
       writableParent.set('updated');
 
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      await delayValue(null, 50);
 
       expect(firstValue).toBe('initial first');
       expect(secondValue).toBe('updated second');
@@ -262,11 +263,7 @@ describe('asyncWritable', () => {
 
     describe('abort/rebounce integration', () => {
       it('loads to rebounced value only', async () => {
-        const load = (value: string) => {
-          return new Promise<string>((resolve) =>
-            setTimeout(() => resolve(value), 100)
-          );
-        };
+        const load = (value: string) => delayValue(value, 100);
 
         const myParent = writable();
         const { store: myStore, state: myState } = asyncDerived(myParent, load);
@@ -286,14 +283,15 @@ describe('asyncWritable', () => {
         });
 
         myParent.set('a');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
 
         myParent.set('b');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
+
         myParent.set('c');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
 
         const finalValue = await myStore.load();
@@ -334,13 +332,15 @@ describe('asyncWritable', () => {
         });
 
         myParent.set('a');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
+
         myParent.set('b');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
+
         myParent.set('c');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         expect(get(myState).isLoading).toBe(true);
 
         const finalValue = await myStore.load();
@@ -355,9 +355,7 @@ describe('asyncWritable', () => {
         let timesCalled = 0;
         const load = (value: string) => {
           timesCalled += 1;
-          return new Promise<string>((resolve) =>
-            setTimeout(() => resolve(value), 200 - timesCalled * 100)
-          );
+          return delayValue(value, 200 - timesCalled * 100);
         };
 
         const myParent = writable();
@@ -382,7 +380,7 @@ describe('asyncWritable', () => {
         const result = await myStore.load();
         expect(result).toBe('b');
 
-        await new Promise((resolve) => setTimeout(resolve, 200));
+        await delayValue(null, 200);
         expect(get(myStore)).toBe('b');
         expect(setIncorrectly).toBe(false);
         expect(get(myState).isLoaded).toBe(true);
@@ -394,41 +392,34 @@ describe('asyncWritable', () => {
           .mockReturnValueOnce('first')
           .mockReturnValueOnce('second');
 
-        const load = () => {
-          const valueToReturn = getFinalValue();
-
-          return new Promise<string>((resolve) =>
-            setTimeout(() => resolve(valueToReturn), 100)
-          );
-        };
-
-        const myLoadable = asyncReadable('initial', load, {
-          reloadable: true,
-        });
+        const myLoadable = asyncReadable(
+          'initial',
+          delayFunction(getFinalValue, 100),
+          {
+            reloadable: true,
+          }
+        );
 
         expect(myLoadable.load()).resolves.toBe('second');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         const finalValue = await myLoadable.reload();
         expect(finalValue).toBe('second');
       });
 
       it('can be aborted correctly', async () => {
-        const load = (value: string) => {
-          return new Promise<string>((resolve) =>
-            setTimeout(() => resolve(value), 100)
-          );
-        };
-
         const myParent = writable();
-        const { store: myStore, state: myState } = asyncDerived(myParent, load);
+        const { store: myStore, state: myState } = asyncDerived(
+          myParent,
+          delayFunction((value) => value, 100)
+        );
 
         myStore.subscribe(vi.fn());
         myParent.set('one');
         let loadValue = await myStore.load();
         expect(loadValue).toBe('one');
 
         myParent.set('two');
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await delayValue(null, 50);
         myStore.abort();
 
         loadValue = await myStore.load();
@@ -475,7 +466,7 @@ describe('asyncWritable', () => {
     it('deterministically sets final value when receiving updates while loading', async () => {
       const delayedParent = asyncReadable(
         undefined,
-        () => new Promise((resolve) => setTimeout(resolve, 1000))
+        delayFunction(() => null, 100)
       );
       const mockLoad = vi
         .fn()
@@ -520,18 +511,17 @@ describe('asyncWritable', () => {
       const parentA = derived(grandParent, (value) => value);
       const parentB = asyncDerived(
         grandParent,
-        (value) =>
-          new Promise((resolve) =>
-            setTimeout(() => resolve(value.toUpperCase()), 100)
-          )
+        delayFunction((value) => value.toUpperCase(), 100)
       );
+      const parentC = asyncDerived(
+        parentB,
+        delayFunction((value) => value, 100)
+      );
+
       const load = vi.fn(
-        ([valueA, valueB]) =>
-          new Promise((resolve) =>
-            setTimeout(() => resolve(valueA + valueB), 100)
-          )
+        delayFunction(([valueA, valueB]) => valueA + valueB, 100)
       );
-      const myLoadable = asyncDerived([parentA, parentB], load);
+      const myLoadable = asyncDerived([parentA, parentC], load);
       myLoadable.subscribe(vi.fn());
 
       let result = await myLoadable.load();
@@ -868,7 +858,7 @@ describe('asyncWritable', () => {
       expect(get(myAsyncWritable)).toBe('derived from first value');
       await myAsyncWritable.reload();
       expect(get(myAsyncWritable)).toBe('derived from second value');
-      expect(myAsyncWritable.load()).resolves.toBe('derived from second value');
+      expect(await myAsyncWritable.load()).toBe('derived from second value');
 
       await myAsyncWritable.set('set value');
       expect(get(myAsyncWritable)).toBe('set value');
@@ -1164,10 +1154,7 @@ describe('trackState', () => {
       const myParent = writable('initial');
       const { store: myStore, state: myState } = asyncDerived(
         myParent,
-        ($myParent) =>
-          new Promise((resolve) =>
-            setTimeout(() => resolve(`derived from ${$myParent}`), 50)
-          ),
+        delayFunction(($myParent) => `derived from ${$myParent}`, 50),
         { trackState: true }
       );
 
@@ -1181,7 +1168,6 @@ describe('trackState', () => {
       expect(get(myState).isLoaded).toBe(true);
 
       myParent.set('updated');
-      await new Promise((resolve) => setTimeout(resolve));
 
       expect(get(myStore)).toBe('derived from initial');
       expect(get(myState).isReloading).toBe(true);
@@ -1204,13 +1190,7 @@ describe('trackState', () => {
       );
       const { store: myStore, state: myState } = asyncDerived(
         [parentA, parentB],
-        ([$parentA, $parentB]) => {
-          return new Promise((resolve) => {
-            setTimeout(() => {
-              resolve(`${$parentA} ${$parentB}`);
-            }, 100);
-          });
-        },
+        delayFunction(([$parentA, $parentB]) => `${$parentA} ${$parentB}`, 100),
         { trackState: true }
       );
 
@@ -1224,7 +1204,6 @@ describe('trackState', () => {
       expect(get(myState).isLoaded).toBe(true);
 
       grandParent.set('updated');
-      await new Promise((resolve) => setTimeout(resolve));
 
       expect(get(myStore)).toBe('initialA initialB');
       expect(get(myState).isReloading).toBe(true);

test/helpers.ts

@@ -0,0 +1,17 @@
+type FlatPromise<T> = T extends Promise<unknown> ? T : Promise<T>;
+
+export const delayValue = <T>(value: T, delay = 0): FlatPromise<T> => {
+  return new Promise((resolve) =>
+    setTimeout(() => resolve(value), delay)
+  ) as FlatPromise<T>;
+};
+
+export const delayFunction = <T, U>(
+  callback: (...args: T[]) => U,
+  delay = 0
+): ((...args: T[]) => FlatPromise<U>) => {
+  return (...args: T[]) => {
+    const result = callback(...args);
+    return delayValue(result, delay);
+  };
+};

test/standard-stores/index.test.ts

@@ -227,7 +227,6 @@ describe('readable/writable stores', () => {
       expect(stop).toHaveBeenCalledTimes(1);
 
       await myReadable.load();
-      await new Promise((resolve) => setTimeout(resolve));
       expect(stop).toHaveBeenCalledTimes(2);
     });
   });

test/utils/index.test.ts

@@ -7,6 +7,7 @@ import {
   safeLoad,
   enableStoreTestingMode,
 } from '../../src';
+import { delayValue } from '../helpers';
 
 enableStoreTestingMode();
 
@@ -111,13 +112,8 @@ describe('rebounce', () => {
 
   const toUpperCase = (input: string) => input.toUpperCase();
 
-  const asyncToUpperCase = (input: string) => {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(input.toUpperCase());
-      }, interval());
-    });
-  };
+  const asyncToUpperCase = (input: string) =>
+    delayValue(input.toUpperCase(), interval());
 
   it('works with no timer or rejects', () => {
     const rebouncedToUpperCase = rebounce(asyncToUpperCase);