@daiso-tech/core 0.49.1 → 0.50.0

package/dist/lock/implementations/test-utilities/{lock-provider.test-suite.js → lock-factory.test-suite.js}

@@ -5,11 +5,12 @@ import { vi, } from "vitest";
 import { FailedAcquireLockError, FailedReleaseLockError, LOCK_EVENTS, FailedRefreshLockError, LOCK_STATE, } from "../../../lock/contracts/_module.js";
 import {} from "../../../serde/contracts/_module.js";
 import { Task } from "../../../task/implementations/_module.js";
-import { TO_MILLISECONDS } from "../../../time-span/contracts/_module.js";
+import { createIsTimeSpanEqualityTester } from "../../../test-utilities/_module.js";
+import { TO_MILLISECONDS, } from "../../../time-span/contracts/_module.js";
 import { TimeSpan } from "../../../time-span/implementations/_module.js";
 import {} from "../../../utilities/_module.js";
 /**
- * The `lockProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ILock | `ILock`} with `vitest`.
+ * The `lockFactoryTestSuite` function simplifies the process of testing your custom implementation of {@link ILock | `ILock`} with `vitest`.
  *
  * IMPORT_PATH: `"@daiso-tech/core/lock/test-utilities"`
  * @group Utilities
@@ -17,23 +18,23 @@ import {} from "../../../utilities/_module.js";
  * ```ts
  * import { describe, expect, test, beforeEach } from "vitest";
  * import { MemoryLockAdapter } from "@daiso-tech/core/lock/memory-lock-adapter";
- * import { LockProvider } from "@daiso-tech/core/lock";
+ * import { LockFactory } from "@daiso-tech/core/lock";
  * import { EventBus } from "@daiso-tech/core/event-bus";
  * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/memory-event-bus-adapter";
- * import { lockProviderTestSuite } from "@daiso-tech/core/lock/test-utilities";
+ * import { lockFactoryTestSuite } from "@daiso-tech/core/lock/test-utilities";
  * import { Serde } from "@daiso-tech/core/serde";
  * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter";
  * import type { ILockData } from "@daiso-tech/core/lock/contracts";
  *
- * describe("class: LockProvider", () => {
- *     lockProviderTestSuite({
- *         createLockProvider: () => {
+ * describe("class: LockFactory", () => {
+ *     lockFactoryTestSuite({
+ *         createLockFactory: () => {
  *             const serde = new Serde(new SuperJsonSerdeAdapter());
- *             const lockProvider = new LockProvider({
+ *             const lockFactory = new LockFactory({
  *                 serde,
  *                 adapter: new MemoryLockAdapter(),
  *             });
- *             return { lockProvider, serde };
+ *             return { lockFactory, serde };
  *         },
  *         beforeEach,
  *         describe,
@@ -44,18 +45,18 @@ import {} from "../../../utilities/_module.js";
  * });
  * ```
  */
-export function lockProviderTestSuite(settings) {
-    const { expect, test, createLockProvider, describe, beforeEach, excludeEventTests = false, excludeSerdeTests = false, } = settings;
-    let lockProvider;
+export function lockFactoryTestSuite(settings) {
+    const { expect, test, createLockFactory, describe, beforeEach, excludeEventTests = false, excludeSerdeTests = false, retry = 0, delayBuffer = TimeSpan.fromMilliseconds(10), timeSpanEqualityBuffer = TimeSpan.fromMilliseconds(10), } = settings;
+    let lockFactory;
     let serde;
     async function delay(time) {
-        await Task.delay(time.addMilliseconds(10));
+        await Task.delay(TimeSpan.fromTimeSpan(time).addTimeSpan(delayBuffer));
     }
     const RETURN_VALUE = "RETURN_VALUE";
-    describe("ILockProvider tests:", () => {
+    describe("ILockFactory tests:", () => {
         beforeEach(async () => {
-            const { lockProvider: lockProvider_, serde: serde_ } = await createLockProvider();
-            lockProvider = lockProvider_;
+            const { lockFactory: lockFactory_, serde: serde_ } = await createLockFactory();
+            lockFactory = lockFactory_;
             serde = serde_;
         });
         describe("Api tests:", () => {
@@ -63,7 +64,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call acquireOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const acquireSpy = vi.spyOn(lock, "acquireOrFail");
@@ -75,7 +76,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call acquireOrFail before release method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const acquireSpy = vi.spyOn(lock, "acquireOrFail");
@@ -88,7 +89,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -100,7 +101,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release after acquireOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -113,7 +114,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release when an error is thrown", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -130,7 +131,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should propagate thrown error", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     class CustomError extends Error {
@@ -146,32 +147,28 @@ export function lockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await lockProvider
+                    await lockFactory
                         .create(key, {
                         ttl,
                     })
                         .runOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is expired", {
-                    retry: 10,
-                }, async () => {
+                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 lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await lockProvider
-                        .create(key, { ttl })
-                        .runOrFail(handlerFn);
+                    await lockFactory.create(key, { ttl }).runOrFail(handlerFn);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
+                test("Should call handler function when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -184,10 +181,10 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
+                test("Should call handler function when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -202,15 +199,15 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
+                test("Should not call handler function when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await lockProvider
+                        await lockFactory
                             .create(key, { ttl })
                             .runOrFail(handlerFn);
                     }
@@ -219,15 +216,15 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
-                test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
+                test("Should not call handler function when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await lockProvider
+                        await lockFactory
                             .create(key, { ttl })
                             .runOrFail(handlerFn);
                     }
@@ -239,7 +236,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return value when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
@@ -248,34 +245,32 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return value when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return value when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should not throw error when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should not throw error when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -284,22 +279,22 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -311,7 +306,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call acquireBlockingOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const acquireSpy = vi.spyOn(lock, "acquireBlockingOrFail");
@@ -326,7 +321,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call acquireBlockingOrFail before release method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const acquireSpy = vi.spyOn(lock, "acquireBlockingOrFail");
@@ -342,7 +337,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -357,7 +352,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release after acquireBlockingOrFail method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -373,7 +368,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should call release when an error is thrown", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const releaseSpy = vi.spyOn(lock, "release");
@@ -393,7 +388,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should propagate thrown error", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     class CustomError extends Error {
@@ -412,7 +407,7 @@ export function lockProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await lockProvider
+                    await lockFactory
                         .create(key, {
                         ttl,
                     })
@@ -422,17 +417,15 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is expired", {
-                    retry: 10,
-                }, async () => {
+                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 lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await lockProvider
+                    await lockFactory
                         .create(key, { ttl })
                         .runBlockingOrFail(handlerFn, {
                         time: TimeSpan.fromMilliseconds(5),
@@ -440,10 +433,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is unexpireable and acquired by same lockId", async () => {
+                test("Should call handler function when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -459,10 +452,10 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should call handler function when key is unexpired and acquired by same lockId", async () => {
+                test("Should call handler function when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -480,15 +473,15 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                 });
-                test("Should not call handler function when key is unexpireable and acquired by different lockId", async () => {
+                test("Should not call handler function when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await lockProvider
+                        await lockFactory
                             .create(key, { ttl })
                             .runBlockingOrFail(handlerFn, {
                             time: TimeSpan.fromMilliseconds(5),
@@ -500,15 +493,15 @@ export function lockProviderTestSuite(settings) {
                     }
                     expect(handlerFn).not.toHaveBeenCalled();
                 });
-                test("Should not call handler function when key is unexpired and acquired by different lockId", async () => {
+                test("Should not call handler function when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await lockProvider
+                        await lockFactory
                             .create(key, { ttl })
                             .runBlockingOrFail(handlerFn, {
                             time: TimeSpan.fromMilliseconds(5),
@@ -523,7 +516,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return value when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
@@ -538,9 +531,9 @@ export function lockProviderTestSuite(settings) {
                 test("Should return value when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -550,10 +543,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return value when key is unexpireable and acquired by same lockId", async () => {
+                test("Should return value when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -563,10 +556,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should return value when key is unexpired and acquired by same lockId", async () => {
+                test("Should return value when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -578,11 +571,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(RETURN_VALUE);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -592,11 +585,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
@@ -606,16 +599,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should retry acquire the lock", async () => {
+                test("Should retry acquire the lock", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl,
                     });
                     await lock1.acquire();
                     const handlerFn = vi.fn(() => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const lock2 = lockProvider.create(key, {
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const lock2 = lockFactory.create(key, {
                         ttl,
                     });
                     try {
@@ -636,57 +629,55 @@ export function lockProviderTestSuite(settings) {
                 test("Should return true when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
                         .acquire();
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return true when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquire();
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is unexpireable and acquired by same lockId", async () => {
+                test("Should return true when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.acquire();
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is unexpired and acquired by same lockId", async () => {
+                test("Should return true when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     const result = await lock.acquire();
                     expect(result).toBe(true);
                 });
-                test("Should return false when key is unexpireable and acquired by different lockId", async () => {
+                test("Should return false when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquire();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpired and acquired by different lockId", async () => {
+                test("Should return false when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquire();
                     expect(result).toBe(false);
@@ -696,57 +687,55 @@ export function lockProviderTestSuite(settings) {
                 test("Should not throw error when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, {
                         ttl,
                     })
                         .acquireOrFail();
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should not throw error when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquireOrFail();
+                    await lockFactory.create(key, { ttl }).acquireOrFail();
                     await delay(ttl);
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireOrFail();
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquireOrFail();
                     const result = lock.acquireOrFail();
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquireOrFail();
                     const result = lock.acquireOrFail();
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquireOrFail();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquireOrFail();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquireOrFail();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquireOrFail();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
@@ -756,7 +745,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return true when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
@@ -766,14 +755,12 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return true when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
@@ -781,10 +768,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is unexpireable and acquired by same lockId", async () => {
+                test("Should return true when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
@@ -792,10 +779,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(true);
                 });
-                test("Should return true when key is unexpired and acquired by same lockId", async () => {
+                test("Should return true when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -805,11 +792,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(true);
                 });
-                test("Should return false when key is unexpireable and acquired by different lockId", async () => {
+                test("Should return false when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
@@ -817,11 +804,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpired and acquired by different lockId", async () => {
+                test("Should return false when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
@@ -829,16 +816,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     expect(result).toBe(false);
                 });
-                test("Should retry acquire the lock", async () => {
+                test("Should retry acquire the lock", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl,
                     });
                     await lock1.acquire();
                     const handlerFn = vi.fn(() => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const lock2 = lockProvider.create(key, {
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const lock2 = lockFactory.create(key, {
                         ttl,
                     });
                     await lock2.acquireBlocking({
@@ -852,7 +839,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should not throw error when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, {
                         ttl,
                     })
@@ -862,14 +849,12 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is expired", {
-                    retry: 10,
-                }, async () => {
+                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 lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
@@ -877,10 +862,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is unexpireable and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
@@ -888,10 +873,10 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when key is unexpired and acquired by same lockId", async () => {
+                test("Should not throw error when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -901,11 +886,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
@@ -913,11 +898,11 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lockId", async () => {
+                test("Should throw FailedAcquireLockError when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
@@ -925,16 +910,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await expect(result).rejects.toBeInstanceOf(FailedAcquireLockError);
                 });
-                test("Should retry acquire the lock", async () => {
+                test("Should retry acquire the lock", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl,
                     });
                     await lock1.acquire();
                     const handlerFn = vi.fn(() => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
-                    const lock2 = lockProvider.create(key, {
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    const lock2 = lockFactory.create(key, {
                         ttl,
                     });
                     try {
@@ -953,107 +938,103 @@ export function lockProviderTestSuite(settings) {
                 test("Should return false when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
                         .release();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpireable and released by different lockId", async () => {
+                test("Should return false when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .release();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpired and released by different lockId", async () => {
+                test("Should return false when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .release();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is expired and released by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should return false when key is expired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = await lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = await lockFactory
                         .create(key, { ttl })
                         .release();
                     await delay(ttl);
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is expired and released by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should return false when key is expired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should return true when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should return true when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should not be reacquirable when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.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 lockId", async () => {
+                test("Should not be reacquirable when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.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 lockId", async () => {
+                test("Should be reacquirable when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await lock1.release();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(true);
                 });
-                test("Should be reacquirable when key is unexpired and released by same lockId", async () => {
+                test("Should be reacquirable when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await lock1.release();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(true);
                 });
@@ -1062,76 +1043,72 @@ export function lockProviderTestSuite(settings) {
                 test("Should throw FailedReleaseLockError when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, {
                         ttl,
                     })
                         .releaseOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseLockError);
                 });
-                test("Should throw FailedReleaseLockError when key is unexpireable and released by different lockId", async () => {
+                test("Should throw FailedReleaseLockError when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .releaseOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseLockError);
                 });
-                test("Should throw FailedReleaseLockError when key is unexpired and released by different lockId", async () => {
+                test("Should throw FailedReleaseLockError when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .releaseOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseLockError);
                 });
-                test("Should throw FailedReleaseLockError when key is expired and released by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should throw FailedReleaseLockError when key is expired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const result = lockProvider
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const result = lockFactory
                         .create(key, { ttl })
                         .releaseOrFail();
                     await delay(ttl);
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseLockError);
                 });
-                test("Should throw FailedReleaseLockError when key is expired and released by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should throw FailedReleaseLockError when key is expired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     await delay(ttl);
                     const result = lock.releaseOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseLockError);
                 });
-                test("Should not throw error when key is unexpireable and released by same lockId", async () => {
+                test("Should not throw error when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should not throw error when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should not be reacquirable when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     try {
                         await lock2.releaseOrFail();
                     }
@@ -1141,12 +1118,12 @@ export function lockProviderTestSuite(settings) {
                     const result = await lock2.acquire();
                     expect(result).toBe(false);
                 });
-                test("Should not be reacquirable when key is unexpired and released by different lockId", async () => {
+                test("Should not be reacquirable when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     try {
                         await lock2.releaseOrFail();
                     }
@@ -1156,23 +1133,23 @@ export function lockProviderTestSuite(settings) {
                     const result = await lock2.acquire();
                     expect(result).toBe(false);
                 });
-                test("Should be reacquirable when key is unexpireable and released by same lockId", async () => {
+                test("Should be reacquirable when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await lock1.releaseOrFail();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(true);
                 });
-                test("Should be reacquirable when key is unexpired and released by same lockId", async () => {
+                test("Should be reacquirable when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await lock1.releaseOrFail();
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(true);
                 });
@@ -1181,19 +1158,17 @@ export function lockProviderTestSuite(settings) {
                 test("Should return false when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
                         .forceRelease();
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return false when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1204,7 +1179,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return true when key is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.forceRelease();
                     expect(result).toBe(true);
@@ -1212,7 +1187,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return true when key is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const result = await lock.forceRelease();
                     expect(result).toBe(true);
@@ -1220,7 +1195,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should be reacquirable when key is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     await lock.forceRelease();
                     const result = await lock.acquire();
@@ -1229,7 +1204,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should be reacquirable when key is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     await lock.forceRelease();
                     const result = await lock.acquire();
@@ -1241,52 +1216,48 @@ export function lockProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const result = await lockProvider
+                    const result = await lockFactory
                         .create(key, {
                         ttl,
                     })
                         .refresh(newTtl);
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpireable and refreshed by different lockId", async () => {
+                test("Should return false when key is unexpireable and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.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 lockId", async () => {
+                test("Should return false when key is unexpired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.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 lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should return false when key is expired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.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 lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should return false when key is expired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1295,49 +1266,45 @@ export function lockProviderTestSuite(settings) {
                     const result = await lock.refresh(newTtl);
                     expect(result).toBe(false);
                 });
-                test("Should return false when key is unexpireable and refreshed by same lockId", async () => {
+                test("Should return false when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", async () => {
+                test("Should return true when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should not update expiration when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.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 lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(false);
                 });
-                test("Should update expiration when key is unexpired and refreshed by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should update expiration when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.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 lock2 = lockFactory.create(key, { ttl });
                     const result1 = await lock2.acquire();
                     expect(result1).toBe(false);
                     await delay(newTtl.divide(2));
@@ -1350,52 +1317,48 @@ export function lockProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const result = lockProvider
+                    const result = lockFactory
                         .create(key, {
                         ttl,
                     })
                         .refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should throw FailedRefreshLockError when key is unexpireable and refreshed by different lockId", async () => {
+                test("Should throw FailedRefreshLockError when key is unexpireable and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = lock2.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should throw FailedRefreshLockError when key is unexpired and refreshed by different lockId", async () => {
+                test("Should throw FailedRefreshLockError when key is unexpired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = lock2.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should throw FailedRefreshLockError when key is expired and refreshed by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should throw FailedRefreshLockError when key is expired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = lock2.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should throw FailedRefreshLockError when key is expired and refreshed by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should throw FailedRefreshLockError when key is expired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1404,30 +1367,28 @@ export function lockProviderTestSuite(settings) {
                     const result = lock.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should throw FailedRefreshLockError when key is unexpireable and refreshed by same lockId", async () => {
+                test("Should throw FailedRefreshLockError when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
                     const result = lock.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshLockError);
                 });
-                test("Should not throw error when key is unexpired and refreshed by same lockId", async () => {
+                test("Should not throw error when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.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 lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should not update expiration when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMilliseconds(50);
                     try {
@@ -1437,21 +1398,19 @@ export function lockProviderTestSuite(settings) {
                         /* EMPTY */
                     }
                     await delay(newTtl);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const result = await lock2.acquire();
                     expect(result).toBe(false);
                 });
-                test("Should update expiration when key is unexpired and refreshed by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should update expiration when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.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 lock2 = lockFactory.create(key, { ttl });
                     const result1 = await lock2.acquire();
                     expect(result1).toBe(false);
                     await delay(newTtl.divide(2));
@@ -1463,7 +1422,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return lock id of ILock instance", () => {
                     const key = "a";
                     const lockId = "1";
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         lockId,
                     });
                     expect(lock.id).toBe(lockId);
@@ -1471,7 +1430,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return lock id of ILock instance implicitly", () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     expect(lock.id).toBeTypeOf("string");
@@ -1482,7 +1441,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return null when given null ttl", () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     expect(lock.ttl).toBeNull();
@@ -1490,7 +1449,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return TimeSpan when given TimeSpan", () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(100);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     expect(lock.ttl).toBeInstanceOf(TimeSpan);
@@ -1501,7 +1460,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return ILockExpiredState when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const result = await lock.getState();
@@ -1509,12 +1468,10 @@ export function lockProviderTestSuite(settings) {
                         type: LOCK_STATE.EXPIRED,
                     });
                 });
-                test("Should return ILockExpiredState when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return ILockExpiredState when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1527,12 +1484,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should return ILockExpiredState when key is released with forceRelease method", async () => {
                     const key = "a";
                     const ttl1 = null;
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl: ttl1,
                     });
                     await lock1.acquire();
                     const ttl2 = null;
-                    const lock2 = lockProvider.create(key, {
+                    const lock2 = lockFactory.create(key, {
                         ttl: ttl2,
                     });
                     await lock2.acquire();
@@ -1545,12 +1502,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should return ILockExpiredState when key is released with release method", async () => {
                     const key = "a";
                     const ttl1 = null;
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl: ttl1,
                     });
                     await lock1.acquire();
                     const ttl2 = null;
-                    const lock2 = lockProvider.create(key, {
+                    const lock2 = lockFactory.create(key, {
                         ttl: ttl2,
                     });
                     await lock2.acquire();
@@ -1564,7 +1521,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should return ILockAcquiredState when key is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1575,9 +1532,12 @@ export function lockProviderTestSuite(settings) {
                     });
                 });
                 test("Should return ILockAcquiredState when key is unexpired", async () => {
+                    expect.addEqualityTesters([
+                        createIsTimeSpanEqualityTester(timeSpanEqualityBuffer),
+                    ]);
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
@@ -1587,14 +1547,14 @@ export function lockProviderTestSuite(settings) {
                         remainingTime: ttl,
                     });
                 });
-                test("Should return ILockUnavailableState when key is acquired by different owner", async () => {
+                test("Should return ILockUnavailableState when key is acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, {
+                    const lock1 = lockFactory.create(key, {
                         ttl,
                     });
                     await lock1.acquire();
-                    const lock2 = lockProvider.create(key, {
+                    const lock2 = lockFactory.create(key, {
                         ttl,
                     });
                     const state = await lock2.getState();
@@ -1610,11 +1570,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1626,16 +1586,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch AcquiredLockEvent when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1647,13 +1605,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1665,15 +1623,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1685,15 +1643,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, {
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1705,13 +1663,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     await lock.acquire();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1728,11 +1686,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1744,16 +1702,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch AcquiredLockEvent when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1765,13 +1721,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1783,15 +1739,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -1803,15 +1759,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, {
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     try {
                         await lock.acquireOrFail();
                     }
@@ -1828,13 +1784,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     try {
                         await lock.acquireOrFail();
                     }
@@ -1856,11 +1812,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -1875,16 +1831,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch AcquiredLockEvent when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -1899,13 +1853,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -1920,15 +1874,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -1943,20 +1897,21 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, {
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                    expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                         lock: expect.objectContaining({
                             getState: expect.any(Function),
@@ -1966,18 +1921,19 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     await lock.acquireBlocking({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                    expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                         lock: expect.objectContaining({
                             getState: expect.any(Function),
@@ -1992,11 +1948,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch AcquiredLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -2011,16 +1967,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch AcquiredLockEvent when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
+                    await lockFactory.create(key, { ttl }).acquire();
                     await delay(ttl);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -2035,13 +1989,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpireable and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -2056,15 +2010,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lockId", async () => {
+                test("Should dispatch AcquiredLockEvent when key is unexpired and acquired by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.ACQUIRED, handlerFn);
                     await lock.acquireBlockingOrFail({
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
@@ -2079,15 +2033,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpireable and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, {
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     try {
                         await lock.acquireBlockingOrFail({
                             time: TimeSpan.fromMilliseconds(5),
@@ -2097,7 +2051,8 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* EMPTY */
                     }
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                    expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                         lock: expect.objectContaining({
                             getState: expect.any(Function),
@@ -2107,13 +2062,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lockId", async () => {
+                test("Should dispatch UnavailableLockEvent when key is unexpired and acquired by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.UNAVAILABLE, handlerFn);
                     try {
                         await lock.acquireBlockingOrFail({
                             time: TimeSpan.fromMilliseconds(5),
@@ -2123,7 +2078,8 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* EMPTY */
                     }
-                    expect(handlerFn).toHaveBeenCalledTimes(1);
+                    expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                    expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                         lock: expect.objectContaining({
                             getState: expect.any(Function),
@@ -2138,11 +2094,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch ForceReleasedLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
                     await lock.forceRelease();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2155,14 +2111,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch ForceReleasedLockEvent when key is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch ForceReleasedLockEvent when key is expired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
                     await lock.acquire();
                     await delay(ttl);
                     await lock.forceRelease();
@@ -2180,9 +2134,9 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch ForceReleasedLockEvent when key exists and is acquired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FORCE_RELEASED, handlerFn);
                     await lock.acquire();
                     await lock.forceRelease();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2201,11 +2155,11 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch FailedReleaseLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.release();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2217,13 +2171,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is unexpireable and released by different lockId", async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.release();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2235,13 +2189,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is unexpired and released by different lockId", async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.release();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2253,15 +2207,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is expired and released by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is expired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.release();
                     await delay(ttl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2274,12 +2226,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is expired and released by same lockId", async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is expired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.acquire();
                     await delay(ttl);
                     await lock.release();
@@ -2293,12 +2245,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same lockId", async () => {
+                test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
                     await lock.acquire();
                     await lock.release();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2311,12 +2263,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch ReleasedLockEvent when key is unexpired and released by same lockId", async () => {
+                test("Should dispatch ReleasedLockEvent when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
                     await lock.acquire();
                     await lock.release();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2334,13 +2286,13 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch FailedReleaseLockEvent when key doesnt exists", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     try {
-                        await lock.release();
+                        await lock.releaseOrFail();
                     }
                     catch {
                         /* EMPTY */
@@ -2355,15 +2307,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is unexpireable and released by different lockId", async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is unexpireable and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     try {
-                        await lock.release();
+                        await lock.releaseOrFail();
                     }
                     catch {
                         /* EMPTY */
@@ -2378,15 +2330,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is unexpired and released by different lockId", async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is unexpired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     try {
-                        await lock.release();
+                        await lock.releaseOrFail();
                     }
                     catch {
                         /* EMPTY */
@@ -2401,15 +2353,13 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is expired and released by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is expired and released by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await lockProvider.create(key, { ttl }).acquire();
-                    const lock = lockProvider.create(key, { ttl });
+                    await lockFactory.create(key, { ttl }).acquire();
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     try {
                         await lock.release();
                     }
@@ -2427,14 +2377,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedReleaseLockEvent when key is expired and released by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedReleaseLockEvent when key is expired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_RELEASE, handlerFn);
                     await lock.acquire();
                     await delay(ttl);
                     try {
@@ -2453,12 +2401,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same lockId", async () => {
+                test("Should dispatch ReleasedLockEvent when key is unexpireable and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
                     await lock.acquire();
                     await lock.releaseOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2471,12 +2419,12 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch ReleasedLockEvent when key is unexpired and released by same lockId", async () => {
+                test("Should dispatch ReleasedLockEvent when key is unexpired and released by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.RELEASED, handlerFn);
                     await lock.acquire();
                     await lock.releaseOrFail();
                     expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -2495,11 +2443,11 @@ export function lockProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2511,15 +2459,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by different lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock2.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2531,15 +2479,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpired and refreshed by different lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock2.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2551,18 +2499,16 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock2.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2574,19 +2520,17 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2598,14 +2542,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by same lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     await lock.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2617,14 +2561,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same lockId", async () => {
+                test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
                     await lock.refresh(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2642,11 +2586,11 @@ export function lockProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock.refreshOrFail(newTtl);
                     }
@@ -2663,15 +2607,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by different lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock2.refreshOrFail(newTtl);
                     }
@@ -2688,15 +2632,15 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpired and refreshed by different lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock2.refreshOrFail(newTtl);
                     }
@@ -2713,18 +2657,16 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by different lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by different lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock1 = lockProvider.create(key, { ttl });
+                    const lock1 = lockFactory.create(key, { ttl });
                     await lock1.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
-                    const lock2 = lockProvider.create(key, { ttl });
+                    const lock2 = lockFactory.create(key, { ttl });
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock2.refreshOrFail(newTtl);
                     }
@@ -2741,19 +2683,17 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by same lockId", {
-                    retry: 10,
-                }, async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is expired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, {
+                    const lock = lockFactory.create(key, {
                         ttl,
                     });
                     await lock.acquire();
                     await delay(ttl);
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock.refreshOrFail(newTtl);
                     }
@@ -2770,14 +2710,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by same lockId", async () => {
+                test("Should dispatch FailedRefreshLockEvent when key is unexpireable and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = null;
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.FAILED_REFRESH, handlerFn);
                     try {
                         await lock.refreshOrFail(newTtl);
                     }
@@ -2794,14 +2734,14 @@ export function lockProviderTestSuite(settings) {
                         }),
                     }));
                 });
-                test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same lockId", async () => {
+                test("Should dispatch RefreshedLockEvent when key is unexpired and refreshed by same lock-id", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const lock = lockProvider.create(key, { ttl });
+                    const lock = lockFactory.create(key, { ttl });
                     await lock.acquire();
                     const newTtl = TimeSpan.fromMinutes(1);
                     const handlerFn = vi.fn((_event) => { });
-                    await lockProvider.events.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
+                    await lockFactory.events.addListener(LOCK_EVENTS.REFRESHED, handlerFn);
                     await lock.refreshOrFail(newTtl);
                     expect(handlerFn).toHaveBeenCalledTimes(1);
                     expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2819,7 +2759,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return ILockExpiredState when is derserialized and key doesnt exists", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProvider.create(key, {
+                const lock = lockFactory.create(key, {
                     ttl,
                 });
                 const deserializedLock = serde.deserialize(serde.serialize(lock));
@@ -2828,12 +2768,10 @@ export function lockProviderTestSuite(settings) {
                     type: LOCK_STATE.EXPIRED,
                 });
             });
-            test("Should return ILockExpiredState when is derserialized and key is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return ILockExpiredState when is derserialized and key is expired", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProvider.create(key, {
+                const lock = lockFactory.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -2847,12 +2785,12 @@ export function lockProviderTestSuite(settings) {
             test("Should return ILockExpiredState when is derserialized and all key is released with forceRelease method", async () => {
                 const key = "a";
                 const ttl1 = null;
-                const lock1 = lockProvider.create(key, {
+                const lock1 = lockFactory.create(key, {
                     ttl: ttl1,
                 });
                 await lock1.acquire();
                 const ttl2 = null;
-                const lock2 = lockProvider.create(key, {
+                const lock2 = lockFactory.create(key, {
                     ttl: ttl2,
                 });
                 await lock2.acquire();
@@ -2866,12 +2804,12 @@ export function lockProviderTestSuite(settings) {
             test("Should return ILockExpiredState when is derserialized and all key is released with release method", async () => {
                 const key = "a";
                 const ttl1 = null;
-                const lock1 = lockProvider.create(key, {
+                const lock1 = lockFactory.create(key, {
                     ttl: ttl1,
                 });
                 await lock1.acquire();
                 const ttl2 = null;
-                const lock2 = lockProvider.create(key, {
+                const lock2 = lockFactory.create(key, {
                     ttl: ttl2,
                 });
                 await lock2.acquire();
@@ -2886,7 +2824,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return ILockAcquiredState when is derserialized and key is unexpireable", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProvider.create(key, {
+                const lock = lockFactory.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -2898,29 +2836,30 @@ export function lockProviderTestSuite(settings) {
                 });
             });
             test("Should return ILockAcquiredState when is derserialized and key is unexpired", async () => {
+                expect.addEqualityTesters([
+                    createIsTimeSpanEqualityTester(timeSpanEqualityBuffer),
+                ]);
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProvider.create(key, {
+                const lock = lockFactory.create(key, {
                     ttl,
                 });
                 await lock.acquire();
                 const deserializedLock = serde.deserialize(serde.serialize(lock));
                 const state = await deserializedLock.getState();
-                const lockAcquiredState = state;
-                expect(state.type).toBe(LOCK_STATE.ACQUIRED);
-                expect(lockAcquiredState.remainingTime?.toMilliseconds()).toBeLessThan((lockAcquiredState.remainingTime?.toMilliseconds() ?? 0) +
-                    10);
-                expect(lockAcquiredState.remainingTime?.toMilliseconds()).toBeGreaterThan((lockAcquiredState.remainingTime?.toMilliseconds() ?? 0) -
-                    10);
+                expect(state).toEqual({
+                    type: LOCK_STATE.ACQUIRED,
+                    remainingTime: ttl,
+                });
             });
-            test("Should return ILockUnavailableState when is derserialized and key is acquired by different owner", async () => {
+            test("Should return ILockUnavailableState when is derserialized and key is acquired by different lock-id", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock1 = lockProvider.create(key, {
+                const lock1 = lockFactory.create(key, {
                     ttl,
                 });
                 await lock1.acquire();
-                const lock2 = lockProvider.create(key, {
+                const lock2 = lockFactory.create(key, {
                     ttl,
                 });
                 const deserializedLock2 = serde.deserialize(serde.serialize(lock2));
@@ -2933,4 +2872,4 @@ export function lockProviderTestSuite(settings) {
         });
     });
 }
-//# sourceMappingURL=lock-provider.test-suite.js.map
+//# sourceMappingURL=lock-factory.test-suite.js.map