@daiso-tech/core 0.38.0 → 0.40.0

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

@@ -1,13 +1,13 @@
 /**
  * @module Lock
  */
-import {} from "vitest";
-import { KeyAlreadyAcquiredLockError, UnownedRefreshLockError, UnownedReleaseLockError, LOCK_EVENTS, } from "../../../lock/contracts/_module-exports.js";
+import { vi, } from "vitest";
+import { KeyAlreadyAcquiredLockError, UnownedRefreshLockError, UnownedReleaseLockError, LOCK_EVENTS, UnrefreshableKeyLockError, } from "../../../lock/contracts/_module-exports.js";
 import { RESULT, resultSuccess, } from "../../../utilities/_module-exports.js";
 import { TimeSpan } from "../../../utilities/_module-exports.js";
-import { LazyPromise } from "../../../async/_module-exports.js";
 import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_module-exports.js";
 import { Serde } from "../../../serde/implementations/derivables/_module-exports.js";
+import { LazyPromise } from "../../../async/_module-exports.js";
 /**
  * The `lockProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ILock | `ILock`} with `vitest`.
  *
@@ -50,1882 +50,3072 @@ export function lockProviderTestSuite(settings) {
     beforeEach(async () => {
         lockProvider = await createLockProvider();
     });
-    const TTL = TimeSpan.fromMilliseconds(50);
-    const DELAY_TIME = TimeSpan.fromMilliseconds(50);
+    async function delay(time) {
+        await LazyPromise.delay(time.addMilliseconds(10));
+    }
+    const RETURN_VALUE = "RETURN_VALUE";
     describe("Api tests:", () => {
         describe("method: run", () => {
-            test("Should return string when lock is available", async () => {
+            test("Should call acquire method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.run(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
+                const acquireSpy = vi.spyOn(lock, "acquire");
+                await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toEqual(resultSuccess("a"));
+                expect(acquireSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should return null when lock is already acquired", async () => {
+            test("Should call acquire before release method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquire();
-                const result = await lock.run(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
+                const acquireSpy = vi.spyOn(lock, "acquire");
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result.type).toBe(RESULT.FAILURE);
-                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
+                expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
             });
-            test("Should work with LazyPromise", async () => {
+            test("Should call release method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.run(new LazyPromise(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }));
-                expect(result).toEqual(resultSuccess("a"));
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-        });
-        describe("method: runOrFail", () => {
-            test("Should return string when lock is available", async () => {
+            test("Should call release after acquire method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.runOrFail(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
+                const releaseSpy = vi.spyOn(lock, "release");
+                const acquireSpy = vi.spyOn(lock, "acquire");
+                await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toBe("a");
+                expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
             });
-            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+            test("Should call release when an error is thrown", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquire();
-                const result = lock.runOrFail(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                });
-                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+                const releaseSpy = vi.spyOn(lock, "release");
+                try {
+                    await lock.run(() => {
+                        return Promise.reject(new Error());
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should work with LazyPromise", async () => {
+            test("Should propagate thrown error", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.runOrFail(new LazyPromise(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }));
-                expect(result).toBe("a");
+                class CustomError extends Error {
+                }
+                const error = lock.run(() => {
+                    return Promise.reject(new CustomError());
+                });
+                await expect(error).rejects.toBeInstanceOf(CustomError);
             });
-        });
-        describe("method: runBlocking", () => {
-            test("Should return string when lock is available", async () => {
+            test("Should call handler function when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
-                    ttl,
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                const result = await lock.runBlocking(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }, {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .run(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+            });
+            test("Should call handler function when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toEqual(resultSuccess("a"));
+                await lockProvider.create(key, { ttl }).run(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-            test("Should return null when lock is already acquired", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lock.run(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(0);
+            });
+            test("Should not call handler function when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
-                const result = await lock.runBlocking(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }, {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result.type).toBe(RESULT.FAILURE);
-                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
+                await lock.run(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(0);
             });
-            test("Should work with LazyPromise", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lockProvider.create(key, { ttl }).run(handlerFn);
+                expect(handlerFn).not.toHaveBeenCalled();
+            });
+            test("Should not call handler function when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lockProvider.create(key, { ttl }).run(handlerFn);
+                expect(handlerFn).not.toHaveBeenCalled();
+            });
+            test("Should return ResultSuccess<string> when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = null;
+                const result = await lockProvider
+                    .create(key, {
                     ttl,
+                })
+                    .run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                const result = await lock.runBlocking(new LazyPromise(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }), {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                expect(result).toEqual(resultSuccess(RETURN_VALUE));
+            });
+            test("Should return ResultSuccess<string> when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toEqual(resultSuccess("a"));
+                expect(result).toEqual(resultSuccess(RETURN_VALUE));
             });
-            test("Should retry acquire the lock", async () => {
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpired and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
-                let index = 0;
-                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
-                    index++;
+                const result = await lock.run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.runBlocking(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                }, {
-                    time: TimeSpan.fromMilliseconds(55),
-                    interval: TimeSpan.fromMilliseconds(5),
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .run(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(index).toBeGreaterThan(1);
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .run(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
         });
-        describe("method: runBlockingOrFail", () => {
-            test("Should return string when lock is available", async () => {
+        describe("method: runOrFail", () => {
+            test("Should call acquireOrFail method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.runBlockingOrFail(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }, {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                const acquireSpy = vi.spyOn(lock, "acquireOrFail");
+                await lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toBe("a");
+                expect(acquireSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+            test("Should call acquireOrFail before release method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquire();
-                const promise = lock.runBlockingOrFail(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }, {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                const acquireSpy = vi.spyOn(lock, "acquireOrFail");
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+                expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
             });
-            test("Should work with LazyPromise", async () => {
+            test("Should call release method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.runBlockingOrFail(new LazyPromise(async () => {
-                    await LazyPromise.delay(DELAY_TIME);
-                    return "a";
-                }), {
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                expect(result).toBe("a");
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should retry acquire the lock", async () => {
+            test("Should call release after acquireOrFail method", async () => {
                 const key = "a";
-                const ttl = TimeSpan.fromMilliseconds(50);
+                const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquire();
-                let index = 0;
-                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
-                    index++;
+                const releaseSpy = vi.spyOn(lock, "release");
+                const acquireSpy = vi.spyOn(lock, "acquireOrFail");
+                await lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
+            });
+            test("Should call release when an error is thrown", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, {
+                    ttl,
                 });
+                const releaseSpy = vi.spyOn(lock, "release");
                 try {
-                    await lock.runBlockingOrFail(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
+                    await lock.runOrFail(() => {
+                        return Promise.reject(new Error());
                     });
                 }
                 catch {
-                    /* Empty */
+                    /* EMPTY */
                 }
-                expect(index).toBeGreaterThan(1);
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-        });
-        describe("method: acquire", () => {
-            test("Should return true when lock is available", async () => {
+            test("Should propagate thrown error", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.acquire();
-                expect(result).toBe(true);
+                class CustomError extends Error {
+                }
+                const error = lock.runOrFail(() => {
+                    return Promise.reject(new CustomError());
+                });
+                await expect(error).rejects.toBeInstanceOf(CustomError);
             });
-            test("Should return false when lock is already acquired", async () => {
+            test("Should call handler function when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lockProvider
+                    .create(key, {
                     ttl,
+                })
+                    .runOrFail(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+            });
+            test("Should call handler function when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquire();
-                const result = await lock.acquire();
-                expect(result).toBe(false);
+                await lockProvider.create(key, { ttl }).runOrFail(handlerFn);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-            test("Should not be expired when released by same owner", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lock.runOrFail(handlerFn);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(0);
+            });
+            test("Should not call handler function when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
                 await lock.acquire();
-                const result = await lock.isExpired();
-                expect(result).toBe(false);
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lock.runOrFail(handlerFn);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(0);
             });
-            test("Should be loked when released by same owner", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquire();
-                const result = await lock.isLocked();
-                expect(result).toBe(true);
+                try {
+                    await lockProvider
+                        .create(key, { ttl })
+                        .runOrFail(handlerFn);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).not.toHaveBeenCalled();
             });
-        });
-        describe("method: acquireOrFail", () => {
-            test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
+            test("Should not call handler function when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lockProvider
+                        .create(key, { ttl })
+                        .runOrFail(handlerFn);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).not.toHaveBeenCalled();
+            });
+            test("Should return value when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
+                const result = await lockProvider
+                    .create(key, {
                     ttl,
+                })
+                    .runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                const result = lock.acquireOrFail();
-                await expect(result).resolves.toBeUndefined();
+                expect(result).toBe(RETURN_VALUE);
+            });
+            test("Should return value when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                expect(result).toBe(RETURN_VALUE);
             });
-            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquireOrFail();
-                const result = lock.acquireOrFail();
+                await lock.acquire();
+                const result = lock.runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .runOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
                 await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
         });
-        describe("method: acquireBlocking", () => {
-            test("Should return true when lock is available", async () => {
+        describe("method: runBlocking", () => {
+            test("Should call acquireBlocking method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const result = await lock.acquireBlocking({
+                const acquireSpy = vi.spyOn(lock, "acquireBlocking");
+                await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                expect(result).toBe(true);
+                expect(acquireSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should return false when lock is already acquired", async () => {
+            test("Should call acquireBlocking before release method", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
-                });
-                const result = await lock.acquireBlocking({
+                const acquireSpy = vi.spyOn(lock, "acquireBlocking");
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                expect(result).toBe(false);
+                expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
             });
-            test("Should not be expired when released by same owner", async () => {
+            test("Should call release method", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquireBlocking({
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock.isExpired();
-                expect(result).toBe(false);
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should be loked when released by same owner", async () => {
+            test("Should call release after acquireBlocking method", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquireBlocking({
+                const releaseSpy = vi.spyOn(lock, "release");
+                const acquireSpy = vi.spyOn(lock, "acquireBlocking");
+                await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock.isLocked();
-                expect(result).toBe(true);
+                expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
             });
-            test("Should retry acquire the lock", async () => {
+            test("Should call release when an error is thrown", async () => {
                 const key = "a";
-                const ttl = TimeSpan.fromMilliseconds(50);
+                const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                await lock.acquire();
-                let index = 0;
-                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
-                    index++;
-                });
-                await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(55),
-                    interval: TimeSpan.fromMilliseconds(5),
-                });
-                expect(index).toBeGreaterThan(1);
+                const releaseSpy = vi.spyOn(lock, "release");
+                try {
+                    await lock.runBlocking(() => {
+                        return Promise.reject(new Error());
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-        });
-        describe("method: acquireBlockingOrFail", () => {
-            test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
+            test("Should propagate thrown error", async () => {
                 const key = "a";
                 const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
-                const promise = lock.acquireBlockingOrFail({
+                class CustomError extends Error {
+                }
+                const error = lock.runBlocking(() => {
+                    return Promise.reject(new CustomError());
+                }, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                await expect(promise).resolves.toBeUndefined();
+                await expect(error).rejects.toBeInstanceOf(CustomError);
             });
-            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+            test("Should call handler function when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
-                    ttl,
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquireBlockingOrFail({
-                    time: TimeSpan.fromMilliseconds(5),
-                    interval: TimeSpan.fromMilliseconds(5),
-                });
-                const promise = lock.acquireBlockingOrFail({
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .runBlocking(handlerFn, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-            test("Should not be expired when released by same owner", async () => {
+            test("Should call handler function when key is expired", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquireBlockingOrFail({
+                await lockProvider.create(key, { ttl }).runBlocking(handlerFn, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock.isExpired();
-                expect(result).toBe(false);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-            test("Should be loked when released by same owner", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquireBlockingOrFail({
+                await lock.runBlocking(handlerFn, {
                     time: TimeSpan.fromMilliseconds(5),
                     interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock.isLocked();
-                expect(result).toBe(true);
+                expect(handlerFn).toHaveBeenCalledTimes(0);
             });
-            test("Should retry acquire the lock", async () => {
+            test("Should not call handler function when key is unexpired and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
-                let index = 0;
-                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
-                    index++;
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                try {
-                    await lock.acquireBlockingOrFail({
-                        time: TimeSpan.fromMilliseconds(55),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                }
-                catch {
-                    /* Empty */
-                }
-                expect(index).toBeGreaterThan(1);
+                await lock.runBlocking(handlerFn, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(handlerFn).toHaveBeenCalledTimes(0);
             });
-        });
-        describe("method: release", () => {
-            test("Should return true when released by same owner", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock.acquire();
-                const result = await lock.release();
-                expect(result).toBe(true);
+                await lockProvider.create(key, { ttl }).runBlocking(handlerFn, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(handlerFn).not.toHaveBeenCalled();
             });
-            test("Should return false when released by different owner", async () => {
+            test("Should not call handler function when key is unexpired and acquired by different owner", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner1 = "b";
-                const lock1 = lockProvider.create(key, {
-                    ttl,
-                    owner: owner1,
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                await lock1.acquire();
-                const owner2 = "c";
-                const lock2 = lockProvider.create(key, {
-                    ttl,
-                    owner: owner2,
+                await lockProvider.create(key, { ttl }).runBlocking(handlerFn, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock2.release();
-                expect(result).toBe(false);
+                expect(handlerFn).not.toHaveBeenCalled();
             });
-            test("Should be expired when released by same owner", async () => {
+            test("Should return ResultSuccess<string> when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
+                const result = await lockProvider
+                    .create(key, {
                     ttl,
-                    owner,
+                })
+                    .runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await lock.release();
-                const result = await lock.isExpired();
-                expect(result).toBe(true);
+                expect(result).toEqual(resultSuccess(RETURN_VALUE));
             });
-            test("Should be not loked when released by same owner", async () => {
+            test("Should return ResultSuccess<string> when key is expired", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await lock.release();
-                const result = await lock.isLocked();
-                expect(result).toBe(false);
+                expect(result).toEqual(resultSuccess(RETURN_VALUE));
             });
-        });
-        describe("method: releaseOrFail", () => {
-            test("Should not throw UnownedReleaseLockError when released by same owner", async () => {
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
-                });
+                const lock = lockProvider.create(key, { ttl });
                 await lock.acquire();
-                const result = lock.releaseOrFail();
-                await expect(result).resolves.toBeUndefined();
+                const result = await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-            test("Should throw UnownedReleaseLockError when released by different owner", async () => {
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpired and acquired by same owner", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner1 = "b";
-                const lock1 = lockProvider.create(key, {
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
                     ttl,
-                    owner: owner1,
                 });
-                await lock1.acquire();
-                const owner2 = "c";
-                const lock2 = lockProvider.create(key, {
-                    ttl,
-                    owner: owner2,
+                await lock.acquire();
+                const result = await lock.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = lock2.releaseOrFail();
-                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-            test("Should be expired when released by same owner", async () => {
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await lock.releaseOrFail();
-                const result = await lock.isExpired();
-                expect(result).toBe(true);
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-            test("Should be not loked when released by same owner", async () => {
+            test("Should return ResultFailure<KeyAlreadyAcquiredLockError> when key is unexpired and acquired by different owner", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await lock.releaseOrFail();
-                const result = await lock.isLocked();
-                expect(result).toBe(false);
+                expect(result.type).toBe(RESULT.FAILURE);
+                expect(result.error).toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-        });
-        describe("method: forceRelease", () => {
-            test("Should release lock no regardless of the owner", async () => {
+            test("Should retry acquire the lock", async () => {
                 const key = "a";
-                const ttl = null;
-                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock1 = lockProvider.create(key, {
                     ttl,
-                    owner: owner1,
                 });
                 await lock1.acquire();
-                const owner2 = "c";
+                let index = 0;
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, (_event) => {
+                    index++;
+                });
                 const lock2 = lockProvider.create(key, {
                     ttl,
-                    owner: owner2,
                 });
-                await lock2.forceRelease();
-                const result = await lock1.acquire();
-                expect(result).toBe(true);
+                await lock2.runBlocking(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(55),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(index).toBeGreaterThan(1);
             });
-            test("Should be expired when released", async () => {
+        });
+        describe("method: runBlockingOrFail", () => {
+            test("Should call acquireBlockingOrFail method", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                await lock.forceRelease();
-                const result = await lock.isExpired();
-                expect(result).toBe(true);
+                const acquireSpy = vi.spyOn(lock, "acquireBlockingOrFail");
+                await lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(acquireSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should be not loked when released", async () => {
+            test("Should call acquireBlockingOrFail before release method", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                await lock.forceRelease();
-                const result = await lock.isLocked();
-                expect(result).toBe(false);
+                const acquireSpy = vi.spyOn(lock, "acquireBlockingOrFail");
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(acquireSpy).toHaveBeenCalledBefore(releaseSpy);
             });
-        });
-        describe("method: isExpired", () => {
-            test("Should return false when lock has no expiration", async () => {
+            test("Should call release method", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                const result = await lock.isExpired();
-                expect(result).toBe(false);
-            });
-            test("Should return false when lock has not expired", async () => {
-                const key = "a";
-                const owner = "b";
-                const ttl = TTL;
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const releaseSpy = vi.spyOn(lock, "release");
+                await lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                const result = await lock.isExpired();
-                expect(result).toBe(false);
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should return true when lock has expired", async () => {
+            test("Should call release after acquireBlockingOrFail method", async () => {
                 const key = "a";
-                const owner = "b";
-                const ttl = TTL;
+                const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                await LazyPromise.delay(ttl.addMilliseconds(25));
-                const result = await lock.isExpired();
-                expect(result).toBe(true);
+                const releaseSpy = vi.spyOn(lock, "release");
+                const acquireSpy = vi.spyOn(lock, "acquireBlockingOrFail");
+                await lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(releaseSpy).toHaveBeenCalledAfter(acquireSpy);
             });
-        });
-        describe("method: isLocked", () => {
-            test("Should return true when lock has no expiration", async () => {
+            test("Should call release when an error is thrown", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                const result = await lock.isLocked();
-                expect(result).toBe(true);
+                const releaseSpy = vi.spyOn(lock, "release");
+                try {
+                    await lock.runBlockingOrFail(() => {
+                        return Promise.reject(new Error());
+                    }, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(releaseSpy).toHaveBeenCalledTimes(1);
             });
-            test("Should return true when lock has not expired", async () => {
+            test("Should propagate thrown error", async () => {
                 const key = "a";
-                const owner = "b";
-                const ttl = TTL;
+                const ttl = null;
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquire();
-                const result = await lock.isLocked();
-                expect(result).toBe(true);
+                class CustomError extends Error {
+                }
+                const error = lock.runBlockingOrFail(() => {
+                    return Promise.reject(new CustomError());
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(error).rejects.toBeInstanceOf(CustomError);
             });
-            test("Should return false when lock has expired", async () => {
+            test("Should call handler function when key doesnt exists", async () => {
                 const key = "a";
-                const owner = "b";
-                const ttl = TTL;
-                const lock = lockProvider.create(key, {
+                const ttl = null;
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lockProvider
+                    .create(key, {
                     ttl,
-                    owner,
+                })
+                    .runBlockingOrFail(handlerFn, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await LazyPromise.delay(ttl.addMilliseconds(25));
-                const result = await lock.isLocked();
-                expect(result).toBe(false);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-        });
-        describe("method: refresh", () => {
-            test("Should return true when refreshed by same owner", async () => {
+            test("Should call handler function when key is expired", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    ttl,
-                    owner,
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                await lockProvider
+                    .create(key, { ttl })
+                    .runBlockingOrFail(handlerFn, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                await lock.acquire();
-                await LazyPromise.delay(ttl);
-                const result = await lock.refresh();
-                expect(result).toBe(true);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
             });
-            test("Should return false when refreshed by different owner", async () => {
+            test("Should not call handler function when key is unexpireable and acquired by same owner", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner1 = "b";
-                const lock1 = lockProvider.create(key, {
-                    ttl,
-                    owner: owner1,
-                });
-                await lock1.acquire();
-                const owner2 = "c";
-                const lock2 = lockProvider.create(key, {
-                    ttl,
-                    owner: owner2,
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
                 });
-                const result = await lock2.refresh();
-                expect(result).toBe(false);
+                try {
+                    await lock.runBlockingOrFail(handlerFn, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(0);
             });
-            test("Should refresh expiration by same owner", async () => {
+            test("Should not call handler function when key is unexpired and acquired by same owner", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
                 await lock.acquire();
-                await LazyPromise.delay(ttl.subtractMilliseconds(10));
-                await lock.refresh();
-                const time = await lock.getRemainingTime();
-                expect(time?.toMilliseconds()).toBeGreaterThan(0);
-            });
-        });
-        describe("method: refreshOrFail", () => {
-            test("Should not throw UnownedRefreshLockError when refreshed by same owner", async () => {
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lock.runBlockingOrFail(handlerFn, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(0);
+            });
+            test("Should not call handler function when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner = "b";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lockProvider
+                        .create(key, { ttl })
+                        .runBlockingOrFail(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 owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                });
+                try {
+                    await lockProvider
+                        .create(key, { ttl })
+                        .runBlockingOrFail(handlerFn, {
+                        time: TimeSpan.fromMilliseconds(5),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).not.toHaveBeenCalled();
+            });
+            test("Should return value when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = null;
+                const result = await lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(RETURN_VALUE);
+            });
+            test("Should return value when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(RETURN_VALUE);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
                 await lock.acquire();
-                await LazyPromise.delay(ttl);
-                const result = lock.refreshOrFail();
-                await expect(result).resolves.toBeUndefined();
+                const result = lock.runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-            test("Should throw UnownedRefreshLockError when refreshed by different owner", async () => {
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner1 = "b";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .runBlockingOrFail(() => {
+                    return Promise.resolve(RETURN_VALUE);
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock1 = lockProvider.create(key, {
                     ttl,
-                    owner: owner1,
                 });
                 await lock1.acquire();
-                const owner2 = "c";
+                let index = 0;
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, (_event) => {
+                    index++;
+                });
                 const lock2 = lockProvider.create(key, {
                     ttl,
-                    owner: owner2,
                 });
-                const result = lock2.refreshOrFail();
-                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+                try {
+                    await lock2.runBlockingOrFail(() => {
+                        return Promise.resolve(RETURN_VALUE);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
+        describe("method: acquire", () => {
+            test("Should return true when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = null;
+                const result = await lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .acquire();
+                expect(result).toBe(true);
             });
-            test("Should refresh expiration by same owner", async () => {
+            test("Should return true when key is expired", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquire();
+                expect(result).toBe(true);
+            });
+            test("Should return false when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.acquire();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                await lock.acquireOrFail();
-                await LazyPromise.delay(ttl.subtractMilliseconds(10));
-                await lock.refresh();
-                const time = await lock.getRemainingTime();
-                expect(time?.toMilliseconds()).toBeGreaterThan(0);
+                await lock.acquire();
+                const result = await lock.acquire();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquire();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquire();
+                expect(result).toBe(false);
             });
         });
-        describe("method: getRemainingTime", () => {
-            test("Should return null when lock is not acquired", async () => {
+        describe("method: acquireOrFail", () => {
+            test("Should not throw error when key doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
+                const result = lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .acquireOrFail();
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should not throw error when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireOrFail();
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.acquireOrFail();
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
-                const result = await lock.getRemainingTime();
-                expect(result).toBeNull();
+                await lock.acquire();
+                const result = lock.acquireOrFail();
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
             });
-            test("Should return null when lock is acquired and has expiration", async () => {
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
                 const ttl = null;
-                const owner = "b";
-                const lock = lockProvider.create(key, {
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireOrFail();
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireOrFail();
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+        });
+        describe("method: acquireBlocking", () => {
+            test("Should return true when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = null;
+                const result = await lockProvider
+                    .create(key, {
                     ttl,
-                    owner,
+                })
+                    .acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
+                expect(result).toBe(true);
+            });
+            test("Should return false when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
                 await lock.acquire();
-                const result = await lock.getRemainingTime();
-                expect(result).toBeNull();
+                const result = await lock.acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(false);
             });
-            test("Should return remaining time when lock is not acquired", async () => {
+            test("Should return false when key is unexpired and acquired by same owner", async () => {
                 const key = "a";
-                const ttl = TTL;
-                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
                 const lock = lockProvider.create(key, {
                     ttl,
-                    owner,
                 });
                 await lock.acquire();
-                const result = await lock.getRemainingTime();
-                expect(result?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                const result = await lock.acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(false);
             });
-        });
-        describe("method: getOwner", () => {
-            test("Should return the owner", async () => {
+            test("Should return false when key is unexpireable and acquired by different owner", async () => {
                 const key = "a";
-                const owner = "b";
-                const lock = lockProvider.create(key, {
-                    owner,
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
-                const result = await lock.getOwner();
-                expect(result).toBe(owner);
+                expect(result).toBe(false);
             });
-            test("Should return the auto generated owner", async () => {
+            test("Should return false when key is unexpired and acquired by different owner", async () => {
                 const key = "a";
-                const lock = lockProvider.create(key);
-                const result = await lock.getOwner();
-                expect(result).toBeDefined();
-                expect(typeof result).toBe("string");
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe(false);
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock1.acquire();
+                let index = 0;
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, (_event) => {
+                    index++;
+                });
+                const lock2 = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock2.acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(55),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(index).toBeGreaterThan(1);
             });
         });
-    });
-    describe("Event tests:", () => {
-        describe("class: Lock", () => {
-            describe("method: run", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runBlocking", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
+        describe("method: acquireBlockingOrFail", () => {
+            test("Should not throw error when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = null;
+                const result = lockProvider
+                    .create(key, {
+                    ttl,
+                })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should not throw error when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                const result = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(result).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock1.acquire();
+                let index = 0;
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, (_event) => {
+                    index++;
+                });
+                const lock2 = lockProvider.create(key, {
+                    ttl,
+                });
+                try {
+                    await lock2.acquireBlockingOrFail({
+                        time: TimeSpan.fromMilliseconds(55),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
+        describe("method: release", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const result = await lockProvider.create(key).release();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .release();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .release();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = await lockProvider
+                    .create(key, { ttl })
+                    .release();
+                await delay(ttl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                await delay(ttl);
+                const result = await lock.release();
+                expect(result).toBe(false);
+            });
+            test("Should return true when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.release();
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.release();
+                expect(result).toBe(true);
+            });
+            test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const lock2 = lockProvider.create(key, { ttl });
+                await lock2.release();
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const lock2 = lockProvider.create(key, { ttl });
+                await lock2.release();
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await lock1.release();
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await lock1.release();
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                expect(result).toBe(true);
+            });
+        });
+        describe("method: releaseOrFail", () => {
+            test("Should throw UnownedReleaseLockError when key doesnt exists", async () => {
+                const key = "a";
+                const result = lockProvider.create(key).releaseOrFail();
+                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+            });
+            test("Should throw UnownedReleaseLockError when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .releaseOrFail();
+                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+            });
+            test("Should throw UnownedReleaseLockError when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .releaseOrFail();
+                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+            });
+            test("Should throw UnownedReleaseLockError when key is expired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const result = lockProvider
+                    .create(key, { ttl })
+                    .releaseOrFail();
+                await delay(ttl);
+                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+            });
+            test("Should throw UnownedReleaseLockError when key is expired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                await delay(ttl);
+                const result = lock.releaseOrFail();
+                await expect(result).rejects.toBeInstanceOf(UnownedReleaseLockError);
+            });
+            test("Should not throw error when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.releaseOrFail();
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should not throw error when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = lock.releaseOrFail();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const lock2 = lockProvider.create(key, { ttl });
+                try {
+                    await lock2.releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const lock2 = lockProvider.create(key, { ttl });
+                try {
+                    await lock2.releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await lock1.releaseOrFail();
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await lock1.releaseOrFail();
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                expect(result).toBe(true);
+            });
+        });
+        describe("method: forceRelease", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const result = await lockProvider.create(key).forceRelease();
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const result = await lock.forceRelease();
+                expect(result).toBe(false);
+            });
+            test("Should return true when key is uenxpired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.forceRelease();
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpireable", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const result = await lock.forceRelease();
+                expect(result).toBe(true);
+            });
+            test("Should be reacquirable when key is uenxpired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                await lock.forceRelease();
+                const result = await lock.acquire();
+                expect(result).toBe(true);
+            });
+            test("Should be reacquirable when key is unexpireable", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                await lock.forceRelease();
+                const result = await lock.acquire();
+                expect(result).toBe(true);
+            });
+        });
+        describe("method: isExpired", () => {
+            test("Should return false when lock has no expiration", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.isExpired();
+                expect(result).toBe(false);
+            });
+            test("Should return false when lock has not expired", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.isExpired();
+                expect(result).toBe(false);
+            });
+            test("Should return true when lock has expired", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const result = await lock.isExpired();
+                expect(result).toBe(true);
+            });
+        });
+        describe("method: isLocked", () => {
+            test("Should return true when lock has no expiration", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.isLocked();
+                expect(result).toBe(true);
+            });
+            test("Should return true when lock has not expired", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.isLocked();
+                expect(result).toBe(true);
+            });
+            test("Should return false when lock has expired", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const result = await lock.isLocked();
+                expect(result).toBe(false);
+            });
+        });
+        describe("method: refresh", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await lockProvider.create(key).refresh(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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.refresh(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 lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.refresh(newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.refresh(newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await lock.refresh(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 lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await lock.refresh(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 lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await lock.refresh(newTtl);
+                expect(result).toBe(true);
+            });
+            test("Should not update expiration when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMilliseconds(50);
+                await lock1.refresh(newTtl);
+                await delay(newTtl);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                expect(result).toBe(false);
+            });
+            test("Should update expiration when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMilliseconds(100);
+                await lock1.refresh(newTtl);
+                await delay(newTtl.divide(2));
+                const lock2 = lockProvider.create(key, { ttl });
+                const result1 = await lock2.acquire();
+                expect(result1).toBe(false);
+                await delay(newTtl.divide(2));
+                const result2 = await lock2.acquire();
+                expect(result2).toBe(true);
+            });
+        });
+        describe("method: refreshOrFail", () => {
+            test("Should throw UnownedRefreshLockError when key doesnt exists", async () => {
+                const key = "a";
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = lockProvider.create(key).refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+            });
+            test("Should throw UnownedRefreshLockError when key is unexpireable and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = lock2.refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+            });
+            test("Should throw UnownedRefreshLockError when key is unexpired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = lock2.refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+            });
+            test("Should throw UnownedRefreshLockError when key is expired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = lock2.refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+            });
+            test("Should throw UnownedRefreshLockError when key is expired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = lock.refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnownedRefreshLockError);
+            });
+            test("Should throw UnrefreshableKeyLockError when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = lock.refreshOrFail(newTtl);
+                await expect(result).rejects.toBeInstanceOf(UnrefreshableKeyLockError);
+            });
+            test("Should not throw error when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = lock.refreshOrFail(newTtl);
+                await expect(result).resolves.toBeUndefined();
+            });
+            test("Should not update expiration when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMilliseconds(50);
+                try {
+                    await lock1.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(newTtl);
+                const lock2 = lockProvider.create(key, { ttl });
+                const result = await lock2.acquire();
+                expect(result).toBe(false);
+            });
+            test("Should update expiration when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMilliseconds(100);
+                await lock1.refreshOrFail(newTtl);
+                await delay(newTtl.divide(2));
+                const lock2 = lockProvider.create(key, { ttl });
+                const result1 = await lock2.acquire();
+                expect(result1).toBe(false);
+                await delay(newTtl.divide(2));
+                const result2 = await lock2.acquire();
+                expect(result2).toBe(true);
+            });
+        });
+        describe("method: getRemainingTime", () => {
+            test("Should return null when lock is not acquired", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                const result = await lock.getRemainingTime();
+                expect(result).toBeNull();
+            });
+            test("Should return null when lock is acquired and has expiration", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.getRemainingTime();
+                expect(result).toBeNull();
+            });
+            test("Should return remaining time when lock is not acquired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const result = await lock.getRemainingTime();
+                expect(result?.toMilliseconds()).toBe(ttl.toMilliseconds());
+            });
+        });
+        describe("method: getOwner", () => {
+            test("Should return the owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    owner,
+                });
+                const result = await lock.getOwner();
+                expect(result).toBe(owner);
+            });
+            test("Should return the auto generated owner", async () => {
+                const key = "a";
+                const lock = lockProvider.create(key);
+                const result = await lock.getOwner();
+                expect(result).toBeDefined();
+                expect(typeof result).toBe("string");
+            });
+        });
+    });
+    describe("Event tests:", () => {
+        describe("method: acquire", () => {
+            test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                    owner,
+                })
+                    .acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl,
+                });
+            });
+            test("Should dispatch AcquiredLockEvent when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                const owner = "b";
+                const ttl2 = null;
+                await lockProvider.create(key, { ttl: ttl2, owner }).acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: ttl2,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                await lock.acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                await lock.acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).acquire();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+        });
+        describe("method: acquireOrFail", () => {
+            test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                    owner,
+                })
+                    .acquireOrFail();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl,
+                });
+            });
+            test("Should dispatch AcquiredLockEvent when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                const owner = "b";
+                const ttl2 = null;
+                await lockProvider
+                    .create(key, { ttl: ttl2, owner })
+                    .acquireOrFail();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: ttl2,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                try {
+                    await lock.acquireOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                try {
+                    await lock.acquireOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .acquireOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .acquireOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+        });
+        describe("method: acquireBlocking", () => {
+            test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                    owner,
+                })
+                    .acquireBlocking();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl,
+                });
+            });
+            test("Should dispatch AcquiredLockEvent when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                const owner = "b";
+                const ttl2 = null;
+                await lockProvider
+                    .create(key, { ttl: ttl2, owner })
+                    .acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: ttl2,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                await lock.acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                await lock.acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).acquireBlocking({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+        });
+        describe("method: acquireBlockingOrFail", () => {
+            test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                await lockProvider
+                    .create(key, {
+                    ttl,
+                    owner,
+                })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl,
+                });
+            });
+            test("Should dispatch AcquiredLockEvent when key is expired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                const owner = "b";
+                const ttl2 = null;
+                await lockProvider
+                    .create(key, { ttl: ttl2, owner })
+                    .acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: ttl2,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                try {
+                    await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.runOrFail(async () => {
-                            await LazyPromise.delay(DELAY_TIME);
-                        });
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquire", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireBlocking", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireBlocking({
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                try {
+                    await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquireBlocking({
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireBlocking({
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireOrFail", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireOrFail();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquireOrFail();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.acquireOrFail();
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: release", () => {
-                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.release();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.release();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: releaseOrFail", () => {
-                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+        });
+        describe("method: release", () => {
+            test("Should dispatch UnownedReleaseTryLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                await lockProvider.create(key, { owner }).release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is expired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { ttl, owner }).release();
+                await delay(ttl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is expired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                await lock.release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                await lock.release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch ReleasedLockEvent when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                await lock.release();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+        });
+        describe("method: releaseOrFail", () => {
+            test("Should dispatch UnownedReleaseTryLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                try {
+                    await lockProvider.create(key, { owner }).releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is expired and released by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await lockProvider.create(key, { ttl }).acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { ttl, owner })
+                        .releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(ttl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedReleaseTryLockEvent when key is expired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                await delay(ttl);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_RELEASE_TRY, handlerFn);
+                try {
+                    await lock.releaseOrFail();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                try {
                     await lock.releaseOrFail();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock2.releaseOrFail();
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: forceRelease", () => {
-                test("Should dispatch ForceReleasedLockEvent when lock forcefully released", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.FORCE_RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.forceRelease();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refresh", () => {
-                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refresh(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock2.refresh(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refreshOrFail", () => {
-                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refreshOrFail(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    try {
-                        await lock2.refreshOrFail(newTTL);
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
+                }
+                catch {
+                    /* EMPTY */
+                }
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch ReleasedLockEvent when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                await lock.releaseOrFail();
+                await delay(TimeSpan.fromMilliseconds(10));
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
                 });
             });
         });
-        describe("LockProvider:", () => {
-            describe("method: run", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runBlocking", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runBlocking(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    }, {
-                        time: TimeSpan.fromMilliseconds(5),
-                        interval: TimeSpan.fromMilliseconds(5),
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await LazyPromise.delay(DELAY_TIME);
-                    });
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.runOrFail(async () => {
-                            await LazyPromise.delay(DELAY_TIME);
-                        });
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquire", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireBlocking", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireOrFail", () => {
-                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireOrFail();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquireOrFail();
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.acquireOrFail();
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe("a");
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: release", () => {
-                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.release();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.release();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: releaseOrFail", () => {
-                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock.releaseOrFail();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock2.releaseOrFail();
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: forceRelease", () => {
-                test("Should dispatch ForceReleasedLockEvent when lock forcefully released", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.FORCE_RELEASED, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.forceRelease();
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refresh", () => {
-                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refresh(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock2.refresh(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refreshOrFail", () => {
-                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProvider.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refreshOrFail(newTTL);
-                    await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner);
-                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProvider.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProvider.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
-                        event_ = event;
-                    });
-                    await LazyPromise.delay(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    try {
-                        await lock2.refreshOrFail(newTTL);
-                        await LazyPromise.delay(DELAY_TIME);
-                    }
-                    catch {
-                        /* Empty */
-                    }
-                    expect(event_?.key).toBe(key);
-                    expect(event_?.owner).toBe(owner2);
-                    await unsubscribe();
+        describe("method: forceRelease", () => {
+            test("Should not dispatch ForceReleasedLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                await lock.forceRelease();
+                expect(handlerFn).toHaveBeenCalledTimes(0);
+            });
+            test("Should dispatch ForceReleasedLockEvent when key is uenxpired", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                await lock.forceRelease();
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                });
+            });
+            test("Should dispatch ForceReleasedLockEvent when key is unexpireable", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProvider.create(key, { ttl });
+                await lock.acquire();
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                await lock.forceRelease();
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                });
+            });
+        });
+        describe("method: refresh", () => {
+            test("Should dispatch UnownedRefreshTryLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                const owner = "b";
+                await lockProvider.create(key, { owner }).refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is unexpireable and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                await lock2.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is unexpired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                await lock2.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is expired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                await lock2.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is expired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                await lock.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnexpireableKeyRefreshTryLockEvent when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNEXPIREABLE_KEY_REFRESH_TRY, handlerFn);
+                await lock.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
+                await lock.refresh(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: newTtl,
+                });
+            });
+        });
+        describe("method: refreshOrFail", () => {
+            test("Should dispatch UnownedRefreshTryLockEvent when key doesnt exists", async () => {
+                const key = "a";
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                const owner = "b";
+                try {
+                    await lockProvider
+                        .create(key, { owner })
+                        .refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is unexpireable and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                try {
+                    await lock2.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is unexpired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                try {
+                    await lock2.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is expired and refreshed by different owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock1 = lockProvider.create(key, { ttl });
+                await lock1.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner = "b";
+                const lock2 = lockProvider.create(key, { ttl, owner });
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                try {
+                    await lock2.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnownedRefreshTryLockEvent when key is expired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquire();
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNOWNED_REFRESH_TRY, handlerFn);
+                try {
+                    await lock.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch UnexpireableKeyRefreshTryLockEvent when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.UNEXPIREABLE_KEY_REFRESH_TRY, handlerFn);
+                try {
+                    await lock.refreshOrFail(newTtl);
+                }
+                catch {
+                    /* EMPTY */
+                }
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                });
+            });
+            test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const owner = "b";
+                const lock = lockProvider.create(key, { ttl, owner });
+                await lock.acquire();
+                const newTtl = TimeSpan.fromMinutes(1);
+                const handlerFn = vi.fn((_event) => { });
+                await lockProvider.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
+                await lock.refreshOrFail(newTtl);
+                expect(handlerFn).toHaveBeenCalledTimes(1);
+                expect(handlerFn).toHaveBeenCalledWith({
+                    key,
+                    owner,
+                    ttl: newTtl,
                 });
             });
         });
@@ -1954,17 +3144,17 @@ export function lockProviderTestSuite(settings) {
         test("Should preserve ttl", async () => {
             const key = "a";
             const owner = "b";
-            const ttl = TTL.multiply(2);
+            const ttl = TimeSpan.fromMilliseconds(50).multiply(2);
             const lock = lockProvider.create(key, {
                 owner,
                 ttl,
             });
             await lock.acquire();
             const deserializedLock = serde.deserialize(serde.serialize(lock));
-            const delayTime = TTL;
-            await LazyPromise.delay(delayTime);
+            const delayTime = TimeSpan.fromMilliseconds(50);
+            await delay(delayTime);
             expect(await deserializedLock.isLocked()).toBe(true);
-            await LazyPromise.delay(delayTime);
+            await delay(delayTime);
             expect(await deserializedLock.isLocked()).toBe(false);
         });
     });