effect-distributed-lock 0.0.2 → 0.0.4

package/redis-semaphore/test/src/multiSemaphore/acquire/internal.test.ts

@@ -0,0 +1,67 @@
+import { expect } from 'chai'
+
+import { acquireLua } from '../../../../src/multiSemaphore/acquire/lua'
+import { client1 as client } from '../../../redisClient'
+
+interface Options {
+  identifier: string
+  lockTimeout: number
+  now: number
+}
+
+const opts = (id: string, nowOffset = 0): Options => ({
+  identifier: id,
+  lockTimeout: 500,
+  now: new Date().getTime() + nowOffset
+})
+
+async function acquire(options: Options) {
+  const { identifier, lockTimeout, now } = options
+  return await acquireLua(client, ['key', 1, 1, identifier, lockTimeout, now])
+}
+
+describe('multiSemaphore acquire internal', () => {
+  it('should return 1 for success acquire', async () => {
+    const result = await acquire(opts('111'))
+    expect(result).to.be.eql(1)
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['111_0'])
+  })
+  it('should return 0 for failure acquire', async () => {
+    const result1 = await acquire(opts('111'))
+    const result2 = await acquire(opts('112'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['111_0'])
+    expect(result1).to.be.eql(1)
+    expect(result2).to.be.eql(0)
+  })
+  describe('TIME SHIFT case', () => {
+    it('should handle time difference less than lockTimeout (nodeA has faster clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeA is for 450ms faster than nodeB
+      const resultA = await acquire(opts('111', 450))
+      const resultB = await acquire(opts('112', 0))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(0)
+    })
+    it('should handle time difference less than lockTimeout (nodeA has slower clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeB is for 450ms faster than nodeA
+      const resultA = await acquire(opts('111', 0))
+      const resultB = await acquire(opts('112', 450))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(0)
+    })
+    it('cant handle time difference greater than lockTimeout (nodeA has slower clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeB is for 550ms faster than nodeA
+      const resultA = await acquire(opts('111', 0))
+      const resultB = await acquire(opts('112', 550))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(1) // Semaphore stealed...
+
+      // This happens due removing "expired" nodeA lock (at nodeB "now" nodeA lock has been expired 50ms ago)
+      // Unfortunatelly "fair" semaphore described here
+      // https://redislabs.com/ebook/part-2-core-concepts/chapter-6-application-components-in-redis/6-3-counting-semaphores/6-3-1-building-a-basic-counting-semaphore/
+      // also has the same problem
+    })
+  })
+})

package/redis-semaphore/test/src/multiSemaphore/refresh/index.test.ts

@@ -0,0 +1,52 @@
+import { expect } from 'chai'
+
+import {
+  Options,
+  refreshSemaphore as refresh
+} from '../../../../src/multiSemaphore/refresh/index'
+import { client1 as client } from '../../../redisClient'
+
+const opts = (id: string): Options => ({
+  identifier: id,
+  lockTimeout: 100
+})
+
+describe('multiSemaphore refresh', () => {
+  it('should return false if resource is already acquired', async () => {
+    const now = '' + (Date.now() - 10)
+    await client.zadd('key', now, '222', now, '333', now, '444')
+    const result = await refresh(client, 'key', 3, 2, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['222', '333', '444'])
+    expect(result).to.be.false
+  })
+  it('should return false if resource is already acquired, but some expired', async () => {
+    const now = '' + (Date.now() - 10)
+    const oldNow = '' + (Date.now() - 10000)
+    await client.zadd('key', oldNow, '222', oldNow, '333', now, '444')
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['222', '333', '444'])
+    const result = await refresh(client, 'key', 3, 2, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['444'])
+    expect(result).to.be.false
+  })
+  it('should return false if resource is not acquired', async () => {
+    const result = await refresh(client, 'key', 3, 2, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql([])
+    expect(result).to.be.false
+  })
+  it('should return true for success refresh', async () => {
+    const now = '' + (Date.now() - 10)
+    await client.zadd('key', now, '111_0', now, '111_1', now, '333')
+    expect(await client.zrange('key', 0, -1)).to.be.eql([
+      '111_0',
+      '111_1',
+      '333'
+    ])
+    const result = await refresh(client, 'key', 3, 2, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql([
+      '333',
+      '111_0',
+      '111_1'
+    ])
+    expect(result).to.be.true
+  })
+})

package/redis-semaphore/test/src/multiSemaphore/release/index.test.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai'
+
+import { releaseSemaphore as release } from '../../../../src/multiSemaphore/release/index'
+import { client1 as client } from '../../../redisClient'
+
+describe('multiSemaphore release', () => {
+  it('should remove key after success release', async () => {
+    await client.zadd('key', '' + Date.now(), '111_0')
+    expect(await client.zcard('key')).to.be.eql(1)
+    await release(client, 'key', 1, '111')
+    expect(await client.zcard('key')).to.be.eql(0)
+  })
+  it('should do nothing if resource is not locked', async () => {
+    expect(await client.zcard('key')).to.be.eql(0)
+    await release(client, 'key', 1, '111')
+    expect(await client.zcard('key')).to.be.eql(0)
+  })
+})

package/redis-semaphore/test/src/mutex/acquire.test.ts

@@ -0,0 +1,78 @@
+import { expect } from 'chai'
+
+import { acquireMutex as acquire, Options } from '../../../src/mutex/acquire'
+import { client1 as client } from '../../redisClient'
+
+const opts = (id: string, overrides?: Partial<Options>): Options => ({
+  identifier: id,
+  acquireTimeout: 50,
+  acquireAttemptsLimit: Number.POSITIVE_INFINITY,
+  lockTimeout: 100,
+  retryInterval: 10,
+  ...overrides
+})
+
+describe('mutex acquire', () => {
+  it('should return true for success lock', async () => {
+    const result = await acquire(client, 'key', opts('111'))
+    expect(result).to.be.true
+  })
+  it('should return false when timeout', async () => {
+    const result1 = await acquire(client, 'key', opts('111'))
+    const result2 = await acquire(client, 'key', opts('222'))
+    expect(result1).to.be.true
+    expect(result2).to.be.false
+  })
+  it('should return false after acquireAttemptsLimit', async () => {
+    const result1 = await acquire(client, 'key', opts('111'))
+    const result2 = await acquire(
+      client,
+      'key',
+      opts('222', {
+        acquireAttemptsLimit: 1,
+        acquireTimeout: Number.POSITIVE_INFINITY
+      })
+    )
+    expect(result1).to.be.true
+    expect(result2).to.be.false
+  })
+  it('should set identifier for key', async () => {
+    await acquire(client, 'key1', opts('111'))
+    const value = await client.get('key1')
+    expect(value).to.be.eql('111')
+  })
+  it('should set TTL for key', async () => {
+    await acquire(client, 'key2', opts('111'))
+    const ttl = await client.pttl('key2')
+    expect(ttl).to.be.gte(90)
+    expect(ttl).to.be.lte(100)
+  })
+  it('should wait for auto-release', async () => {
+    const start1 = Date.now()
+    await acquire(client, 'key', opts('111'))
+    const start2 = Date.now()
+    await acquire(client, 'key', opts('222'))
+    const now = Date.now()
+    expect(start2 - start1).to.be.gte(0)
+    expect(start2 - start1).to.be.lt(10)
+    expect(now - start1).to.be.gte(50)
+    expect(now - start2).to.be.gte(50)
+  })
+  it('should wait per key', async () => {
+    const start1 = Date.now()
+    await Promise.all([
+      acquire(client, 'key1', opts('a1')),
+      acquire(client, 'key2', opts('a2'))
+    ])
+    const start2 = Date.now()
+    await Promise.all([
+      acquire(client, 'key1', opts('b1')),
+      acquire(client, 'key2', opts('b2'))
+    ])
+    const now = Date.now()
+    expect(start2 - start1).to.be.gte(0)
+    expect(start2 - start1).to.be.lt(10)
+    expect(now - start1).to.be.gte(50)
+    expect(now - start2).to.be.gte(50)
+  })
+})

package/redis-semaphore/test/src/mutex/refresh.test.ts

@@ -0,0 +1,22 @@
+import { expect } from 'chai'
+
+import { refreshMutex as refresh } from '../../../src/mutex/refresh'
+import { client1 as client } from '../../redisClient'
+
+describe('mutex refresh', () => {
+  it('should return false if resource is already acquired by different instance', async () => {
+    await client.set('key', '222')
+    const result = await refresh(client, 'key', '111', 10000)
+    expect(result).to.be.false
+  })
+  it('should return false if resource is not acquired', async () => {
+    const result = await refresh(client, 'key', '111', 10000)
+    expect(result).to.be.false
+  })
+  it('should return true for success refresh', async () => {
+    await client.set('key', '111')
+    const result = await refresh(client, 'key', '111', 20000)
+    expect(result).to.be.true
+    expect(await client.pttl('key')).to.be.gte(10000)
+  })
+})

package/redis-semaphore/test/src/mutex/release.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai'
+
+import { releaseMutex as release } from '../../../src/mutex/release'
+import { client1 as client } from '../../redisClient'
+
+describe('Mutex release', () => {
+  it('should remove key after release', async () => {
+    await client.set('key', '111')
+    await release(client, 'key', '111')
+    expect(await client.get('key')).to.be.eql(null)
+  })
+  it('should do nothing if resource is not locked', async () => {
+    expect(await client.get('key')).to.be.eql(null)
+    await release(client, 'key', '111')
+    expect(await client.get('key')).to.be.eql(null)
+  })
+})

package/redis-semaphore/test/src/redlockMutex/acquire.test.ts

@@ -0,0 +1,90 @@
+import { expect } from 'chai'
+
+import {
+  acquireRedlockMutex as acquire,
+  Options
+} from '../../../src/redlockMutex/acquire'
+import { allClients } from '../../redisClient'
+
+const opts = (id: string, overrides?: Partial<Options>): Options => ({
+  identifier: id,
+  acquireTimeout: 50,
+  acquireAttemptsLimit: Number.POSITIVE_INFINITY,
+  lockTimeout: 100,
+  retryInterval: 10,
+  ...overrides
+})
+
+describe('redlockMutex acquire', () => {
+  it('should return true for success lock', async () => {
+    const result = await acquire(allClients, 'key', opts('111'))
+    expect(result).to.be.true
+  })
+  it('should return false when timeout', async () => {
+    const result1 = await acquire(allClients, 'key', opts('111'))
+    const result2 = await acquire(allClients, 'key', opts('222'))
+    expect(result1).to.be.true
+    expect(result2).to.be.false
+  })
+  it('should return false after acquireAttemptsLimit', async () => {
+    const result1 = await acquire(allClients, 'key', opts('111'))
+    const result2 = await acquire(
+      allClients,
+      'key',
+      opts('222', {
+        acquireAttemptsLimit: 1,
+        acquireTimeout: Number.POSITIVE_INFINITY
+      })
+    )
+    expect(result1).to.be.true
+    expect(result2).to.be.false
+  })
+  it('should set identifier for key', async () => {
+    await acquire(allClients, 'key1', opts('111'))
+    const values = await Promise.all(
+      allClients.map(client => client.get('key1'))
+    )
+    expect(values).to.be.eql(['111', '111', '111'])
+  })
+  it('should set TTL for key', async () => {
+    await acquire(allClients, 'key2', opts('111'))
+    const ttls = await Promise.all(
+      allClients.map(client => client.pttl('key2'))
+    )
+    for (const ttl of ttls) {
+      if (ttl === -2) {
+        continue
+      }
+      expect(ttl).to.be.gte(90)
+      expect(ttl).to.be.lte(100)
+    }
+  })
+  it('should wait for auto-release', async () => {
+    const start1 = Date.now()
+    await acquire(allClients, 'key', opts('111'))
+    const start2 = Date.now()
+    await acquire(allClients, 'key', opts('222'))
+    const now = Date.now()
+    expect(start2 - start1).to.be.gte(0)
+    expect(start2 - start1).to.be.lt(10)
+    expect(now - start1).to.be.gte(50)
+    expect(now - start2).to.be.gte(50)
+  })
+  it('should wait per key', async () => {
+    const start1 = Date.now()
+    await Promise.all([
+      acquire(allClients, 'key1', opts('a1')),
+      acquire(allClients, 'key2', opts('a2'))
+    ])
+    const start2 = Date.now()
+    await Promise.all([
+      acquire(allClients, 'key1', opts('b1')),
+      acquire(allClients, 'key2', opts('b2'))
+    ])
+    const now = Date.now()
+    expect(start2 - start1).to.be.gte(0)
+    expect(start2 - start1).to.be.lt(10)
+    expect(now - start1).to.be.gte(50)
+    expect(now - start2).to.be.gte(50)
+  })
+})

package/redis-semaphore/test/src/redlockMutex/refresh.test.ts

@@ -0,0 +1,27 @@
+import { expect } from 'chai'
+
+import { refreshRedlockMutex as refresh } from '../../../src/redlockMutex/refresh'
+import { allClients, client1, client2, client3 } from '../../redisClient'
+
+describe('redlockMutex refresh', () => {
+  it('should return false if resource is acquired by different instance on quorum', async () => {
+    await client1.set('key', '111')
+    await client2.set('key', '222')
+    await client3.set('key', '222')
+    const result = await refresh(allClients, 'key', '111', 10000)
+    expect(result).to.be.false
+  })
+  it('should return true if resource is acquired on quorum', async () => {
+    await client1.set('key', '111')
+    await client2.set('key', '111')
+    const result = await refresh(allClients, 'key', '111', 20000)
+    expect(result).to.be.true
+    expect(await client1.pttl('key')).to.be.gte(10000)
+    expect(await client2.pttl('key')).to.be.gte(10000)
+  })
+  it('should return false if resource is not acquired on quorum', async () => {
+    await client1.set('key', '111')
+    const result = await refresh(allClients, 'key', '111', 10000)
+    expect(result).to.be.false
+  })
+})

package/redis-semaphore/test/src/redlockMutex/release.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai'
+
+import { releaseRedlockMutex as release } from '../../../src/redlockMutex/release'
+import { allClients, client1 } from '../../redisClient'
+
+describe('redlockMutex release', () => {
+  it('should remove key after release', async () => {
+    await client1.set('key', '111')
+    await release(allClients, 'key', '111')
+    expect(await client1.get('key')).to.be.eql(null)
+  })
+  it('should do nothing if resource is not locked', async () => {
+    expect(await client1.get('key')).to.be.eql(null)
+    await release(allClients, 'key', '111')
+    expect(await client1.get('key')).to.be.eql(null)
+  })
+})

package/redis-semaphore/test/src/semaphore/acquire/index.test.ts

@@ -0,0 +1,49 @@
+import { expect } from 'chai'
+
+import {
+  acquireSemaphore as acquire,
+  Options
+} from '../../../../src/semaphore/acquire/index'
+import { client1 as client } from '../../../redisClient'
+
+const opts = (id: string, overrides?: Partial<Options>): Options => ({
+  identifier: id,
+  acquireTimeout: 50,
+  acquireAttemptsLimit: Number.POSITIVE_INFINITY,
+  lockTimeout: 100,
+  retryInterval: 10,
+  ...overrides
+})
+
+describe('semaphore acquire', () => {
+  it('should return true for success acquire', async () => {
+    const result = await acquire(client, 'key', 1, opts('111'))
+    expect(result).to.be.true
+  })
+  it('should return false when timeout', async () => {
+    const result1 = await acquire(client, 'key', 2, opts('111')) // expire after 100ms
+    const result2 = await acquire(client, 'key', 2, opts('112')) // expire after 100ms
+    const result3 = await acquire(client, 'key', 2, opts('113')) // timeout after 50ms
+
+    expect(result1).to.be.true
+    expect(result2).to.be.true
+    expect(result3).to.be.false
+  })
+  it('should return false after acquireAttemptsLimit', async () => {
+    const result1 = await acquire(client, 'key', 2, opts('111')) // expire after 100ms
+    const result2 = await acquire(client, 'key', 2, opts('112')) // expire after 100ms
+    const result3 = await acquire(
+      client,
+      'key',
+      2,
+      opts('113', {
+        acquireAttemptsLimit: 1,
+        acquireTimeout: Number.POSITIVE_INFINITY
+      })
+    ) // no timeout, acquire limit = 1
+
+    expect(result1).to.be.true
+    expect(result2).to.be.true
+    expect(result3).to.be.false
+  })
+})

package/redis-semaphore/test/src/semaphore/acquire/internal.test.ts

@@ -0,0 +1,65 @@
+import { expect } from 'chai'
+
+import { acquireLua } from '../../../../src/semaphore/acquire/lua'
+import { client1 as client } from '../../../redisClient'
+
+interface Options {
+  identifier: string
+  lockTimeout: number
+  now: number
+}
+
+const opts = (id: string, nowOffset = 0): Options => ({
+  identifier: id,
+  lockTimeout: 500,
+  now: new Date().getTime() + nowOffset
+})
+
+async function acquire(options: Options) {
+  const { identifier, lockTimeout, now } = options
+  return await acquireLua(client, ['key', 1, identifier, lockTimeout, now])
+}
+
+describe('semaphore acquire internal', () => {
+  it('should return 1 for success acquire', async () => {
+    const result = await acquire(opts('111'))
+    expect(result).to.be.eql(1)
+  })
+  it('should return 0 for failure acquire', async () => {
+    const result1 = await acquire(opts('111'))
+    const result2 = await acquire(opts('112'))
+    expect(result1).to.be.eql(1)
+    expect(result2).to.be.eql(0)
+  })
+  describe('TIME SHIFT case', () => {
+    it('should handle time difference less than lockTimeout (nodeA has faster clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeA is for 450ms faster than nodeB
+      const resultA = await acquire(opts('111', 450))
+      const resultB = await acquire(opts('112', 0))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(0)
+    })
+    it('should handle time difference less than lockTimeout (nodeA has slower clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeB is for 450ms faster than nodeA
+      const resultA = await acquire(opts('111', 0))
+      const resultB = await acquire(opts('112', 450))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(0)
+    })
+    it('cant handle time difference greater than lockTimeout (nodeA has slower clocks)', async () => {
+      // lockTimeout = 500ms
+      // nodeB is for 550ms faster than nodeA
+      const resultA = await acquire(opts('111', 0))
+      const resultB = await acquire(opts('112', 550))
+      expect(resultA).to.be.eql(1)
+      expect(resultB).to.be.eql(1) // Semaphore stealed...
+
+      // This happens due removing "expired" nodeA lock (at nodeB "now" nodeA lock has been expired 50ms ago)
+      // Unfortunatelly "fair" semaphore described here
+      // https://redislabs.com/ebook/part-2-core-concepts/chapter-6-application-components-in-redis/6-3-counting-semaphores/6-3-1-building-a-basic-counting-semaphore/
+      // also has the same problem
+    })
+  })
+})

package/redis-semaphore/test/src/semaphore/refresh/index.test.ts

@@ -0,0 +1,44 @@
+import { expect } from 'chai'
+
+import {
+  Options,
+  refreshSemaphore as refresh
+} from '../../../../src/semaphore/refresh/index'
+import { client1 as client } from '../../../redisClient'
+
+const opts = (id: string): Options => ({
+  identifier: id,
+  lockTimeout: 100
+})
+
+describe('semaphore refresh', () => {
+  it('should return false if resource is already acquired', async () => {
+    const now = '' + (Date.now() - 10)
+    await client.zadd('key', now, '222', now, '333', now, '444')
+    const result = await refresh(client, 'key', 3, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['222', '333', '444'])
+    expect(result).to.be.false
+  })
+  it('should return false if resource is already acquired, but some expired', async () => {
+    const now = '' + (Date.now() - 10)
+    const oldNow = '' + (Date.now() - 10000)
+    await client.zadd('key', oldNow, '222', now, '333', now, '444')
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['222', '333', '444'])
+    const result = await refresh(client, 'key', 3, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['333', '444'])
+    expect(result).to.be.false
+  })
+  it('should return false if resource is not acquired', async () => {
+    const result = await refresh(client, 'key', 3, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql([])
+    expect(result).to.be.false
+  })
+  it('should return true for success refresh', async () => {
+    const now = '' + (Date.now() - 10)
+    await client.zadd('key', now, '111', now, '222', now, '333')
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['111', '222', '333'])
+    const result = await refresh(client, 'key', 3, opts('111'))
+    expect(await client.zrange('key', 0, -1)).to.be.eql(['222', '333', '111'])
+    expect(result).to.be.true
+  })
+})

package/redis-semaphore/test/src/semaphore/release.test.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai'
+
+import { releaseSemaphore as release } from '../../../src/semaphore/release'
+import { client1 as client } from '../../redisClient'
+
+describe('semaphore release', () => {
+  it('should remove key after success release', async () => {
+    await client.zadd('key', '' + Date.now(), '111')
+    expect(await client.zcard('key')).to.be.eql(1)
+    await release(client, 'key', '111')
+    expect(await client.zcard('key')).to.be.eql(0)
+  })
+  it('should do nothing if resource is not locked', async () => {
+    expect(await client.zcard('key')).to.be.eql(0)
+    await release(client, 'key', '111')
+    expect(await client.zcard('key')).to.be.eql(0)
+  })
+})

package/redis-semaphore/test/src/utils/eval.test.ts

@@ -0,0 +1,22 @@
+import { expect } from 'chai'
+
+import { createEval } from '../../../src/utils/index'
+import { client1 as client } from '../../redisClient'
+
+describe('utils createEval', () => {
+  it('should return function', async () => {
+    expect(createEval('return 5', 0)).to.be.a('function')
+  })
+  it('should call evalsha or fallback to eval', async () => {
+    const now = Date.now()
+    const SCRIPT = `return ${now}`
+    const execScript = createEval(SCRIPT, 0)
+    const result = await execScript(client, [])
+    expect(result).to.be.eql(now)
+    expect(Date.now() - now).to.be.lt(50)
+  })
+  it('should handle eval errors', async () => {
+    const execScript = createEval('return asdfkasjdf', 0)
+    await expect(execScript(client, [])).to.be.rejected
+  })
+})

package/redis-semaphore/test/src/utils/index.test.ts

@@ -0,0 +1,19 @@
+import { expect } from 'chai'
+import Redis from 'ioredis'
+import { getConnectionName } from '../../../src/utils/index'
+import { client1 } from '../../redisClient'
+
+describe('utils getConnectionName', () => {
+  it('should return connection name', async () => {
+    expect(getConnectionName(client1)).to.be.eql('<client1>')
+  })
+  it('should return unknown if connection name not configured', () => {
+    const client = new Redis('redis://127.0.0.1:6000', {
+      lazyConnect: true,
+      enableOfflineQueue: false,
+      autoResendUnfulfilledCommands: false, // dont queue commands while server is offline (dont break test logic)
+      maxRetriesPerRequest: 0 // dont retry, fail faster (default is 20)
+    })
+    expect(getConnectionName(client)).to.be.eql('<unknown client>')
+  })
+})

package/redis-semaphore/test/src/utils/redlock.test.ts

@@ -0,0 +1,31 @@
+import { expect } from 'chai'
+
+import { getQuorum } from '../../../src/utils/redlock'
+
+describe('redlockMutex utils', () => {
+  describe('getQuorum', () => {
+    function makeTest(count: number, expectedResult: number) {
+      it(`should return valid majority for ${count} nodes`, () => {
+        expect(getQuorum(count)).to.be.eql(expectedResult)
+        expect(getQuorum(2)).to.be.eql(2)
+        expect(getQuorum(3)).to.be.eql(2)
+        expect(getQuorum(4)).to.be.eql(3)
+        expect(getQuorum(5)).to.be.eql(3)
+        expect(getQuorum(6)).to.be.eql(4)
+        expect(getQuorum(7)).to.be.eql(4)
+        expect(getQuorum(8)).to.be.eql(5)
+        expect(getQuorum(9)).to.be.eql(5)
+      })
+    }
+    // makeTest(0, 1)
+    makeTest(1, 1)
+    makeTest(2, 2)
+    makeTest(3, 2)
+    makeTest(4, 3)
+    makeTest(5, 3)
+    makeTest(6, 4)
+    makeTest(7, 4)
+    makeTest(8, 5)
+    makeTest(9, 5)
+  })
+})