@daiso-tech/core 0.39.0 → 0.41.0

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js

@@ -1,5 +1,5 @@
-import { DefaultAdapterNotDefinedError, Namespace, resolveOneOrMore, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
-import { LockProvider, } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
+import { DefaultAdapterNotDefinedError, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
+import { DEFAULT_LOCK_PROVIDER_NAMESPACE, LockProvider, } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
 /**
  * The `LockProviderFactory` class is immutable.
  *
@@ -38,10 +38,10 @@ export class LockProviderFactory {
             namespace,
         });
     }
-    setCreateOwnerId(createId) {
+    setCreateLockId(createId) {
         return new LockProviderFactory({
             ...this.settings,
-            createOwnerId: createId,
+            createLockId: createId,
         });
     }
     setEventBus(eventBus) {
@@ -74,12 +74,6 @@ export class LockProviderFactory {
             defaultRefreshTime: time,
         });
     }
-    setLazyPromiseFactory(factory) {
-        return new LockProviderFactory({
-            ...this.settings,
-            lazyPromiseFactory: factory,
-        });
-    }
     /**
      * @example
      * ```ts
@@ -88,7 +82,7 @@ export class LockProviderFactory {
      * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
      * import { Serde } from "@daiso-tech/core/serde";
      * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
+     * import { TimeSpan } from "@daiso-tech/core/time-span" from "@daiso-tech/core/time-span";
      * import Redis from "ioredis";
      *
      * const serde = new Serde(new SuperJsonSerdeAdapter());
@@ -122,14 +116,11 @@ export class LockProviderFactory {
         if (adapter === undefined) {
             throw new UnregisteredAdapterError(adapterName);
         }
-        const { namespace = new Namespace(["@", "lock"]) } = this.settings;
+        const { namespace = DEFAULT_LOCK_PROVIDER_NAMESPACE } = this.settings;
         return new LockProvider({
             ...this.settings,
             adapter,
-            namespace: new Namespace([
-                ...resolveOneOrMore(namespace._getInternal().original),
-                adapterName,
-            ]),
+            namespace: namespace.appendRoot(adapterName),
             serdeTransformerName: adapterName,
         });
     }

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"lock-provider-factory.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.ts"],"names":[],"mappings":"AAQA,OAAO,EACH,6BAA6B,EAC7B,SAAS,EACT,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAOxC,OAAO,EACH,YAAY,GAGf,MAAM,4DAA4D,CAAC;AAwBpE;;;;;GAKG;AACH,MAAM,OAAO,mBAAmB;IAyBP;IAtBrB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YACqB,QAAgD;QAAhD,aAAQ,GAAR,QAAQ,CAAwC;IAClE,CAAC;IAEJ,YAAY,CAAC,SAAoB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,SAAS;SACZ,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CACZ,QAA+B;QAE/B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CAAC,QAAmB;QAC3B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,QAAQ;SACX,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,GAAa;QACvB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,UAAU,EAAE,GAAG;SAClB,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B,CACtB,QAAkB;QAElB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,uBAAuB,EAAE,QAAQ;SACpC,CAAC,CAAC;IACP,CAAC;IAED,sBAAsB,CAAC,IAAc;QACjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,mBAAmB,EAAE,IAAI;SAC5B,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,IAAc;QAChC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,kBAAkB,EAAE,IAAI;SAC3B,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CACjB,OAAkD;QAElD,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,kBAAkB,EAAE,OAAO;SAC9B,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,QAAQ,CAAC,cAAc;QAEjE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,EAAE,SAAS,GAAG,IAAI,SAAS,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QACnE,OAAO,IAAI,YAAY,CAAC;YACpB,GAAG,IAAI,CAAC,QAAQ;YAChB,OAAO;YACP,SAAS,EAAE,IAAI,SAAS,CAAC;gBACrB,GAAG,gBAAgB,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,QAAQ,CAAC;gBACtD,WAAW;aACd,CAAC;YACF,oBAAoB,EAAE,WAAW;SACpC,CAAC,CAAC;IACP,CAAC;CACJ"}
+{"version":3,"file":"lock-provider-factory.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.ts"],"names":[],"mappings":"AASA,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACH,+BAA+B,EAC/B,YAAY,GAEf,MAAM,4DAA4D,CAAC;AAyBpE;;;;;GAKG;AACH,MAAM,OAAO,mBAAmB;IAyBP;IAtBrB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YACqB,QAAgD;QAAhD,aAAQ,GAAR,QAAQ,CAAwC;IAClE,CAAC;IAEJ,YAAY,CAAC,SAAoB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,SAAS;SACZ,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CACX,QAA+B;QAE/B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,YAAY,EAAE,QAAQ;SACzB,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CAAC,QAAmB;QAC3B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,QAAQ;SACX,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,GAAc;QACxB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,UAAU,EAAE,GAAG;SAClB,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B,CACtB,QAAmB;QAEnB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,uBAAuB,EAAE,QAAQ;SACpC,CAAC,CAAC;IACP,CAAC;IAED,sBAAsB,CAAC,IAAe;QAClC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,mBAAmB,EAAE,IAAI;SAC5B,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,IAAe;QACjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,kBAAkB,EAAE,IAAI;SAC3B,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,QAAQ,CAAC,cAAc;QAEjE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,EAAE,SAAS,GAAG,+BAA+B,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtE,OAAO,IAAI,YAAY,CAAC;YACpB,GAAG,IAAI,CAAC,QAAQ;YAChB,OAAO;YACP,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC;YAC5C,oBAAoB,EAAE,WAAW;SACpC,CAAC,CAAC;IACP,CAAC;CACJ"}

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

@@ -1,10 +1,10 @@
 /**
  * @module Lock
  */
-import { vi, } from "vitest";
+import {} from "vitest";
 import {} from "../../../lock/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
-import { TimeSpan } from "../../../utilities/_module-exports.js";
+import { TimeSpan } from "../../../time-span/implementations/_module-exports.js";
 /**
  * The `databaseLockAdapterTestSuite` function simplifies the process of testing your custom implementation of {@link IDatabaseLockAdapter | `IDatabaseLockAdapter`} with `vitest`.
  *
@@ -47,205 +47,326 @@ import { TimeSpan } from "../../../utilities/_module-exports.js";
  */
 export function databaseLockAdapterTestSuite(settings) {
     const { expect, test, createAdapter, describe, beforeEach } = settings;
-    let adapter;
-    beforeEach(async () => {
-        adapter = await createAdapter();
-    });
-    const ttl = TimeSpan.fromMilliseconds(50);
-    describe("method: insert", () => {
-        test("Should insert lock when not existing", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration = null;
-            await adapter.insert(key, owner, expiration);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner,
-                expiration,
-            });
+    describe("Reusable tests:", () => {
+        let adapter;
+        beforeEach(async () => {
+            adapter = await createAdapter();
         });
-        test("Should insert lock with expiration when not existing", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration = ttl.toEndDate();
-            await adapter.insert(key, owner, expiration);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner,
-                expiration,
+        describe("method: transaction find", () => {
+            test("Should return null when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExistingKey = "b";
+                const result = await adapter.transaction(async (trx) => {
+                    return await trx.find(noneExistingKey);
+                });
+                expect(result).toBeNull();
             });
-        });
-        test("Should throw error when lock already existing", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration = null;
-            await adapter.insert(key, owner, expiration);
-            const result = adapter.insert(key, owner, expiration);
-            await expect(result).rejects.toBeDefined();
-        });
-    });
-    describe("method: update", () => {
-        test("Should return false when lock has no expiration", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const expiration = null;
-            await adapter.insert(key, owner1, expiration);
-            const owner2 = "c";
-            const result = await adapter.update(key, owner2, expiration);
-            expect(result).toBe(0);
-        });
-        test("Should not update when lock has no expiration", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const expiration = null;
-            await adapter.insert(key, owner1, expiration);
-            const owner2 = "c";
-            await adapter.update(key, owner2, expiration);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner: owner1,
-                expiration,
+            test("Should return ILockData when key exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMinutes(2).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const result = await adapter.transaction(async (trx) => {
+                    return await trx.find(key);
+                });
+                expect(result).toEqual({
+                    owner,
+                    expiration,
+                });
             });
         });
-        test("Should return false when lock has not expired", async () => {
-            vi.useFakeTimers();
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            vi.advanceTimersByTime(ttl.divide(2).toMilliseconds());
-            const owner2 = "c";
-            const expiration2 = ttl.addMilliseconds(25).toEndDate();
-            const result = await adapter.update(key, owner2, expiration2);
-            expect(result).toBe(0);
-            vi.useRealTimers();
-        });
-        test("Should not update when lock has not expired", async () => {
-            vi.useFakeTimers();
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            vi.advanceTimersByTime(ttl.divide(2).toMilliseconds());
-            const owner2 = "c";
-            const expiration2 = ttl.addMilliseconds(25).toEndDate();
-            await adapter.update(key, owner2, expiration2);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner: owner1,
-                expiration: expiration1,
-            });
-            vi.useRealTimers();
-        });
-        test("Should return true when lock has expired", async () => {
-            vi.useFakeTimers();
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            vi.advanceTimersByTime(ttl.addMilliseconds(1).toMilliseconds());
-            const owner2 = "c";
-            const expiration2 = ttl.addMilliseconds(25).toEndDate();
-            const result = await adapter.update(key, owner2, expiration2);
-            expect(result).toBe(1);
-            vi.useRealTimers();
-        });
-        test("Should update when lock has expired", async () => {
-            vi.useFakeTimers();
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            vi.advanceTimersByTime(ttl.addMilliseconds(1).toMilliseconds());
-            const owner2 = "c";
-            const expiration2 = ttl.addMilliseconds(25).toEndDate();
-            await adapter.update(key, owner2, expiration2);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner: owner2,
-                expiration: expiration2,
-            });
-            vi.useRealTimers();
-        });
-    });
-    describe("method: remove", () => {
-        test("Should not remove lock when not same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const expiration = null;
-            await adapter.insert(key, owner1, expiration);
-            const owner2 = "c";
-            await adapter.remove(key, owner2);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner: owner1,
-                expiration,
+        describe("method: transaction upsert", () => {
+            test("Should insert when key doesnt exists exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    expiration,
+                    owner,
+                });
+            });
+            test("Should update when key exists exists", async () => {
+                const key = "a";
+                const owner1 = "1";
+                const expiration1 = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner1, expiration1);
+                });
+                const owner2 = "2";
+                const expiration2 = TimeSpan.fromMilliseconds(100).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner2, expiration2);
+                });
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    expiration: expiration2,
+                    owner: owner2,
+                });
             });
         });
-        test("Should remove lock when same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration = null;
-            await adapter.insert(key, owner, expiration);
-            await adapter.remove(key, owner);
-            const result = await adapter.find(key);
-            expect(result).toBeNull();
-        });
-        test("Should remove lock when given null as owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration = null;
-            await adapter.insert(key, owner, expiration);
-            await adapter.remove(key, null);
-            const result = await adapter.find(key);
-            expect(result).toBeNull();
-        });
-    });
-    describe("method: refresh", () => {
-        test("Should return false when not same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            const expiration2 = ttl.multiply(2).toEndDate();
-            const owner2 = "c";
-            const result = await adapter.refresh(key, owner2, expiration2);
-            expect(result).toBe(0);
+        describe("method: remove", () => {
+            test("Should return null when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExistingKey = "c";
+                const lockExpirationData = await adapter.remove(noneExistingKey);
+                expect(lockExpirationData).toBeNull();
+            });
+            test("Should return expiration as null when key exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const lockExpirationData = await adapter.remove(key);
+                expect(lockExpirationData).toEqual({
+                    expiration,
+                });
+            });
+            test("Should return expiration as date when key exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = TimeSpan.fromMinutes(5).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const lockExpirationData = await adapter.remove(key);
+                expect(lockExpirationData).toEqual({
+                    expiration,
+                });
+            });
+            test("Should remove lock when key exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = TimeSpan.fromMinutes(5).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                await adapter.remove(key);
+                const lockExpirationData = await adapter.find(key);
+                expect(lockExpirationData).toBeNull();
+            });
         });
-        test("Should not update lock when not same owner", async () => {
-            const key = "a";
-            const owner1 = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner1, expiration1);
-            const expiration2 = ttl.multiply(2).toEndDate();
-            const owner2 = "c";
-            await adapter.refresh(key, owner2, expiration2);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner: owner1,
-                expiration: expiration1,
+        describe("method: removeIfOwner", () => {
+            test("Should return null when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExistingKey = "c";
+                const lockData = await adapter.removeIfOwner(noneExistingKey, owner);
+                expect(lockData).toBeNull();
+            });
+            test("Should return null when owner doesnt exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExistingOwner = "c";
+                const lockData = await adapter.removeIfOwner(key, noneExistingOwner);
+                expect(lockData).toBeNull();
+            });
+            test("Should return expiration as null when key and owner exists and is unexpireable", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const lockData = await adapter.removeIfOwner(key, owner);
+                expect(lockData).toEqual({
+                    expiration,
+                    owner,
+                });
+            });
+            test("Should return expiration as date when key and owner exists and is unexpireable", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = TimeSpan.fromMinutes(10).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const lockData = await adapter.removeIfOwner(key, owner);
+                expect(lockData).toEqual({
+                    expiration,
+                    owner,
+                });
+            });
+            test("Should remove lock when key and owner exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = TimeSpan.fromMinutes(10).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                await adapter.removeIfOwner(key, owner);
+                const lockData = await adapter.find(key);
+                expect(lockData).toBeNull();
+            });
+            test("Should not remove lock when key exists and owner does not exists", async () => {
+                const key = "a";
+                const owner = "b";
+                const expiration = TimeSpan.fromMinutes(10).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExsitingOwner = "c";
+                await adapter.removeIfOwner(key, noneExsitingOwner);
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    expiration,
+                    owner,
+                });
             });
         });
-        test("Should return true when same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner, expiration1);
-            const expiration2 = ttl.multiply(2).toEndDate();
-            const result = await adapter.refresh(key, owner, expiration2);
-            expect(result).toBe(1);
+        describe("method: updateExpiration", () => {
+            test("Should return 0 when semaphore key doesnt exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                const noneExistingKey = "b";
+                const result1 = await adapter.updateExpiration(noneExistingKey, owner, newExpiration);
+                expect(result1).toBe(0);
+            });
+            test("Should return 0 when owner doesnt exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                const noneExistingOwner = "b";
+                const result1 = await adapter.updateExpiration(key, noneExistingOwner, newExpiration);
+                expect(result1).toBe(0);
+            });
+            test("Should return 0 when lock is expired", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50).toStartDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                const result1 = await adapter.updateExpiration(key, owner, newExpiration);
+                expect(result1).toBe(0);
+            });
+            test("Should return 0 when lock is unexpireable", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                const result1 = await adapter.updateExpiration(key, owner, newExpiration);
+                expect(result1).toBe(0);
+            });
+            test("Should return number greater than 0 when lock is unexpired", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50);
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration.toEndDate());
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100);
+                const result1 = await adapter.updateExpiration(key, owner, newExpiration.toEndDate());
+                expect(result1).toBeGreaterThan(0);
+            });
+            test("Should not update expiration when lock is expired", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50).toStartDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                await adapter.updateExpiration(key, owner, newExpiration);
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    owner,
+                    expiration,
+                });
+            });
+            test("Should not update expiration when lock is unexpireable", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                await adapter.updateExpiration(key, owner, newExpiration);
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    owner,
+                    expiration,
+                });
+            });
+            test("Should update expiration when lock is unexpired", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMilliseconds(50).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const newExpiration = TimeSpan.fromMilliseconds(100).toEndDate();
+                await adapter.updateExpiration(key, owner, newExpiration);
+                const lockData = await adapter.find(key);
+                expect(lockData).toEqual({
+                    owner,
+                    expiration: newExpiration,
+                });
+            });
         });
-        test("Should update lock when same owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const expiration1 = ttl.toEndDate();
-            await adapter.insert(key, owner, expiration1);
-            const expiration2 = ttl.multiply(2).toEndDate();
-            await adapter.refresh(key, owner, expiration2);
-            const result = await adapter.find(key);
-            expect(result).toEqual({
-                owner,
-                expiration: expiration2,
+        describe("method: find", () => {
+            test("Should return null when key doesnt exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = null;
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const noneExistingKey = "b";
+                const result = await adapter.find(noneExistingKey);
+                expect(result).toBeNull();
+            });
+            test("Should return ILockData when key exists", async () => {
+                const key = "a";
+                const owner = "1";
+                const expiration = TimeSpan.fromMinutes(2).toEndDate();
+                await adapter.transaction(async (trx) => {
+                    await trx.upsert(key, owner, expiration);
+                });
+                const result = await adapter.find(key);
+                expect(result).toEqual({
+                    owner,
+                    expiration,
+                });
             });
         });
     });