Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

7.8 KB
Raw Blame
// Exercise the pinned Baileys socket over loopback WebSocket.
// Loopback WebSocket transport; no WhatsApp traffic, account or persisted auth.
import test from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { pathToFileURL } from 'node:url';
import path from 'node:path';
import { once } from 'node:events';
const require = createRequire(process.env.BAILEYS_TEST_PROVIDER_PACKAGE || import.meta.url);
const root = path.dirname(require.resolve('@whiskeysockets/baileys/package.json'));
const load = relative => import(pathToFileURL(path.join(root, relative)));
const { default: makeWASocket } = await load('lib/Socket/index.js');
const { initAuthCreds } = await load('lib/Utils/auth-utils.js');
const { DEF_CALLBACK_PREFIX } = await load('lib/Defaults/index.js');
const { decodeBinaryNode } = await load('lib/WABinary/index.js');
const { WebSocketServer } = require('ws');
function deliver(ws, node) {
  const child = Array.isArray(node.content) ? node.content[0]?.tag : '';
  for (const [attr, value] of Object.entries(node.attrs)) {
    ws.emit(`${DEF_CALLBACK_PREFIX}${node.tag},${attr}:${value},${child}`, node);
    ws.emit(`${DEF_CALLBACK_PREFIX}${node.tag},${attr}:${value}`, node);
    ws.emit(`${DEF_CALLBACK_PREFIX}${node.tag},${attr}`, node);
  }
  ws.emit(`${DEF_CALLBACK_PREFIX}${node.tag},,${child}`, node);
  ws.emit(`${DEF_CALLBACK_PREFIX}${node.tag}`, node);
}
function nextQr(sock) {
  return new Promise(resolve => {
    const listener = update => {
      if (update.qr) {
        sock.ev.off('connection.update', listener);
        resolve(update.qr);
      }
    };
    sock.ev.on('connection.update', listener);
  });
}
const refresh = child => ({
  tag: 'notification',
  attrs: { id: 'fixture-refresh', from: 's.whatsapp.net', type: 'companion_reg_refresh' },
  content: child ? [{ tag: child, attrs: {} }] : [],
});
async function boot(t, { qrTimeout = 10000 } = {}) {
  const server = new WebSocketServer({ host: '127.0.0.1', port: 0 });
  await once(server, 'listening');
  server.on('connection', client =>
    client.on('message', data => {
      const frame = Buffer.from(data);
      server.emit('fixture-frame', frame);
    }),
  );
  const errors = [],
    logger = {
      level: 'silent',
      child: () => logger,
      trace() {},
      debug() {},
      info() {},
      warn() {},
      error() {
        errors.push(true);
      },
    };
  const creds = initAuthCreds();
  let sock;
  t.after(async () => {
    await sock?.end(new Error('fixture complete'));
    for (const client of server.clients) client.terminate();
    await new Promise(resolve => server.close(resolve));
  });
  sock = makeWASocket({
    auth: { creds, keys: { get: async () => ({}), set: async () => {} } },
    logger,
    waWebSocketUrl: `ws://127.0.0.1:${server.address().port}`,
    connectTimeoutMs: 5000,
    qrTimeout,
  });
  if (!sock.ws.isOpen) await once(sock.ws, 'open');
  const qrs = [],
    updates = [];
  sock.ev.on('connection.update', update => {
    if (update.qr) qrs.push(update.qr);
  });
  sock.ev.on('creds.update', update => updates.push(update));
  return { sock, creds, qrs, updates, errors, server };
}
const pairDevice = () => ({
  tag: 'iq',
  attrs: { from: 's.whatsapp.net', type: 'set', id: 'fixture-pair' },
  content: [
    {
      tag: 'pair-device',
      attrs: {},
      content: ['fixture-ref-1', 'fixture-ref-2'].map(ref => ({ tag: 'ref', attrs: {}, content: Buffer.from(ref) })),
    },
  ],
});
for (const child of ['companion_reg_refresh', 'pair-device-rotate-qr'])
  test('real socket emits fresh credentials and renders same ref for ' + child, { timeout: 10000 }, async t => {
    const { sock, creds, qrs, updates, errors } = await boot(t);
    let qr = nextQr(sock);
    deliver(sock.ws, pairDevice());
    await qr;
    const initial = qrs[0].split('#')[1].split(','),
      secret = creds.advSecretKey;
    qr = nextQr(sock);
    deliver(sock.ws, refresh(child));
    await qr;
    const current = qrs[1].split('#')[1].split(',');
    assert.equal(current[0], initial[0]);
    assert.deepEqual(current.slice(1, 3), initial.slice(1, 3));
    assert.notEqual(current[3], secret);
    assert.equal(current[3], creds.advSecretKey);
    assert.equal(Buffer.from(current[3], 'base64').length, 32);
    assert.ok(updates.some(update => update.advSecretKey === current[3]));
    for (let n = 0; n < 50; n++) deliver(sock.ws, refresh(child));
    assert.equal(qrs.length, 52);
    assert.ok(qrs.every(value => value.split('#')[1].split(',')[0] === initial[0]));
    // Generic notification handler still runs concurrently and must not throw.
    await new Promise(resolve => setImmediate(resolve));
    assert.equal(errors.length, 0);
  });
test('real ACK succeeds before login and writes the expected notification stanza', { timeout: 10000 }, async t => {
  const { sock, creds, server, errors } = await boot(t);
  const receiveAck = () =>
    new Promise(resolve =>
      server.on('fixture-frame', async frame => {
        try {
          const offset = frame.subarray(0, 2).toString() === 'WA' ? 7 : 3;
          const node = await decodeBinaryNode(frame.subarray(offset));
          if (node.tag === 'ack') resolve(node);
        } catch {}
      }),
    );
  const received = receiveAck();
  await sock.sendMessageAck(refresh('companion_reg_refresh'));
  const ack = await received;
  assert.deepEqual(ack.attrs, {
    id: 'fixture-refresh',
    to: 's.whatsapp.net',
    class: 'notification',
    type: 'companion_reg_refresh',
  });
  creds.me = { id: '[email protected]' };
  const registeredAck = receiveAck();
  await sock.sendMessageAck(
    {
      tag: 'message',
      attrs: {
        id: 'registered-message',
        from: '[email protected]',
        participant: '[email protected]',
        type: 'text',
      },
    },
    42,
  );
  assert.deepEqual((await registeredAck).attrs, {
    id: 'registered-message',
    to: '[email protected]',
    class: 'message',
    error: '42',
    participant: '[email protected]',
    type: 'text',
    from: creds.me.id,
  });
  assert.equal(errors.length, 0);
});
test('malformed refresh and established identity leave credentials and QR intact', { timeout: 10000 }, async t => {
  const { sock, creds, qrs, updates } = await boot(t);
  let qr = nextQr(sock);
  deliver(sock.ws, pairDevice());
  await qr;
  const secret = creds.advSecretKey;
  deliver(sock.ws, refresh());
  deliver(sock.ws, refresh('wrong-child'));
  assert.equal(qrs.length, 1);
  assert.equal(creds.advSecretKey, secret);
  assert.equal(updates.length, 0);
  creds.me = { id: '[email protected]', name: 'fixture' };
  deliver(sock.ws, refresh('companion_reg_refresh'));
  assert.equal(qrs.length, 1);
  assert.equal(creds.advSecretKey, secret);
  assert.equal(updates.length, 0);
});
test(
  'a pairing code request stops the QR timer, so running out of refs does not end the socket',
  { timeout: 10000 },
  async t => {
    // Upstream keeps the timer running: the second ref is rendered and the third wait ends the socket with
    // 'QR refs attempts ended'. This patch adapts #2765 to stop at creds.me, which requestPairingCode writes
    // before the code is entered.
    const { sock, creds, qrs } = await boot(t, { qrTimeout: 150 });
    const closed = [];
    sock.ev.on('connection.update', update => {
      if (update.connection === 'close') closed.push(update.lastDisconnect?.error?.message);
    });
    const qr = nextQr(sock);
    deliver(sock.ws, pairDevice());
    await qr;
    creds.me = { id: '[email protected]', name: '~' };
    // Longer than the two refs last with a 150 ms timer.
    await new Promise(resolve => setTimeout(resolve, 700));
    assert.equal(qrs.length, 1, 'a QR was rendered after the pairing code was requested');
    assert.deepEqual(closed, [], 'the socket ended when the QR refs ran out');
    assert.ok(sock.ws.isOpen);
  },
);