@daiso-tech/core 0.42.0 → 0.43.2

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

@@ -2,10 +2,11 @@
  * @module SharedLock
  */
 import { vi, } from "vitest";
-import { FailedAcquireWriterLockError, FailedRefreshReaderSemaphoreError, FailedRefreshWriterLockError, FailedReleaseReaderSemaphoreError, FailedReleaseWriterLockError, LimitReachedReaderSemaphoreError, SHARED_LOCK_EVENTS, SHARED_LOCK_STATE, } from "../../../shared-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 {} from "../../../serde/contracts/_module.js";
+import { FailedAcquireWriterLockError, FailedRefreshReaderSemaphoreError, FailedRefreshWriterLockError, FailedReleaseReaderSemaphoreError, FailedReleaseWriterLockError, LimitReachedReaderSemaphoreError, SHARED_LOCK_EVENTS, SHARED_LOCK_STATE, } from "../../../shared-lock/contracts/_module.js";
+import { Task } from "../../../task/implementations/_module.js";
+import { TimeSpan } from "../../../time-span/implementations/_module.js";
+import {} from "../../../utilities/_module.js";
 /**
  * The `sharedLockProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ISharedLock | `ISharedLock`} with `vitest`.
  *
@@ -57,76 +58,76 @@ export function sharedLockProviderTestSuite(settings) {
             serde = serde_;
         });
         describe("Api tests:", () => {
-            describe("method: runWriter", () => {
-                test("Should call acquire method", async () => {
+            describe("method: runWriterOrFail", () => {
+                test("Should call acquireReaderOrFail method", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriter");
-                    await sharedLock.runWriter(() => {
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
+                    await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(acquireSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call acquire before release method", async () => {
+                test("Should call acquireReaderOrFail before release method", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriter");
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriter(() => {
+                    await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
                 });
                 test("Should call release method", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriter(() => {
+                    await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(releaseSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call release after acquire method", async () => {
+                test("Should call release after acquireReaderOrFail method", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriter");
-                    await sharedLock.runWriter(() => {
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
+                    await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
                 });
                 test("Should call release when an error is thrown", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
                     try {
-                        await sharedLock.runWriter(() => {
+                        await sharedLock.runWriterOrFail(() => {
                             return Promise.reject(new Error());
                         });
                     }
@@ -137,15 +138,15 @@ export function sharedLockProviderTestSuite(settings) {
                 });
                 test("Should propagate thrown error", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     class CustomError extends Error {
                     }
-                    const error = sharedLock.runWriter(() => {
+                    const error = sharedLock.runWriterOrFail(() => {
                         return Promise.reject(new CustomError());
                     });
                     await expect(error).rejects.toBeInstanceOf(CustomError);
@@ -162,7 +163,7 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriter(handlerFn);
+                        .runWriterOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should call handler function when key is expired", {
@@ -186,7 +187,7 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriter(handlerFn);
+                        .runWriterOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
@@ -201,7 +202,12 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLock.runWriter(handlerFn);
+                    try {
+                        await sharedLock.runWriterOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
@@ -216,7 +222,12 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLock.runWriter(handlerFn);
+                    try {
+                        await sharedLock.runWriterOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
@@ -232,12 +243,17 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runWriter(handlerFn);
+                    try {
+                        await sharedLockProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runWriterOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
@@ -253,15 +269,20 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runWriter(handlerFn);
+                    try {
+                        await sharedLockProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runWriterOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
-                test("Should return ResultSuccess<string> when key doesnt exists", async () => {
+                test("Should return value when key doesnt exists", async () => {
                     const key = "a";
                     const limit = 4;
                     const ttl = null;
@@ -270,12 +291,12 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriter(() => {
+                        .runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return ResultSuccess<string> when key is expired", {
+                test("Should return value when key is expired", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
@@ -293,12 +314,12 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriter(() => {
+                        .runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return ResultSuccess<string> when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same lockId", async () => {
                     const key = "a";
                     const limit = 4;
                     const ttl = null;
@@ -307,12 +328,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriter(() => {
+                    const result = await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return ResultSuccess<string> when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same lockId", async () => {
                     const key = "a";
                     const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
@@ -321,12 +342,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriter(() => {
+                    const result = await sharedLock.runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return ResultFailure<FailedAcquireWriterLockError> when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different lockId", async () => {
                     const key = "a";
                     const limit = 4;
                     const ttl = null;
@@ -336,20 +357,17 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     })
                         .acquireWriter();
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runWriter(() => {
+                        .runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireWriterLockError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-                test("Should return ResultFailure<FailedAcquireWriterLockError> when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different lockId", async () => {
                     const key = "a";
                     const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
@@ -359,22 +377,19 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     })
                         .acquireWriter();
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runWriter(() => {
+                        .runWriterOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireWriterLockError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
             });
-            describe("method: runWriterOrFail", () => {
-                test("Should call acquireReaderOrFail method", async () => {
+            describe("method: runWriterBlockingOrFail", () => {
+                test("Should call acquireWriterBlockingOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -382,13 +397,16 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
-                    await sharedLock.runWriterOrFail(() => {
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
+                    await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(acquireSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call acquireReaderOrFail before release method", async () => {
+                test("Should call acquireWriterBlockingOrFail before release method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -396,10 +414,13 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterOrFail(() => {
+                    await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
                 });
@@ -412,12 +433,15 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterOrFail(() => {
+                    await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(releaseSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call release after acquireReaderOrFail method", async () => {
+                test("Should call release after acquireWriterBlockingOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -426,9 +450,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterOrFail");
-                    await sharedLock.runWriterOrFail(() => {
+                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
+                    await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
                 });
@@ -442,8 +469,11 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
                     try {
-                        await sharedLock.runWriterOrFail(() => {
+                        await sharedLock.runWriterBlockingOrFail(() => {
                             return Promise.reject(new Error());
+                        }, {
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
                         });
                     }
                     catch {
@@ -461,15 +491,18 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     class CustomError extends Error {
                     }
-                    const error = sharedLock.runWriterOrFail(() => {
+                    const error = sharedLock.runWriterBlockingOrFail(() => {
                         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 limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
@@ -478,15 +511,18 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(handlerFn);
+                        .runWriterBlockingOrFail(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 limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -502,13 +538,16 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(handlerFn);
+                        .runWriterBlockingOrFail(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 limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
@@ -518,7 +557,10 @@ export function sharedLockProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await sharedLock.runWriterOrFail(handlerFn);
+                        await sharedLock.runWriterBlockingOrFail(handlerFn, {
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
                     }
                     catch {
                         /* EMPTY */
@@ -527,8 +569,8 @@ export function sharedLockProviderTestSuite(settings) {
                 });
                 test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
@@ -538,7 +580,10 @@ export function sharedLockProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await sharedLock.runWriterOrFail(handlerFn);
+                        await sharedLock.runWriterBlockingOrFail(handlerFn, {
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
                     }
                     catch {
                         /* EMPTY */
@@ -547,8 +592,8 @@ export function sharedLockProviderTestSuite(settings) {
                 });
                 test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -564,7 +609,10 @@ export function sharedLockProviderTestSuite(settings) {
                             ttl,
                             limit,
                         })
-                            .runWriterOrFail(handlerFn);
+                            .runWriterBlockingOrFail(handlerFn, {
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
                     }
                     catch {
                         /* EMPTY */
@@ -573,8 +621,8 @@ export function sharedLockProviderTestSuite(settings) {
                 });
                 test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -590,7 +638,10 @@ export function sharedLockProviderTestSuite(settings) {
                             ttl,
                             limit,
                         })
-                            .runWriterOrFail(handlerFn);
+                            .runWriterBlockingOrFail(handlerFn, {
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
                     }
                     catch {
                         /* EMPTY */
@@ -599,15 +650,18 @@ export function sharedLockProviderTestSuite(settings) {
                 });
                 test("Should return value when key doesnt exists", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const result = await sharedLockProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(() => {
+                        .runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
@@ -615,8 +669,8 @@ export function sharedLockProviderTestSuite(settings) {
                     retry: 10,
                 }, async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -629,43 +683,52 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(() => {
+                        .runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should not throw error when key is unexpireable and acquired by same lockId", async () => {
+                test("Should return value when key is unexpireable and acquired by same lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterOrFail(() => {
+                    const result = await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should not throw error when key is unexpired and acquired by same lockId", async () => {
+                test("Should return value when key is unexpired and acquired by same lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterOrFail(() => {
+                    const result = await sharedLock.runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
                 test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -677,15 +740,18 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(() => {
+                        .runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
                 test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different lockId", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     await sharedLockProvider
                         .create(key, {
                         ttl,
@@ -697,831 +763,656 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runWriterOrFail(() => {
+                        .runWriterBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-            });
-            describe("method: runWriterBlocking", () => {
-                test("Should call acquireWriterBlocking method", async () => {
+                test("Should retry acquire the shared lock when blocked by a writer", async () => {
                     const key = "a";
-                    const ttl = null;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlocking");
-                    await sharedLock.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call acquireWriterBlocking before release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    await sharedLock1.acquireWriter();
+                    const handlerFn = vi.fn(() => { });
+                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlocking");
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterBlocking(() => {
-                        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 limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
+                    try {
+                        await sharedLock2.runWriterBlockingOrFail(() => {
+                            return Promise.resolve(RETURN_VALUE);
+                        }, {
+                            time: TimeSpan.fromMilliseconds(55),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
-                test("Should call release after acquireWriterBlocking method", async () => {
+                test("Should retry acquire the shared lock when blocked by a reader", async () => {
                     const key = "a";
-                    const ttl = null;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlocking");
-                    await sharedLock.runWriterBlocking(() => {
-                        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 limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    await sharedLock1.acquireReader();
+                    const handlerFn = vi.fn(() => { });
+                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
                     try {
-                        await sharedLock.runWriterBlocking(() => {
-                            return Promise.reject(new Error());
+                        await sharedLock2.runWriterBlockingOrFail(() => {
+                            return Promise.resolve(RETURN_VALUE);
                         }, {
-                            time: TimeSpan.fromMilliseconds(5),
+                            time: TimeSpan.fromMilliseconds(55),
                             interval: TimeSpan.fromMilliseconds(5),
                         });
                     }
                     catch {
                         /* EMPTY */
                     }
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should propagate thrown error", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = sharedLock.runWriterBlocking(() => {
-                        return Promise.reject(new CustomError());
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(error).rejects.toBeInstanceOf(CustomError);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
-                test("Should call handler function when key doesnt exists", async () => {
+            });
+            describe("method: acquireWriter", () => {
+                test("Should return true when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
+                    const result = await sharedLockProvider
                         .create(key, {
-                        ttl,
                         limit,
+                        ttl,
                     })
-                        .runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                        .acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should call handler function when key is expired", {
+                test("Should return true when key is expired", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
                         ttl,
-                        limit,
-                    })
-                        .runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    await sharedLock.acquireWriter();
+                    await delay(ttl);
+                    const result = await sharedLock.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
+                test("Should return true when key is unexpireable and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLock.runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    const result = await sharedLock.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
+                test("Should return true when key is unexpired and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLock.runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    const result = await sharedLock.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
+                test("Should return false when key is unexpireable and acquired by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLockProvider
-                        .create(key, {
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn).not.toHaveBeenCalled();
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
+                test("Should return false when key is unexpired and acquired by different owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        limit,
                         ttl,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
+                        ttl,
                     });
-                    await sharedLockProvider
-                        .create(key, {
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
+                });
+                test("Should return false when key is acquired as reader", async () => {
+                    const key = "a";
+                    const limit = 2;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
+                        limit,
+                        ttl,
+                    });
+                    await sharedLock.acquireReader();
+                    const result = await sharedLock.acquireWriter();
+                    expect(result).toBe(false);
+                });
+                test("Should not update state when key is acquired as reader", async () => {
+                    const key = "a";
+                    const limit = 3;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
+                        limit,
                         ttl,
+                    });
+                    await sharedLock.acquireReader();
+                    await sharedLock.acquireWriter();
+                    const state = await sharedLock.getState();
+                    expect(state).toEqual({
+                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
                         limit,
-                    })
-                        .runWriterBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                        remainingTime: null,
+                        freeSlotsCount: 2,
+                        acquiredSlotsCount: 1,
+                        acquiredSlots: [sharedLock.id],
                     });
-                    expect(handlerFn).not.toHaveBeenCalled();
                 });
-                test("Should return ResultSuccess<string> when key doesnt exists", async () => {
+            });
+            describe("method: acquireWriterOrFail", () => {
+                test("Should not throw error when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
-                        ttl,
                         limit,
+                        ttl,
                     })
-                        .runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                        .acquireWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return ResultSuccess<string> when key is expired", {
+                test("Should not throw error when key is expired", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    await delay(ttl);
-                    const result = await sharedLockProvider
-                        .create(key, {
                         ttl,
-                        limit,
-                    })
-                        .runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    await sharedLock.acquireWriterOrFail();
+                    await delay(ttl);
+                    const result = sharedLock.acquireWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return ResultSuccess<string> when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    await sharedLock.acquireWriterOrFail();
+                    const result = sharedLock.acquireWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return ResultSuccess<string> when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
+                    await sharedLock.acquireWriterOrFail();
+                    const result = sharedLock.acquireWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return ResultFailure<FailedAcquireWriterLockError> when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .acquireWriter();
-                    const result = await sharedLockProvider
-                        .create(key, {
+                    });
+                    await sharedLock1.acquireWriterOrFail();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireWriterLockError),
-                    }));
+                    const result = sharedLock2.acquireWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-                test("Should return ResultFailure<FailedAcquireWriterLockError> when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    const result = await sharedLockProvider
-                        .create(key, {
                         ttl,
+                    });
+                    await sharedLock1.acquireWriterOrFail();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                        ttl,
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(FailedAcquireWriterLockError),
-                    }));
+                    const result = sharedLock2.acquireWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-                test("Should retry acquire the shared lock when blocked by a writer", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is acquired as reader", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
+                    const limit = 2;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
+                    });
+                    await sharedLock.acquireReader();
+                    const result = sharedLock.acquireWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                });
+                test("Should not update state when key is acquired as reader", async () => {
+                    const key = "a";
+                    const limit = 3;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
+                        ttl,
                     });
-                    await sharedLock2.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
+                    await sharedLock.acquireReader();
+                    try {
+                        await sharedLock.acquireWriterOrFail();
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    const state = await sharedLock.getState();
+                    expect(state).toEqual({
+                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
+                        limit,
+                        remainingTime: null,
+                        freeSlotsCount: 2,
+                        acquiredSlotsCount: 1,
+                        acquiredSlots: [sharedLock.id],
                     });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
-                test("Should retry acquire the shared lock when blocked by a reader", async () => {
+            });
+            describe("method: acquireWriterBlocking", () => {
+                test("Should return true when key doesnt exists", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const ttl = null;
                     const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
+                    const result = await sharedLockProvider
+                        .create(key, {
                         limit,
-                    });
-                    await sharedLock1.acquireReader();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
-                        limit,
-                    });
-                    await sharedLock2.runWriterBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
+                    })
+                        .acquireWriterBlocking({
+                        time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
+                    expect(result).toBe(true);
                 });
-            });
-            describe("method: runWriterBlockingOrFail", () => {
-                test("Should call acquireWriterBlockingOrFail method", async () => {
+                test("Should return true when key is expired", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
                         limit,
+                        ttl,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
-                    await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    await sharedLock.acquireWriter();
+                    await delay(ttl);
+                    const result = await sharedLock.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
+                    expect(result).toBe(true);
                 });
-                test("Should call acquireWriterBlockingOrFail before release method", async () => {
+                test("Should return true when key is unexpireable and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    await sharedLock.acquireWriter();
+                    const result = await sharedLock.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
+                    expect(result).toBe(true);
                 });
-                test("Should call release method", async () => {
+                test("Should return true when key is unexpired and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    await sharedLock.acquireWriter();
+                    const result = await sharedLock.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
+                    expect(result).toBe(true);
                 });
-                test("Should call release after acquireWriterBlockingOrFail method", async () => {
+                test("Should return false when key is unexpireable and acquired by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireWriterBlockingOrFail");
-                    await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    const result = await sharedLock2.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
+                    expect(result).toBe(false);
                 });
-                test("Should call release when an error is thrown", async () => {
+                test("Should return false when key is unexpired and acquired by different owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        limit,
                         ttl,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         limit,
+                        ttl,
                     });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseWriter");
-                    try {
-                        await sharedLock.runWriterBlockingOrFail(() => {
-                            return Promise.reject(new Error());
-                        }, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
+                    const result = await sharedLock2.acquireWriterBlocking({
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                    expect(result).toBe(false);
                 });
-                test("Should propagate thrown error", async () => {
+                test("Should return false when key is acquired as reader", async () => {
                     const key = "a";
+                    const limit = 2;
                     const ttl = null;
-                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
                         limit,
+                        ttl,
                     });
-                    class CustomError extends Error {
-                    }
-                    const error = sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.reject(new CustomError());
-                    }, {
+                    await sharedLock.acquireReader();
+                    const result = await sharedLock.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await expect(error).rejects.toBeInstanceOf(CustomError);
+                    expect(result).toBe(false);
                 });
-                test("Should call handler function when key doesnt exists", async () => {
+                test("Should not update state when key is acquired as reader", async () => {
                     const key = "a";
+                    const limit = 3;
                     const ttl = null;
-                    const limit = 4;
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .runWriterBlockingOrFail(handlerFn, {
+                        ttl,
+                    });
+                    await sharedLock.acquireReader();
+                    await sharedLock.acquireWriterBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    const state = await sharedLock.getState();
+                    expect(state).toEqual({
+                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
+                        limit,
+                        remainingTime: null,
+                        freeSlotsCount: 2,
+                        acquiredSlotsCount: 1,
+                        acquiredSlots: [sharedLock.id],
+                    });
                 });
-                test("Should call handler function when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should retry acquire the shared lock when blocked by a writer", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireWriter();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .runWriterBlockingOrFail(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 limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    await sharedLock1.acquireWriter();
+                    const handlerFn = vi.fn(() => { });
+                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
+                    await sharedLock2.acquireWriterBlocking({
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    try {
-                        await sharedLock.runWriterBlockingOrFail(handlerFn, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
+                test("Should retry acquire the shared lock when blocked by a reader", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await sharedLock.runWriterBlockingOrFail(handlerFn, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    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;
-                    const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
+                    await sharedLock1.acquireReader();
+                    const handlerFn = vi.fn(() => { });
+                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
                     });
-                    try {
-                        await sharedLockProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runWriterBlockingOrFail(handlerFn, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    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);
-                    const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireWriter();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
+                    await sharedLock2.acquireWriterBlocking({
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    try {
-                        await sharedLockProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runWriterBlockingOrFail(handlerFn, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn).not.toHaveBeenCalled();
+                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
-                test("Should return value when key doesnt exists", async () => {
+            });
+            describe("method: acquireWriterBlockingOrFail", () => {
+                test("Should not throw error when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
-                        ttl,
                         limit,
+                        ttl,
                     })
-                        .runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                        .acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toBe(RETURN_VALUE);
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return value when key is expired", {
+                test("Should not throw error when key is expired", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    await delay(ttl);
-                    const result = await sharedLockProvider
-                        .create(key, {
                         ttl,
-                        limit,
-                    })
-                        .runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    });
+                    await sharedLock.acquireWriter();
+                    await delay(ttl);
+                    const result = sharedLock.acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toBe(RETURN_VALUE);
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return value when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = null;
                     const limit = 4;
+                    const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    const result = sharedLock.acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toBe(RETURN_VALUE);
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return value when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    const result = sharedLock.acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toBe(RETURN_VALUE);
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .acquireWriter();
-                    const result = sharedLockProvider
-                        .create(key, {
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                    });
+                    const result = sharedLock2.acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different owner", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .acquireWriter();
-                    const result = sharedLockProvider
-                        .create(key, {
                         ttl,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         limit,
-                    })
-                        .runWriterBlockingOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
+                        ttl,
+                    });
+                    const result = sharedLock2.acquireWriterBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
                 });
-                test("Should retry acquire the shared lock when blocked by a writer", async () => {
+                test("Should throw FailedAcquireWriterLockError when key is acquired as reader", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
+                    const limit = 2;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
                         limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
-                        limit,
                     });
-                    try {
-                        await sharedLock2.runWriterBlockingOrFail(() => {
-                            return Promise.resolve(RETURN_VALUE);
-                        }, {
-                            time: TimeSpan.fromMilliseconds(55),
+                    await sharedLock.acquireReader();
+                    const result = sharedLock.acquireWriterBlockingOrFail({
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                });
+                test("Should not update state when key is acquired as reader", async () => {
+                    const key = "a";
+                    const limit = 3;
+                    const ttl = null;
+                    const sharedLock = sharedLockProvider.create(key, {
+                        limit,
+                        ttl,
+                    });
+                    await sharedLock.acquireReader();
+                    try {
+                        await sharedLock.acquireWriterBlockingOrFail({
+                            time: TimeSpan.fromMilliseconds(5),
+                            interval: TimeSpan.fromMilliseconds(5),
+                        });
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    const state = await sharedLock.getState();
+                    expect(state).toEqual({
+                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
+                        limit,
+                        remainingTime: null,
+                        freeSlotsCount: 2,
+                        acquiredSlotsCount: 1,
+                        acquiredSlots: [sharedLock.id],
+                    });
+                });
+                test("Should retry acquire the shared lock when blocked by a writer", async () => {
+                    const key = "a";
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const handlerFn = vi.fn(() => { });
+                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    try {
+                        await sharedLock2.acquireWriterBlockingOrFail({
+                            time: TimeSpan.fromMilliseconds(55),
                             interval: TimeSpan.fromMilliseconds(5),
                         });
                     }
@@ -1546,9 +1437,7 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     try {
-                        await sharedLock2.runWriterBlockingOrFail(() => {
-                            return Promise.resolve(RETURN_VALUE);
-                        }, {
+                        await sharedLock2.acquireWriterBlockingOrFail({
                             time: TimeSpan.fromMilliseconds(55),
                             interval: TimeSpan.fromMilliseconds(5),
                         });
@@ -1559,59 +1448,109 @@ export function sharedLockProviderTestSuite(settings) {
                     expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
                 });
             });
-            describe("method: acquireWriter", () => {
-                test("Should return true when key doesnt exists", async () => {
+            describe("method: releaseWriter", () => {
+                test("Should return false when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const result = await sharedLockProvider
-                        .create(key, {
+                    const sharedLock = sharedLockProvider.create(key, {
+                        ttl,
                         limit,
+                    });
+                    const result = await sharedLock.releaseWriter();
+                    expect(result).toBe(false);
+                });
+                test("Should return false when key is unexpireable and released by different owner", async () => {
+                    const key = "a";
+                    const ttl = null;
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
-                    })
-                        .acquireWriter();
-                    expect(result).toBe(true);
+                        limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    const result = await sharedLock2.releaseWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should return true when key is expired", {
+                test("Should return false when key is unexpired and released by different owner", async () => {
+                    const key = "a";
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        limit,
+                        ttl,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        limit,
+                        ttl,
+                    });
+                    const result = await sharedLock2.releaseWriter();
+                    expect(result).toBe(false);
+                });
+                test("Should return false when key is expired and released by different owner", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    const result = await sharedLock2.releaseWriter();
+                    await delay(ttl);
+                    expect(result).toBe(false);
+                });
+                test("Should return false when key is expired and released by same owner", {
+                    retry: 10,
+                }, async () => {
+                    const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireWriter();
                     await delay(ttl);
-                    const result = await sharedLock.acquireWriter();
-                    expect(result).toBe(true);
+                    const result = await sharedLock.releaseWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should return true when key is unexpireable and acquired by same owner", async () => {
+                test("Should return true when key is unexpireable and released by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.acquireWriter();
+                    const result = await sharedLock.releaseWriter();
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is unexpired and acquired by same owner", async () => {
+                test("Should return true when key is unexpired and released by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.acquireWriter();
+                    const result = await sharedLock.releaseWriter();
                     expect(result).toBe(true);
                 });
-                test("Should return false when key is unexpireable and acquired by different owner", async () => {
+                test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -1624,35 +1563,71 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
+                    await sharedLock2.releaseWriter();
                     const result = await sharedLock2.acquireWriter();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpired and acquired by different owner", async () => {
+                test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
                         limit,
+                    });
+                    await sharedLock2.releaseWriter();
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
+                });
+                test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
+                    const key = "a";
+                    const ttl = null;
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
+                        limit,
                     });
                     await sharedLock1.acquireWriter();
+                    await sharedLock1.releaseWriter();
                     const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(true);
+                });
+                test("Should be reacquirable when key is unexpired and released by same owner", async () => {
+                    const key = "a";
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
                         limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    await sharedLock1.releaseWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
+                        limit,
                     });
                     const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
+                    expect(result).toBe(true);
                 });
                 test("Should return false when key is acquired as reader", async () => {
                     const key = "a";
                     const limit = 2;
-                    const ttl = null;
+                    const ttl = TimeSpan.fromSeconds(10);
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = await sharedLock.acquireWriter();
+                    const result = await sharedLock.releaseWriter();
                     expect(result).toBe(false);
                 });
                 test("Should not update state when key is acquired as reader", async () => {
@@ -1660,11 +1635,11 @@ export function sharedLockProviderTestSuite(settings) {
                     const limit = 3;
                     const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    await sharedLock.acquireWriter();
+                    await sharedLock.releaseWriter();
                     const state = await sharedLock.getState();
                     expect(state).toEqual({
                         type: SHARED_LOCK_STATE.READER_ACQUIRED,
@@ -1676,59 +1651,19 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                 });
             });
-            describe("method: acquireWriterOrFail", () => {
-                test("Should not throw error when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const result = sharedLockProvider
-                        .create(key, {
-                        limit,
-                        ttl,
-                    })
-                        .acquireWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should not throw error when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const limit = 4;
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const sharedLock = sharedLockProvider.create(key, {
-                        limit,
-                        ttl,
-                    });
-                    await sharedLock.acquireWriterOrFail();
-                    await delay(ttl);
-                    const result = sharedLock.acquireWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should not throw error when key is unexpireable and acquired by same owner", async () => {
+            describe("method: releaseWriterOrFail", () => {
+                test("Should throw FailedReleaseWriterLockError when key doesnt exists", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriterOrFail();
-                    const result = sharedLock.acquireWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should not throw error when key is unexpired and acquired by same owner", async () => {
-                    const key = "a";
                     const limit = 4;
-                    const ttl = TimeSpan.fromMilliseconds(50);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriterOrFail();
-                    const result = sharedLock.acquireWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
+                    const result = sharedLock.releaseWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different owner", async () => {
+                test("Should throw FailedReleaseWriterLockError when key is unexpireable and released by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -1736,133 +1671,133 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    await sharedLock1.acquireWriterOrFail();
+                    await sharedLock1.acquireWriter();
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = sharedLock2.acquireWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const result = sharedLock2.releaseWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different owner", async () => {
+                test("Should throw FailedReleaseWriterLockError when key is unexpired and released by different owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
                         limit,
                         ttl,
                     });
-                    await sharedLock1.acquireWriterOrFail();
+                    await sharedLock1.acquireWriter();
                     const sharedLock2 = sharedLockProvider.create(key, {
                         limit,
                         ttl,
                     });
-                    const result = sharedLock2.acquireWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const result = sharedLock2.releaseWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is acquired as reader", async () => {
+                test("Should throw FailedReleaseWriterLockError when key is expired and released by different owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
-                    const limit = 2;
-                    const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
                         limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
+                        limit,
                     });
-                    await sharedLock.acquireReader();
-                    const result = sharedLock.acquireWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const result = sharedLock2.releaseWriterOrFail();
+                    await delay(ttl);
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
-                test("Should not update state when key is acquired as reader", async () => {
+                test("Should throw FailedReleaseWriterLockError when key is expired and released by same owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
-                    const limit = 3;
-                    const ttl = null;
+                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
-                    });
-                    await sharedLock.acquireReader();
-                    try {
-                        await sharedLock.acquireWriterOrFail();
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    const state = await sharedLock.getState();
-                    expect(state).toEqual({
-                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
                         limit,
-                        remainingTime: null,
-                        freeSlotsCount: 2,
-                        acquiredSlotsCount: 1,
-                        acquiredSlots: [sharedLock.id],
                     });
+                    await sharedLock.acquireWriter();
+                    await delay(ttl);
+                    const result = sharedLock.releaseWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
-            });
-            describe("method: acquireWriterBlocking", () => {
-                test("Should return true when key doesnt exists", async () => {
+                test("Should not throw error when key is unexpireable and released by same owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
-                    const result = await sharedLockProvider
-                        .create(key, {
-                        limit,
+                    const sharedLock = sharedLockProvider.create(key, {
                         ttl,
-                    })
-                        .acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                        limit,
                     });
-                    expect(result).toBe(true);
+                    await sharedLock.acquireWriter();
+                    const result = sharedLock.releaseWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return true when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should not throw error when key is unexpired and released by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireWriter();
-                    await delay(ttl);
-                    const result = await sharedLock.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toBe(true);
+                    const result = sharedLock.releaseWriterOrFail();
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should return true when key is unexpireable and acquired by same owner", async () => {
+                test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
                     });
-                    expect(result).toBe(true);
+                    try {
+                        await sharedLock2.releaseWriterOrFail();
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should return true when key is unexpired and acquired by same owner", async () => {
+                test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const limit = 4;
+                    const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                    await sharedLock1.acquireWriter();
+                    const sharedLock2 = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
                     });
-                    expect(result).toBe(true);
+                    try {
+                        await sharedLock2.releaseWriterOrFail();
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpireable and acquired by different owner", async () => {
+                test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -1871,63 +1806,58 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    await sharedLock1.releaseWriterOrFail();
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = await sharedLock2.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toBe(false);
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should return false when key is unexpired and acquired by different owner", async () => {
+                test("Should be reacquirable when key is unexpired and released by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock1.acquireWriter();
+                    await sharedLock1.releaseWriterOrFail();
                     const sharedLock2 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
-                    const result = await sharedLock2.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toBe(false);
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should return false when key is acquired as reader", async () => {
+                test("Should throw FailedReleaseWriterLockError when key is acquired as reader", async () => {
                     const key = "a";
                     const limit = 2;
-                    const ttl = null;
+                    const ttl = TimeSpan.fromSeconds(10);
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = await sharedLock.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toBe(false);
+                    const result = sharedLock.releaseWriterOrFail();
+                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
                 });
                 test("Should not update state when key is acquired as reader", async () => {
                     const key = "a";
                     const limit = 3;
                     const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    await sharedLock.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await sharedLock.releaseWriterOrFail();
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     const state = await sharedLock.getState();
                     expect(state).toEqual({
                         type: SHARED_LOCK_STATE.READER_ACQUIRED,
@@ -1938,28 +1868,38 @@ export function sharedLockProviderTestSuite(settings) {
                         acquiredSlots: [sharedLock.id],
                     });
                 });
-                test("Should retry acquire the shared lock when blocked by a writer", async () => {
+            });
+            describe("method: refreshWriter", () => {
+                test("Should return false when key doesnt exists", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
+                    const ttl = TimeSpan.fromMilliseconds(25);
+                    const limit = 4;
+                    const sharedLock = sharedLockProvider.create(key, {
+                        ttl,
+                        limit,
+                    });
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = await sharedLock.refreshWriter(newTtl);
+                    expect(result).toBe(false);
+                });
+                test("Should return false when key is unexpireable and refreshed by different owner", async () => {
+                    const key = "a";
+                    const ttl = null;
                     const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock1.acquireWriter();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const newTtl = TimeSpan.fromMinutes(1);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock2.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
+                    const result = await sharedLock2.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
-                test("Should retry acquire the shared lock when blocked by a reader", async () => {
+                test("Should return false when key is unexpired and refreshed by different owner", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
@@ -1967,85 +1907,80 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    await sharedLock1.acquireReader();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMinutes(1);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock2.acquireWriterBlocking({
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
+                    const result = await sharedLock2.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
-            });
-            describe("method: acquireWriterBlockingOrFail", () => {
-                test("Should not throw error when key doesnt exists", async () => {
+                test("Should return false when key is expired and refreshed by different owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
-                    const ttl = null;
+                    const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
-                    const result = sharedLockProvider
-                        .create(key, {
+                    const sharedLock1 = sharedLockProvider.create(key, {
+                        ttl,
                         limit,
+                    });
+                    await sharedLock1.acquireWriter();
+                    await delay(ttl);
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
-                    })
-                        .acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
+                        limit,
                     });
-                    await expect(result).resolves.toBeUndefined();
+                    const result = await sharedLock2.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
-                test("Should not throw error when key is expired", {
+                test("Should return false when key is expired and refreshed by same owner", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireWriter();
                     await delay(ttl);
-                    const result = sharedLock.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).resolves.toBeUndefined();
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = await sharedLock.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
-                test("Should not throw error when key is unexpireable and acquired by same owner", async () => {
+                test("Should return false when key is unexpireable and refreshed by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = null;
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = sharedLock.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).resolves.toBeUndefined();
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = await sharedLock.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
-                test("Should not throw error when key is unexpired and acquired by same owner", async () => {
+                test("Should return true when key is unexpired and refreshed by same owner", async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = sharedLock.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).resolves.toBeUndefined();
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = await sharedLock.refreshWriter(newTtl);
+                    expect(result).toBe(true);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpireable and acquired by different owner", async () => {
+                test("Should not update expiration when key is unexpireable and refreshed by same owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2054,68 +1989,64 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMilliseconds(50);
+                    await sharedLock1.refreshWriter(newTtl);
+                    await delay(newTtl);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = sharedLock2.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is unexpired and acquired by different owner", async () => {
+                test("Should update expiration when key is unexpired and refreshed by same owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
-                    const limit = 4;
                     const ttl = TimeSpan.fromMilliseconds(50);
+                    const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMilliseconds(100);
+                    await sharedLock1.refreshWriter(newTtl);
+                    await delay(newTtl.divide(2));
                     const sharedLock2 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
-                    const result = sharedLock2.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const result1 = await sharedLock2.acquireWriter();
+                    expect(result1).toBe(false);
+                    await delay(newTtl.divide(2));
+                    const result2 = await sharedLock2.acquireWriter();
+                    expect(result2).toBe(true);
                 });
-                test("Should throw FailedAcquireWriterLockError when key is acquired as reader", async () => {
+                test("Should return false when key is acquired as reader", async () => {
                     const key = "a";
                     const limit = 2;
-                    const ttl = null;
+                    const ttl = TimeSpan.fromSeconds(10);
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = sharedLock.acquireWriterBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await expect(result).rejects.toBeInstanceOf(FailedAcquireWriterLockError);
+                    const newTtl = TimeSpan.fromSeconds(20);
+                    const result = await sharedLock.refreshWriter(newTtl);
+                    expect(result).toBe(false);
                 });
                 test("Should not update state when key is acquired as reader", async () => {
                     const key = "a";
                     const limit = 3;
                     const ttl = null;
                     const sharedLock = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock.acquireReader();
-                    try {
-                        await sharedLock.acquireWriterBlockingOrFail({
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
+                    const newTtl = TimeSpan.fromSeconds(20);
+                    await sharedLock.refreshWriter(newTtl);
                     const state = await sharedLock.getState();
                     expect(state).toEqual({
                         type: SHARED_LOCK_STATE.READER_ACQUIRED,
@@ -2126,72 +2057,21 @@ export function sharedLockProviderTestSuite(settings) {
                         acquiredSlots: [sharedLock.id],
                     });
                 });
-                test("Should retry acquire the shared lock when blocked by a writer", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    try {
-                        await sharedLock2.acquireWriterBlockingOrFail({
-                            time: TimeSpan.fromMilliseconds(55),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
-                });
-                test("Should retry acquire the shared lock when blocked by a reader", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireReader();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    try {
-                        await sharedLock2.acquireWriterBlockingOrFail({
-                            time: TimeSpan.fromMilliseconds(55),
-                            interval: TimeSpan.fromMilliseconds(5),
-                        });
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
-                });
             });
-            describe("method: releaseWriter", () => {
-                test("Should return false when key doesnt exists", async () => {
+            describe("method: refreshWriterOrFail", () => {
+                test("Should throw FailedRefreshWriterLockError when key doesnt exists", async () => {
                     const key = "a";
-                    const ttl = null;
+                    const ttl = TimeSpan.fromMilliseconds(25);
                     const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = await sharedLock.releaseWriter();
-                    expect(result).toBe(false);
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = sharedLock.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return false when key is unexpireable and released by different owner", async () => {
+                test("Should throw FailedRefreshWriterLockError when key is unexpireable and refreshed by different owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2200,30 +2080,32 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMinutes(1);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = await sharedLock2.releaseWriter();
-                    expect(result).toBe(false);
+                    const result = sharedLock2.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return false when key is unexpired and released by different owner", async () => {
+                test("Should throw FailedRefreshWriterLockError when key is unexpired and refreshed by different owner", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
                     const sharedLock1 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMinutes(1);
                     const sharedLock2 = sharedLockProvider.create(key, {
-                        limit,
                         ttl,
+                        limit,
                     });
-                    const result = await sharedLock2.releaseWriter();
-                    expect(result).toBe(false);
+                    const result = sharedLock2.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return false when key is expired and released by different owner", {
+                test("Should throw FailedRefreshWriterLockError when key is expired and refreshed by different owner", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
@@ -2234,15 +2116,16 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    await delay(ttl);
+                    const newTtl = TimeSpan.fromMinutes(1);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = await sharedLock2.releaseWriter();
-                    await delay(ttl);
-                    expect(result).toBe(false);
+                    const result = sharedLock2.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return false when key is expired and released by same owner", {
+                test("Should throw FailedRefreshWriterLockError when key is expired and refreshed by same owner", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
@@ -2254,10 +2137,11 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     await sharedLock.acquireWriter();
                     await delay(ttl);
-                    const result = await sharedLock.releaseWriter();
-                    expect(result).toBe(false);
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = sharedLock.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return true when key is unexpireable and released by same owner", async () => {
+                test("Should throw FailedRefreshWriterLockError when key is unexpireable and refreshed by same owner", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2266,10 +2150,11 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.releaseWriter();
-                    expect(result).toBe(true);
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = sharedLock.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
-                test("Should return true when key is unexpired and released by same owner", async () => {
+                test("Should not throw error when key is unexpired and refreshed by same owner", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
@@ -2278,10 +2163,13 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = await sharedLock.releaseWriter();
-                    expect(result).toBe(true);
+                    const newTtl = TimeSpan.fromMinutes(1);
+                    const result = sharedLock.refreshWriterOrFail(newTtl);
+                    await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
+                test("Should not update expiration when key is unexpireable and refreshed by same owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2290,15 +2178,24 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMilliseconds(50);
+                    try {
+                        await sharedLock1.refreshWriterOrFail(newTtl);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    await delay(newTtl);
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock2.releaseWriter();
                     const result = await sharedLock2.acquireWriter();
                     expect(result).toBe(false);
                 });
-                test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
+                test("Should update expiration when key is unexpired and refreshed by same owner", {
+                    retry: 10,
+                }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
@@ -2307,59 +2204,36 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
+                    const newTtl = TimeSpan.fromMilliseconds(100);
+                    try {
+                        await sharedLock1.refreshWriterOrFail(newTtl);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
+                    await delay(newTtl.divide(2));
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    await sharedLock2.releaseWriter();
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
+                    const result1 = await sharedLock2.acquireWriter();
+                    expect(result1).toBe(false);
+                    await delay(newTtl.divide(2));
+                    const result2 = await sharedLock2.acquireWriter();
+                    expect(result2).toBe(true);
                 });
-                test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
+                test("Should throw FailedRefreshWriterLockError when key is acquired as reader", async () => {
                     const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await sharedLock1.releaseWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should be reacquirable when key is unexpired and released by same owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await sharedLock1.releaseWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 2;
-                    const ttl = TimeSpan.fromSeconds(10);
-                    const sharedLock = sharedLockProvider.create(key, {
+                    const limit = 2;
+                    const ttl = TimeSpan.fromSeconds(10);
+                    const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = await sharedLock.releaseWriter();
-                    expect(result).toBe(false);
+                    const newTtl = TimeSpan.fromSeconds(20);
+                    const result = sharedLock.refreshWriterOrFail(newTtl);
+                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
                 });
                 test("Should not update state when key is acquired as reader", async () => {
                     const key = "a";
@@ -2370,7 +2244,13 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireReader();
-                    await sharedLock.releaseWriter();
+                    const newTtl = TimeSpan.fromSeconds(20);
+                    try {
+                        await sharedLock.refreshWriterOrFail(newTtl);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     const state = await sharedLock.getState();
                     expect(state).toEqual({
                         type: SHARED_LOCK_STATE.READER_ACQUIRED,
@@ -2382,8 +2262,8 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                 });
             });
-            describe("method: releaseWriterOrFail", () => {
-                test("Should throw FailedReleaseWriterLockError when key doesnt exists", async () => {
+            describe("method: forceReleaseWriter", () => {
+                test("Should return false when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2391,61 +2271,10 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const result = sharedLock.releaseWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
-                });
-                test("Should throw FailedReleaseWriterLockError when key is unexpireable and released by different owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = sharedLock2.releaseWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
-                });
-                test("Should throw FailedReleaseWriterLockError when key is unexpired and released by different owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        limit,
-                        ttl,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        limit,
-                        ttl,
-                    });
-                    const result = sharedLock2.releaseWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
-                });
-                test("Should throw FailedReleaseWriterLockError when key is expired and released by different owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = sharedLock2.releaseWriterOrFail();
-                    await delay(ttl);
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
+                    const result = await sharedLock.forceReleaseWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should throw FailedReleaseWriterLockError when key is expired and released by same owner", {
+                test("Should return false when key is expired", {
                     retry: 10,
                 }, async () => {
                     const key = "a";
@@ -2457,22 +2286,10 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     await sharedLock.acquireWriter();
                     await delay(ttl);
-                    const result = sharedLock.releaseWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
-                });
-                test("Should not throw error when key is unexpireable and released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const result = sharedLock.releaseWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
+                    const result = await sharedLock.forceReleaseWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should not throw error when key is unexpired and released by same owner", async () => {
+                test("Should return true when key is uenxpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 4;
@@ -2481,139 +2298,22 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireWriter();
-                    const result = sharedLock.releaseWriterOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    try {
-                        await sharedLock2.releaseWriterOrFail();
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    try {
-                        await sharedLock2.releaseWriterOrFail();
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await sharedLock1.releaseWriterOrFail();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should be reacquirable when key is unexpired and released by same owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await sharedLock1.releaseWriterOrFail();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
+                    const result = await sharedLock.forceReleaseWriter();
                     expect(result).toBe(true);
                 });
-                test("Should throw FailedReleaseWriterLockError when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 2;
-                    const ttl = TimeSpan.fromSeconds(10);
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const result = sharedLock.releaseWriterOrFail();
-                    await expect(result).rejects.toBeInstanceOf(FailedReleaseWriterLockError);
-                });
-                test("Should not update state when key is acquired as reader", async () => {
+                test("Should return true when key is unexpireable", async () => {
                     const key = "a";
-                    const limit = 3;
                     const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    try {
-                        await sharedLock.releaseWriterOrFail();
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    const state = await sharedLock.getState();
-                    expect(state).toEqual({
-                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
-                        limit,
-                        remainingTime: null,
-                        freeSlotsCount: 2,
-                        acquiredSlotsCount: 1,
-                        acquiredSlots: [sharedLock.id],
-                    });
-                });
-            });
-            describe("method: refreshWriter", () => {
-                test("Should return false when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(25);
                     const limit = 4;
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = await sharedLock.refreshWriter(newTtl);
-                    expect(result).toBe(false);
+                    await sharedLock.acquireWriter();
+                    const result = await sharedLock.forceReleaseWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should return false when key is unexpireable and refreshed by different owner", async () => {
+                test("Should be reacquirable when key is force released", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 4;
@@ -2622,1147 +2322,49 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
+                    await sharedLock1.forceReleaseWriter();
                     const sharedLock2 = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
-                    const result = await sharedLock2.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return false when key is unexpired and refreshed by different owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return false when key is expired and refreshed by different owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await delay(ttl);
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return false when key is expired and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    await delay(ttl);
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = await sharedLock.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return false when key is unexpireable and refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = await sharedLock.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return true when key is unexpired and refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = await sharedLock.refreshWriter(newTtl);
-                    expect(result).toBe(true);
-                });
-                test("Should not update expiration when key is unexpireable and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMilliseconds(50);
-                    await sharedLock1.refreshWriter(newTtl);
-                    await delay(newTtl);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should update expiration when key is unexpired and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMilliseconds(100);
-                    await sharedLock1.refreshWriter(newTtl);
-                    await delay(newTtl.divide(2));
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result1 = await sharedLock2.acquireWriter();
-                    expect(result1).toBe(false);
-                    await delay(newTtl.divide(2));
-                    const result2 = await sharedLock2.acquireWriter();
-                    expect(result2).toBe(true);
-                });
-                test("Should return false when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 2;
-                    const ttl = TimeSpan.fromSeconds(10);
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const newTtl = TimeSpan.fromSeconds(20);
-                    const result = await sharedLock.refreshWriter(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should not update state when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 3;
-                    const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const newTtl = TimeSpan.fromSeconds(20);
-                    await sharedLock.refreshWriter(newTtl);
-                    const state = await sharedLock.getState();
-                    expect(state).toEqual({
-                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
-                        limit,
-                        remainingTime: null,
-                        freeSlotsCount: 2,
-                        acquiredSlotsCount: 1,
-                        acquiredSlots: [sharedLock.id],
-                    });
-                });
-            });
-            describe("method: refreshWriterOrFail", () => {
-                test("Should throw FailedRefreshWriterLockError when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(25);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = sharedLock.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is unexpireable and refreshed by different owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = sharedLock2.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is unexpired and refreshed by different owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = sharedLock2.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is expired and refreshed by different owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await delay(ttl);
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = sharedLock2.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is expired and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    await delay(ttl);
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = sharedLock.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is unexpireable and refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = sharedLock.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should not throw error when key is unexpired and refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const newTtl = TimeSpan.fromMinutes(1);
-                    const result = sharedLock.refreshWriterOrFail(newTtl);
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should not update expiration when key is unexpireable and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMilliseconds(50);
-                    try {
-                        await sharedLock1.refreshWriterOrFail(newTtl);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    await delay(newTtl);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should update expiration when key is unexpired and refreshed by same owner", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const newTtl = TimeSpan.fromMilliseconds(100);
-                    try {
-                        await sharedLock1.refreshWriterOrFail(newTtl);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    await delay(newTtl.divide(2));
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result1 = await sharedLock2.acquireWriter();
-                    expect(result1).toBe(false);
-                    await delay(newTtl.divide(2));
-                    const result2 = await sharedLock2.acquireWriter();
-                    expect(result2).toBe(true);
-                });
-                test("Should throw FailedRefreshWriterLockError when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 2;
-                    const ttl = TimeSpan.fromSeconds(10);
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const newTtl = TimeSpan.fromSeconds(20);
-                    const result = sharedLock.refreshWriterOrFail(newTtl);
-                    await expect(result).rejects.toBeInstanceOf(FailedRefreshWriterLockError);
-                });
-                test("Should not update state when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 3;
-                    const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const newTtl = TimeSpan.fromSeconds(20);
-                    try {
-                        await sharedLock.refreshWriterOrFail(newTtl);
-                    }
-                    catch {
-                        /* EMPTY */
-                    }
-                    const state = await sharedLock.getState();
-                    expect(state).toEqual({
-                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
-                        limit,
-                        remainingTime: null,
-                        freeSlotsCount: 2,
-                        acquiredSlotsCount: 1,
-                        acquiredSlots: [sharedLock.id],
-                    });
-                });
-            });
-            describe("method: forceReleaseWriter", () => {
-                test("Should return false when key doesnt exists", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock.forceReleaseWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should return false when key is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    await delay(ttl);
-                    const result = await sharedLock.forceReleaseWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should return true when key is uenxpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.forceReleaseWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should return true when key is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireWriter();
-                    const result = await sharedLock.forceReleaseWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should be reacquirable when key is force released", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    await sharedLock1.forceReleaseWriter();
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const result = await sharedLock2.acquireWriter();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 2;
-                    const ttl = TimeSpan.fromSeconds(10);
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const result = await sharedLock.forceReleaseWriter();
-                    expect(result).toBe(false);
-                });
-                test("Should not update state when key is acquired as reader", async () => {
-                    const key = "a";
-                    const limit = 3;
-                    const ttl = null;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    await sharedLock.forceReleaseWriter();
-                    const state = await sharedLock.getState();
-                    expect(state).toEqual({
-                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
-                        limit,
-                        remainingTime: null,
-                        freeSlotsCount: 2,
-                        acquiredSlotsCount: 1,
-                        acquiredSlots: [sharedLock.id],
-                    });
-                });
-            });
-            describe("method: runReader", () => {
-                test("Should call acquire method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
-                    await sharedLock.runReader(() => {
-                        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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReader(() => {
-                        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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReader(() => {
-                        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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
-                    await sharedLock.runReader(() => {
-                        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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    try {
-                        await sharedLock.runReader(() => {
-                            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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = sharedLock.runReader(() => {
-                        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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when slot is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLock.runReader(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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLock.runReader(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return value when slot is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    await delay(ttl);
-                    const result = await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(resultSuccess(RETURN_VALUE));
-                });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const result = await sharedLock.runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const result = await sharedLock.runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const result = await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
-                });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const result = await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReader(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
-                });
-            });
-            describe("method: runReaderOrFail", () => {
-                test("Should call acquireReaderOrFail method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
-                    await sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireReaderOrFailSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call acquireReaderOrFail before release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(acquireReaderOrFailSpy).toHaveBeenCalledBefore(releaseSpy);
-                });
-                test("Should call release method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledTimes(1);
-                });
-                test("Should call release after acquireReaderOrFail method", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
-                    await sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireReaderOrFailSpy);
-                });
-                test("Should call release when an error is thrown", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    try {
-                        await sharedLock.runReaderOrFail(() => {
-                            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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    class CustomError extends Error {
-                    }
-                    const error = sharedLock.runReaderOrFail(() => {
-                        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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderOrFail(handlerFn);
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
-                });
-                test("Should call handler function when slot is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    await delay(ttl);
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderOrFail(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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await sharedLock.runReaderOrFail(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 sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await sharedLock.runReaderOrFail(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await sharedLockProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runReaderOrFail(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const handlerFn = vi.fn(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    try {
-                        await sharedLockProvider
-                            .create(key, {
-                            ttl,
-                            limit,
-                        })
-                            .runReaderOrFail(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 sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toBe(RETURN_VALUE);
-                });
-                test("Should return value when slot is expired", {
-                    retry: 10,
-                }, async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    await delay(ttl);
-                    const result = await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    expect(result).toBe(RETURN_VALUE);
-                });
-                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpireable", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const limit = 1;
-                    const sharedLock = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock.acquireReader();
-                    const result = sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
+                    const result = await sharedLock2.acquireWriter();
+                    expect(result).toBe(true);
                 });
-                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpired", async () => {
+                test("Should return false when key is acquired as reader", async () => {
                     const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
+                    const limit = 2;
+                    const ttl = TimeSpan.fromSeconds(10);
                     const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = sharedLock.runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
+                    const result = await sharedLock.forceReleaseWriter();
+                    expect(result).toBe(false);
                 });
-                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpireable", async () => {
+                test("Should not update state when key is acquired as reader", async () => {
                     const key = "a";
+                    const limit = 3;
                     const ttl = null;
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const result = sharedLockProvider
-                        .create(key, {
+                    const sharedLock = sharedLockProvider.create(key, {
                         ttl,
                         limit,
-                    })
-                        .runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
                     });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
-                });
-                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .acquireReader();
-                    const result = sharedLockProvider
-                        .create(key, {
-                        ttl,
+                    await sharedLock.acquireReader();
+                    await sharedLock.forceReleaseWriter();
+                    const state = await sharedLock.getState();
+                    expect(state).toEqual({
+                        type: SHARED_LOCK_STATE.READER_ACQUIRED,
                         limit,
-                    })
-                        .runReaderOrFail(() => {
-                        return Promise.resolve(RETURN_VALUE);
+                        remainingTime: null,
+                        freeSlotsCount: 2,
+                        acquiredSlotsCount: 1,
+                        acquiredSlots: [sharedLock.id],
                     });
-                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
                 });
             });
-            describe("method: runReaderBlocking", () => {
-                test("Should call acquire method", async () => {
+            describe("method: runReaderOrFail", () => {
+                test("Should call acquireReaderOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -3770,16 +2372,13 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
-                    await sharedLock.runReaderBlocking(() => {
+                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
+                    await sharedLock.runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledTimes(1);
+                    expect(acquireReaderOrFailSpy).toHaveBeenCalledTimes(1);
                 });
-                test("Should call acquire before release method", async () => {
+                test("Should call acquireReaderOrFail before release method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -3787,15 +2386,12 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     });
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
+                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
                     const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReaderBlocking(() => {
+                    await sharedLock.runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
+                    expect(acquireReaderOrFailSpy).toHaveBeenCalledBefore(releaseSpy);
                 });
                 test("Should call release method", async () => {
                     const key = "a";
@@ -3806,15 +2402,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    await sharedLock.runReaderBlocking(() => {
+                    await sharedLock.runReaderOrFail(() => {
                         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 acquireReaderOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -3823,14 +2416,11 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
-                    const acquireSpy = vi.spyOn(sharedLock, "acquireReader");
-                    await sharedLock.runReaderBlocking(() => {
+                    const acquireReaderOrFailSpy = vi.spyOn(sharedLock, "acquireReaderOrFail");
+                    await sharedLock.runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
+                    expect(releaseSpy).toHaveBeenCalledAfter(acquireReaderOrFailSpy);
                 });
                 test("Should call release when an error is thrown", async () => {
                     const key = "a";
@@ -3842,11 +2432,8 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     const releaseSpy = vi.spyOn(sharedLock, "releaseReader");
                     try {
-                        await sharedLock.runReaderBlocking(() => {
+                        await sharedLock.runReaderOrFail(() => {
                             return Promise.reject(new Error());
-                        }, {
-                            time: TimeSpan.fromMilliseconds(5),
-                            interval: TimeSpan.fromMilliseconds(5),
                         });
                     }
                     catch {
@@ -3864,11 +2451,8 @@ export function sharedLockProviderTestSuite(settings) {
                     });
                     class CustomError extends Error {
                     }
-                    const error = sharedLock.runReaderBlocking(() => {
+                    const error = sharedLock.runReaderOrFail(() => {
                         return Promise.reject(new CustomError());
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(error).rejects.toBeInstanceOf(CustomError);
                 });
@@ -3884,10 +2468,7 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                        .runReaderOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should call handler function when slot is expired", {
@@ -3911,10 +2492,7 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                        .runReaderOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
                 test("Should not call handler function when slot is unexpireable", async () => {
@@ -3929,10 +2507,12 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLock.runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await sharedLock.runReaderOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpired", async () => {
@@ -3947,10 +2527,12 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLock.runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await sharedLock.runReaderOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpireable", async () => {
@@ -3966,15 +2548,17 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await sharedLockProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runReaderOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should not call handler function when slot is unexpired", async () => {
@@ -3990,15 +2574,17 @@ export function sharedLockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await sharedLockProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .runReaderBlocking(handlerFn, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
+                    try {
+                        await sharedLockProvider
+                            .create(key, {
+                            ttl,
+                            limit,
+                        })
+                            .runReaderOrFail(handlerFn);
+                    }
+                    catch {
+                        /* EMPTY */
+                    }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
                 test("Should return value when key doesnt exists", async () => {
@@ -4010,13 +2596,10 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(() => {
+                        .runReaderOrFail(() => {
                         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", {
                     retry: 10,
@@ -4036,15 +2619,12 @@ export function sharedLockProviderTestSuite(settings) {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(() => {
+                        .runReaderOrFail(() => {
                         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<LimitReachedReaderSemaphoreError> when slot is unexpireable", async () => {
+                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -4053,18 +2633,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = await sharedLock.runReaderBlocking(() => {
+                    const result = sharedLock.runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpired", async () => {
+                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
@@ -4073,18 +2647,12 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     });
                     await sharedLock.acquireReader();
-                    const result = await sharedLock.runReaderBlocking(() => {
+                    const result = sharedLock.runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpireable", async () => {
+                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
@@ -4094,23 +2662,17 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     })
                         .acquireReader();
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(() => {
+                        .runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
                 });
-                test("Should return ResultFailure<LimitReachedReaderSemaphoreError> when slot is unexpired", async () => {
+                test("Should throw LimitReachedReaderSemaphoreError when slot is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
@@ -4120,67 +2682,15 @@ export function sharedLockProviderTestSuite(settings) {
                         limit,
                     })
                         .acquireReader();
-                    const result = await sharedLockProvider
+                    const result = sharedLockProvider
                         .create(key, {
                         ttl,
                         limit,
                     })
-                        .runReaderBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(result).toEqual(expect.objectContaining({
-                        type: RESULT.FAILURE,
-                        error: expect.any(LimitReachedReaderSemaphoreError),
-                    }));
-                });
-                test("Should retry acquire the shared lock when blocked by a writer", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 4;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireWriter();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock2.runReaderBlocking(() => {
-                        return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
-                });
-                test("Should retry acquire the shared lock when blocked by a reader", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 1;
-                    const sharedLock1 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock1.acquireReader();
-                    const handlerFn = vi.fn(() => { });
-                    await sharedLockProvider.addListener(SHARED_LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const sharedLock2 = sharedLockProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await sharedLock2.runReaderBlocking(() => {
+                        .runReaderOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn.mock.calls.length).toBeGreaterThan(1);
+                    await expect(result).rejects.toBeInstanceOf(LimitReachedReaderSemaphoreError);
                 });
             });
             describe("method: runReaderBlockingOrFail", () => {