From eaeb92c4dc1423bfd3b6b121084a6d59150cfb1a Mon Sep 17 00:00:00 2001
From: "Mr.Z" <zrd0921@qq.com>
Date: Mon, 18 Dec 2023 17:19:40 +0800
Subject: [PATCH] feat(test): add `Scheduler`

---
 packages/test/__tests__/scheduler.spec.ts | 104 ++++++++++++++++++++++
 packages/test/src/index.ts                |   3 +-
 packages/test/src/scheduler.ts            |  60 +++++++++++++
 3 files changed, 166 insertions(+), 1 deletion(-)
 create mode 100644 packages/test/__tests__/scheduler.spec.ts
 create mode 100644 packages/test/src/scheduler.ts

diff --git a/packages/test/__tests__/scheduler.spec.ts b/packages/test/__tests__/scheduler.spec.ts
new file mode 100644
index 0000000..f83c868
--- /dev/null
+++ b/packages/test/__tests__/scheduler.spec.ts
@@ -0,0 +1,104 @@
+import { Scheduler } from '@deot/dev-test';
+
+describe('scheduler.ts', () => {
+	it('next', async () => {
+		const scheduler = new Scheduler();
+		const next = vi.fn(scheduler.next);
+		const fail = vi.fn(scheduler.nextWithError);
+		setTimeout(next, 10);
+		await scheduler;
+
+		expect(next).toBeCalledTimes(1);
+		expect(fail).toBeCalledTimes(0);
+
+		setTimeout(next, 10);
+		await scheduler;
+		expect(next).toBeCalledTimes(2);
+		expect(fail).toBeCalledTimes(0);
+
+		try {
+			setTimeout(fail, 10);
+			await scheduler;
+		} catch {
+			expect(next).toBeCalledTimes(2);
+			expect(fail).toBeCalledTimes(1);
+		}
+	});
+
+	it('resolve', async () => {
+		expect.assertions(1);
+		const scheduler = new Scheduler();
+		const resolve = vi.fn(scheduler.finish);
+		setTimeout(resolve, 10);
+		await scheduler;
+
+		await scheduler.next();
+		await scheduler.nextWithError();
+		await scheduler;
+		await scheduler;
+		await scheduler;
+		await scheduler;
+
+		expect(resolve).toBeCalledTimes(1);
+	});
+
+	it('reject', async () => {
+		expect.assertions(4);
+		const scheduler = new Scheduler();
+		const reject = vi.fn(scheduler.finishWithError);
+		setTimeout(reject, 10);
+		try {
+			await scheduler;
+		} catch {
+			expect(reject).toBeCalledTimes(1);
+		}
+
+		try {
+			await scheduler;
+		} catch {
+			expect(reject).toBeCalledTimes(1);
+		}
+
+		try {
+			await scheduler.next();
+		} catch {
+			expect(reject).toBeCalledTimes(1);
+		}
+
+		try {
+			await scheduler.nextWithError();
+		} catch {
+			expect(reject).toBeCalledTimes(1);
+		}
+	});
+
+	it('catch', async () => {
+		expect.assertions(1);
+		const scheduler = new Scheduler();
+		const reject = vi.fn(scheduler.finishWithError);
+		setTimeout(reject, 10);
+
+		scheduler.catch(() => {
+			expect(reject).toBeCalledTimes(1);
+		});
+
+		try {
+			await scheduler;
+		} catch {
+			// any
+		}
+	});
+
+	it('finally', async () => {
+		expect.assertions(1);
+		const scheduler = new Scheduler();
+		const resolve = vi.fn(scheduler.finish);
+		setTimeout(resolve, 10);
+
+		scheduler.finally(() => {
+			expect(resolve).toBeCalledTimes(1);
+		});
+
+		await scheduler;
+	});
+});
diff --git a/packages/test/src/index.ts b/packages/test/src/index.ts
index ace85f4..5269627 100644
--- a/packages/test/src/index.ts
+++ b/packages/test/src/index.ts
@@ -5,9 +5,10 @@
 import { Command } from './command';
 import { Launch } from './launch';
 import { Operater } from './operater';
+import { Scheduler } from './scheduler';
 
 import * as E2E from './e2e';
 import * as Utils from './utils';
 import * as Server from './server';
 
-export { Command, E2E, Utils, Launch, Operater, Server };
+export { Command, E2E, Utils, Launch, Operater, Server, Scheduler };
diff --git a/packages/test/src/scheduler.ts b/packages/test/src/scheduler.ts
new file mode 100644
index 0000000..033f749
--- /dev/null
+++ b/packages/test/src/scheduler.ts
@@ -0,0 +1,60 @@
+type Func<T> = (_?: T) => void;
+
+export class Scheduler<T = any> {
+	_success?: Func<any>;
+	_fail?: Func<any>;
+	_task!: Promise<any>;
+	_finish = false;
+	constructor() {
+		this.next();
+	}
+
+	next = (v?: T) => {
+		if (!this._finish) {
+			this._success?.(v);
+			this._task = new Promise<T>((resolve, reject) => {
+				this._success = (value?: any) => {
+					this._fail = undefined;
+					resolve(value);
+				};
+				this._fail = (value?: any) => {
+					this._success = undefined;
+					reject(value);
+				};
+			});
+		}
+		return this;
+	};
+
+	nextWithError = (v?: any) => {
+		if (!this._finish) {
+			this._fail?.(v);
+			this.next();
+		}
+		return this;
+	};
+
+	finish = (v?: T) => {
+		this._success?.(v);
+		this._finish = true;
+		return this;
+	};
+
+	finishWithError = (v?: T) => {
+		this._fail?.(v);
+		this._finish = true;
+		return this;
+	};
+
+	then(resolve: Func<T>, reject: Func<T>) {
+		return this._task.then(resolve, reject);
+	}
+
+	catch(callback?: Func<T>) {
+		return this._task.catch(callback);
+	}
+
+	finally(callback?: Func<void>) {
+		return this._task.finally(callback);
+	}
+}