@daiso-tech/core 0.22.2 → 0.24.0

package/dist/cjs/lock/implementations/_shared/lock-provider.test-suite.js

@@ -1,1841 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lockProviderTestSuite = lockProviderTestSuite;
-const _module_1 = require("../../../lock/contracts/_module");
-const _module_2 = require("../../../utilities/_module");
-const _module_3 = require("../../../async/_module");
-const _module_4 = require("../../../serde/implementations/_module");
-function lockProviderTestSuite(settings) {
-    const { expect, test, createLockProvider, describe, beforeEach, serde = new _module_4.NoOpSerde(), } = settings;
-    let lockProviderA;
-    let lockProviderB;
-    beforeEach(async () => {
-        const lockProvider = await createLockProvider();
-        lockProviderA = lockProvider;
-        lockProviderB = lockProvider.withGroup("b");
-    });
-    const TTL = _module_2.TimeSpan.fromMilliseconds(50);
-    describe("Api tests:", () => {
-        describe("class: Lock", () => {
-            describe("method: run", () => {
-                test("Should return string when lock is available", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const [result, error] = await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    });
-                    expect(result).toBe("a");
-                    expect(error).toBeNull();
-                });
-                test("Should return null when lock is already acquired", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const [result, error] = await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    });
-                    expect(result).toBeNull();
-                    expect(error).toBeInstanceOf(_module_1.KeyAlreadyAcquiredLockError);
-                });
-                test("Should work with LazyPromise", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const [result, error] = await lock.run(new _module_3.LazyPromise(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    }));
-                    expect(result).toBe("a");
-                    expect(error).toBeNull();
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should return string when lock is available", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const result = await lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    });
-                    expect(result).toBe("a");
-                });
-                test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const result = lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    });
-                    await expect(result).rejects.toBeInstanceOf(_module_1.KeyAlreadyAcquiredLockError);
-                });
-                test("Should work with LazyPromise", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const result = await lock.runOrFail(new _module_3.LazyPromise(async () => {
-                        await (0, _module_3.delay)(TTL);
-                        return "a";
-                    }));
-                    expect(result).toBe("a");
-                });
-            });
-            describe("method: acquire", () => {
-                test("Should return true when lock is available", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const result = await lock.acquire();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when lock is already acquired", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    await lock.acquire();
-                    const result = await lock.acquire();
-                    expect(result).toBe(false);
-                });
-                test("Should not be expired when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(false);
-                });
-                test("Should be loked when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(true);
-                });
-            });
-            describe("method: acquireOrFail", () => {
-                test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    const result = lock.acquireOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                    });
-                    await lock.acquireOrFail();
-                    const result = lock.acquireOrFail();
-                    await expect(result).rejects.toBeInstanceOf(_module_1.KeyAlreadyAcquiredLockError);
-                });
-            });
-            describe("method: release", () => {
-                test("Should return true when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.release();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when released by different owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner2,
-                    });
-                    const result = await lock2.release();
-                    expect(result).toBe(false);
-                });
-                test("Should be expired when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.release();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(true);
-                });
-                test("Should be not loked when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.release();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(false);
-                });
-            });
-            describe("method: releaseOrFail", () => {
-                test("Should not throw UnownedReleaseLockError when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = lock.releaseOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should throw UnownedReleaseLockError when released by different owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner2,
-                    });
-                    const result = lock2.releaseOrFail();
-                    await expect(result).rejects.toBeInstanceOf(_module_1.UnownedReleaseLockError);
-                });
-                test("Should be expired when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.releaseOrFail();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(true);
-                });
-                test("Should be not loked when released by same owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.releaseOrFail();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(false);
-                });
-            });
-            describe("method: forceRelease", () => {
-                test("Should release lock no regardless of the owner", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner2,
-                    });
-                    await lock2.forceRelease();
-                    const result = await lock1.acquire();
-                    expect(result).toBe(true);
-                });
-                test("Should be expired when released", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.forceRelease();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(true);
-                });
-                test("Should be not loked when released", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await lock.forceRelease();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(false);
-                });
-            });
-            describe("method: isExpired", () => {
-                test("Should return false when lock has no expiration", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(false);
-                });
-                test("Should return false when lock has not expired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const ttl = TTL;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isExpired();
-                    expect(result).toBe(false);
-                });
-                test("Should return true when lock has expired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const ttl = TTL;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(ttl.addMilliseconds(25));
-                    const result = await lock.isExpired();
-                    expect(result).toBe(true);
-                });
-            });
-            describe("method: isLocked", () => {
-                test("Should return true when lock has no expiration", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(true);
-                });
-                test("Should return true when lock has not expired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const ttl = TTL;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.isLocked();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when lock has expired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const ttl = TTL;
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(ttl.addMilliseconds(25));
-                    const result = await lock.isLocked();
-                    expect(result).toBe(false);
-                });
-            });
-            describe("method: refresh", () => {
-                test("Should return true when refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(ttl);
-                    const result = await lock.refresh();
-                    expect(result).toBe(true);
-                });
-                test("Should return false when refreshed by different owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner2,
-                    });
-                    const result = await lock2.refresh();
-                    expect(result).toBe(false);
-                });
-                test("Should refresh expiration by same owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(ttl.subtractMilliseconds(10));
-                    await lock.refresh();
-                    const time = await lock.getRemainingTime();
-                    expect(time?.toMilliseconds()).toBeGreaterThan(0);
-                });
-            });
-            describe("method: refreshOrFail", () => {
-                test("Should not throw UnownedExtendLockError when refreshed by same owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(ttl);
-                    const result = lock.refreshOrFail();
-                    await expect(result).resolves.toBeUndefined();
-                });
-                test("Should throw UnownedExtendLockError when refreshed by different owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        ttl,
-                        owner: owner2,
-                    });
-                    const result = lock2.refreshOrFail();
-                    await expect(result).rejects.toBeInstanceOf(_module_1.UnownedExtendLockError);
-                });
-                test("Should refresh expiration by same owner", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquireOrFail();
-                    await (0, _module_3.delay)(ttl.subtractMilliseconds(10));
-                    await lock.refresh();
-                    const time = await lock.getRemainingTime();
-                    expect(time?.toMilliseconds()).toBeGreaterThan(0);
-                });
-            });
-            describe("method: getRemainingTime", () => {
-                test("Should return null when lock is not acquired", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    const result = await lock.getRemainingTime();
-                    expect(result).toBeNull();
-                });
-                test("Should return null when lock is acquired and has expiration", async () => {
-                    const key = "a";
-                    const ttl = null;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.getRemainingTime();
-                    expect(result).toBeNull();
-                });
-                test("Should return remaining time when lock is not acquired", async () => {
-                    const key = "a";
-                    const ttl = TTL;
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        ttl,
-                        owner,
-                    });
-                    await lock.acquire();
-                    const result = await lock.getRemainingTime();
-                    expect(result?.toMilliseconds()).toBe(ttl.toMilliseconds());
-                });
-            });
-            describe("method: getOwner", () => {
-                test("Should return the owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    const result = await lock.getOwner();
-                    expect(result).toBe(owner);
-                });
-                test("Should return the auto generated owner", async () => {
-                    const key = "a";
-                    const lock = lockProviderA.create(key);
-                    const result = await lock.getOwner();
-                    expect(result).toBeDefined();
-                    expect(typeof result).toBe("string");
-                });
-            });
-        });
-    });
-    describe("Event tests:", () => {
-        describe("calss: Lock", () => {
-            describe("method: run", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.runOrFail(async () => {
-                            await (0, _module_3.delay)(TTL);
-                        });
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquire", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireOrFail();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquireOrFail();
-                    const unsubscribe = await lock.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.acquireOrFail();
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: release", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.release();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedReleaseLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.release();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: releaseOrFail", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.releaseOrFail();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedReleaseLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock2.releaseOrFail();
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: forceRelease", () => {
-                test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.KeyForceReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.forceRelease();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refresh", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyRefreshedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refresh(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedRefreshLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock2.refresh(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refreshOrFail", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lock.subscribe(_module_1.KeyRefreshedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refreshOrFail(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedRefreshLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    try {
-                        await lock2.refreshOrFail(newTTL);
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-        });
-        describe("LockProvider:", () => {
-            describe("method: run", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.run(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: runOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.runOrFail(async () => {
-                        await (0, _module_3.delay)(TTL);
-                    });
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.runOrFail(async () => {
-                            await (0, _module_3.delay)(TTL);
-                        });
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquire", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquire();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: acquireOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.acquireOrFail();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    let event_ = null;
-                    await lock.acquireOrFail();
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyAlreadyAcquiredLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock.acquireOrFail();
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-            });
-            describe("method: release", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.release();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedReleaseLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.release();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: releaseOrFail", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock.releaseOrFail();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedReleaseLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    try {
-                        await lock2.releaseOrFail();
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: forceRelease", () => {
-                test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.KeyForceReleasedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await lock2.forceRelease();
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refresh", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyRefreshedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refresh(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedRefreshLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock2.refresh(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-            describe("method: refreshOrFail", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
-                    const key = "a";
-                    const owner = "b";
-                    const lock = lockProviderA.create(key, {
-                        owner,
-                        ttl: TTL,
-                    });
-                    await lock.acquire();
-                    let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(_module_1.KeyRefreshedLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    await lock.refreshOrFail(newTTL);
-                    await (0, _module_3.delay)(TTL);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
-                    await unsubscribe();
-                });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
-                    const key = "a";
-                    const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
-                        owner: owner1,
-                        ttl: TTL,
-                    });
-                    await lock1.acquire();
-                    const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
-                        owner: owner2,
-                    });
-                    let event_ = null;
-                    const unsubscribe = await lock1.subscribe(_module_1.UnownedRefreshLockEvent, (event) => {
-                        event_ = event;
-                    });
-                    await (0, _module_3.delay)(TTL.divide(2));
-                    const newTTL = TTL.multiply(2);
-                    try {
-                        await lock2.refreshOrFail(newTTL);
-                        await (0, _module_3.delay)(TTL);
-                    }
-                    catch {
-                    }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
-                    await unsubscribe();
-                });
-            });
-        });
-    });
-    describe("Group tests:", () => {
-        test("method: run", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.run(async () => {
-                await (0, _module_3.delay)(TTL);
-                return "a";
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.run(async () => {
-                await (0, _module_3.delay)(TTL);
-                return "a";
-            });
-            const [[resultA, errorA], [resultB, errorB]] = await Promise.all([
-                promiseA,
-                promiseB,
-            ]);
-            expect(resultA).toBe("a");
-            expect(errorA).toBeNull();
-            expect(resultB).toBe("a");
-            expect(errorB).toBeNull();
-        });
-        test("method: runOrFail", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.runOrFail(async () => {
-                await (0, _module_3.delay)(TTL);
-                return "a";
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.runOrFail(async () => {
-                await (0, _module_3.delay)(TTL);
-                return "a";
-            });
-            const [resultA, resultB] = await Promise.all([promiseA, promiseB]);
-            expect(resultA).toBe("a");
-            expect(resultB).toBe("a");
-        });
-        test("method: acquire", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const resultA = await lockA.acquire();
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const resultB = await lockB.acquire();
-            expect(resultA).toBe(true);
-            expect(resultB).toBe(true);
-        });
-        test("method: acquireOrFail", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.acquireOrFail();
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.acquireOrFail();
-            await expect(promiseA).resolves.toBeUndefined();
-            await expect(promiseB).resolves.toBeUndefined();
-        });
-        test("method: release", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: releaseOrFail", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.releaseOrFail();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: forceRelease", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.forceRelease();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: isExpired", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, { owner });
-            const lockB = lockProviderB.create(key, { owner });
-            await lockA.acquire();
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(true);
-            expect(resultB).toBe(false);
-        });
-        test("method: isLocked", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, { owner });
-            const lockB = lockProviderB.create(key, { owner });
-            await lockA.acquire();
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: refresh", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TTL;
-            const lockA = lockProviderA.create(key, {
-                owner,
-                ttl,
-            });
-            const lockB = lockProviderB.create(key, {
-                owner,
-                ttl,
-            });
-            await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await (0, _module_3.delay)(ttl.divide(2));
-            await lockA.refresh();
-            await (0, _module_3.delay)(ttl.divide(2));
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: refreshOrFail", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TTL;
-            const lockA = lockProviderA.create(key, {
-                owner,
-                ttl,
-            });
-            const lockB = lockProviderB.create(key, {
-                owner,
-                ttl,
-            });
-            await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await (0, _module_3.delay)(ttl.divide(2));
-            await lockA.refreshOrFail();
-            await (0, _module_3.delay)(ttl.divide(2));
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        describe("class: Lock", () => {
-            test("method: addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: addListenerMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListenerMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const lockB = lockProviderB.create(key);
-                await lockB.addListenerMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListener / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockB.removeListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListenerMany / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockB.removeListenerMany([_module_1.KeyAcquiredLockEvent], listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribe / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockB.subscribe(_module_1.KeyAcquiredLockEvent, listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribeMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.subscribeMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockB.subscribeMany([_module_1.KeyAcquiredLockEvent], listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-        });
-        describe("class: LockProvider", () => {
-            test("method: addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                await lockProviderB.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: addListenerMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListenerMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                await lockProviderB.addListenerMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListener / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockProviderB.addListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockProviderB.removeListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListenerMany / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockProviderB.addListener(_module_1.KeyAcquiredLockEvent, listenerB);
-                await lockProviderB.removeListenerMany([_module_1.KeyAcquiredLockEvent], listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribe / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.subscribe(_module_1.KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockProviderB.subscribe(_module_1.KeyAcquiredLockEvent, listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribeMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.subscribeMany([_module_1.KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockProviderB.subscribeMany([_module_1.KeyAcquiredLockEvent], listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await (0, _module_3.delay)(TTL);
-                expect(result_a).toBeInstanceOf(_module_1.KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-        });
-    });
-    describe("Serde tests:", () => {
-        test("Should preserve state", async () => {
-            const key = "a";
-            const owner = "b";
-            const lock = lockProviderB.create(key, {
-                owner,
-            });
-            await lock.acquire();
-            const deserializedLock = serde.deserialize(serde.serialize(lock));
-            expect(await deserializedLock.isLocked()).toBe(true);
-            expect(await deserializedLock.isExpired()).toBe(false);
-        });
-        test("Should preserve owner", async () => {
-            const key = "a";
-            const owner = "b";
-            const lock = lockProviderB.create(key, {
-                owner,
-            });
-            const deserializedLock = serde.deserialize(serde.serialize(lock));
-            expect(await deserializedLock.getOwner()).toBe(owner);
-        });
-        test("Should preserve ttl", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TTL.multiply(2);
-            const lock = lockProviderB.create(key, {
-                owner,
-                ttl,
-            });
-            await lock.acquire();
-            const deserializedLock = serde.deserialize(serde.serialize(lock));
-            const delayTime = TTL;
-            await (0, _module_3.delay)(delayTime);
-            expect(await deserializedLock.isLocked()).toBe(true);
-            await (0, _module_3.delay)(delayTime);
-            expect(await deserializedLock.isLocked()).toBe(false);
-        });
-    });
-}
-//# sourceMappingURL=lock-provider.test-suite.js.map