test: fix flakky test

Author: Julien-R44

packages/verrou/README.md

@@ -0,0 +1,49 @@
+<p align="center">
+  <br/>
+  <a href="https://verrou.dev/">Verrou 🔐</a> is a locking library for Node.js applications
+  <br/>
+</p>
+
+## Features
+
+- 🔒 Easy usage
+- 🔄 Multiple drivers (Redis, Postgres, MySQL, Sqlite, In-Memory and others)
+- 🔑 Customizable named locks
+- 🌐 Consistent API across all drivers
+- 🧪 Easy testing by switching to an in-memory driver
+- 🔨 Easily extensible with your own drivers
+
+See documentation at [verrou.dev](https://verrou.dev/docs/introduction)
+
+## Why Verrou ? 
+
+Main advantage of Verrou is that it provides a consistent API across all drivers. This means that you can switch from one driver to another without having to change your code. It also means you can switch to an in-memory in your test environment, making tests faster and easier to setup (no infrastructure or anything fancy to setup).
+
+Having a consistent API also means that you don't have to learn a new API when switching from one driver to another. Today, in the node ecosystem, we have different npm packages to manage locks, but they all have differents APIs and behaviors.
+
+But having a consistent API doesn't mean having a less powerful API. Verrou provides every features you would expect from a locking library, and even more.
+
+## Basic usage
+
+```ts
+import { Verrou } from '@verrou/core'
+import { redisStore } from '@verrou/core/drivers/redis'
+import { memoryStore } from '@verrou/core/drivers/memory'
+
+const verrou = new Verrou({
+  default: 'redis',
+  drivers: {
+    redis: { driver: redisStore() },
+    memory: { driver: memoryStore() }
+  }
+})
+
+// Lock a resource and run a function
+await verrou.createLock('my-resource').run(async () => {
+  await doSomething()
+}) // Lock is automatically released
+```
+
+## Sponsor 
+
+If you like this project, [please consider supporting it by sponsoring it](https://github.com/sponsors/Julien-R44/). It will help a lot to maintain and improve it. Thanks a lot !

packages/verrou/src/test_suite.ts

@@ -1,6 +1,6 @@
 /// <reference types="@japa/assert" />
 
-import type { Group } from '@japa/runner/core'
+import { type Group } from '@japa/runner/core'
 import type { test as JapaTest } from '@japa/runner'
 import { setTimeout as sleep } from 'node:timers/promises'
 
@@ -136,6 +136,7 @@ export function registerStoreTestSuite<T extends { new (options: any): LockStore
     lock.run(async () => {
       await sleep(500)
       flag = true
+      console.log('runned')
     })
 
     assert.isFalse(flag)
@@ -154,17 +155,160 @@ export function registerStoreTestSuite<T extends { new (options: any): LockStore
     const lock = provider.createLock('foo')
     let flag = false
 
-    lock
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    assert.isTrue(flag)
+    await lock.run(async () => undefined)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
       .run(async () => {
         flag = true
         throw new Error('hello world')
       })
       .catch(() => undefined)
 
-    assert.isFalse(flag)
     await lock.run(async () => undefined)
     assert.isTrue(flag)
-  })
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
+
+  test('exceptions during run do not leave mutex in locked state', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    let flag = false
+
+    await lock
+      .run(async () => {
+        flag = true
+        throw new Error('hello world')
+      })
+      .catch(() => undefined)
+
+    await lock.run(async () => undefined)
+    assert.isTrue(flag)
+  }).pin()
 
   test('multiple calls to release behave as expected', async ({ assert }) => {
     let v = 0