@daiso-tech/core 0.41.1 → 0.43.2

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

@@ -2,11 +2,12 @@
  * @module Lock
  */
 import { vi, } from "vitest";
-import { FailedAcquireLockError, FailedReleaseLockError, LOCK_EVENTS, FailedRefreshLockError, LOCK_STATE, } from "../../../lock/contracts/_module-exports.js";
-import { RESULT, resultSuccess, } from "../../../utilities/_module-exports.js";
-import { Task } from "../../../task/_module-exports.js";
-import { TimeSpan } from "../../../time-span/implementations/_module-exports.js";
-import { TO_MILLISECONDS } from "../../../time-span/contracts/_module-exports.js";
+import { FailedAcquireLockError, FailedReleaseLockError, LOCK_EVENTS, FailedRefreshLockError, LOCK_STATE, } from "../../../lock/contracts/_module.js";
+import {} from "../../../serde/contracts/_module.js";
+import { Task } from "../../../task/implementations/_module.js";
+import { TO_MILLISECONDS } from "../../../time-span/contracts/_module.js";
+import { TimeSpan } from "../../../time-span/implementations/_module.js";
+import {} from "../../../utilities/_module.js";
 /**
  * The `lockProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ILock | `ILock`} with `vitest`.
  *
@@ -15,13 +16,13 @@ import { TO_MILLISECONDS } from "../../../time-span/contracts/_module-exports.js
  * @example
  * ```ts
  * import { describe, expect, test, beforeEach } from "vitest";
- * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+ * import { MemoryLockAdapter } from "@daiso-tech/core/lock/memory-lock-adapter";
  * 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 { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/memory-event-bus-adapter";
  * 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 { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter";
  * import type { ILockData } from "@daiso-tech/core/lock/contracts";
  *
  * describe("class: LockProvider", () => {
@@ -58,234 +59,6 @@ export function lockProviderTestSuite(settings) {
             serde = serde_;
         });
         describe("Api tests:", () => {
-            describe("method: run", () => {
-                test("Should call acquire method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const acquireSpy = vi.spyOn(lock, "acquire");
-                    await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call acquire before release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const acquireSpy = vi.spyOn(lock, "acquire");
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
-                });
-                test("Should call release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call release after acquire method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    const acquireSpy = vi.spyOn(lock, "acquire");
-                    await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
-                });
-                test("Should call release when an error is thrown", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    try {
-                        await lock.run(() => {
-                            return Promise.reject(new Error());
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should propagate thrown error", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = lock.run(() => {
-                        return Promise.reject(new CustomError());
-                    });
-                    await expect(error).rejects.toBeInstanceOf(CustomError);
-                });
-                test("Should call handler function when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider
-                        .create(key, {
-                        ttl,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider.create(key, { ttl }).run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
-                    await lock.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lock.run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lock.run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider.create(key, { ttl }).run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider.create(key, { ttl }).run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should return ResultSuccess<string> when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const result = await lockProvider
-                        .create(key, {
-                        ttl,
-                    })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    await delay(ttl);
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is unexpireable and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
-                    await lock.acquire();
-                    const result = await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is unexpired and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const result = await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultFailure<FailedAcquireLockError> when key is unexpireable and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireLockError),
-                    }));
-                });
-                test("Should return ResultFailure<FailedAcquireLockError> when key is unexpired and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireLockError),
-                    }));
-                });
-            });
             describe("method: runOrFail", () => {
                 test("Should call acquireOrFail method", async () => {
                     const key = "a";
@@ -534,314 +307,6 @@ export function lockProviderTestSuite(settings) {
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
             });
-            describe("method: runBlocking", () => {
-                test("Should call acquireBlocking method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const acquireSpy = vi.spyOn(lock, "acquireBlocking");
-                    await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call acquireBlocking before release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const acquireSpy = vi.spyOn(lock, "acquireBlocking");
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
-                });
-                test("Should call release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call release after acquireBlocking method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    const acquireSpy = vi.spyOn(lock, "acquireBlocking");
-                    await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
-                });
-                test("Should call release when an error is thrown", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    const releaseSpy = vi.spyOn(lock, "release");
-                    try {
-                        await lock.runBlocking(() => {
-                            return Promise.reject(new Error());
-                        }, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should propagate thrown error", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = lock.runBlocking(() => {
-                        return Promise.reject(new CustomError());
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(error).rejects.toBeInstanceOf(CustomError);
-                });
-                test("Should call handler function when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider
-                        .create(key, {
-                        ttl,
-                    })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
-                    await lock.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lock.runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lock.runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should return ResultSuccess<string> when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const result = await lockProvider
-                        .create(key, {
-                        ttl,
-                    })
-                        .runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    await delay(ttl);
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is unexpireable and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
-                    await lock.acquire();
-                    const result = await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultSuccess<string> when key is unexpired and acquired by same lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const result = await lock.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultFailure<FailedAcquireLockError> when key is unexpireable and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireLockError),
-                    }));
-                });
-                test("Should return ResultFailure<FailedAcquireLockError> when key is unexpired and acquired by different lockId", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
-                        .create(key, { ttl })
-                        .runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireLockError),
-                    }));
-                });
-                test("Should retry acquire the lock", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock1.acquire();
-                    const handlerFn = vi.fn(() => { });
-                    await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const lock2 = lockProvider.create(key, {
-                        ttl,
-                    });
-                    await lock2.runBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
-                });
-            });
             describe("method: runBlockingOrFail", () => {
                 test("Should call acquireBlockingOrFail method", async () => {
                     const key = "a";