@daiso-tech/core 0.40.0 → 0.41.0

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

@@ -1,11 +1,11 @@
 /**
  * @module Lock
  */
-import {} from "vitest";
-import { LOCK_REFRESH_RESULT, } from "../../../lock/contracts/_module-exports.js";
+import { vi, } from "vitest";
+import {} from "../../../lock/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
-import { TimeSpan } from "../../../utilities/_module-exports.js";
-import { LazyPromise } from "../../../async/_module-exports.js";
+import { Task } from "../../../task/_module-exports.js";
+import { TimeSpan } from "../../../time-span/implementations/_module-exports.js";
 /**
  * The `lockAdapterTestSuite` function simplifies the process of testing your custom implementation of {@link ILockAdapter | `ILockAdapter`} with `vitest`.
  *
@@ -21,7 +21,7 @@ import { LazyPromise } from "../../../async/_module-exports.js";
  *     RedisContainer,
  *     type StartedRedisContainer,
  * } from "@testcontainers/redis";
- * import { TimeSpan } from "@daiso-tech/core/utilities";
+ * import { TimeSpan } from "@daiso-tech/core/time-span" from "@daiso-tech/core/time-span";
  *
  * const timeout = TimeSpan.fromMinutes(2);
  * describe("class: RedisLockAdapter", () => {
@@ -49,300 +49,384 @@ import { LazyPromise } from "../../../async/_module-exports.js";
 export function lockAdapterTestSuite(settings) {
     const { expect, test, createAdapter, describe, beforeEach } = settings;
     let adapter;
-    beforeEach(async () => {
-        adapter = await createAdapter();
-    });
     async function delay(time) {
-        await LazyPromise.delay(time.addMilliseconds(10));
+        await Task.delay(time.addMilliseconds(10));
     }
-    describe("method: acquire", () => {
-        test("Should return true when key doesnt exists", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = null;
-            const result = await adapter.acquire(key, owner, ttl);
-            expect(result).toBe(true);
-        });
-        test("Should return true when key is expired", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            await delay(ttl);
-            const result = await adapter.acquire(key, owner, null);
-            expect(result).toBe(true);
-        });
-        test("Should return false when key is unexpireable and acquired by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.acquire(key, owner, ttl);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is unexpired and acquired by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.acquire(key, owner, ttl);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is unexpireable and acquired by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is unexpired and acquired by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(false);
-        });
-    });
-    describe("method: release", () => {
-        test("Should return false when key doesnt exists", async () => {
-            const key = "a";
-            const owner = "b";
-            const result = await adapter.release(key, owner);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is unexpireable and released by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            const result = await adapter.release(key, owner2);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is unexpired and released by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            const result = await adapter.release(key, owner2);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is expired and released by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            const result = await adapter.release(key, owner2);
-            await delay(ttl);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is expired and released by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            await delay(ttl);
-            const result = await adapter.release(key, owner);
-            expect(result).toBe(false);
-        });
-        test("Should return true when key is unexpireable and released by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.release(key, owner);
-            expect(result).toBe(true);
-        });
-        test("Should return true when key is unexpired and released by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.release(key, owner);
-            expect(result).toBe(true);
-        });
-        test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            await adapter.release(key, owner2);
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(false);
-        });
-        test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const owner2 = "c";
-            await adapter.release(key, owner2);
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(false);
-        });
-        test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            await adapter.release(key, owner1);
-            const owner2 = "c";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(true);
-        });
-        test("Should be reacquirable when key is unexpired and released by same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            await adapter.release(key, owner1);
-            const owner2 = "c";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(true);
-        });
-    });
-    describe("method: forceRelease", () => {
-        test("Should return false when key doesnt exists", async () => {
-            const key = "a";
-            const result = await adapter.forceRelease(key);
-            expect(result).toBe(false);
-        });
-        test("Should return false when key is expired", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            await delay(ttl);
-            const result = await adapter.forceRelease(key);
-            expect(result).toBe(false);
-        });
-        test("Should return true when key is uenxpired", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.forceRelease(key);
-            expect(result).toBe(true);
-        });
-        test("Should return true when key is unexpireable", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner, ttl);
-            const result = await adapter.forceRelease(key);
-            expect(result).toBe(true);
-        });
-        test("Should be reacquirable when force released", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            await adapter.forceRelease(key);
-            const owner2 = "c";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(true);
-        });
-    });
-    describe("method: refresh", () => {
-        test("Should return LOCK_REFRESH.UNOWNED_REFRESH when key doesnt exists", async () => {
-            const key = "a";
-            const owner = "b";
-            const newTtl = TimeSpan.fromMinutes(1);
-            const result = await adapter.refresh(key, owner, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNOWNED_REFRESH);
-        });
-        test("Should return LOCK_REFRESH.UNOWNED_REFRESH when key is unexpireable and refreshed by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const owner2 = "c";
-            const result = await adapter.refresh(key, owner2, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNOWNED_REFRESH);
-        });
-        test("Should return LOCK_REFRESH.UNOWNED_REFRESH when key is unexpired and refreshed by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const owner2 = "c";
-            const result = await adapter.refresh(key, owner2, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNOWNED_REFRESH);
-        });
-        test("Should return LOCK_REFRESH.UNOWNED_REFRESH when key is expired and refreshed by different owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            await delay(ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const owner2 = "c";
-            const result = await adapter.refresh(key, owner2, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNOWNED_REFRESH);
+    describe("Reusable tests:", () => {
+        beforeEach(async () => {
+            adapter = await createAdapter();
         });
-        test("Should return LOCK_REFRESH.UNOWNED_REFRESH when key is expired and refreshed by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            await delay(ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const result = await adapter.refresh(key, owner, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNOWNED_REFRESH);
+        describe("method: acquire", () => {
+            test("Should return true when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                const result = await adapter.acquire(key, owner, ttl);
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is expired", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                await delay(ttl);
+                const result = await adapter.acquire(key, owner, null);
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpireable and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.acquire(key, owner, ttl);
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpired and acquired by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.acquire(key, owner, ttl);
+                expect(result).toBe(true);
+            });
+            test("Should return false when key is unexpireable and acquired by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and acquired by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(false);
+            });
         });
-        test("Should return LOCK_REFRESH.UNEXPIRABLE_KEY when key is unexpireable and refreshed by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner, ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const result = await adapter.refresh(key, owner, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.UNEXPIRABLE_KEY);
+        describe("method: release", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const result = await adapter.release(key, owner);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                const result = await adapter.release(key, owner2);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                const result = await adapter.release(key, owner2);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and released by different owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                const result = await adapter.release(key, owner2);
+                await delay(ttl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and released by same owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                await delay(ttl);
+                const result = await adapter.release(key, owner);
+                expect(result).toBe(false);
+            });
+            test("Should return true when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.release(key, owner);
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.release(key, owner);
+                expect(result).toBe(true);
+            });
+            test("Should not be reacquirable when key is unexpireable and released by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                await adapter.release(key, owner2);
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(false);
+            });
+            test("Should not be reacquirable when key is unexpired and released by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const owner2 = "c";
+                await adapter.release(key, owner2);
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(false);
+            });
+            test("Should be reacquirable when key is unexpireable and released by same owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                await adapter.release(key, owner1);
+                const owner2 = "c";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(true);
+            });
+            test("Should be reacquirable when key is unexpired and released by same owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                await adapter.release(key, owner1);
+                const owner2 = "c";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(true);
+            });
         });
-        test("Should return LOCK_REFRESH.REFRESHED when key is unexpired and refreshed by same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner, ttl);
-            const newTtl = TimeSpan.fromMinutes(1);
-            const result = await adapter.refresh(key, owner, newTtl);
-            expect(result).toBe(LOCK_REFRESH_RESULT.REFRESHED);
+        describe("method: forceRelease", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const result = await adapter.forceRelease(key);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                await delay(ttl);
+                const result = await adapter.forceRelease(key);
+                expect(result).toBe(false);
+            });
+            test("Should return true when key is uenxpired", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.forceRelease(key);
+                expect(result).toBe(true);
+            });
+            test("Should return true when key is unexpireable", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner, ttl);
+                const result = await adapter.forceRelease(key);
+                expect(result).toBe(true);
+            });
+            test("Should be reacquirable when force released", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                await adapter.forceRelease(key);
+                const owner2 = "c";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(true);
+            });
         });
-        test("Should not update expiration when key is unexpireable and refreshed by same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = null;
-            await adapter.acquire(key, owner1, ttl);
-            const newTtl = TimeSpan.fromMilliseconds(50);
-            await adapter.refresh(key, owner1, newTtl);
-            await delay(newTtl);
-            const owner2 = "b";
-            const result = await adapter.acquire(key, owner2, ttl);
-            expect(result).toBe(false);
+        describe("method: refresh", () => {
+            test("Should return false when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await adapter.refresh(key, owner, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpireable and refreshed by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner2 = "c";
+                const result = await adapter.refresh(key, owner2, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpired and refreshed by different owner", async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner2 = "c";
+                const result = await adapter.refresh(key, owner2, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and refreshed by different owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const owner2 = "c";
+                const result = await adapter.refresh(key, owner2, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is expired and refreshed by same owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                await delay(ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await adapter.refresh(key, owner, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return false when key is unexpireable and refreshed by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner, ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await adapter.refresh(key, owner, newTtl);
+                expect(result).toBe(false);
+            });
+            test("Should return true when key is unexpired and refreshed by same owner", async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                const newTtl = TimeSpan.fromMinutes(1);
+                const result = await adapter.refresh(key, owner, newTtl);
+                expect(result).toBe(true);
+            });
+            test("Should not update expiration when key is unexpireable and refreshed by same owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = null;
+                await adapter.acquire(key, owner1, ttl);
+                const newTtl = TimeSpan.fromMilliseconds(50);
+                await adapter.refresh(key, owner1, newTtl);
+                await delay(newTtl);
+                const owner2 = "a";
+                const result = await adapter.acquire(key, owner2, ttl);
+                expect(result).toBe(false);
+            });
+            test("Should update expiration when key is unexpired and refreshed by same owner", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner1 = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner1, ttl);
+                const newTtl = TimeSpan.fromMilliseconds(100);
+                await adapter.refresh(key, owner1, newTtl);
+                await delay(newTtl.divide(2));
+                const owner2 = "c";
+                const result1 = await adapter.acquire(key, owner2, ttl);
+                expect(result1).toBe(false);
+                await delay(newTtl.divide(2));
+                const result2 = await adapter.acquire(key, owner2, ttl);
+                expect(result2).toBe(true);
+            });
         });
-        test("Should update expiration when key is unexpired and refreshed by same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const ttl = TimeSpan.fromMilliseconds(50);
-            await adapter.acquire(key, owner1, ttl);
-            const newTtl = TimeSpan.fromMilliseconds(100);
-            await adapter.refresh(key, owner1, newTtl);
-            await delay(newTtl.divide(2));
-            const owner2 = "c";
-            const result1 = await adapter.acquire(key, owner2, ttl);
-            expect(result1).toBe(false);
-            await delay(newTtl.divide(2));
-            const result2 = await adapter.acquire(key, owner2, ttl);
-            expect(result2).toBe(true);
+        describe("method: getState", () => {
+            test("Should return null when key doesnt exists", async () => {
+                const key = "a";
+                const lockData = await adapter.getState(key);
+                expect(lockData).toBeNull();
+            });
+            test("Should return null when lock is expired", {
+                retry: 10,
+            }, async () => {
+                const key = "a";
+                const owner = "b";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await adapter.acquire(key, owner, ttl);
+                await delay(ttl);
+                const lockData = await adapter.getState(key);
+                expect(lockData).toBeNull();
+            });
+            test("Should return null when lock is released with forceRelease method", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "1";
+                await adapter.acquire(key, owner, ttl);
+                await adapter.forceRelease(key);
+                const lockData = await adapter.getState(key);
+                expect(lockData).toBeNull();
+            });
+            test("Should return null when lock is released with release method", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "1";
+                await adapter.acquire(key, owner, ttl);
+                await adapter.release(key, owner);
+                const lockData = await adapter.getState(key);
+                expect(lockData).toBeNull();
+            });
+            test("Should return ILockAdapterState when lock exists and is uenxpireable", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "1";
+                await adapter.acquire(key, owner, ttl);
+                const state = await adapter.getState(key);
+                expect(state).toEqual({
+                    owner,
+                    expiration: ttl,
+                });
+            });
+            test("Should return ILockAdapterState when lock exists and is unexpired", async () => {
+                const key = "a";
+                const owner = "1";
+                const ttl = TimeSpan.fromMinutes(5);
+                let expiration;
+                try {
+                    vi.useFakeTimers();
+                    expiration = ttl.toEndDate();
+                    await adapter.acquire(key, owner, ttl);
+                }
+                finally {
+                    vi.useRealTimers();
+                }
+                const state = await adapter.getState(key);
+                expect(state).toEqual({
+                    owner,
+                    expiration,
+                });
+            });
         });
     });
 }