Add tests for other lock types

Author: kibertoad

test/src/RedisMultiSemaphore.test.ts

@@ -87,7 +87,7 @@ describe('MultiSemaphore', () => {
  const semaphore2 = new MultiSemaphore(client, 'key', 3, 1, timeoutOptions)
  await semaphore1.acquire()
  await semaphore2.acquire()
- await delay(100)
+ await delay(400)
  expect(await client.zrange('semaphore:key', 0, -1)).to.have.members([
  semaphore1.identifier + '_0',
  semaphore1.identifier + '_1',
@@ -100,6 +100,20 @@ describe('MultiSemaphore', () => {
  await semaphore2.release()
  expect(await client.zcard('semaphore:key')).to.be.eql(0)
  })
+ it('should stop refreshing lock if stopped', async () => {
+ const semaphore1 = new MultiSemaphore(client, 'key', 3, 2, timeoutOptions)
+ const semaphore2 = new MultiSemaphore(client, 'key', 3, 1, timeoutOptions)
+ await semaphore1.acquire()
+ await semaphore2.acquire()
+ await semaphore1.stopRefresh()
+ await delay(400)
+ expect(await client.zrange('semaphore:key', 0, -1)).to.be.eql([
+ semaphore2.identifier + '_0'
+ ])
+ await semaphore2.stopRefresh()
+ await delay(400)
+ expect(await client.zcard('semaphore:key')).to.be.eql(0)
+ })
  it('should acquire maximum LIMIT semaphores', async () => {
  const s = () =>
  new MultiSemaphore(client, 'key', 3, 1, {

test/src/RedisSemaphore.test.ts

@@ -77,7 +77,7 @@ describe('Semaphore', () => {
  const semaphore2 = new Semaphore(client, 'key', 2, timeoutOptions)
  await semaphore1.acquire()
  await semaphore2.acquire()
- await delay(100)
+ await delay(400)
  expect(await client.zrange('semaphore:key', 0, -1)).to.have.members([
  semaphore1.identifier,
  semaphore2.identifier
@@ -89,6 +89,20 @@ describe('Semaphore', () => {
  await semaphore2.release()
  expect(await client.zcard('semaphore:key')).to.be.eql(0)
  })
+ it('should stop refreshing lock if stopped', async () => {
+ const semaphore1 = new Semaphore(client, 'key', 2, timeoutOptions)
+ const semaphore2 = new Semaphore(client, 'key', 2, timeoutOptions)
+ await semaphore1.acquire()
+ await semaphore2.acquire()
+ await semaphore1.stopRefresh()
+ await delay(400)
+ expect(await client.zrange('semaphore:key', 0, -1)).to.be.eql([
+ semaphore2.identifier
+ ])
+ await semaphore2.stopRefresh()
+ await delay(400)
+ expect(await client.zcard('semaphore:key')).to.be.eql(0)
+ })
  it('should acquire maximum LIMIT semaphores', async () => {
  const s = () =>
  new Semaphore(client, 'key', 3, {

test/src/RedlockMultiSemaphore.test.ts

@@ -151,7 +151,7 @@ describe('RedlockMultiSemaphore', () => {
  )
  await semaphore1.acquire()
  await semaphore2.acquire()
- await delay(100)
+ await delay(400)
  await expectZRangeAllHaveMembers('semaphore:key', [
  semaphore1.identifier + '_0',
  semaphore1.identifier + '_1',
@@ -162,6 +162,30 @@ describe('RedlockMultiSemaphore', () => {
  await semaphore2.release()
  await expectZCardAllEql('semaphore:key', 0)
  })
+ it('should stop refreshing lock if stopped', async () => {
+ const semaphore1 = new RedlockMultiSemaphore(
+ allClients,
+ 'key',
+ 3,
+ 2,
+ timeoutOptions
+ )
+ const semaphore2 = new RedlockMultiSemaphore(
+ allClients,
+ 'key',
+ 3,
+ 1,
+ timeoutOptions
+ )
+ await semaphore1.acquire()
+ await semaphore2.acquire()
+ semaphore1.stopRefresh()
+ await delay(400)
+ await expectZRangeAllEql('semaphore:key', [semaphore2.identifier + '_0'])
+ semaphore2.stopRefresh()
+ await delay(400)
+ await expectZCardAllEql('semaphore:key', 0)
+ })
  it('should acquire maximum LIMIT semaphores', async () => {
  const s = () =>
  new RedlockMultiSemaphore(allClients, 'key', 3, 1, {

test/src/RedlockMutex.test.ts

@@ -63,11 +63,18 @@ describe('RedlockMutex', () => {
  it('should refresh lock every refreshInterval ms until release', async () => {
  const mutex = new RedlockMutex(allClients, 'key', timeoutOptions)
  await mutex.acquire()
- await delay(100)
+ await delay(400)
  await expectGetAll('mutex:key', mutex.identifier)
  await mutex.release()
  await expectGetAll('mutex:key', null)
  })
+ it('should stop refreshing if stopped', async () => {
+ const mutex = new RedlockMutex(allClients, 'key', timeoutOptions)
+ await mutex.acquire()
+ mutex.stopRefresh()
+ await delay(400)
+ await expectGetAll('mutex:key', null)
+ })
  describe('lost lock case', () => {
  beforeEach(() => {
  catchUnhandledRejection()

test/src/RedlockSemaphore.test.ts

@@ -118,7 +118,7 @@ describe('RedlockSemaphore', () => {
  )
  await semaphore1.acquire()
  await semaphore2.acquire()
- await delay(100)
+ await delay(400)
  await expectZRangeAllHaveMembers('semaphore:key', [
  semaphore1.identifier,
  semaphore2.identifier
@@ -128,6 +128,28 @@ describe('RedlockSemaphore', () => {
  await semaphore2.release()
  await expectZCardAllEql('semaphore:key', 0)
  })
+ it('should stop refreshing lock if stopped', async () => {
+ const semaphore1 = new RedlockSemaphore(
+ allClients,
+ 'key',
+ 2,
+ timeoutOptions
+ )
+ const semaphore2 = new RedlockSemaphore(
+ allClients,
+ 'key',
+ 2,
+ timeoutOptions
+ )
+ await semaphore1.acquire()
+ await semaphore2.acquire()
+ semaphore1.stopRefresh()
+ await delay(400)
+ await expectZRangeAllEql('semaphore:key', [semaphore2.identifier])
+ semaphore2.stopRefresh()
+ await delay(400)
+ await expectZCardAllEql('semaphore:key', 0)
+ })
  it('should acquire maximum LIMIT semaphores', async () => {
  const s = () =>
  new RedlockSemaphore(allClients, 'key', 3, {