@yolo-croket-dev/core 1.10.0-jun.2-beta.1 → 1.10.1

package/tests/graceful-shutdown-rmq.test.cjs

@@ -0,0 +1,102 @@
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const test = require('node:test');
+
+const {
+  GracefulServerRMQ,
+} = require('../modules/graceful-shutdown/graceful-shutdown.rmq.js');
+
+const CONNECTION_NAME_ENV_KEYS = [
+  'ENV',
+  'NODE_ENV',
+  'RMQ_OWNER',
+  'USER',
+  'USERNAME',
+];
+
+function getClientProperties(options) {
+  const server = new GracefulServerRMQ(options);
+  return server.options.socketOptions.connectionOptions.clientProperties;
+}
+
+function runWithEnvironment(environment, callback) {
+  const originalEnvironment = Object.fromEntries(
+    CONNECTION_NAME_ENV_KEYS.map((key) => [key, process.env[key]]),
+  );
+  try {
+    for (const key of CONNECTION_NAME_ENV_KEYS) {
+      delete process.env[key];
+    }
+    Object.assign(process.env, environment);
+    callback();
+  } finally {
+    for (const key of CONNECTION_NAME_ENV_KEYS) {
+      const originalValue = originalEnvironment[key];
+      if (originalValue === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = originalValue;
+      }
+    }
+  }
+}
+
+test('자동 connection_name에 큐와 실행 주체 정보를 포함한다', () => {
+  runWithEnvironment({ ENV: 'release', RMQ_OWNER: 'jun' }, () => {
+    const actualClientProperties = getClientProperties({ queue: 'STORE_ITEM_SERVER' });
+    const expectedConnectionName = `STORE_ITEM_SERVER/release/jun/${os.hostname()}/pid-${process.pid}`;
+    assert.equal(actualClientProperties.connection_name, expectedConnectionName);
+  });
+});
+
+test('기존 connectionOptions와 clientProperties를 보존한다', () => {
+  runWithEnvironment({ NODE_ENV: 'production', USER: 'deploy' }, () => {
+    const inputOptions = {
+      queue: 'USER_SERVICE',
+      socketOptions: {
+        noDelay: true,
+        connectionOptions: {
+          locale: 'ko_KR',
+          clientProperties: {
+            product: 'croket',
+          },
+        },
+      },
+    };
+    const server = new GracefulServerRMQ(inputOptions);
+    assert.equal(server.options.socketOptions.noDelay, true);
+    assert.equal(server.options.socketOptions.connectionOptions.locale, 'ko_KR');
+    assert.equal(server.options.socketOptions.connectionOptions.clientProperties.product, 'croket');
+  });
+});
+
+test('명시적으로 설정한 문자열 connection_name을 보존한다', () => {
+  const actualClientProperties = getClientProperties({
+    queue: 'USER_SERVICE',
+    socketOptions: {
+      connectionOptions: {
+        clientProperties: {
+          connection_name: 'custom-connection-name',
+        },
+      },
+    },
+  });
+  assert.equal(actualClientProperties.connection_name, 'custom-connection-name');
+});
+
+test('문자열이 아닌 connection_name은 자동 생성값으로 대체한다', () => {
+  runWithEnvironment({ ENV: 'release', RMQ_OWNER: 'jun' }, () => {
+    const actualClientProperties = getClientProperties({
+      queue: 'STORE_ITEM_SERVER',
+      socketOptions: {
+        connectionOptions: {
+          clientProperties: {
+            connection_name: 123,
+          },
+        },
+      },
+    });
+    const expectedConnectionName = `STORE_ITEM_SERVER/release/jun/${os.hostname()}/pid-${process.pid}`;
+    assert.equal(actualClientProperties.connection_name, expectedConnectionName);
+  });
+});

package/tests/rmq-consumer-diagnostics.test.cjs

@@ -0,0 +1,150 @@
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const test = require('node:test');
+const { ServerRMQ, RmqContext } = require('@nestjs/microservices');
+const { lastValueFrom, throwError } = require('rxjs');
+const { MsaLogger } = require('@yolo-croket-dev/msa-logger');
+const { GracefulServerRMQ } = require('../modules/graceful-shutdown/graceful-shutdown.rmq');
+const { LoggingServiceInterceptor } = require('../interceptors/logging-service.interceptor');
+const { RPCInterceptor } = require('../interceptors/rpc.interceptor');
+const { getRmqDiagnosticSnapshot, RmqConnectionObserver, registerRmqObservation } = require('../functions/rmq-diagnostics.function');
+
+test('default/manage consumers preserve QoS/ACK, correlate failures and dispose observers on close', async t => {
+  const flag = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  t.after(() => { if (flag === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = flag; });
+  const managers = [];
+  t.mock.method(ServerRMQ.prototype, 'createClient', () => {
+    const manager = new EventEmitter(); managers.push(manager); return manager;
+  });
+  const close = t.mock.method(ServerRMQ.prototype, 'close', () => {});
+  const errors = [];
+  for (const method of ['info', 'warn', 'printInputInterceptorService', 'printOutService']) t.mock.method(MsaLogger.prototype, method, () => {});
+  t.mock.method(MsaLogger.prototype, 'printExceptionFliterService', (info, details) => errors.push({ info, details }));
+  const identities = new Set();
+  for (const queue of ['USER_SERVICE', 'MANAGE_SERVICE']) {
+    const calls = [];
+    const channel = {
+      assertQueue: async (...args) => calls.push(['assert', ...args]),
+      prefetch: async (...args) => calls.push(['prefetch', ...args]),
+      consume: async (...args) => { calls.push(['consume', ...args]); return { consumerTag: 'tag' }; },
+      cancel: async tag => calls.push(['cancel', tag]),
+    };
+    const server = new GracefulServerRMQ({ queue, noAck: false, prefetchCount: 7, queueOptions: { durable: true, deadLetterExchange: 'existing.dlx' }, waitingEndingHandlersTimeoutMs: 1 });
+    const manager = server.createClient(); manager.emit('connect');
+    await server.setupChannel(channel, () => {});
+    assert.deepEqual(calls[0], ['assert', queue, { durable: true, deadLetterExchange: 'existing.dlx' }]);
+    assert.deepEqual(calls[1], ['prefetch', 7, undefined]);
+    assert.deepEqual(calls[2][3], { noAck: false });
+    const snapshot = getRmqDiagnosticSnapshot(channel);
+    identities.add(snapshot.connectionId);
+    const data = { payload: { ok: true }, param: { traceId: 'consumer-trace' } };
+    const context = new RmqContext([{ content: Buffer.from(JSON.stringify({ pattern: 'test.receive' })) }, channel, 'test.receive']);
+    const execution = { getArgs: () => [data, context], switchToRpc: () => ({ getContext: () => context, getData: () => data }), switchToHttp: () => ({ getRequest: () => data }) };
+    const error = Object.assign(Error('handler failed'), { status: 409, errOption: { logErrorLevel: 'warn' } });
+    await assert.rejects(lastValueFrom(new LoggingServiceInterceptor().intercept(execution, { handle: () => throwError(() => error) })), actual => actual === error);
+    const record = errors.at(-1);
+    assert.equal(record.info.diagnosticInfo.connectionId, snapshot.connectionId);
+    assert.equal(record.info.diagnosticInfo.targetService, queue);
+    assert.equal(record.info.diagnosticInfo.direction, 'consumer');
+    assert.equal(record.info.diagnosticInfo.kind, 'service_error');
+    assert.equal(record.info.errInfo.errOption.logErrorLevel, 'warn');
+    server.channel = { removeSetup: async (_, cancel) => cancel(channel) };
+    await server.close();
+    assert.deepEqual(calls.at(-1), ['cancel', 'tag']);
+    assert.equal(manager.eventNames().length, 0);
+  }
+  assert.equal(identities.size, 2);
+  assert.equal(close.mock.callCount(), 2);
+});
+
+test('primitive and getter failures retain the original rejection and emit diagnostics', async t => {
+  const output = [];
+  for (const method of ['printInputInterceptorService', 'printOutService']) t.mock.method(MsaLogger.prototype, method, () => {});
+  t.mock.method(MsaLogger.prototype, 'printExceptionFliterService', (info, details) => output.push({ info, details }));
+  const channel = {};
+  registerRmqObservation(channel, new RmqConnectionObserver('USER_SERVICE', 'consumer', undefined, () => {}));
+  const data = { payload: {}, param: { traceId: 'primitive-error' } };
+  const context = new RmqContext([{ content: Buffer.from(JSON.stringify({ pattern: 'test.receive' })) }, channel, 'test.receive']);
+  const execution = { getArgs: () => [data, context], switchToRpc: () => ({ getContext: () => context, getData: () => data }), switchToHttp: () => ({ getRequest: () => data }) };
+  const throwingGetter = new Proxy({}, { get() { throw Error('getter failed'); } });
+  for (const original of [null, 'remote failed', throwingGetter]) {
+    const settled = await Promise.allSettled([lastValueFrom(new LoggingServiceInterceptor().intercept(execution, { handle: () => throwError(() => original) }))]);
+    assert.equal(settled[0].status, 'rejected');
+    assert.equal(settled[0].reason, original);
+    assert.equal(output.at(-1).info.traceId, 'primitive-error');
+    assert.equal(output.at(-1).info.diagnosticInfo.event, 'handler_failed');
+  }
+});
+
+test('consumer observer is disposed even when channel setup removal fails', async t => {
+  const flag = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  t.after(() => { if (flag === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = flag; });
+  const manager = new EventEmitter();
+  t.mock.method(ServerRMQ.prototype, 'createClient', () => manager);
+  t.mock.method(ServerRMQ.prototype, 'close', () => {});
+  const server = new GracefulServerRMQ({ queue: 'USER_SERVICE' });
+  server.createClient();
+  server.channel = { removeSetup: async () => { throw Error('channel closed'); } };
+  await assert.rejects(server.close(), /channel closed/);
+  assert.equal(manager.listenerCount('connect'), 0);
+});
+
+test('RPC-only consumer failure keeps the existing reply and adds connection diagnostics to its warning', async t => {
+  const warnings = [];
+  t.mock.method(MsaLogger.prototype, 'warn', (message, info, details) => warnings.push({ message, info, details }));
+  const replies = [];
+  const channel = {
+    sendToQueue: (...args) => replies.push(args),
+    ack: () => {},
+  };
+  const observer = new RmqConnectionObserver('MANAGE_SERVICE', 'consumer', undefined, () => {});
+  registerRmqObservation(channel, observer);
+  const request = { pattern: 'manage.fail', data: { payload: {}, param: { traceId: 'rpc-only' } } };
+  const message = {
+    content: Buffer.from(JSON.stringify(request)),
+    properties: { headers: {}, correlationId: 'correlation', replyTo: 'reply.queue' },
+    fields: { routingKey: 'MANAGE_SERVICE', consumerTag: 'consumer' },
+  };
+  const context = { getArgs: () => [{}, new RmqContext([message, channel, 'manage.fail'])], getHandler: () => function handler() {} };
+  const interceptor = new RPCInterceptor({ get: () => ({ isAdminGuard: true }) }, { isApplicationExit: false });
+  await interceptor.intercept(context, { handle: () => { throw Error('guard should reject first'); } });
+  assert.equal(warnings.length, 1);
+  assert.equal(warnings[0].info.traceId, 'rpc-only');
+  assert.equal(warnings[0].info.diagnosticInfo.connectionId, observer.connectionId);
+  assert.equal(warnings[0].info.diagnosticInfo.targetService, 'MANAGE_SERVICE');
+  assert.equal(warnings[0].info.diagnosticInfo.messagePattern, 'manage.fail');
+  assert.equal(warnings[0].info.diagnosticInfo.event, 'handler_failed');
+  assert.equal(replies.length, 1);
+  assert.equal(JSON.parse(replies[0][1].toString()).isError, true);
+});
+
+test('RPC-only handler failure records its trace and channel on the existing warning', async t => {
+  const warnings = [];
+  t.mock.method(MsaLogger.prototype, 'warn', (message, info) => warnings.push({ message, info }));
+  const acknowledgements = [];
+  const channel = {
+    sendToQueue: () => {},
+    ack: message => acknowledgements.push(message),
+  };
+  const observer = new RmqConnectionObserver('MANAGE_SERVICE', 'consumer', undefined, () => {});
+  registerRmqObservation(channel, observer);
+  const request = { pattern: 'manage.fail', data: { payload: {}, param: { traceId: 'handler-trace' } } };
+  const message = {
+    content: Buffer.from(JSON.stringify(request)),
+    properties: { headers: {}, correlationId: 'correlation', replyTo: 'reply.queue' },
+    fields: { routingKey: 'MANAGE_SERVICE', consumerTag: 'consumer' },
+  };
+  const context = { getArgs: () => [{}, new RmqContext([message, channel, 'manage.fail'])], getHandler: () => function handler() {} };
+  const shutdown = { isApplicationExit: false, pushActiveInterceptors: () => {}, popActiveInterceptors: () => {} };
+  const interceptor = new RPCInterceptor({ get: () => undefined }, shutdown);
+  const failure = Error('handler failed');
+  const stream = await interceptor.intercept(context, { handle: () => throwError(() => failure) });
+  await assert.rejects(lastValueFrom(stream), actual => actual === failure);
+  assert.equal(warnings.length, 1);
+  assert.equal(warnings[0].info.traceId, 'handler-trace');
+  assert.equal(warnings[0].info.diagnosticInfo.connectionId, observer.connectionId);
+  assert.equal(warnings[0].info.diagnosticInfo.event, 'handler_failed');
+  assert.equal(acknowledgements.length, 1);
+});

package/tests/rmq-diagnostics.test.cjs

@@ -0,0 +1,177 @@
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const test = require('node:test');
+const { Observable, of, throwError } = require('rxjs');
+const { ClientRMQ, Transport } = require('@nestjs/microservices');
+const { MsaLogger } = require('@yolo-croket-dev/msa-logger');
+const {
+  RmqConnectionObserver, createDiagnosticRmqClient, registerRmqObservation, getRmqDiagnosticSnapshot,
+} = require('../functions/rmq-diagnostics.function');
+const { AmqpHandler, HttpExceptionCustom } = require('../functions/amqp-handler.function');
+const { AmqpManagement } = require('../functions/amqp-call-manager.function');
+
+test('connection events have no request context; generation, summary and cleanup follow lifecycle', t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
+  const records = [];
+  const observer = new RmqConnectionObserver('USER_SERVICE', 'client', undefined, (info, details) => records.push({ info, details }));
+  const manager = new EventEmitter();
+  observer.observe(manager); observer.observe(manager);
+  assert.equal(manager.listenerCount('connectFailed'), 1);
+  assert.equal(observer.snapshot().connectionState, 'not_connected');
+  const error = Object.assign(Error('refused amqp://user:password@host'), { code: 'ECONNREFUSED' });
+  manager.emit('connectFailed', { err: error });
+  for (let i = 0; i < 100; i += 1) manager.emit('connectFailed', { err: error });
+  assert.equal(records.length, 1);
+  t.mock.timers.tick(60_000);
+  assert.equal(records[1].info.repeatCount, 100);
+  manager.emit('connectFailed', { err: error });
+  manager.emit('connect', {});
+  assert.equal(records[2].info.repeatCount, 1);
+  assert.equal(observer.snapshot().generation, 1);
+  manager.emit('blocked', { reason: 'private' });
+  assert.equal(observer.snapshot().connectionState, 'blocked');
+  manager.emit('unblocked');
+  manager.emit('disconnect', { err: Error('closed') });
+  assert.equal(records.at(-1).info.kind, 'connection_lost');
+  manager.emit('connect', {});
+  assert.equal(observer.snapshot().generation, 2);
+  manager.emit('connectFailed', { err: error });
+  manager.emit('connectFailed', { err: error });
+  observer.close();
+  const count = records.length;
+  t.mock.timers.tick(120_000);
+  manager.emit('connect', {});
+  assert.equal(records.length, count);
+  assert.equal(manager.eventNames().length, 0);
+  assert.ok(!JSON.stringify(records).includes('user:password'));
+  assert.ok(!JSON.stringify(records).includes('private'));
+});
+
+test('factory is lazy, preserves transport options and configured names, opt-in defaults off', async t => {
+  const previous = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  t.after(() => { if (previous === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = previous; });
+  const createSpy = t.mock.method(ClientRMQ.prototype, 'createClient', () => { throw Error('must remain lazy'); });
+  const options = {
+    transport: Transport.RMQ,
+    options: { queue: 'USER_SERVICE', noAck: true, queueOptions: { noAssert: true, durable: true },
+      socketOptions: { heartbeatIntervalInSeconds: 60, connectionOptions: { clientProperties: { connection_name: 'explicit' } } } },
+  };
+  const copy = JSON.stringify(options);
+  delete process.env.RMQ_DIAGNOSTICS_ENABLED;
+  const disabled = createDiagnosticRmqClient(options);
+  assert.equal(getRmqDiagnosticSnapshot(disabled), undefined);
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  const client = createDiagnosticRmqClient(options);
+  const other = createDiagnosticRmqClient(options);
+  assert.equal(createSpy.mock.callCount(), 0);
+  assert.equal(getRmqDiagnosticSnapshot(client).connectionState, 'not_connected');
+  assert.equal(getRmqDiagnosticSnapshot(client).connectionName, 'explicit');
+  assert.notEqual(getRmqDiagnosticSnapshot(client).connectionId, getRmqDiagnosticSnapshot(other).connectionId);
+  assert.equal(JSON.stringify(options), copy);
+  assert.deepEqual(client.options, options.options);
+  await disabled.close(); await client.close(); await other.close();
+});
+
+test('same trace and shared error retain each call target and start/failure generation', async t => {
+  const records = [];
+  t.mock.method(MsaLogger.prototype, 'warn', (message, info, details) => records.push({ message, info, details }));
+  const error = { err: Object.assign(Error('reset'), { code: 'ECONNRESET' }) };
+  const subscribers = [];
+  const calls = ['USER_SERVICE', 'PAYMENT_SERVICE'].map(target => {
+    const observer = new RmqConnectionObserver(target, 'client', undefined, () => {});
+    const manager = new EventEmitter(); observer.observe(manager);
+    const client = { send: () => new Observable(subscriber => { subscribers.push(subscriber); }) };
+    registerRmqObservation(client, observer);
+    const promise = AmqpHandler(client, `test.${target}`, { payload: { secret: 'not logged' }, param: { traceId: 'same', timeout: 1000 } });
+    manager.emit('connect'); manager.emit('disconnect', error); manager.emit('connect');
+    return promise;
+  });
+  const results = Promise.allSettled(calls);
+  subscribers.forEach(subscriber => subscriber.error(error));
+  assert.ok((await results).every(result => result.reason === error));
+  assert.equal(records.length, 2);
+  assert.deepEqual(records.map(record => record.info.diagnosticInfo.targetService), ['USER_SERVICE', 'PAYMENT_SERVICE']);
+  for (const record of records) {
+    assert.equal(record.info.traceId, 'same');
+    assert.equal(record.info.diagnosticInfo.startGeneration, 0);
+    assert.equal(record.info.diagnosticInfo.startConnectionState, 'not_connected');
+    assert.equal(record.info.diagnosticInfo.generation, 2);
+    assert.equal(record.info.diagnosticInfo.kind, 'connection_lost');
+    assert.equal(record.info.diagnosticInfo.timeoutMs, 1000);
+  }
+  assert.ok(!JSON.stringify(records).includes('not logged'));
+});
+
+test('success adds no logs; initial connect failure, timeout, service and no-handler stay distinct', async t => {
+  const records = [];
+  for (const method of ['info', 'warn', 'error']) t.mock.method(MsaLogger.prototype, method, (message, info) => records.push(info));
+  const observer = new RmqConnectionObserver('USER_SERVICE', 'client', undefined, () => {});
+  const cases = [
+    [() => throwError(() => ({ err: Object.assign(Error('refused'), { code: 'ECONNREFUSED' }) })), 'connection_failed'],
+    [() => new Observable(() => {}), 'response_timeout'],
+    [() => of({ isError: true, status: 400, errType: 'BUSINESS', errMessage: 'no' }), 'service_error'],
+    [() => throwError(() => 'There is no matching message handler defined in the remote service.'), 'handler_not_found'],
+  ];
+  for (const [send, kind] of cases) {
+    const client = { send }; registerRmqObservation(client, observer);
+    await assert.rejects(AmqpHandler(client, 'test.call', { payload: {}, param: { traceId: kind, timeout: 5 } }));
+    assert.equal(records.at(-1).diagnosticInfo.kind, kind);
+  }
+  const client = { send: () => of({ data: 42 }) }; registerRmqObservation(client, observer);
+  const count = records.length;
+  assert.deepEqual(await AmqpHandler(client, 'ok', { payload: {}, param: { traceId: 'ok' } }), { data: 42 });
+  assert.equal(records.length, count);
+  const business = { send: () => of({ isError: true, status: 409, errType: 'EXISTS', errMessage: 'exists' }) };
+  registerRmqObservation(business, observer);
+  await assert.rejects(AmqpHandler(business, 'test.call', { payload: {}, param: { traceId: 'business' } }), err => {
+    assert.ok(err instanceof HttpExceptionCustom); assert.equal(err.getStatus(), 409); assert.equal(err.errInfo.type, 'EXISTS'); return true;
+  });
+});
+
+test('legacy unobserved clients report failed pattern without inventing connection state', async t => {
+  const previous = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  t.after(() => { if (previous === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = previous; });
+  const records = [];
+  t.mock.method(MsaLogger.prototype, 'warn', (message, info) => records.push({ message, info }));
+  const client = { send: () => throwError(() => Object.assign(Error('connection reset'), { code: 'ECONNRESET' })) };
+
+  await assert.rejects(AmqpHandler(client, 'user.lookup', { payload: {}, param: { traceId: 'legacy-call' } }));
+  assert.equal(records.length, 1);
+  assert.equal(records[0].info.traceId, 'legacy-call');
+  assert.equal(records[0].info.diagnosticInfo.messagePattern, 'user.lookup');
+  assert.equal(records[0].info.diagnosticInfo.connectionState, 'unobserved');
+  assert.equal(records[0].info.diagnosticInfo.connectionId, undefined);
+
+  const legacyClient = new ClientRMQ({ queue: 'USER_SERVICE' });
+  legacyClient.send = client.send;
+  await assert.rejects(AmqpHandler(legacyClient, 'user.lookup', { payload: {}, param: { traceId: 'legacy-rmq' } }));
+  assert.equal(records[1].info.diagnosticInfo.targetService, 'USER_SERVICE');
+
+  const manager = new AmqpManagement(legacyClient);
+  await assert.rejects(manager.call('lookup', 'user.lookup', {}, { traceId: 'legacy-wrapper' }, { isErrorThrowing: true }));
+  assert.equal(records.length, 3);
+  assert.equal(records[2].info.traceId, 'legacy-wrapper');
+});
+
+test('close waits for native async close and retains its rejection after listener cleanup', async t => {
+  const previous = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  t.after(() => { if (previous === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = previous; });
+  const manager = new EventEmitter();
+  t.mock.method(ClientRMQ.prototype, 'createClient', () => manager);
+  let finish;
+  t.mock.method(ClientRMQ.prototype, 'close', () => new Promise((resolve, reject) => { finish = reject; }));
+  const client = createDiagnosticRmqClient({ transport: Transport.RMQ, options: { queue: 'TEST' } });
+  client.createClient();
+  let settled = false;
+  const error = Error('close failed');
+  const closed = client.close().finally(() => { settled = true; });
+  const rejected = assert.rejects(closed, err => err === error);
+  await Promise.resolve();
+  assert.equal(settled, false);
+  assert.equal(manager.listenerCount('connect'), 1);
+  finish(error);
+  await rejected;
+  assert.equal(manager.listenerCount('connect'), 0);
+});