effect-distributed-lock 0.0.6 → 0.0.8

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

@@ -1,67 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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)
-  })
-})