@daiso-tech/core 0.33.0 → 0.35.0

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

@@ -2,16 +2,16 @@
  * @module Lock
  */
 import {} from "vitest";
-import { UnownedRefreshLockEvent, KeyForceReleasedLockEvent, KeyAlreadyAcquiredLockEvent, UnownedReleaseLockEvent, KeyReleasedLockEvent, KeyAcquiredLockEvent, KeyAlreadyAcquiredLockError, UnownedRefreshLockError, UnownedReleaseLockError, KeyRefreshedLockEvent, } from "../../../lock/contracts/_module-exports.js";
+import { KeyAlreadyAcquiredLockError, UnownedRefreshLockError, UnownedReleaseLockError, LOCK_EVENTS, } from "../../../lock/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
 import { TimeSpan } from "../../../utilities/_module-exports.js";
 import { LazyPromise } from "../../../async/_module-exports.js";
 import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_module-exports.js";
 import { Serde } from "../../../serde/implementations/derivables/_module-exports.js";
 /**
- * The <i>lockProviderTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ILock}</i> with <i>vitest</i>.
+ * The `lockProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ILock | `ILock`} with `vitest`.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/lock/test-utilities"```
+ * IMPORT_PATH: `"@daiso-tech/core/lock/test-utilities"`
  * @group Utilities
  * @example
  * ```ts
@@ -200,7 +200,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 let index = 0;
-                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
                     index++;
                 });
                 await lock.runBlocking(async () => {
@@ -267,7 +267,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 let index = 0;
-                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
                     index++;
                 });
                 try {
@@ -417,7 +417,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 let index = 0;
-                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
                     index++;
                 });
                 await lock.acquireBlocking({
@@ -494,7 +494,7 @@ export function lockProviderTestSuite(settings) {
                 });
                 await lock.acquire();
                 let index = 0;
-                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(LOCK_EVENTS.NOT_AVAILABLE, (_event) => {
                     index++;
                 });
                 try {
@@ -896,9 +896,9 @@ export function lockProviderTestSuite(settings) {
         });
     });
     describe("Event tests:", () => {
-        describe("calss: Lock", () => {
+        describe("class: Lock", () => {
             describe("method: run", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -906,19 +906,19 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -926,18 +926,18 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -945,20 +945,20 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: runBlocking", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -966,7 +966,7 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -976,12 +976,12 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -989,7 +989,7 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -999,11 +999,11 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1011,7 +1011,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1021,13 +1021,13 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: runOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1035,19 +1035,19 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1055,18 +1055,18 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1074,7 +1074,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1086,13 +1086,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquire", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1100,17 +1100,17 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1118,18 +1118,18 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquireBlocking", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1137,7 +1137,7 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquireBlocking({
@@ -1145,12 +1145,12 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1161,7 +1161,7 @@ export function lockProviderTestSuite(settings) {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.acquireBlocking({
@@ -1169,13 +1169,13 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquireOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1183,17 +1183,17 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1201,7 +1201,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquireOrFail();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1211,13 +1211,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: release", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
+                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1225,16 +1225,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.release();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
+                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1246,18 +1246,18 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
                         event_ = event;
                     });
                     await lock2.release();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: releaseOrFail", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
+                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1265,16 +1265,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
+                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1286,7 +1286,7 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1296,13 +1296,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: forceRelease", () => {
-                test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
+                test("Should dispatch ForceReleasedLockEvent when lock forcefully released", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1314,17 +1314,17 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyForceReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.FORCE_RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock2.forceRelease();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
+                    expect(event_?.key).toBe(key);
                     await unsubscribe();
                 });
             });
             describe("method: refresh", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
+                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1333,19 +1333,19 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refresh(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
+                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1358,20 +1358,20 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock2.refresh(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: refreshOrFail", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
+                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1380,19 +1380,19 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refreshOrFail(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
+                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1405,7 +1405,7 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1417,15 +1417,15 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
         });
         describe("LockProvider:", () => {
             describe("method: run", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1433,19 +1433,19 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1453,18 +1453,18 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1472,20 +1472,20 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: runBlocking", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1493,7 +1493,7 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1503,12 +1503,12 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1516,7 +1516,7 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1526,11 +1526,11 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1538,7 +1538,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1548,13 +1548,13 @@ export function lockProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: runOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1562,19 +1562,19 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
+                test("Should dispatch ReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1582,18 +1582,18 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
                         await LazyPromise.delay(DELAY_TIME);
                     });
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1601,7 +1601,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1613,13 +1613,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquire", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1627,17 +1627,17 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1645,18 +1645,18 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquireBlocking", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1664,17 +1664,17 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1682,18 +1682,18 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: acquireOrFail", () => {
-                test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
+                test("Should dispatch AcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1701,17 +1701,17 @@ export function lockProviderTestSuite(settings) {
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.ACQUIRED, (event) => {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl?.toMilliseconds()).toBe(TTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
+                test("Should dispatch NotAvailableLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1719,7 +1719,7 @@ export function lockProviderTestSuite(settings) {
                     });
                     let event_ = null;
                     await lock.acquireOrFail();
-                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.NOT_AVAILABLE, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1729,13 +1729,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe("a");
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe("a");
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
             });
             describe("method: release", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
+                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1743,16 +1743,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.release();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
+                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1764,18 +1764,18 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
                         event_ = event;
                     });
                     await lock2.release();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: releaseOrFail", () => {
-                test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
+                test("Should dispatch ReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1783,16 +1783,16 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
+                test("Should dispatch UnownedReleaseTryLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1804,7 +1804,7 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_RELEASE_TRY, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1814,13 +1814,13 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: forceRelease", () => {
-                test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
+                test("Should dispatch ForceReleasedLockEvent when lock forcefully released", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1832,17 +1832,17 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyForceReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.FORCE_RELEASED, (event) => {
                         event_ = event;
                     });
                     await lock2.forceRelease();
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
+                    expect(event_?.key).toBe(key);
                     await unsubscribe();
                 });
             });
             describe("method: refresh", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
+                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1851,19 +1851,19 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refresh(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
+                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1876,20 +1876,20 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock2.refresh(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });
             describe("method: refreshOrFail", () => {
-                test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
+                test("Should dispatch RefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
                     const lock = lockProvider.create(key, {
@@ -1898,19 +1898,19 @@ export function lockProviderTestSuite(settings) {
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.REFRESHED, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
                     const newTTL = TTL.multiply(2);
                     await lock.refreshOrFail(newTTL);
                     await LazyPromise.delay(DELAY_TIME);
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner);
-                    expect(event_?.fields.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner);
+                    expect(event_?.ttl.toMilliseconds()).toBe(newTTL.toMilliseconds());
                     await unsubscribe();
                 });
-                test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
+                test("Should dispatch UnownedRefreshTryLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
                     const lock1 = lockProvider.create(key, {
@@ -1923,7 +1923,7 @@ export function lockProviderTestSuite(settings) {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(LOCK_EVENTS.UNOWNED_REFRESH_TRY, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1935,8 +1935,8 @@ export function lockProviderTestSuite(settings) {
                     catch {
                         /* Empty */
                     }
-                    expect(event_?.fields.key).toBe(key);
-                    expect(event_?.fields.owner).toBe(owner2);
+                    expect(event_?.key).toBe(key);
+                    expect(event_?.owner).toBe(owner2);
                     await unsubscribe();
                 });
             });