@daiso-tech/core 0.41.1 → 0.43.2

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

@@ -2,11 +2,12 @@
  * @module Semaphore
  */
 import { vi, } from "vitest";
-import { LimitReachedSemaphoreError, SEMAPHORE_EVENTS, FailedReleaseSemaphoreError, FailedRefreshSemaphoreError, SEMAPHORE_STATE, } from "../../../semaphore/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 { LimitReachedSemaphoreError, SEMAPHORE_EVENTS, FailedReleaseSemaphoreError, FailedRefreshSemaphoreError, SEMAPHORE_STATE, } from "../../../semaphore/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 `semaphoreProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ISemaphore | `ISemaphore`} 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 { MemorySemaphoreAdapter } from "@daiso-tech/core/semaphore/adapters";
+ * import { MemorySemaphoreAdapter } from "@daiso-tech/core/semaphore/memory-semaphore-adapter";
  * import { SemaphoreProvider } from "@daiso-tech/core/semaphore";
  * 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 { semaphoreProviderTestSuite } from "@daiso-tech/core/semaphore/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 { ISemaphoreData } from "@daiso-tech/core/semaphore/contracts";
  *
  * describe("class: SemaphoreProvider", () => {
@@ -58,667 +59,8 @@ export function semaphoreProviderTestSuite(settings) {
             serde = serde_;
         });
         describe("Api tests:", () => {
-            describe("method: run", () => {
-                test("Should call acquire method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
-                    await semaphore.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 limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
-                });
-                test("Should call release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.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 limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
-                    await semaphore.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 limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    try {
-                        await semaphore.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 limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = semaphore.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 limit = 1;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when slot is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should not call handler function when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphore.run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphore.run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(handlerFn);
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should return value when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return value when slot is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    await delay(ttl);
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock.acquire();
-                    const result = await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock.acquire();
-                    const result = await lock.run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .run(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should call acquireOrFail method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
-                    await semaphore.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireOrFailSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call acquireOrFail before release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireOrFailSpy).toHaveBeenCalledBefore(releaseSpy);
-                });
-                test("Should call release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call release after acquireOrFail method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
-                    await semaphore.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireOrFailSpy);
-                });
-                test("Should call release when an error is thrown", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(semaphore, "release");
-                    try {
-                        await semaphore.runOrFail(() => {
-                            return Promise.reject(new Error());
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should propagate thrown error", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = semaphore.runOrFail(() => {
-                        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 limit = 1;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when slot is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should not call handler function when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await semaphore.runOrFail(handlerFn);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore.acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await semaphore.runOrFail(handlerFn);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await semaphoreProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runOrFail(handlerFn);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should not call handler function when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await semaphoreProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runOrFail(handlerFn);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).not.toHaveBeenCalled();
-                });
-                test("Should return value when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toBe(RETURN_VALUE);
-                });
-                test("Should return value when slot is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    await delay(ttl);
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toBe(RETURN_VALUE);
-                });
-                test("Should throw LimitReachedSemaphoreError when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock.acquire();
-                    const result = lock.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                });
-                test("Should throw LimitReachedSemaphoreError when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock.acquire();
-                    const result = lock.runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                });
-                test("Should throw LimitReachedSemaphoreError when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const result = semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                });
-                test("Should throw LimitReachedSemaphoreError when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquire();
-                    const result = semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                });
-            });
-            describe("method: runBlocking", () => {
-                test("Should call acquire method", async () => {
+            describe("method: runOrFail", () => {
+                test("Should call acquireOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -726,16 +68,13 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
-                    await semaphore.runBlocking(() => {
+                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
+                    await semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
+                    expect(acquireOrFailSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call acquire before release method", async () => {
+                test("Should call acquireOrFail before release method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -743,15 +82,12 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
+                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
                     const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.runBlocking(() => {
+                    await semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
+                    expect(acquireOrFailSpy).toHaveBeenCalledBefore(releaseSpy);
                 });
                 test("Should call release method", async () => {
                     const key = "a";
@@ -762,15 +98,12 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(semaphore, "release");
-                    await semaphore.runBlocking(() => {
+                    await semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(releaseSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call release after acquire method", async () => {
+                test("Should call release after acquireOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -779,14 +112,11 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(semaphore, "release");
-                    const acquireSpy = vi.spyOn(semaphore, "acquire");
-                    await semaphore.runBlocking(() => {
+                    const acquireOrFailSpy = vi.spyOn(semaphore, "acquireOrFail");
+                    await semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
+                    expect(releaseSpy).toHaveBeenCalledAfter(acquireOrFailSpy);
                 });
                 test("Should call release when an error is thrown", async () => {
                     const key = "a";
@@ -798,11 +128,8 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                     const releaseSpy = vi.spyOn(semaphore, "release");
                     try {
-                        await semaphore.runBlocking(() => {
+                        await semaphore.runOrFail(() => {
                             return Promise.reject(new Error());
-                        }, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
                         });
                     }
                     catch {
@@ -820,11 +147,8 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                     class CustomError extends Error {
                     }
-                    const error = semaphore.runBlocking(() => {
+                    const error = semaphore.runOrFail(() => {
                         return Promise.reject(new CustomError());
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(error).rejects.toBeInstanceOf(CustomError);
                 });
@@ -840,10 +164,7 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                        .runOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should call handler function when slot is expired", async () => {
@@ -865,10 +186,7 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                        .runOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should not call handler function when slot is unexpireable", async () => {
@@ -883,10 +201,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphore.runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await semaphore.runOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpired", async () => {
@@ -901,10 +221,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphore.runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await semaphore.runOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpireable", async () => {
@@ -920,15 +242,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await semaphoreProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpired", async () => {
@@ -944,15 +268,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await semaphoreProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should return value when key doesnt exists", async () => {
@@ -964,13 +290,10 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runBlocking(() => {
+                        .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
                 test("Should return value when slot is expired", async () => {
                     const key = "a";
@@ -988,15 +311,12 @@ export function semaphoreProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runBlocking(() => {
+                        .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpireable", async () => {
+                test("Should throw LimitReachedSemaphoreError when slot is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -1005,18 +325,12 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     });
                     await lock.acquire();
-                    const result = await lock.runBlocking(() => {
+                    const result = lock.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpired", async () => {
+                test("Should throw LimitReachedSemaphoreError when slot is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
@@ -1025,18 +339,12 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     });
                     await lock.acquire();
-                    const result = await lock.runBlocking(() => {
+                    const result = lock.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpireable", async () => {
+                test("Should throw LimitReachedSemaphoreError when slot is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -1046,23 +354,17 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     })
                         .acquire();
-                    const result = await semaphoreProvider
+                    const result = semaphoreProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runBlocking(() => {
+                        .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedSemaphoreError> when slot is unexpired", async () => {
+                test("Should throw LimitReachedSemaphoreError when slot is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
@@ -1072,46 +374,15 @@ export function semaphoreProviderTestSuite(settings) {
                         limit,
                     })
                         .acquire();
-                    const result = await semaphoreProvider
+                    const result = semaphoreProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .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(LimitReachedSemaphoreError),
-                    }));
-                });
-                test("Should retry acquire the lock", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const lock1 = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock1.acquire();
-                    let index = 0;
-                    await semaphoreProvider.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
-                        index++;
-                    });
-                    const lock2 = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await lock2.runBlocking(() => {
+                        .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(index).toBeGreaterThan(1);
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
                 });
             });
             describe("method: runBlockingOrFail", () => {
@@ -3082,7 +2353,7 @@ export function semaphoreProviderTestSuite(settings) {
                 });
             });
             describe("method: getId", () => {
-                test("Should return semaphore id of ILock instance when given explicitly", () => {
+                test("Should return semaphore id of ISemaphore instance when given explicitly", () => {
                     const key = "a";
                     const limit = 2;
                     const slotId = "1";
@@ -3092,7 +2363,7 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                     expect(semaphore.id).toBe(slotId);
                 });
-                test("Should return semaphore id of ILock instance when given explicitly", () => {
+                test("Should return semaphore id of ISemaphore instance when given explicitly", () => {
                     const key = "a";
                     const limit = 2;
                     const semaphore = semaphoreProvider.create(key, {