@daiso-tech/core 0.26.0 → 0.27.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),
@@ -556,7 +552,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 +591,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 +606,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 +636,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 +652,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 +682,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 +759,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 +779,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 +798,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 +819,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 +842,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 +864,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 +888,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 +908,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 +928,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 +953,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 +971,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 +993,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 +1017,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 +1036,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 +1055,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.acquireOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1082,7 +1078,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 +1099,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 +1118,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 +1140,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock2.releaseOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1171,7 +1167,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 +1185,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 +1210,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 +1232,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 +1257,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 +1286,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 +1306,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 +1325,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 +1346,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 +1369,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 +1391,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 +1415,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 +1435,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 +1455,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 +1480,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 +1498,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 +1517,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 +1535,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 +1554,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 +1573,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock.acquireOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1600,7 +1596,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 +1617,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 +1636,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 +1658,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     try {
                         await lock2.releaseOrFail();
-                        await delay(TTL);
+                        await LazyPromise.delay(DELAY_TIME);
                     }
                     catch {
                         /* Empty */
@@ -1689,7 +1685,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 +1703,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 +1728,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 +1750,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 +1775,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 +1799,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 +1807,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 +1826,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 +1834,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 +1856,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 +1864,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 +2009,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 +2030,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 +2052,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 +2069,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 +2089,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 +2109,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 +2129,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 +2149,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 +2167,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 +2183,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 +2203,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 +2223,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 +2243,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 +2263,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 +2273,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 +2284,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 +2294,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);
         });
     });