test: added externallyAcquiredIdentifier tests

Author: swarthy

test/src/RedisMultiSemaphore.test.ts

@@ -10,7 +10,9 @@ import { delay } from '../../src/utils/index'
 import { client1 as client } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -23,28 +25,28 @@ const timeoutOptions: TimeoutOptions = {
 describe('MultiSemaphore', () => {
  it('should fail on invalid arguments', () => {
  expect(
- () => new MultiSemaphore((null as unknown) as Redis, 'key', 5, 2)
+ () => new MultiSemaphore(null as unknown as Redis, 'key', 5, 2)
  ).to.throw('"client" is required')
  expect(
- () => new MultiSemaphore(({} as unknown) as Redis, 'key', 5, 2)
+ () => new MultiSemaphore({} as unknown as Redis, 'key', 5, 2)
  ).to.throw('"client" must be instance of ioredis client')
  expect(() => new MultiSemaphore(client, '', 5, 2)).to.throw(
  '"key" is required'
  )
  expect(
- () => new MultiSemaphore(client, (1 as unknown) as string, 5, 2)
+ () => new MultiSemaphore(client, 1 as unknown as string, 5, 2)
  ).to.throw('"key" must be a string')
  expect(() => new MultiSemaphore(client, 'key', 0, 2)).to.throw(
  '"limit" is required'
  )
  expect(
- () => new MultiSemaphore(client, 'key', ('10' as unknown) as number, 2)
+ () => new MultiSemaphore(client, 'key', '10' as unknown as number, 2)
  ).to.throw('"limit" must be a number')
  expect(() => new MultiSemaphore(client, 'key', 5, 0)).to.throw(
  '"permits" is required'
  )
  expect(
- () => new MultiSemaphore(client, 'key', 5, ('2' as unknown) as number)
+ () => new MultiSemaphore(client, 'key', 5, '2' as unknown as number)
  ).to.throw('"permits" must be a number')
  })
  it('should acquire and release semaphore', async () => {
@@ -136,6 +138,25 @@ describe('MultiSemaphore', () => {
  .and.not.include(ids1[1])
  .and.not.include(ids1[2])
  })
+ it('should support externally acquired semaphore', async () => {
+ const externalSemaphore = new MultiSemaphore(client, 'key', 3, 2, {
+ ...timeoutOptions,
+ refreshInterval: 0
+ })
+ const localSemaphore = new MultiSemaphore(client, 'key', 3, 2, {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalSemaphore.identifier
+ })
+ await externalSemaphore.acquire()
+ await localSemaphore.acquire()
+ await delay(400)
+ expect(await client.zrange('semaphore:key', 0, -1)).to.be.eql([
+ localSemaphore.identifier + '_0',
+ localSemaphore.identifier + '_1'
+ ])
+ await localSemaphore.release()
+ expect(await client.zcard('semaphore:key')).to.be.eql(0)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedisMutex.test.ts

@@ -9,7 +9,9 @@ import { delay } from '../../src/utils/index'
 import { client1 as client } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -21,14 +23,14 @@ const timeoutOptions: TimeoutOptions = {
 
 describe('Mutex', () => {
  it('should fail on invalid arguments', () => {
- expect(() => new Mutex((null as unknown) as Redis, 'key')).to.throw(
+ expect(() => new Mutex(null as unknown as Redis, 'key')).to.throw(
  '"client" is required'
  )
- expect(() => new Mutex(({} as unknown) as Redis, 'key')).to.throw(
+ expect(() => new Mutex({} as unknown as Redis, 'key')).to.throw(
  '"client" must be instance of ioredis client'
  )
  expect(() => new Mutex(client, '')).to.throw('"key" is required')
- expect(() => new Mutex(client, (1 as unknown) as string)).to.throw(
+ expect(() => new Mutex(client, 1 as unknown as string)).to.throw(
  '"key" must be a string'
  )
  })
@@ -92,6 +94,22 @@ describe('Mutex', () => {
  await mutex.release()
  expect(await client.get('mutex:key')).to.be.eql(null)
  })
+ it('should support externally acquired mutex', async () => {
+ const externalMutex = new Mutex(client, 'key', {
+ ...timeoutOptions,
+ refreshInterval: 0
+ })
+ const localMutex = new Mutex(client, 'key', {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalMutex.identifier
+ })
+ await externalMutex.acquire()
+ await localMutex.acquire()
+ await delay(400)
+ expect(await client.get('mutex:key')).to.be.eql(localMutex.identifier)
+ await localMutex.release()
+ expect(await client.get('mutex:key')).to.be.eql(null)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedisSemaphore.test.ts

@@ -9,7 +9,9 @@ import { delay } from '../../src/utils/index'
 import { client1 as client } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -21,21 +23,21 @@ const timeoutOptions: TimeoutOptions = {
 
 describe('Semaphore', () => {
  it('should fail on invalid arguments', () => {
- expect(() => new Semaphore((null as unknown) as Redis, 'key', 5)).to.throw(
+ expect(() => new Semaphore(null as unknown as Redis, 'key', 5)).to.throw(
  '"client" is required'
  )
- expect(() => new Semaphore(({} as unknown) as Redis, 'key', 5)).to.throw(
+ expect(() => new Semaphore({} as unknown as Redis, 'key', 5)).to.throw(
  '"client" must be instance of ioredis client'
  )
  expect(() => new Semaphore(client, '', 5)).to.throw('"key" is required')
- expect(() => new Semaphore(client, (1 as unknown) as string, 5)).to.throw(
+ expect(() => new Semaphore(client, 1 as unknown as string, 5)).to.throw(
  '"key" must be a string'
  )
  expect(() => new Semaphore(client, 'key', 0)).to.throw(
  '"limit" is required'
  )
  expect(
- () => new Semaphore(client, 'key', ('10' as unknown) as number)
+ () => new Semaphore(client, 'key', '10' as unknown as number)
  ).to.throw('"limit" must be a number')
  })
  it('should acquire and release semaphore', async () => {
@@ -125,6 +127,24 @@ describe('Semaphore', () => {
  .and.not.include(ids1[1])
  .and.not.include(ids1[2])
  })
+ it('should support externally acquired semaphore', async () => {
+ const externalSemaphore = new Semaphore(client, 'key', 3, {
+ ...timeoutOptions,
+ refreshInterval: 0
+ })
+ const localSemaphore = new Semaphore(client, 'key', 3, {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalSemaphore.identifier
+ })
+ await externalSemaphore.acquire()
+ await localSemaphore.acquire()
+ await delay(400)
+ expect(await client.zrange('semaphore:key', 0, -1)).to.have.members([
+ localSemaphore.identifier
+ ])
+ await localSemaphore.release()
+ expect(await client.zcard('semaphore:key')).to.be.eql(0)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedlockMultiSemaphore.test.ts

@@ -10,7 +10,9 @@ import { delay } from '../../src/utils/index'
 import { allClients, client1, client2, client3 } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -52,17 +54,16 @@ async function expectZCardAllEql(key: string, count: number) {
 describe('RedlockMultiSemaphore', () => {
  it('should fail on invalid arguments', () => {
  expect(
- () => new RedlockMultiSemaphore((null as unknown) as Redis[], 'key', 5, 2)
+ () => new RedlockMultiSemaphore(null as unknown as Redis[], 'key', 5, 2)
  ).to.throw('"clients" array is required')
  expect(
- () => new RedlockMultiSemaphore(([{}] as unknown) as Redis[], 'key', 5, 2)
+ () => new RedlockMultiSemaphore([{}] as unknown as Redis[], 'key', 5, 2)
  ).to.throw('"client" must be instance of ioredis client')
  expect(() => new RedlockMultiSemaphore(allClients, '', 5, 2)).to.throw(
  '"key" is required'
  )
  expect(
- () =>
- new RedlockMultiSemaphore(allClients, (1 as unknown) as string, 5, 2)
+ () => new RedlockMultiSemaphore(allClients, 1 as unknown as string, 5, 2)
  ).to.throw('"key" must be a string')
  expect(() => new RedlockMultiSemaphore(allClients, 'key', 0, 2)).to.throw(
  '"limit" is required'
@@ -72,7 +73,7 @@ describe('RedlockMultiSemaphore', () => {
  new RedlockMultiSemaphore(
  allClients,
  'key',
- ('10' as unknown) as number,
+ '10' as unknown as number,
  2
  )
  ).to.throw('"limit" must be a number')
@@ -85,7 +86,7 @@ describe('RedlockMultiSemaphore', () => {
  allClients,
  'key',
  5,
- ('2' as unknown) as number
+ '2' as unknown as number
  )
  ).to.throw('"permits" must be a number')
  })
@@ -214,6 +215,31 @@ describe('RedlockMultiSemaphore', () => {
  ])
  await expectZCardAllEql('semaphore:key', 3)
  })
+ it('should support externally acquired semaphore', async () => {
+ const externalSemaphore = new RedlockMultiSemaphore(
+ allClients,
+ 'key',
+ 3,
+ 2,
+ {
+ ...timeoutOptions,
+ refreshInterval: 0
+ }
+ )
+ const localSemaphore = new RedlockMultiSemaphore(allClients, 'key', 3, 2, {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalSemaphore.identifier
+ })
+ await externalSemaphore.acquire()
+ await localSemaphore.acquire()
+ await delay(400)
+ await expectZRangeAllHaveMembers('semaphore:key', [
+ localSemaphore.identifier + '_0',
+ localSemaphore.identifier + '_1'
+ ])
+ await localSemaphore.release()
+ await expectZCardAllEql('semaphore:key', 0)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedlockMutex.test.ts

@@ -9,7 +9,9 @@ import { delay } from '../../src/utils/index'
 import { allClients, client1, client2, client3 } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -27,16 +29,16 @@ async function expectGetAll(key: string, value: string | null) {
 
 describe('RedlockMutex', () => {
  it('should fail on invalid arguments', () => {
- expect(
- () => new RedlockMutex((null as unknown) as Redis[], 'key')
- ).to.throw('"clients" array is required')
- expect(
- () => new RedlockMutex(([{}] as unknown) as Redis[], 'key')
- ).to.throw('"client" must be instance of ioredis client')
+ expect(() => new RedlockMutex(null as unknown as Redis[], 'key')).to.throw(
+ '"clients" array is required'
+ )
+ expect(() => new RedlockMutex([{}] as unknown as Redis[], 'key')).to.throw(
+ '"client" must be instance of ioredis client'
+ )
  expect(() => new RedlockMutex(allClients, '')).to.throw('"key" is required')
- expect(
- () => new RedlockMutex(allClients, (1 as unknown) as string)
- ).to.throw('"key" must be a string')
+ expect(() => new RedlockMutex(allClients, 1 as unknown as string)).to.throw(
+ '"key" must be a string'
+ )
  })
  it('should acquire and release lock', async () => {
  const mutex = new RedlockMutex(allClients, 'key')
@@ -75,6 +77,22 @@ describe('RedlockMutex', () => {
  await delay(400)
  await expectGetAll('mutex:key', null)
  })
+ it('should support externally acquired mutex', async () => {
+ const externalMutex = new RedlockMutex(allClients, 'key', {
+ ...timeoutOptions,
+ refreshInterval: 0
+ })
+ const localMutex = new RedlockMutex(allClients, 'key', {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalMutex.identifier
+ })
+ await externalMutex.acquire()
+ await localMutex.acquire()
+ await delay(400)
+ await expectGetAll('mutex:key', localMutex.identifier)
+ await localMutex.release()
+ await expectGetAll('mutex:key', null)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedlockSemaphore.test.ts

@@ -9,7 +9,9 @@ import { delay } from '../../src/utils/index'
 import { allClients, client1, client2, client3 } from '../redisClient'
 import { downRedisServer, upRedisServer } from '../shell'
 import {
- catchUnhandledRejection, throwUnhandledRejection, unhandledRejectionSpy
+ catchUnhandledRejection,
+ throwUnhandledRejection,
+ unhandledRejectionSpy
 } from '../unhandledRejection'
 
 const timeoutOptions: TimeoutOptions = {
@@ -51,22 +53,22 @@ async function expectZCardAllEql(key: string, count: number) {
 describe('RedlockSemaphore', () => {
  it('should fail on invalid arguments', () => {
  expect(
- () => new RedlockSemaphore((null as unknown) as Redis[], 'key', 5)
+ () => new RedlockSemaphore(null as unknown as Redis[], 'key', 5)
  ).to.throw('"clients" array is required')
  expect(
- () => new RedlockSemaphore(([{}] as unknown) as Redis[], 'key', 5)
+ () => new RedlockSemaphore([{}] as unknown as Redis[], 'key', 5)
  ).to.throw('"client" must be instance of ioredis client')
  expect(() => new RedlockSemaphore(allClients, '', 5)).to.throw(
  '"key" is required'
  )
  expect(
- () => new RedlockSemaphore(allClients, (1 as unknown) as string, 5)
+ () => new RedlockSemaphore(allClients, 1 as unknown as string, 5)
  ).to.throw('"key" must be a string')
  expect(() => new RedlockSemaphore(allClients, 'key', 0)).to.throw(
  '"limit" is required'
  )
  expect(
- () => new RedlockSemaphore(allClients, 'key', ('10' as unknown) as number)
+ () => new RedlockSemaphore(allClients, 'key', '10' as unknown as number)
  ).to.throw('"limit" must be a number')
  })
  it('should acquire and release semaphore', async () => {
@@ -178,6 +180,22 @@ describe('RedlockSemaphore', () => {
  ])
  await expectZCardAllEql('semaphore:key', 3)
  })
+ it('should support externally acquired semaphore', async () => {
+ const externalSemaphore = new RedlockSemaphore(allClients, 'key', 3, {
+ ...timeoutOptions,
+ refreshInterval: 0
+ })
+ const localSemaphore = new RedlockSemaphore(allClients, 'key', 3, {
+ ...timeoutOptions,
+ externallyAcquiredIdentifier: externalSemaphore.identifier
+ })
+ await externalSemaphore.acquire()
+ await localSemaphore.acquire()
+ await delay(400)
+ await expectZRangeAllEql('semaphore:key', [localSemaphore.identifier])
+ await localSemaphore.release()
+ await expectZCardAllEql('semaphore:key', 0)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()