@daiso-tech/core 0.26.1 → 0.28.0

package/dist/lock/implementations/test-utilities/lock-provider.test-suite.js

@@ -5,46 +5,41 @@ import {} from "vitest";
 import { UnownedRefreshLockEvent, KeyForceReleasedLockEvent, KeyAlreadyAcquiredLockEvent, UnownedReleaseLockEvent, KeyReleasedLockEvent, KeyAcquiredLockEvent, KeyAlreadyAcquiredLockError, UnownedRefreshLockError, UnownedReleaseLockError, KeyRefreshedLockEvent, } from "../../../lock/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
 import { TimeSpan } from "../../../utilities/_module-exports.js";
-import { delay, LazyPromise } from "../../../async/_module-exports.js";
+import { LazyPromise } from "../../../async/_module-exports.js";
 import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_module-exports.js";
 import { Serde } from "../../../serde/implementations/derivables/_module-exports.js";
 /**
  * The <i>lockProviderTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ILock}</i> with <i>vitest</i>.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/test-utilities"```
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/test-utilities"```
  * @group Utilities
  * @example
  * ```ts
- * import { beforeEach, describe, expect, test } from "vitest";
- * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
- * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
- * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
- * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
- * import { lockProviderTestSuite } from "@daiso-tech/core/lock/implementations/test-utilities";
- * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
- * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+ * import { describe, expect, test } from "vitest";
+ * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+ * import { LockProvider } from "@daiso-tech/core/lock";
+ * import { EventBus } from "@daiso-tech/core/event-bus";
+ * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+ * import { lockProviderTestSuite } from "@daiso-tech/core/lock/test-utilities";
+ * import { Serde } from "@daiso-tech/core/serde";
+ * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
  * import type { ILockData } from "@daiso-tech/core/lock/contracts";
+ * import { KeyPrefixer } from "@daiso-tech/core/utilities";
  *
  * describe("class: LockProvider", () => {
  *     const eventBus = new EventBus({
- *         adapter: new MemoryEventBusAdapter({
- *             rootGroup: "@global",
- *         }),
+ *         keyPrefixer: new KeyPrefixer("event-bus"),
+ *         adapter: new MemoryEventBusAdapter(),
  *     });
  *     const serde = new Serde(new SuperJsonSerdeAdapter());
  *     let map: Map<string, ILockData>;
- *     beforeEach(() => {
- *         map = new Map();
- *     });
  *     lockProviderTestSuite({
  *         createLockProvider: () => {
  *             const lockProvider = new LockProvider({
  *                 serde,
- *                 adapter: new MemoryLockAdapter({
- *                     rootGroup: "@a",
- *                     map,
- *                 }),
+ *                 adapter: new MemoryLockAdapter(),
  *                 eventBus,
+ *                 keyPrefixer: new KeyPrefixer("lock"),
  *             });
  *             return lockProvider;
  *         },
@@ -67,6 +62,7 @@ export function lockProviderTestSuite(settings) {
         lockProviderB = lockProvider.withGroup("b");
     });
     const TTL = TimeSpan.fromMilliseconds(50);
+    const DELAY_TIME = TimeSpan.fromMilliseconds(50);
     describe("Api tests:", () => {
         describe("method: run", () => {
             test("Should return string when lock is available", async () => {
@@ -76,7 +72,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const [result, error] = await lock.run(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 });
                 expect(result).toBe("a");
@@ -90,7 +86,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 const [result, error] = await lock.run(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 });
                 expect(result).toBeNull();
@@ -103,7 +99,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const [result, error] = await lock.run(new LazyPromise(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 }));
                 expect(result).toBe("a");
@@ -118,7 +114,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const result = await lock.runOrFail(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 });
                 expect(result).toBe("a");
@@ -131,7 +127,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 const result = lock.runOrFail(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 });
                 await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
@@ -143,7 +139,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const result = await lock.runOrFail(new LazyPromise(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 }));
                 expect(result).toBe("a");
@@ -157,7 +153,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const [result, error] = await lock.runBlocking(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 }, {
                     time: TimeSpan.fromMilliseconds(5),
@@ -174,7 +170,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 const [result, error] = await lock.runBlocking(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 }, {
                     time: TimeSpan.fromMilliseconds(5),
@@ -190,7 +186,7 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 const [result, error] = await lock.runBlocking(new LazyPromise(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     return "a";
                 }), {
                     time: TimeSpan.fromMilliseconds(5),
@@ -211,7 +207,7 @@ export function lockProviderTestSuite(settings) {
                     index++;
                 });
                 await lock.runBlocking(async () => {
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                 }, {
                     time: TimeSpan.fromMilliseconds(55),
                     interval: TimeSpan.fromMilliseconds(5),
@@ -219,6 +215,78 @@ export function lockProviderTestSuite(settings) {
                 expect(index).toBeGreaterThan(1);
             });
         });
+        describe("method: runBlockingOrFail", () => {
+            test("Should return string when lock is available", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const result = await lock.runBlockingOrFail(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe("a");
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                const promise = lock.runBlockingOrFail(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should work with LazyPromise", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const result = await lock.runBlockingOrFail(new LazyPromise(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }), {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe("a");
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                let index = 0;
+                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                    index++;
+                });
+                try {
+                    await lock.runBlockingOrFail(async () => {
+                        await LazyPromise.delay(DELAY_TIME);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* Empty */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
         describe("method: acquire", () => {
             test("Should return true when lock is available", async () => {
                 const key = "a";
@@ -305,12 +373,12 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 expect(result).toBe(false);
             });
@@ -323,8 +391,8 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.isExpired();
                 expect(result).toBe(false);
@@ -338,8 +406,8 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.isLocked();
                 expect(result).toBe(true);
@@ -362,6 +430,88 @@ export function lockProviderTestSuite(settings) {
                 expect(index).toBeGreaterThan(1);
             });
         });
+        describe("method: acquireBlockingOrFail", () => {
+            test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const promise = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).resolves.toBeUndefined();
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const promise = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should not be expired when released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const result = await lock.isExpired();
+                expect(result).toBe(false);
+            });
+            test("Should be loked when released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const result = await lock.isLocked();
+                expect(result).toBe(true);
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                let index = 0;
+                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                    index++;
+                });
+                try {
+                    await lock.acquireBlockingOrFail({
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* Empty */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
         describe("method: release", () => {
             test("Should return true when released by same owner", async () => {
                 const key = "a";
@@ -556,7 +706,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquire();
-                await delay(ttl.addMilliseconds(25));
+                await LazyPromise.delay(ttl.addMilliseconds(25));
                 const result = await lock.isExpired();
                 expect(result).toBe(true);
             });
@@ -595,7 +745,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquire();
-                await delay(ttl.addMilliseconds(25));
+                await LazyPromise.delay(ttl.addMilliseconds(25));
                 const result = await lock.isLocked();
                 expect(result).toBe(false);
             });
@@ -610,7 +760,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquire();
-                await delay(ttl);
+                await LazyPromise.delay(ttl);
                 const result = await lock.refresh();
                 expect(result).toBe(true);
             });
@@ -640,7 +790,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquire();
-                await delay(ttl.subtractMilliseconds(10));
+                await LazyPromise.delay(ttl.subtractMilliseconds(10));
                 await lock.refresh();
                 const time = await lock.getRemainingTime();
                 expect(time?.toMilliseconds()).toBeGreaterThan(0);
@@ -656,7 +806,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquire();
-                await delay(ttl);
+                await LazyPromise.delay(ttl);
                 const result = lock.refreshOrFail();
                 await expect(result).resolves.toBeUndefined();
             });
@@ -686,7 +836,7 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquireOrFail();
-                await delay(ttl.subtractMilliseconds(10));
+                await LazyPromise.delay(ttl.subtractMilliseconds(10));
                 await lock.refresh();
                 const time = await lock.getRemainingTime();
                 expect(time?.toMilliseconds()).toBeGreaterThan(0);
@@ -763,9 +913,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -783,9 +933,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -802,9 +952,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -823,12 +973,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -846,12 +996,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -868,12 +1018,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -892,9 +1042,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -912,9 +1062,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -932,9 +1082,9 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.runOrFail(async () => {
-                            await delay(TTL);
+                            await LazyPromise.delay(DELAY_TIME);
                         });
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -957,7 +1107,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -975,7 +1125,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -997,7 +1147,7 @@ export function lockProviderTestSuite(settings) {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1021,7 +1171,7 @@ export function lockProviderTestSuite(settings) {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1040,7 +1190,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1059,7 +1209,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.acquireOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1082,7 +1232,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.release();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1103,7 +1253,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock2.release();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner2);
                     await unsubscribe();
@@ -1122,7 +1272,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1144,7 +1294,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock2.releaseOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1171,7 +1321,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock2.forceRelease();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     await unsubscribe();
                 });
@@ -1189,10 +1339,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refresh(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
@@ -1214,10 +1364,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock2.refresh(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner2);
                     await unsubscribe();
@@ -1236,10 +1386,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refreshOrFail(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
@@ -1261,11 +1411,11 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     try {
                         await lock2.refreshOrFail(newTTL);
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1290,9 +1440,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1310,9 +1460,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1329,9 +1479,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.run(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1350,12 +1500,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1373,12 +1523,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1395,12 +1545,12 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1419,9 +1569,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1439,9 +1589,9 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     });
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1459,9 +1609,9 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.runOrFail(async () => {
-                            await delay(TTL);
+                            await LazyPromise.delay(DELAY_TIME);
                         });
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1484,7 +1634,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1502,7 +1652,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1521,7 +1671,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1539,7 +1689,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquire();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1558,7 +1708,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe("a");
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
@@ -1577,7 +1727,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.acquireOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1600,7 +1750,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.release();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1621,7 +1771,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock2.release();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner2);
                     await unsubscribe();
@@ -1640,7 +1790,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     await unsubscribe();
@@ -1662,7 +1812,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock2.releaseOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1689,7 +1839,7 @@ export function lockProviderTestSuite(settings) {
                         event_ = event;
                     });
                     await lock2.forceRelease();
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     await unsubscribe();
                 });
@@ -1707,10 +1857,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lockProviderA.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refresh(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
@@ -1732,10 +1882,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock2.refresh(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner2);
                     await unsubscribe();
@@ -1754,10 +1904,10 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lockProviderA.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refreshOrFail(newTTL);
-                    await delay(TTL);
+                    await LazyPromise.delay(DELAY_TIME);
                     expect(event_?.fields.key).toBe(key);
                     expect(event_?.fields.owner).toBe(owner);
                     expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
@@ -1779,11 +1929,11 @@ export function lockProviderTestSuite(settings) {
                     const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
-                    await delay(TTL.divide(2));
+                    await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     try {
                         await lock2.refreshOrFail(newTTL);
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1803,7 +1953,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerA,
             });
             const promiseA = lockA.run(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             });
             const ownerB = "c";
@@ -1811,7 +1961,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerB,
             });
             const promiseB = lockB.run(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             });
             const [[resultA, errorA], [resultB, errorB]] = await Promise.all([
@@ -1830,7 +1980,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerA,
             });
             const promiseA = lockA.run(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             });
             const ownerB = "c";
@@ -1838,7 +1988,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerB,
             });
             const promiseB = lockB.runBlocking(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             }, {
                 time: TimeSpan.fromMilliseconds(5),
@@ -1860,7 +2010,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerA,
             });
             const promiseA = lockA.runOrFail(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             });
             const ownerB = "c";
@@ -1868,7 +2018,7 @@ export function lockProviderTestSuite(settings) {
                 owner: ownerB,
             });
             const promiseB = lockB.runOrFail(async () => {
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 return "a";
             });
             const [resultA, resultB] = await Promise.all([promiseA, promiseB]);
@@ -2013,9 +2163,9 @@ export function lockProviderTestSuite(settings) {
                 ttl,
             });
             await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await delay(ttl.divide(2));
+            await LazyPromise.delay(ttl.divide(2));
             await lockA.refresh();
-            await delay(ttl.divide(2));
+            await LazyPromise.delay(ttl.divide(2));
             const resultA = await lockA.isExpired();
             const resultB = await lockB.isExpired();
             expect(resultA).toBe(false);
@@ -2034,9 +2184,9 @@ export function lockProviderTestSuite(settings) {
                 ttl,
             });
             await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await delay(ttl.divide(2));
+            await LazyPromise.delay(ttl.divide(2));
             await lockA.refreshOrFail();
-            await delay(ttl.divide(2));
+            await LazyPromise.delay(ttl.divide(2));
             const resultA = await lockA.isExpired();
             const resultB = await lockB.isExpired();
             expect(resultA).toBe(false);
@@ -2056,7 +2206,7 @@ export function lockProviderTestSuite(settings) {
                     result_b = event;
                 });
                 await lockA.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2073,7 +2223,7 @@ export function lockProviderTestSuite(settings) {
                     result_b = event;
                 });
                 await lockA.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2093,7 +2243,7 @@ export function lockProviderTestSuite(settings) {
                 await lockB.removeListener(KeyAcquiredLockEvent, listenerB);
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2113,7 +2263,7 @@ export function lockProviderTestSuite(settings) {
                 await lockB.removeListenerMany([KeyAcquiredLockEvent], listenerB);
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2133,7 +2283,7 @@ export function lockProviderTestSuite(settings) {
                 await unsubscribe();
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2153,7 +2303,7 @@ export function lockProviderTestSuite(settings) {
                 await unsubscribe();
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2171,7 +2321,7 @@ export function lockProviderTestSuite(settings) {
                     result_b = event;
                 });
                 await lockA.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2187,7 +2337,7 @@ export function lockProviderTestSuite(settings) {
                     result_b = event;
                 });
                 await lockA.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2207,7 +2357,7 @@ export function lockProviderTestSuite(settings) {
                 await lockProviderB.removeListener(KeyAcquiredLockEvent, listenerB);
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2227,7 +2377,7 @@ export function lockProviderTestSuite(settings) {
                 await lockProviderB.removeListenerMany([KeyAcquiredLockEvent], listenerB);
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2247,7 +2397,7 @@ export function lockProviderTestSuite(settings) {
                 await unsubscribe();
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2267,7 +2417,7 @@ export function lockProviderTestSuite(settings) {
                 await unsubscribe();
                 await lockA.acquire();
                 await lockB.acquire();
-                await delay(TTL);
+                await LazyPromise.delay(DELAY_TIME);
                 expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
                 expect(result_b).toBeNull();
             });
@@ -2277,7 +2427,7 @@ export function lockProviderTestSuite(settings) {
         test("Should preserve state", async () => {
             const key = "a";
             const owner = "b";
-            const lock = lockProviderB.create(key, {
+            const lock = lockProviderA.create(key, {
                 owner,
             });
             await lock.acquire();
@@ -2288,7 +2438,7 @@ export function lockProviderTestSuite(settings) {
         test("Should preserve owner", async () => {
             const key = "a";
             const owner = "b";
-            const lock = lockProviderB.create(key, {
+            const lock = lockProviderA.create(key, {
                 owner,
             });
             const deserializedLock = serde.deserialize(serde.serialize(lock));
@@ -2298,16 +2448,16 @@ export function lockProviderTestSuite(settings) {
             const key = "a";
             const owner = "b";
             const ttl = TTL.multiply(2);
-            const lock = lockProviderB.create(key, {
+            const lock = lockProviderA.create(key, {
                 owner,
                 ttl,
             });
             await lock.acquire();
             const deserializedLock = serde.deserialize(serde.serialize(lock));
             const delayTime = TTL;
-            await delay(delayTime);
+            await LazyPromise.delay(delayTime);
             expect(await deserializedLock.isLocked()).toBe(true);
-            await delay(delayTime);
+            await LazyPromise.delay(delayTime);
             expect(await deserializedLock.isLocked()).toBe(false);
         });
     });