comq 0.25.1 → 0.26.0

package/test/shards/connection.test.js

@@ -15,32 +15,79 @@ it('should be', async () => {
   expect(Connection).toBeDefined()
 })
 
-/** @type {jest.MockedObject<comq.Connection>[]} */
+/** @type {jest.MockedObject<comq.Connection>[]} the connections made, in the order they were */
 let connections
 
+/** @type {jest.MockedFunction<(url: string, servername?: string) => comq.Connection>} */
+let make
+
 /** @type {comq.Connection} */
 let connection
 
+/** @type {jest.MockedObject<comq.Channel>[]} */
+let channels
+
+const urls = ['amqp://10.0.0.1', 'amqp://10.0.0.2']
+
+const sharded = () => {
+  const channel = {
+    has: jest.fn(() => false),
+    join: jest.fn(async () => undefined),
+    retire: jest.fn(() => undefined),
+    restore: jest.fn(() => undefined),
+    quiet: jest.fn(async () => 0),
+    leave: jest.fn(async () => undefined)
+  }
+
+  channels.push(channel)
+
+  return channel
+}
+
 beforeEach(() => {
   jest.clearAllMocks()
 
-  connections = [mock.connection(), mock.connection()]
-  connection = new Connection(connections)
+  connections = []
+  channels = []
+
+  make = jest.fn(() => {
+    const connection = mock.connection()
+
+    connections.push(connection)
+
+    return connection
+  })
+
+  create.mockImplementation(async () => sharded())
+
+  connection = new Connection(urls, make)
 })
 
 describe('open', () => {
+  it('should make a connection to each of the urls', async () => {
+    await connection.open()
+
+    expect(make).toHaveBeenCalledTimes(2)
+    urls.forEach((url) => expect(make).toHaveBeenCalledWith(url, undefined))
+    connections.forEach((conn) => expect(conn.open).toHaveBeenCalled())
+  })
+
   it('should resolve when all of the connections are established', async () => {
     expect.assertions(2)
 
     /** @type {Promex[]} */
     const promises = []
 
-    for (const conn of connections) {
+    make.mockImplementation(() => {
+      const conn = mock.connection()
       const promise = new Promex()
 
       conn.open.mockImplementation(() => promise)
       promises.push(promise)
-    }
+      connections.push(conn)
+
+      return conn
+    })
 
     let resolved = false
 
@@ -64,21 +111,29 @@ describe('open', () => {
   })
 
   it('should close opened connection if one fails', async () => {
-    connections.push(mock.connection())
-
-    const [one, bad, two] = connections
     const exception = new Error(generate())
 
-    one.open.mockImplementation(() => Promise.resolve())
-    two.open.mockImplementation(() => Promise.resolve())
+    connection = new Connection([...urls, 'amqp://10.0.0.3'], make)
 
-    bad.open.mockImplementation(async () => {
-      await immediate()
-      throw exception
+    make.mockImplementation(() => {
+      const conn = mock.connection()
+
+      if (connections.length === 1) {
+        conn.open.mockImplementation(async () => {
+          await immediate()
+          throw exception
+        })
+      }
+
+      connections.push(conn)
+
+      return conn
     })
 
     await expect(connection.open()).rejects.toThrow(exception)
 
+    const [one, , two] = connections
+
     expect(one.close).toHaveBeenCalled()
     expect(two.close).toHaveBeenCalled()
   })
@@ -86,6 +141,7 @@ describe('open', () => {
 
 describe('close', () => {
   it('should close all connections', async () => {
+    await connection.open()
     await connection.close()
 
     for (const conn of connections) {
@@ -97,17 +153,20 @@ describe('close', () => {
 describe('createChannel', () => {
   const type = generate()
 
-  beforeEach(() => {
-    connection.createChannel(type)
+  beforeEach(async () => {
+    await connection.open()
+    await connection.createChannel(type)
   })
 
-  it('should create channel', async () => {
-    expect(create).toHaveBeenCalledWith(connections, type)
+  it('should create channel over the connections, by the number of each', async () => {
+    expect(create).toHaveBeenCalledWith(new Map(connections.entries()), type)
   })
 })
 
 describe.each(/** @type {comq.diagnostics.Event[]} */ ['open', 'close'])('diagnose %s event',
   (event) => {
+    beforeEach(() => connection.open())
+
     it('should re-emit event', async () => {
       const index = random(connections.length)
 
@@ -134,6 +193,8 @@ describe.each(/** @type {comq.diagnostics.Event[]} */ ['open', 'close'])('diagno
 
 describe('forget', () => {
   it('should stop re-emitting to the listener', async () => {
+    await connection.open()
+
     const listener = /** @type {Function} */ jest.fn()
 
     connection.diagnose('open', listener)
@@ -146,3 +207,297 @@ describe('forget', () => {
     expect(listener).not.toHaveBeenCalled()
   })
 })
+
+describe('names', () => {
+  const INTERVAL = 1000
+  const SETTLE = 3000
+  const LINGER = 5000
+
+  const names = ['amqp://one', 'amqp://two', 'amqp://three', 'amqp://four']
+
+  /** @type {Record<string, string>} */
+  let addresses
+
+  /** @type {Record<string, jest.MockedFunction<Function>>} */
+  let heard
+
+  const tick = (ms = INTERVAL) => jest.advanceTimersByTimeAsync(ms)
+
+  /**
+   * @param {jest.MockedObject<comq.Connection>} conn
+   * @param {comq.diagnostics.Event} event
+   * @param {...any} args
+   */
+  const tell = (conn, event, ...args) => {
+    for (const [name, listener] of conn.diagnose.mock.calls) if (name === event) listener(...args)
+  }
+
+  beforeEach(async () => {
+    jest.useFakeTimers()
+
+    addresses = { one: '10.0.0.1', two: '10.0.0.1', three: '10.0.0.2', four: '10.0.0.2' }
+
+    global.COMQ_TESTING_LOOKUP = async (host) => ({ addresses: [addresses[host]], ttl: 1 })
+
+    connection = new Connection(names, make, { interval: INTERVAL, settle: SETTLE, linger: LINGER })
+    heard = { join: jest.fn(), retire: jest.fn(), leave: jest.fn() }
+
+    for (const [event, listener] of Object.entries(heard)) connection.diagnose(event, listener)
+
+    await connection.open()
+    await connection.createChannel(generate())
+  })
+
+  afterEach(async () => {
+    await connection.close()
+
+    jest.useRealTimers()
+
+    delete global.COMQ_TESTING_LOOKUP
+  })
+
+  it('should make a connection to each broker rather than to each name', async () => {
+    expect(make).toHaveBeenCalledTimes(2)
+    expect(make).toHaveBeenCalledWith('amqp://10.0.0.1', 'one')
+    expect(make).toHaveBeenCalledWith('amqp://10.0.0.2', 'three')
+  })
+
+  it('should join a broker a name has moved to, once that has settled', async () => {
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE)
+
+    expect(make).toHaveBeenCalledTimes(2)
+
+    await tick()
+
+    expect(make).toHaveBeenCalledWith('amqp://10.0.0.3', 'four')
+    expect(connections[2].open).toHaveBeenCalled()
+    expect(channels[0].join).toHaveBeenCalledWith(connections[2], 2)
+    expect(heard.join).toHaveBeenCalledWith(2, '10.0.0.3')
+  })
+
+  it('should not retire a broker that is still named', async () => {
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + LINGER * 2)
+
+    expect(channels[0].retire).not.toHaveBeenCalled()
+    expect(heard.retire).not.toHaveBeenCalled()
+  })
+
+  it('should retire a broker no name points at', async () => {
+    addresses.three = '10.0.0.3'
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + INTERVAL)
+
+    expect(channels[0].retire).toHaveBeenCalledWith(1)
+    expect(heard.retire).toHaveBeenCalledWith(1, '10.0.0.2')
+    expect(connections[1].close).not.toHaveBeenCalled()
+  })
+
+  it('should not retire a broker before the one named instead has joined', async () => {
+    const opening = new Promex()
+
+    make.mockImplementation(() => {
+      const conn = mock.connection()
+
+      conn.open.mockImplementation(() => opening)
+      connections.push(conn)
+
+      return conn
+    })
+
+    addresses.three = '10.0.0.3'
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + LINGER * 2)
+
+    expect(heard.retire).not.toHaveBeenCalled()
+
+    opening.resolve()
+
+    await tick(0)
+
+    expect(heard.retire).toHaveBeenCalledWith(1, '10.0.0.2')
+  })
+
+  it('should take a shard that has joined into a channel made later', async () => {
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + INTERVAL)
+    await connection.createChannel(generate())
+
+    expect(create).toHaveBeenLastCalledWith(new Map(connections.entries()), expect.any(String))
+  })
+
+  describe('retired', () => {
+    beforeEach(async () => {
+      addresses.three = '10.0.0.3'
+      addresses.four = '10.0.0.3'
+
+      await tick(SETTLE + INTERVAL)
+    })
+
+    it('should leave a broker that has been idle for the linger time', async () => {
+      await tick(LINGER - INTERVAL)
+
+      expect(heard.leave).not.toHaveBeenCalled()
+
+      await tick(INTERVAL * 2)
+
+      expect(channels[0].leave).toHaveBeenCalledWith(1)
+      expect(connections[1].close).toHaveBeenCalled()
+      expect(heard.leave).toHaveBeenCalledWith(1, '10.0.0.2')
+    })
+
+    it('should not leave a broker that has something to do', async () => {
+      channels[0].quiet.mockImplementation(async () => Date.now())
+
+      await tick(LINGER * 3)
+
+      expect(heard.leave).not.toHaveBeenCalled()
+      expect(connections[1].close).not.toHaveBeenCalled()
+
+      channels[0].quiet.mockImplementation(async () => 0)
+
+      await tick()
+
+      expect(heard.leave).toHaveBeenCalledWith(1, '10.0.0.2')
+    })
+
+    it('should count the linger time from when the broker was last busy', async () => {
+      const busy = Date.now() + INTERVAL * 2
+
+      channels[0].quiet.mockImplementation(async () => busy)
+
+      await tick(LINGER + INTERVAL)
+
+      expect(heard.leave).not.toHaveBeenCalled()
+
+      await tick(INTERVAL * 2)
+
+      expect(heard.leave).toHaveBeenCalled()
+    })
+
+    it('should give up on a broker that is out of reach for the linger time', async () => {
+      connections[1].connected = false
+      channels[0].quiet.mockImplementation(async () => Date.now())
+
+      await tick(LINGER + INTERVAL * 2)
+
+      expect(heard.leave).toHaveBeenCalledWith(1, '10.0.0.2')
+    })
+
+    it('should put a broker that is named again back', async () => {
+      addresses.four = '10.0.0.2'
+
+      await tick(SETTLE + INTERVAL)
+
+      expect(channels[0].restore).toHaveBeenCalledWith(1)
+      expect(heard.join).toHaveBeenCalledWith(1, '10.0.0.2')
+
+      await tick(LINGER * 2)
+
+      expect(heard.leave).not.toHaveBeenCalled()
+    })
+
+    it('should retire in a channel made later', async () => {
+      const channel = await connection.createChannel(generate())
+
+      expect(channel.retire).toHaveBeenCalledWith(1)
+    })
+
+    it('should join anew a broker that was left', async () => {
+      await tick(LINGER + INTERVAL)
+
+      addresses.four = '10.0.0.2'
+
+      await tick(SETTLE + INTERVAL)
+
+      expect(make).toHaveBeenCalledTimes(4)
+      expect(heard.join).toHaveBeenCalledWith(3, '10.0.0.2')
+    })
+  })
+
+  it('should follow at once the names of a broker that is out of reach', async () => {
+    addresses.three = '10.0.0.3'
+    addresses.four = '10.0.0.3'
+
+    connections[1].connected = false
+
+    tell(connections[1], 'close', new Error('lost'))
+
+    await tick(0)
+
+    expect(make).toHaveBeenCalledWith('amqp://10.0.0.3', 'three')
+    expect(heard.join).toHaveBeenCalledWith(2, '10.0.0.3')
+  })
+
+  it('should report a name that fails to resolve', async () => {
+    const listener = jest.fn()
+    const exception = new Error('ENOTFOUND')
+
+    connection.diagnose('error', listener)
+
+    global.COMQ_TESTING_LOOKUP = async () => { throw exception }
+
+    await tick()
+
+    expect(listener).toHaveBeenCalledWith(exception)
+    expect(heard.retire).not.toHaveBeenCalled()
+  })
+
+  it('should not take a broker that cannot be consumed from for one that has joined', async () => {
+    const exception = new Error('PRECONDITION_FAILED')
+    const listener = jest.fn()
+
+    connection.diagnose('error', listener)
+    channels[0].join.mockImplementationOnce(async () => { throw exception })
+
+    addresses.three = '10.0.0.3'
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + INTERVAL)
+
+    expect(listener).toHaveBeenCalledWith(exception, 2)
+    expect(heard.join).not.toHaveBeenCalled()
+    expect(heard.retire).not.toHaveBeenCalled()
+    expect(channels[0].leave).toHaveBeenCalledWith(2)
+    expect(connections[2].close).toHaveBeenCalled()
+
+    // and joins it anew later
+    await tick()
+
+    expect(heard.join).toHaveBeenCalledWith(3, '10.0.0.3')
+    expect(heard.retire).toHaveBeenCalledWith(1, '10.0.0.2')
+  })
+
+  it('should ask again a broker that refused', async () => {
+    const exception = new Error('ACCESS-REFUSED')
+    const listener = jest.fn()
+
+    connection.diagnose('error', listener)
+
+    make.mockImplementationOnce(() => {
+      const conn = mock.connection()
+
+      conn.open.mockImplementation(async () => { throw exception })
+      connections.push(conn)
+
+      return conn
+    })
+
+    addresses.four = '10.0.0.3'
+
+    await tick(SETTLE + INTERVAL)
+
+    expect(listener).toHaveBeenCalledWith(exception, 2)
+    expect(heard.join).not.toHaveBeenCalled()
+
+    await tick()
+
+    expect(heard.join).toHaveBeenCalledWith(3, '10.0.0.3')
+  })
+})

package/test/shards/expand.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const { expand } = require('../../source/shards/expand')
+
+it('should leave a url without a range as it is', async () => {
+  expect(expand('amqp://user:secret@rmq.example.com:5672/vhost?heartbeat=5'))
+    .toStrictEqual(['amqp://user:secret@rmq.example.com:5672/vhost?heartbeat=5'])
+})
+
+it('should expand a range, its end being exclusive', async () => {
+  expect(expand('amqp://rmq[0..3].example.com')).toStrictEqual([
+    'amqp://rmq0.example.com',
+    'amqp://rmq1.example.com',
+    'amqp://rmq2.example.com'
+  ])
+})
+
+it('should name as many hosts as the end of a range that starts at zero', async () => {
+  expect(expand('amqp://rmq[0..32].example.com')).toHaveLength(32)
+})
+
+it('should keep what surrounds the host', async () => {
+  expect(expand('amqps://user:secret@rmq-[1..3].example.com:5671/vhost?heartbeat=5')).toStrictEqual([
+    'amqps://user:secret@rmq-1.example.com:5671/vhost?heartbeat=5',
+    'amqps://user:secret@rmq-2.example.com:5671/vhost?heartbeat=5'
+  ])
+})
+
+it('should pad to the width the start is written with', async () => {
+  expect(expand('amqp://rmq[08..11]')).toStrictEqual(['amqp://rmq08', 'amqp://rmq09', 'amqp://rmq10'])
+})
+
+it('should expand every range', async () => {
+  expect(expand('amqp://rmq[0..2].zone[0..2]')).toStrictEqual([
+    'amqp://rmq0.zone0',
+    'amqp://rmq0.zone1',
+    'amqp://rmq1.zone0',
+    'amqp://rmq1.zone1'
+  ])
+})
+
+it('should leave an IPv6 literal alone', async () => {
+  expect(expand('amqp://[::1]:5672')).toStrictEqual(['amqp://[::1]:5672'])
+})
+
+it('should look at the host only', async () => {
+  const url = 'amqp://user:[0..2]@rmq.example.com/[0..2]?name=[0..2]'
+
+  expect(expand(url)).toStrictEqual([url])
+})
+
+it('should leave what is not a url as it is', async () => {
+  expect(expand('whatever')).toStrictEqual(['whatever'])
+})
+
+it.each(['[3..3]', '[3..1]'])('should refuse a range that names no hosts: %s', async (range) => {
+  expect(() => expand(`amqp://rmq${range}`)).toThrow(RangeError)
+})

package/test/shards/resolve.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const { choose, hostOf, locate } = require('../../source/shards/resolve')
+
+describe('choose', () => {
+  it('should choose the same address whichever order they came in', async () => {
+    expect(choose(['10.0.0.2', '10.0.0.1'])).toStrictEqual('10.0.0.1')
+    expect(choose(['10.0.0.1', '10.0.0.2'])).toStrictEqual('10.0.0.1')
+  })
+
+  it('should prefer IPv4', async () => {
+    expect(choose(['::1', '127.0.0.1'])).toStrictEqual('127.0.0.1')
+  })
+
+  it('should keep the address in use while it is listed', async () => {
+    expect(choose(['10.0.0.1', '10.0.0.2'], '10.0.0.2')).toStrictEqual('10.0.0.2')
+  })
+
+  it('should let go of an address that is no longer listed', async () => {
+    expect(choose(['10.0.0.1', '10.0.0.3'], '10.0.0.2')).toStrictEqual('10.0.0.1')
+  })
+})
+
+describe('hostOf', () => {
+  it('should tell the name', async () => {
+    expect(hostOf('amqp://user:secret@rmq.example.com:5672/vhost')).toStrictEqual('rmq.example.com')
+  })
+
+  it.each(['amqp://10.0.0.1:5672', 'amqp://[::1]', 'whatever'])('should tell nothing of %s',
+    async (url) => {
+      expect(hostOf(url)).toBeUndefined()
+    })
+})
+
+describe('locate', () => {
+  it('should put the address in place of the name, which the broker is verified by', async () => {
+    expect(locate('amqps://user:secret@rmq.example.com:5671/vhost?heartbeat=5', '10.0.0.1')).toStrictEqual({
+      url: 'amqps://user:secret@10.0.0.1:5671/vhost?heartbeat=5',
+      address: '10.0.0.1',
+      servername: 'rmq.example.com'
+    })
+  })
+
+  it('should bracket an IPv6 address', async () => {
+    expect(locate('amqp://rmq.example.com:5672', '::1').url).toStrictEqual('amqp://[::1]:5672')
+  })
+
+  it('should locate the names of one broker alike', async () => {
+    const one = locate('amqp://rmq0.example.com', '10.0.0.1')
+    const another = locate('amqp://rmq1.example.com', '10.0.0.1')
+
+    expect(one.url).toStrictEqual(another.url)
+  })
+
+  it('should tell brokers apart by port, credentials and virtual host', async () => {
+    const urls = [
+      'amqp://rmq.example.com',
+      'amqp://rmq.example.com:5673',
+      'amqp://user:secret@rmq.example.com',
+      'amqp://rmq.example.com/vhost'
+    ].map((url) => locate(url, '10.0.0.1').url)
+
+    expect(new Set(urls).size).toStrictEqual(urls.length)
+  })
+
+  it('should leave an address as it is', async () => {
+    expect(locate('amqp://10.0.0.1:5672')).toStrictEqual({ url: 'amqp://10.0.0.1:5672', address: '10.0.0.1' })
+  })
+
+  it('should leave what is not a url as it is', async () => {
+    expect(locate('whatever')).toStrictEqual({ url: 'whatever', address: 'whatever' })
+  })
+})