@daiso-tech/core 0.49.0 → 0.50.0

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

@@ -4,6 +4,7 @@
 import { vi, } from "vitest";
 import {} from "../../../shared-lock/contracts/_module.js";
 import { Task } from "../../../task/implementations/_module.js";
+import {} from "../../../time-span/contracts/_module.js";
 import { TimeSpan } from "../../../time-span/implementations/_module.js";
 import {} from "../../../utilities/_module.js";
 /**
@@ -47,10 +48,10 @@ import {} from "../../../utilities/_module.js";
  * ```
  */
 export function sharedLockAdapterTestSuite(settings) {
-    const { expect, test, createAdapter, describe, beforeEach } = settings;
+    const { expect, test, createAdapter, describe, beforeEach, delayBuffer = TimeSpan.fromMilliseconds(10), } = settings;
     let adapter;
     async function delay(time) {
-        await Task.delay(time.addMilliseconds(10));
+        await Task.delay(TimeSpan.fromTimeSpan(time).addTimeSpan(delayBuffer));
     }
     describe("ISharedLockAdapter tests:", () => {
         beforeEach(async () => {
@@ -59,54 +60,52 @@ export function sharedLockAdapterTestSuite(settings) {
         describe("method: acquireWriter", () => {
             test("Should return true when key doesnt exists", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                const result = await adapter.acquireWriter(key, owner, ttl);
+                const result = await adapter.acquireWriter(key, sharedLockId, ttl);
                 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 owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 await delay(ttl);
-                const result = await adapter.acquireWriter(key, owner, null);
+                const result = await adapter.acquireWriter(key, sharedLockId, null);
                 expect(result).toBe(true);
             });
-            test("Should return true when key is unexpireable and acquired by same owner", async () => {
+            test("Should return true when key is unexpireable and acquired by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner, ttl);
-                const result = await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
+                const result = await adapter.acquireWriter(key, sharedLockId, ttl);
                 expect(result).toBe(true);
             });
-            test("Should return true when key is unexpired and acquired by same owner", async () => {
+            test("Should return true when key is unexpired and acquired by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
-                const result = await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
+                const result = await adapter.acquireWriter(key, sharedLockId, ttl);
                 expect(result).toBe(true);
             });
-            test("Should return false when key is unexpireable and acquired by different owner", async () => {
+            test("Should return false when key is unexpireable and acquired by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpired and acquired by different owner", async () => {
+            test("Should return false when key is unexpired and acquired by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(false);
             });
             test("Should return false when key is acquired as reader", async () => {
@@ -156,105 +155,101 @@ export function sharedLockAdapterTestSuite(settings) {
         describe("method: releaseWriter", () => {
             test("Should return false when key doesnt exists", async () => {
                 const key = "a";
-                const owner = "b";
-                const result = await adapter.releaseWriter(key, owner);
+                const sharedLockId = "b";
+                const result = await adapter.releaseWriter(key, sharedLockId);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpireable and released by different owner", async () => {
+            test("Should return false when key is unexpireable and released by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                const result = await adapter.releaseWriter(key, owner2);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.releaseWriter(key, sharedLockId2);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpired and released by different owner", async () => {
+            test("Should return false when key is unexpired and released by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                const result = await adapter.releaseWriter(key, owner2);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.releaseWriter(key, sharedLockId2);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is expired and released by different owner", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is expired and released by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                const result = await adapter.releaseWriter(key, owner2);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 await delay(ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.releaseWriter(key, sharedLockId2);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is expired and released by same owner", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is expired and released by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 await delay(ttl);
-                const result = await adapter.releaseWriter(key, owner);
+                const result = await adapter.releaseWriter(key, sharedLockId);
                 expect(result).toBe(false);
             });
-            test("Should return true when key is unexpireable and released by same owner", async () => {
+            test("Should return true when key is unexpireable and released by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner, ttl);
-                const result = await adapter.releaseWriter(key, owner);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
+                const result = await adapter.releaseWriter(key, sharedLockId);
                 expect(result).toBe(true);
             });
-            test("Should return true when key is unexpired and released by same owner", async () => {
+            test("Should return true when key is unexpired and released by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
-                const result = await adapter.releaseWriter(key, owner);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
+                const result = await adapter.releaseWriter(key, sharedLockId);
                 expect(result).toBe(true);
             });
-            test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
+            test("Should not be reacquirable when key is unexpireable and released by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                await adapter.releaseWriter(key, owner2);
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                await adapter.releaseWriter(key, sharedLockId2);
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(false);
             });
-            test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
+            test("Should not be reacquirable when key is unexpired and released by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
-                const owner2 = "c";
-                await adapter.releaseWriter(key, owner2);
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                const sharedLockId2 = "c";
+                await adapter.releaseWriter(key, sharedLockId2);
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(false);
             });
-            test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
+            test("Should be reacquirable when key is unexpireable and released by same shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
-                await adapter.releaseWriter(key, owner1);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                await adapter.releaseWriter(key, sharedLockId1);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(true);
             });
-            test("Should be reacquirable when key is unexpired and released by same owner", async () => {
+            test("Should be reacquirable when key is unexpired and released by same shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
-                await adapter.releaseWriter(key, owner1);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
+                await adapter.releaseWriter(key, sharedLockId1);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(true);
             });
             test("Should return false when key is acquired as reader", async () => {
@@ -307,41 +302,39 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceReleaseWriter(key);
                 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 owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 await delay(ttl);
                 const result = await adapter.forceReleaseWriter(key);
                 expect(result).toBe(false);
             });
             test("Should return true when key is uenxpired", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const result = await adapter.forceReleaseWriter(key);
                 expect(result).toBe(true);
             });
             test("Should return true when key is unexpireable", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const result = await adapter.forceReleaseWriter(key);
                 expect(result).toBe(true);
             });
             test("Should be reacquirable when key is force released", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 await adapter.forceReleaseWriter(key);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(true);
             });
             test("Should return false when key is acquired as reader", async () => {
@@ -391,103 +384,95 @@ export function sharedLockAdapterTestSuite(settings) {
         describe("method: refreshWriter", () => {
             test("Should return false when key doesnt exists", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const newTtl = TimeSpan.fromMinutes(1);
-                const result = await adapter.refreshWriter(key, owner, newTtl);
+                const result = await adapter.refreshWriter(key, sharedLockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpireable and refreshed by different owner", async () => {
+            test("Should return false when key is unexpireable and refreshed by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const owner2 = "c";
-                const result = await adapter.refreshWriter(key, owner2, newTtl);
+                const sharedLockId2 = "c";
+                const result = await adapter.refreshWriter(key, sharedLockId2, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpired and refreshed by different owner", async () => {
+            test("Should return false when key is unexpired and refreshed by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const owner2 = "c";
-                const result = await adapter.refreshWriter(key, owner2, newTtl);
+                const sharedLockId2 = "c";
+                const result = await adapter.refreshWriter(key, sharedLockId2, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is expired and refreshed by different owner", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is expired and refreshed by different shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 await delay(ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const owner2 = "c";
-                const result = await adapter.refreshWriter(key, owner2, newTtl);
+                const sharedLockId2 = "c";
+                const result = await adapter.refreshWriter(key, sharedLockId2, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is expired and refreshed by same owner", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is expired and refreshed by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 await delay(ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const result = await adapter.refreshWriter(key, owner, newTtl);
+                const result = await adapter.refreshWriter(key, sharedLockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is unexpireable and refreshed by same owner", async () => {
+            test("Should return false when key is unexpireable and refreshed by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const result = await adapter.refreshWriter(key, owner, newTtl);
+                const result = await adapter.refreshWriter(key, sharedLockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return true when key is unexpired and refreshed by same owner", async () => {
+            test("Should return true when key is unexpired and refreshed by same shared-lock-id", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const newTtl = TimeSpan.fromMinutes(1);
-                const result = await adapter.refreshWriter(key, owner, newTtl);
+                const result = await adapter.refreshWriter(key, sharedLockId, newTtl);
                 expect(result).toBe(true);
             });
-            test("Should not update expiration when key is unexpireable and refreshed by same owner", {
-                retry: 10,
-            }, async () => {
+            test("Should not update expiration when key is unexpireable and refreshed by same shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "1";
+                const sharedLockId1 = "1";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 const newTtl = TimeSpan.fromMilliseconds(50);
-                await adapter.refreshWriter(key, owner1, newTtl);
+                await adapter.refreshWriter(key, sharedLockId1, newTtl);
                 await delay(newTtl);
-                const owner2 = "2";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                const sharedLockId2 = "2";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(false);
             });
-            test("Should update expiration when key is unexpired and refreshed by same owner", {
-                retry: 10,
-            }, async () => {
+            test("Should update expiration when key is unexpired and refreshed by same shared-lock-id", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 const newTtl = TimeSpan.fromMilliseconds(100);
-                await adapter.refreshWriter(key, owner1, newTtl);
+                await adapter.refreshWriter(key, sharedLockId1, newTtl);
                 await delay(newTtl.divide(2));
-                const owner2 = "c";
-                const result1 = await adapter.acquireWriter(key, owner2, ttl);
+                const sharedLockId2 = "c";
+                const result1 = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result1).toBe(false);
                 await delay(newTtl.divide(2));
-                const result2 = await adapter.acquireWriter(key, owner2, ttl);
+                const result2 = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result2).toBe(true);
             });
             test("Should return false when key is acquired as reader", async () => {
@@ -550,9 +535,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should return true when key exists and slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return true when key exists and shared-lock-slot is expired", async () => {
                 const key = "a";
                 const lockId = "b";
                 const limit = 2;
@@ -619,9 +602,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(false);
             });
-            test("Should return true when one slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return true when one shared-lock-slot is expired", async () => {
                 const key = "a";
                 const limit = 2;
                 const lockId1 = "1";
@@ -651,7 +632,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should return true when slot exists, is unexpireable and acquired multiple times", async () => {
+            test("Should return true when shared-lock-slot exists, is unexpireable and acquired multiple times", async () => {
                 const key = "a";
                 const lockId = "b";
                 const limit = 2;
@@ -670,7 +651,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should return true when slot exists, is unexpired and acquired multiple times", async () => {
+            test("Should return true when shared-lock-slot exists, is unexpired and acquired multiple times", async () => {
                 const key = "a";
                 const lockId = "b";
                 const limit = 2;
@@ -689,7 +670,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should not acquire a slot when slot exists, is unexpireable and acquired multiple times", async () => {
+            test("Should not acquire a shared-lock-slot when shared-lock-slot exists, is unexpireable and acquired multiple times", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -715,7 +696,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should not acquire a slot when slot exists, is unexpired and acquired multiple times", async () => {
+            test("Should not acquire a shared-lock-slot when shared-lock-slot exists, is unexpired and acquired multiple times", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = TimeSpan.fromMilliseconds(50);
@@ -741,7 +722,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result).toBe(true);
             });
-            test("Should not update limit when slot count is more than 0", async () => {
+            test("Should not update limit when shared-lock-slot count is more than 0", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -823,7 +804,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.releaseReader(noneExistingKey, lockId);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot doesnt exists", async () => {
+            test("Should return false when shared-lock-slot doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
                 const limit = 2;
@@ -838,34 +819,14 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.releaseReader(key, noneExistingLockId);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when shared-lock-slot is expired", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
                 const limit = 2;
-                const lockId1 = "1";
-                await adapter.acquireReader({
-                    key,
-                    lockId: lockId1,
-                    ttl,
-                    limit,
-                });
-                await delay(ttl);
-                const lockId2 = "2";
-                const result = await adapter.releaseReader(key, lockId2);
-                expect(result).toBe(false);
-            });
-            test("Should return false when slot exists, is expired", {
-                retry: 10,
-            }, async () => {
-                const key = "a";
-                const lockId = "b";
-                const ttl = TimeSpan.fromMilliseconds(50);
-                const limit = 2;
+                const lockId = "1";
                 await adapter.acquireReader({
                     key,
-                    lockId,
+                    lockId: lockId,
                     ttl,
                     limit,
                 });
@@ -873,7 +834,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.releaseReader(key, lockId);
                 expect(result).toBe(false);
             });
-            test("Should return true when slot exists, is unexpired", async () => {
+            test("Should return true when shared-lock-slot exists and is unexpired", async () => {
                 const key = "a";
                 const lockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
@@ -887,7 +848,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.releaseReader(key, lockId);
                 expect(result).toBe(true);
             });
-            test("Should return true when slot exists, is unexpireable", async () => {
+            test("Should return true when shared-lock-slot exists and is unexpireable", async () => {
                 const key = "a";
                 const lockId = "b";
                 const ttl = null;
@@ -901,7 +862,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.releaseReader(key, lockId);
                 expect(result).toBe(true);
             });
-            test("Should update limit when slot count is 0", async () => {
+            test("Should update limit when shared-lock-slot count is 0", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -955,7 +916,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result3).toBe(false);
             });
-            test("Should decrement slot count when one slot is released", async () => {
+            test("Should decrement shared-lock-slot count when one shared-lock-slot is released", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -1034,9 +995,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceReleaseAllReaders(noneExistingKey);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when shared-lock-slot is expired", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
                 const limit = 2;
@@ -1051,7 +1010,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceReleaseAllReaders(key);
                 expect(result).toBe(false);
             });
-            test("Should return false when no slots are acquired", async () => {
+            test("Should return false when no shared-lock-slots are acquired", async () => {
                 const key = "a";
                 const ttl = null;
                 const lockId1 = "1";
@@ -1074,7 +1033,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceReleaseAllReaders(key);
                 expect(result).toBe(false);
             });
-            test("Should return true when at least 1 slot is acquired", async () => {
+            test("Should return true when at least 1 shared-lock-slot is acquired", async () => {
                 const key = "a";
                 const ttl = null;
                 const limit = 2;
@@ -1088,7 +1047,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceReleaseAllReaders(key);
                 expect(result).toBe(true);
             });
-            test("Should make all slots reacquirable", async () => {
+            test("Should make all shared-lock-slots reacquirable", async () => {
                 const key = "a";
                 const limit = 2;
                 const lockId1 = "1";
@@ -1127,7 +1086,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result2).toBe(true);
             });
-            test("Should update limit when slot count is 0", async () => {
+            test("Should update limit when shared-lock-slot count is 0", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -1221,7 +1180,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.refreshReader(noneExistingKey, lockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot doesnt exists", async () => {
+            test("Should return false when shared-lock-slot doesnt exists", async () => {
                 const key = "a";
                 const ttl = null;
                 const limit = 2;
@@ -1237,9 +1196,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.refreshReader(key, noneExistingLockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when shared-lock-slot is expired", async () => {
                 const key = "a";
                 const lockId = "b";
                 const limit = 2;
@@ -1255,25 +1212,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.refreshReader(key, lockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return false when slot exists, is expired", {
-                retry: 10,
-            }, async () => {
-                const key = "a";
-                const lockId = "b";
-                const ttl = TimeSpan.fromMilliseconds(50);
-                const limit = 2;
-                await adapter.acquireReader({
-                    key,
-                    lockId,
-                    ttl,
-                    limit,
-                });
-                await delay(ttl);
-                const newTtl = TimeSpan.fromMilliseconds(100);
-                const result = await adapter.refreshReader(key, lockId, newTtl);
-                expect(result).toBe(false);
-            });
-            test("Should return false when slot exists, is unexpireable", async () => {
+            test("Should return false when shared-lock-slot exists and is unexpireable", async () => {
                 const key = "a";
                 const lockId = "b";
                 const ttl = null;
@@ -1288,7 +1227,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.refreshReader(key, lockId, newTtl);
                 expect(result).toBe(false);
             });
-            test("Should return true when slot exists, is unexpired", async () => {
+            test("Should return true when shared-lock-slot exists and is unexpired", async () => {
                 const key = "a";
                 const lockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
@@ -1303,9 +1242,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.refreshReader(key, lockId, newTtl);
                 expect(result).toBe(true);
             });
-            test("Should not update expiration when slot exists, is unexpireable", {
-                retry: 10,
-            }, async () => {
+            test("Should not update expiration when shared-lock-slot exists and is unexpireable", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl1 = null;
@@ -1336,9 +1273,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result1).toBe(false);
             });
-            test("Should update expiration when slot exists, is unexpired", {
-                retry: 10,
-            }, async () => {
+            test("Should update expiration when shared-lock-slot exists and is unexpired", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl1 = null;
@@ -1409,46 +1344,42 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is acquired as writer and is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is acquired as writer and is expired", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 await delay(ttl);
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(false);
             });
             test("Should return true when key is acquired as writer and is uenxpired", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(true);
             });
             test("Should return true when key is acquired as writer and is unexpireable", async () => {
                 const key = "a";
-                const owner = "b";
+                const sharedLockId = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner, ttl);
+                await adapter.acquireWriter(key, sharedLockId, ttl);
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(true);
             });
             test("Should be reacquirable when key is acquired as writer and is force released", async () => {
                 const key = "a";
-                const owner1 = "b";
+                const sharedLockId1 = "b";
                 const ttl = null;
-                await adapter.acquireWriter(key, owner1, ttl);
+                await adapter.acquireWriter(key, sharedLockId1, ttl);
                 await adapter.forceRelease(key);
-                const owner2 = "c";
-                const result = await adapter.acquireWriter(key, owner2, ttl);
+                const sharedLockId2 = "c";
+                const result = await adapter.acquireWriter(key, sharedLockId2, ttl);
                 expect(result).toBe(true);
             });
-            test("Should return false when key is acquired as reader and slot is expired", {
-                retry: 10,
-            }, async () => {
+            test("Should return false when key is acquired as reader and shared-lock-slot is expired", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
                 const limit = 2;
@@ -1463,7 +1394,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(false);
             });
-            test("Should return false when key is acquired as reader and no slots are acquired", async () => {
+            test("Should return false when key is acquired as reader and no shared-lock-slots are acquired", async () => {
                 const key = "a";
                 const ttl = null;
                 const lockId1 = "1";
@@ -1486,7 +1417,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(false);
             });
-            test("Should return true when key is acquired as reader and at least 1 slot is acquired", async () => {
+            test("Should return true when key is acquired as reader and at least 1 shared-lock-slot is acquired", async () => {
                 const key = "a";
                 const ttl = null;
                 const limit = 2;
@@ -1500,7 +1431,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 const result = await adapter.forceRelease(key);
                 expect(result).toBe(true);
             });
-            test("Should make all slots reacquirable when key is acquired as reader", async () => {
+            test("Should make all shared-lock-slots reacquirable when key is acquired as reader", async () => {
                 const key = "a";
                 const limit = 2;
                 const lockId1 = "1";
@@ -1539,7 +1470,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
                 expect(result2).toBe(true);
             });
-            test("Should update limit when key is reader mode and slot count is 0", async () => {
+            test("Should update limit when key is reader mode and shared-lock-slot count is 0", async () => {
                 const key = "a";
                 const limit = 2;
                 const ttl = null;
@@ -1600,13 +1531,11 @@ export function sharedLockAdapterTestSuite(settings) {
                 expect(sharedLockData).toBeNull();
             });
             describe("Writer state:", () => {
-                test("Should return null when writer lock is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return null when writer lock is expired", async () => {
                     const key = "a";
-                    const owner = "b";
+                    const sharedLockId = "b";
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    await adapter.acquireWriter(key, owner, ttl);
+                    await adapter.acquireWriter(key, sharedLockId, ttl);
                     await delay(ttl);
                     const sharedLockData = await adapter.getState(key);
                     expect(sharedLockData).toBeNull();
@@ -1614,8 +1543,8 @@ export function sharedLockAdapterTestSuite(settings) {
                 test("Should return null when writer lock is released with forceReleaseWriter method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const owner = "1";
-                    await adapter.acquireWriter(key, owner, ttl);
+                    const sharedLockId = "1";
+                    await adapter.acquireWriter(key, sharedLockId, ttl);
                     await adapter.forceReleaseWriter(key);
                     const sharedLockData = await adapter.getState(key);
                     expect(sharedLockData).toBeNull();
@@ -1623,8 +1552,8 @@ export function sharedLockAdapterTestSuite(settings) {
                 test("Should return null when writer lock is released with forceRelease method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const owner = "1";
-                    await adapter.acquireWriter(key, owner, ttl);
+                    const sharedLockId = "1";
+                    await adapter.acquireWriter(key, sharedLockId, ttl);
                     await adapter.forceRelease(key);
                     const sharedLockData = await adapter.getState(key);
                     expect(sharedLockData).toBeNull();
@@ -1632,35 +1561,35 @@ export function sharedLockAdapterTestSuite(settings) {
                 test("Should return null when lock is released with releaseWriter method", async () => {
                     const key = "a";
                     const ttl = null;
-                    const owner = "1";
-                    await adapter.acquireWriter(key, owner, ttl);
-                    await adapter.releaseWriter(key, owner);
+                    const sharedLockId = "1";
+                    await adapter.acquireWriter(key, sharedLockId, ttl);
+                    await adapter.releaseWriter(key, sharedLockId);
                     const sharedLockData = await adapter.getState(key);
                     expect(sharedLockData).toBeNull();
                 });
                 test("Should return unactive reader and active writer when writer lock exists and is uenxpireable", async () => {
                     const key = "a";
                     const ttl = null;
-                    const owner = "1";
-                    await adapter.acquireWriter(key, owner, ttl);
+                    const sharedLockId = "1";
+                    await adapter.acquireWriter(key, sharedLockId, ttl);
                     const state = await adapter.getState(key);
                     expect(state).toEqual({
                         reader: null,
                         writer: {
-                            owner,
+                            owner: sharedLockId,
                             expiration: ttl,
                         },
                     });
                 });
                 test("Should return unactive reader and active writer when writer lock exists and is unexpired", async () => {
                     const key = "a";
-                    const owner = "1";
+                    const sharedLockId = "1";
                     const ttl = TimeSpan.fromMinutes(5);
                     let expiration;
                     try {
                         vi.useFakeTimers();
                         expiration = ttl.toEndDate();
-                        await adapter.acquireWriter(key, owner, ttl);
+                        await adapter.acquireWriter(key, sharedLockId, ttl);
                     }
                     finally {
                         vi.useRealTimers();
@@ -1668,7 +1597,10 @@ export function sharedLockAdapterTestSuite(settings) {
                     const state = await adapter.getState(key);
                     expect(state).toEqual({
                         reader: null,
-                        writer: { owner, expiration },
+                        writer: {
+                            owner: sharedLockId,
+                            expiration,
+                        },
                     });
                 });
                 test("Should return active reader and unactive writer when acquired as reader first", async () => {
@@ -1683,8 +1615,8 @@ export function sharedLockAdapterTestSuite(settings) {
                         ttl,
                     });
                     const keyB = "a";
-                    const owner = "2";
-                    await adapter.acquireWriter(keyB, owner, ttl);
+                    const sharedLockId = "2";
+                    await adapter.acquireWriter(keyB, sharedLockId, ttl);
                     const state = await adapter.getState(keyB);
                     expect({
                         ...state,
@@ -1704,9 +1636,7 @@ export function sharedLockAdapterTestSuite(settings) {
                 });
             });
             describe("Reader state:", () => {
-                test("Should return null when slot is expired", {
-                    retry: 10,
-                }, async () => {
+                test("Should return null when shared-lock-slot is expired", async () => {
                     const key = "a";
                     const lockId = "b";
                     const ttl = TimeSpan.fromMilliseconds(50);
@@ -1721,7 +1651,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const result = await adapter.getState(key);
                     expect(result).toBeNull();
                 });
-                test("Should return null when all slots are released with forceReleaseAllReaders method", async () => {
+                test("Should return null when all shared-lock-slots are released with forceReleaseAllReaders method", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
@@ -1744,7 +1674,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const result = await adapter.getState(key);
                     expect(result).toBeNull();
                 });
-                test("Should return null when all slots are released with forceRelease method", async () => {
+                test("Should return null when all shared-lock-slots are released with forceRelease method", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
@@ -1767,7 +1697,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const result = await adapter.getState(key);
                     expect(result).toBeNull();
                 });
-                test("Should return null when all slots are released with releaseReader method", async () => {
+                test("Should return null when all shared-lock-slots are released with releaseReader method", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
@@ -1805,7 +1735,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const state = await adapter.getState(key);
                     expect(state?.reader?.limit).toBe(limit);
                 });
-                test("Should return slot count when key exists", async () => {
+                test("Should return shared-lock-slot count when key exists", async () => {
                     const key = "a";
                     const limit = 3;
                     const lockId1 = "1";
@@ -1827,7 +1757,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const state = await adapter.getState(key);
                     expect(state?.reader?.acquiredSlots.size).toBe(2);
                 });
-                test("Should return slot when key exists, slot exists and slot is unexpired", async () => {
+                test("Should return shared-lock-slot when key exists, shared-lock-slot exists and shared-lock-slot is unexpired", async () => {
                     const key = "a";
                     const limit = 3;
                     const lockId = "a";
@@ -1855,7 +1785,7 @@ export function sharedLockAdapterTestSuite(settings) {
                         },
                     });
                 });
-                test("Should return slot when key exists, slot exists and slot is unexpireable", async () => {
+                test("Should return shared-lock-slot when key exists, shared-lock-slot exists and shared-lock-slot is unexpireable", async () => {
                     const key = "a";
                     const limit = 3;
                     const lockId = "a";
@@ -1894,8 +1824,8 @@ export function sharedLockAdapterTestSuite(settings) {
                 test("Should return unactive reader and active writer when acquired as reader first", async () => {
                     const ttl = null;
                     const keyB = "a";
-                    const owner = "2";
-                    await adapter.acquireWriter(keyB, owner, ttl);
+                    const sharedLockId = "2";
+                    await adapter.acquireWriter(keyB, sharedLockId, ttl);
                     const keyA = "a";
                     const lockId = "1";
                     const limit = 4;
@@ -1908,7 +1838,7 @@ export function sharedLockAdapterTestSuite(settings) {
                     const state = await adapter.getState(keyB);
                     expect(state).toEqual({
                         writer: {
-                            owner,
+                            owner: sharedLockId,
                             expiration: ttl,
                         },
                         reader: null,