signalium 0.3.7 → 1.0.0

package/src/__tests__/async-task.test.ts

@@ -0,0 +1,327 @@
+import { describe, expect, test } from 'vitest';
+import { task, reactive } from './utils/instrumented-hooks.js';
+import { nextTick } from './utils/async.js';
+
+describe('async tasks', () => {
+  test('Basic async task works', async () => {
+    let taskCount = 0;
+    const getC = reactive((a: number, b: number) => {
+      return task(async () => {
+        taskCount++;
+        return a + b;
+      });
+    });
+
+    // First set of args
+    const task1 = getC(1, 2);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(taskCount).toEqual(0);
+
+    await nextTick();
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(taskCount).toEqual(0);
+
+    const result1 = task1.run();
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(undefined);
+
+    expect(await result1).toBe(3);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(3);
+    expect(taskCount).toEqual(1);
+
+    const result2 = task1.run();
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(3);
+    expect(taskCount).toEqual(2);
+
+    expect(await result2).toBe(3);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(3);
+    expect(taskCount).toEqual(2);
+
+    // Second set of args
+    const task2 = getC(2, 2);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+    expect(taskCount).toEqual(2);
+
+    await nextTick();
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+    expect(taskCount).toEqual(2);
+
+    const result3 = task2.run();
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(undefined);
+    expect(taskCount).toEqual(3);
+
+    expect(await result3).toBe(4);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(4);
+    expect(taskCount).toEqual(3);
+
+    const result4 = task2.run();
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(4);
+    expect(taskCount).toEqual(4);
+
+    expect(await result4).toBe(4);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(4);
+    expect(taskCount).toEqual(4);
+  });
+
+  test('Can run separate tasks separately', async () => {
+    const getC = reactive((a: number, b: number) => {
+      return task(async () => {
+        return a + b;
+      });
+    });
+
+    const task1 = getC(1, 2);
+    const task2 = getC(2, 2);
+
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    await nextTick();
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    const result1 = task1.run();
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    expect(await result1).toBe(3);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(3);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    const result2 = task2.run();
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(undefined);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(3);
+
+    expect(await result2).toBe(4);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(3);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(4);
+  });
+
+  test('Tasks do not notify when the result is not used in a computed', async () => {
+    const getC = reactive((a: number, b: number) => {
+      return task(async () => {
+        return a + b;
+      });
+    });
+
+    const computed1 = reactive(() => {
+      return getC(1, 2);
+    });
+    const computed2 = reactive(() => {
+      return getC(2, 2);
+    });
+
+    const task1 = computed1();
+    const task2 = computed2();
+
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+
+    await nextTick();
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+
+    const result1 = task1.run();
+
+    computed1();
+    computed2();
+
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(undefined);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+
+    computed1();
+    computed2();
+
+    expect(await result1).toBe(3);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(3);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    computed1();
+    computed2();
+
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+
+    const result2 = task2.run();
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(undefined);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(3);
+    expect(getC.withParams(1, 2)).toHaveCounts({ compute: 1 });
+    expect(getC.withParams(2, 2)).toHaveCounts({ compute: 1 });
+
+    computed1();
+    computed2();
+
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+
+    expect(await result2).toBe(4);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(3);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(4);
+    expect(getC.withParams(1, 2)).toHaveCounts({ compute: 1 });
+    expect(getC.withParams(2, 2)).toHaveCounts({ compute: 1 });
+
+    computed1();
+    computed2();
+
+    expect(computed1).toHaveCounts({ compute: 1 });
+    expect(computed2).toHaveCounts({ compute: 1 });
+  });
+
+  test('Basic async task works with run args', async () => {
+    const getC = reactive((a: number, b: number) => {
+      return task(async (c: number, d: number) => {
+        return a + b + c + d;
+      });
+    });
+
+    // First set of args
+    const task1 = getC(1, 2);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+
+    await nextTick();
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+
+    const result1 = task1.run(3, 4);
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(undefined);
+
+    expect(await result1).toBe(10);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(10);
+
+    const result2 = task1.run(5, 6);
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(10);
+
+    expect(await result2).toBe(14);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(14);
+
+    // Second set of args
+    const task2 = getC(2, 2);
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    await nextTick();
+    expect(task2.isPending).toBe(false);
+    expect(task2.value).toBe(undefined);
+
+    const result3 = task2.run(7, 8);
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(undefined);
+
+    expect(await result3).toBe(19);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(19);
+
+    const result4 = task2.run(9, 10);
+    expect(task2.isPending).toBe(true);
+    expect(task2.value).toBe(19);
+
+    expect(await result4).toBe(23);
+    expect(task2.isResolved).toBe(true);
+    expect(task2.value).toBe(23);
+  });
+
+  test('Task can be defined with rest params', async () => {
+    const getC = reactive((...outerNums: number[]) => {
+      return task(async (...nums: number[]) => {
+        return [...outerNums, ...nums].reduce((acc, num) => acc + num, 0);
+      });
+    });
+
+    // First set of args
+    const task1 = getC(1, 2);
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+
+    await nextTick();
+    expect(task1.isPending).toBe(false);
+    expect(task1.value).toBe(undefined);
+
+    const result1 = task1.run(3, 4);
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(undefined);
+
+    expect(await result1).toBe(10);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(10);
+
+    const result2 = task1.run(5, 6, 7);
+    expect(task1.isPending).toBe(true);
+    expect(task1.value).toBe(10);
+
+    expect(await result2).toBe(21);
+    expect(task1.isResolved).toBe(true);
+    expect(task1.value).toBe(21);
+  });
+
+  test('Async task handles errors', async () => {
+    const getC = reactive((shouldError: boolean) => {
+      return task(async () => {
+        if (shouldError) {
+          throw new Error('Test error');
+        }
+        return 'success';
+      });
+    });
+
+    const result1 = getC(false);
+    await expect(result1.run()).resolves.toBe('success');
+    expect(result1.isPending).toBe(false);
+    expect(result1.value).toBe('success');
+    // await nextTick();
+    // expect(result1.isResolved).toBe(true);
+    // expect(result1.value).toBe('success');
+
+    // const result2 = getC(true);
+    // await expect(result2.run()).rejects.toThrow('Test error');
+    // await nextTick();
+    // expect(result2.isRejected).toBe(true);
+    // expect(result2.error).toBeInstanceOf(Error);
+    // expect((result2.error as Error).message).toBe('Test error');
+  });
+});