Testes end-to-end sem WhatsApp

npm install --save-dev @zapo-js/fake-server zapo-js

import { FakeWaServer } from '@zapo-js/fake-server'
import { createStore, WaClient } from 'zapo-js'

const server = await FakeWaServer.start()

const client = new WaClient({
  store: createStore({
    providers: { auth: 'memory', signal: 'memory', senderKey: 'memory', appState: 'memory' }
  }),
  sessionId: 'test',
  chatSocketUrls: [server.url],
  testHooks: { noiseRootCa: server.noiseRootCa },
  proxy: { mediaUpload: server.mediaProxyAgent, mediaDownload: server.mediaProxyAgent }
})

await client.connect()
const pipeline = await server.waitForAuthenticatedPipeline()
// ...dirija o fluxo, valide os dois lados...
await server.stop()

import { FakeWaServer, type FakeNoiseRootCa } from '@zapo-js/fake-server'
import { deriveRootCaFromSeed } from './my-test-seed' // sua própria derivação determinística

const noiseRootCa: FakeNoiseRootCa = await deriveRootCaFromSeed(process.env.TEST_SEED!)

// Processo do server
const server = await FakeWaServer.start({ noiseRootCa })

// Processo do client — pinna o mesmo anchor antes de discar
const client = new WaClient({
  /* ... */,
  testHooks: { noiseRootCa: { publicKey: noiseRootCa.publicKey, serial: noiseRootCa.serial } }
})

const alice = await server.createFakePeer('5511999999999@s.whatsapp.net')

// Seu app recebe isto como uma mensagem inbound normal:
await alice.sendConversation('hello from Alice')

// Seu app manda uma resposta; valide no conteúdo descriptografado:
const outbound = await alice.expectMessage({ timeoutMs: 5_000 })
expect(outbound.message?.conversation).toBe('hi Alice')

const stanzas: BinaryNode[] = []
server.onCapturedStanza((node) => stanzas.push(node))

await client.presence.send('available')

expect(stanzas.some((n) => n.tag === 'presence' && n.attrs.type === 'available')).toBe(true)

const server = await FakeWaServer.start({
  sessionKey: ({ clientPayload }) =>
    clientPayload.kind === 'login' ? clientPayload.username : 'pending'
})

// Spawn dois apps contra o mesmo server (sessionIds diferentes → sessões diferentes):
await appA.connect() // → session '<userA>'
await appB.connect() // → session '<userB>'

// Operações escopadas por sessão:
const alice = await server.sessionFor(pipelineA).createFakePeer(aliceJid)
// ou por key:
const bob = await server.session('<userB>').createFakePeer(bobJid)

import { FakeWaServer, seedFakeMobilePrimary } from '@zapo-js/fake-server'
import { createStore, WaClient } from 'zapo-js'

const server = await FakeWaServer.start({ tcp: true })

const store = createStore({})
const primary = await seedFakeMobilePrimary(store, 'mobile-primary', {
  phoneNumber: '5511999999999'
})

const client = new WaClient({
  store,
  sessionId: 'mobile-primary',
  mobileTransport: {
    deviceInfo: primary.deviceInfo,
    tcpUrl: server.tcpUrl
  },
  testHooks: { noiseRootCa: server.noiseRootCa }
})
await client.connect()

const companion = new WaClient({ store: companionStore, sessionId: 'companion', /* ... */ })
await companion.connect()
const companionPipeline = await server.waitForAuthenticatedPipeline()

// Empurra as refs que o companion vira num QR:
const refs = await server.offerCompanionPairing(companionPipeline)

// No lado do primary, alimente a string QR em client.mobile.linkCompanion(qr).
// O primary assina e uploada pair-device; o server relay o pair-success
// de volta pro companion.

npx fake-wa-server --port 5222 --peer 5511888@s.whatsapp.net --log

import { FakeWaServer } from '@zapo-js/fake-server'
import { afterAll, beforeAll, test } from 'vitest'

let server: FakeWaServer

beforeAll(async () => {
  server = await FakeWaServer.start()
})

afterAll(async () => {
  await server.stop()
})

test('bot replies to inbound message', async () => {
  const app = await startYourApp({
    socketUrl: server.url,
    noiseRootCa: server.noiseRootCa,
    mediaProxy: server.mediaProxyAgent
  })
  const alice = await server.createFakePeer('5511999999999@s.whatsapp.net')
  await alice.sendConversation('hi')
  const reply = await alice.expectMessage({ timeoutMs: 5_000 })
  expect(reply.message?.conversation).toBe('hello, human')
})