mirror of
https://github.com/immich-app/immich.git
synced 2025-12-22 15:17:05 -08:00
541 lines
16 KiB
TypeScript
541 lines
16 KiB
TypeScript
import { CancellableTask } from '$lib/utils/cancellable-task';
|
|
|
|
describe('CancellableTask', () => {
|
|
describe('execute', () => {
|
|
it('should execute task successfully and return LOADED', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async (_: AbortSignal) => {
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
});
|
|
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('LOADED');
|
|
expect(task.executed).toBe(true);
|
|
expect(task.loading).toBe(false);
|
|
expect(taskFn).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should call loadedCallback when task completes successfully', async () => {
|
|
const loadedCallback = vi.fn();
|
|
const task = new CancellableTask(loadedCallback);
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
|
|
expect(loadedCallback).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should return DONE if task is already executed', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('DONE');
|
|
expect(taskFn).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should wait if task is already running', async () => {
|
|
const task = new CancellableTask();
|
|
let resolveTask: () => void;
|
|
const taskPromise = new Promise<void>((resolve) => {
|
|
resolveTask = resolve;
|
|
});
|
|
const taskFn = vi.fn(async () => {
|
|
await taskPromise;
|
|
});
|
|
|
|
const promise1 = task.execute(taskFn, true);
|
|
const promise2 = task.execute(taskFn, true);
|
|
|
|
expect(task.loading).toBe(true);
|
|
resolveTask!();
|
|
|
|
const [result1, result2] = await Promise.all([promise1, promise2]);
|
|
|
|
expect(result1).toBe('LOADED');
|
|
expect(result2).toBe('WAITED');
|
|
expect(taskFn).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should pass AbortSignal to task function', async () => {
|
|
const task = new CancellableTask();
|
|
let capturedSignal: AbortSignal | null = null;
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
await Promise.resolve();
|
|
capturedSignal = signal;
|
|
};
|
|
|
|
await task.execute(taskFn, true);
|
|
|
|
expect(capturedSignal).toBeInstanceOf(AbortSignal);
|
|
});
|
|
|
|
it('should set cancellable flag correctly', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
expect(task.cancellable).toBe(true);
|
|
const promise = task.execute(taskFn, false);
|
|
expect(task.cancellable).toBe(false);
|
|
await promise;
|
|
});
|
|
|
|
it('should not allow transition from prevent cancel to allow cancel when task is running', async () => {
|
|
const task = new CancellableTask();
|
|
let resolveTask: () => void;
|
|
const taskPromise = new Promise<void>((resolve) => {
|
|
resolveTask = resolve;
|
|
});
|
|
const taskFn = vi.fn(async () => {
|
|
await taskPromise;
|
|
});
|
|
|
|
const promise1 = task.execute(taskFn, false);
|
|
expect(task.cancellable).toBe(false);
|
|
|
|
const promise2 = task.execute(taskFn, true);
|
|
expect(task.cancellable).toBe(false);
|
|
|
|
resolveTask!();
|
|
await Promise.all([promise1, promise2]);
|
|
});
|
|
});
|
|
|
|
describe('cancel', () => {
|
|
it('should cancel a running task', async () => {
|
|
const task = new CancellableTask();
|
|
let taskStarted = false;
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
taskStarted = true;
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
|
|
// Wait a bit to ensure task has started
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
expect(taskStarted).toBe(true);
|
|
|
|
task.cancel();
|
|
|
|
const result = await promise;
|
|
expect(result).toBe('CANCELED');
|
|
expect(task.executed).toBe(false);
|
|
});
|
|
|
|
it('should call canceledCallback when task is canceled', async () => {
|
|
const canceledCallback = vi.fn();
|
|
const task = new CancellableTask(undefined, canceledCallback);
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
task.cancel();
|
|
await promise;
|
|
|
|
expect(canceledCallback).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should not cancel if task is not cancellable', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
});
|
|
|
|
const promise = task.execute(taskFn, false);
|
|
task.cancel();
|
|
const result = await promise;
|
|
|
|
expect(result).toBe('LOADED');
|
|
expect(task.executed).toBe(true);
|
|
});
|
|
|
|
it('should not cancel if task is already executed', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
expect(task.executed).toBe(true);
|
|
|
|
task.cancel();
|
|
expect(task.executed).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('reset', () => {
|
|
it('should reset task to initial state', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
expect(task.executed).toBe(true);
|
|
|
|
await task.reset();
|
|
|
|
expect(task.executed).toBe(false);
|
|
expect(task.cancelToken).toBe(null);
|
|
expect(task.loading).toBe(false);
|
|
});
|
|
|
|
it('should cancel running task before resetting', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
|
|
const resetPromise = task.reset();
|
|
|
|
await promise;
|
|
await resetPromise;
|
|
|
|
expect(task.executed).toBe(false);
|
|
expect(task.loading).toBe(false);
|
|
});
|
|
|
|
it('should allow re-execution after reset', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
await task.reset();
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('LOADED');
|
|
expect(task.executed).toBe(true);
|
|
expect(taskFn).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe('waitUntilCompletion', () => {
|
|
it('should return DONE if task is already executed', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
const result = await task.waitUntilCompletion();
|
|
|
|
expect(result).toBe('DONE');
|
|
});
|
|
|
|
it('should return WAITED if task completes while waiting', async () => {
|
|
const task = new CancellableTask();
|
|
let resolveTask: () => void;
|
|
const taskPromise = new Promise<void>((resolve) => {
|
|
resolveTask = resolve;
|
|
});
|
|
const taskFn = async () => {
|
|
await taskPromise;
|
|
};
|
|
|
|
const executePromise = task.execute(taskFn, true);
|
|
const waitPromise = task.waitUntilCompletion();
|
|
|
|
resolveTask!();
|
|
|
|
const [, waitResult] = await Promise.all([executePromise, waitPromise]);
|
|
|
|
expect(waitResult).toBe('WAITED');
|
|
});
|
|
|
|
it('should return CANCELED if task is canceled', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const executePromise = task.execute(taskFn, true);
|
|
const waitPromise = task.waitUntilCompletion();
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
task.cancel();
|
|
|
|
const [, waitResult] = await Promise.all([executePromise, waitPromise]);
|
|
|
|
expect(waitResult).toBe('CANCELED');
|
|
});
|
|
});
|
|
|
|
describe('waitUntilExecution', () => {
|
|
it('should return DONE if task is already executed', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
await task.execute(taskFn, true);
|
|
const result = await task.waitUntilExecution();
|
|
|
|
expect(result).toBe('DONE');
|
|
});
|
|
|
|
it('should return WAITED if task completes successfully', async () => {
|
|
const task = new CancellableTask();
|
|
let resolveTask: () => void;
|
|
const taskPromise = new Promise<void>((resolve) => {
|
|
resolveTask = resolve;
|
|
});
|
|
const taskFn = async () => {
|
|
await taskPromise;
|
|
};
|
|
|
|
const executePromise = task.execute(taskFn, true);
|
|
const waitPromise = task.waitUntilExecution();
|
|
|
|
resolveTask!();
|
|
|
|
const [, waitResult] = await Promise.all([executePromise, waitPromise]);
|
|
|
|
expect(waitResult).toBe('WAITED');
|
|
});
|
|
|
|
it('should retry if task is canceled and wait for next execution', async () => {
|
|
vi.useFakeTimers();
|
|
|
|
const task = new CancellableTask();
|
|
let attempt = 0;
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
attempt++;
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted && attempt === 1) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
// Start first execution
|
|
const executePromise1 = task.execute(taskFn, true);
|
|
const waitPromise = task.waitUntilExecution();
|
|
|
|
// Cancel the first execution
|
|
vi.advanceTimersByTime(10);
|
|
task.cancel();
|
|
vi.advanceTimersByTime(100);
|
|
await executePromise1;
|
|
|
|
// Start second execution
|
|
const executePromise2 = task.execute(taskFn, true);
|
|
vi.advanceTimersByTime(100);
|
|
|
|
const [executeResult, waitResult] = await Promise.all([executePromise2, waitPromise]);
|
|
|
|
expect(executeResult).toBe('LOADED');
|
|
expect(waitResult).toBe('WAITED');
|
|
expect(attempt).toBe(2);
|
|
|
|
vi.useRealTimers();
|
|
});
|
|
});
|
|
|
|
describe('error handling', () => {
|
|
it('should return ERRORED when task throws non-abort error', async () => {
|
|
const task = new CancellableTask();
|
|
const error = new Error('Task failed');
|
|
const taskFn = async () => {
|
|
await Promise.resolve();
|
|
throw error;
|
|
};
|
|
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('ERRORED');
|
|
expect(task.executed).toBe(false);
|
|
});
|
|
|
|
it('should call errorCallback when task throws non-abort error', async () => {
|
|
const errorCallback = vi.fn();
|
|
const task = new CancellableTask(undefined, undefined, errorCallback);
|
|
const error = new Error('Task failed');
|
|
const taskFn = async () => {
|
|
await Promise.resolve();
|
|
throw error;
|
|
};
|
|
|
|
await task.execute(taskFn, true);
|
|
|
|
expect(errorCallback).toHaveBeenCalledTimes(1);
|
|
expect(errorCallback).toHaveBeenCalledWith(error);
|
|
});
|
|
|
|
it('should return CANCELED when task throws AbortError', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async () => {
|
|
await Promise.resolve();
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
};
|
|
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('CANCELED');
|
|
expect(task.executed).toBe(false);
|
|
});
|
|
|
|
it('should allow re-execution after error', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn1 = async () => {
|
|
await Promise.resolve();
|
|
throw new Error('Failed');
|
|
};
|
|
const taskFn2 = vi.fn(async () => {});
|
|
|
|
const result1 = await task.execute(taskFn1, true);
|
|
expect(result1).toBe('ERRORED');
|
|
|
|
const result2 = await task.execute(taskFn2, true);
|
|
expect(result2).toBe('LOADED');
|
|
expect(task.executed).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('loading property', () => {
|
|
it('should return true when task is running', async () => {
|
|
const task = new CancellableTask();
|
|
let resolveTask: () => void;
|
|
const taskPromise = new Promise<void>((resolve) => {
|
|
resolveTask = resolve;
|
|
});
|
|
const taskFn = async () => {
|
|
await taskPromise;
|
|
};
|
|
|
|
expect(task.loading).toBe(false);
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
expect(task.loading).toBe(true);
|
|
|
|
resolveTask!();
|
|
await promise;
|
|
|
|
expect(task.loading).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('complete promise', () => {
|
|
it('should resolve when task completes successfully', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = vi.fn(async () => {});
|
|
|
|
const completePromise = task.complete;
|
|
await task.execute(taskFn, true);
|
|
await expect(completePromise).resolves.toBeUndefined();
|
|
});
|
|
|
|
it('should reject when task is canceled', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const completePromise = task.complete;
|
|
const promise = task.execute(taskFn, true);
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
task.cancel();
|
|
await promise;
|
|
|
|
await expect(completePromise).rejects.toBeUndefined();
|
|
});
|
|
|
|
it('should reject when task errors', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async () => {
|
|
await Promise.resolve();
|
|
throw new Error('Failed');
|
|
};
|
|
|
|
const completePromise = task.complete;
|
|
await task.execute(taskFn, true);
|
|
|
|
await expect(completePromise).rejects.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('abort signal handling', () => {
|
|
it('should automatically call abort() on signal when task is canceled', async () => {
|
|
const task = new CancellableTask();
|
|
let capturedSignal: AbortSignal | null = null;
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
capturedSignal = signal;
|
|
// Simulate a long-running task
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
if (signal.aborted) {
|
|
throw new DOMException('Aborted', 'AbortError');
|
|
}
|
|
};
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
|
|
// Wait a bit to ensure task has started
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
|
|
expect(capturedSignal).not.toBeNull();
|
|
expect(capturedSignal!.aborted).toBe(false);
|
|
|
|
// Cancel the task
|
|
task.cancel();
|
|
|
|
// Verify the signal was aborted
|
|
expect(capturedSignal!.aborted).toBe(true);
|
|
|
|
const result = await promise;
|
|
expect(result).toBe('CANCELED');
|
|
});
|
|
|
|
it('should detect if signal was aborted after task completes', async () => {
|
|
const task = new CancellableTask();
|
|
let controller: AbortController | null = null;
|
|
const taskFn = async (_: AbortSignal) => {
|
|
// Capture the controller to abort it externally
|
|
controller = task.cancelToken;
|
|
// Simulate some work
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
// Now abort before the function returns
|
|
controller?.abort();
|
|
};
|
|
|
|
const result = await task.execute(taskFn, true);
|
|
|
|
expect(result).toBe('CANCELED');
|
|
expect(task.executed).toBe(false);
|
|
});
|
|
|
|
it('should handle abort signal in async operations', async () => {
|
|
const task = new CancellableTask();
|
|
const taskFn = async (signal: AbortSignal) => {
|
|
// Simulate listening to abort signal during async operation
|
|
return new Promise<void>((resolve, reject) => {
|
|
signal.addEventListener('abort', () => {
|
|
reject(new DOMException('Aborted', 'AbortError'));
|
|
});
|
|
setTimeout(() => resolve(), 100);
|
|
});
|
|
};
|
|
|
|
const promise = task.execute(taskFn, true);
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
task.cancel();
|
|
|
|
const result = await promise;
|
|
expect(result).toBe('CANCELED');
|
|
});
|
|
});
|
|
});
|