Files
bubble/test/gvoice.test.ts
trav 8c84feaa91 v0.2.0: bubble for Android 0.2.0 — chat search, swipe for unread, faster chat opening
Desktop:
- Search lists chats whose own name matches first, so a named group
  isn't pushed out of the top 8 by chats that merely include a member.

Android (Rabbit R1) app, 0.2.0:
- Pull the chat list past its top for a search box (name, person,
  number, then group members; archived chats too; Back clears it).
- Swipe right to left marks a chat unread / read over a magenta band;
  left to right still archives (SwipeActions replaces SwipeArchive).
- Google Voice chats don't offer voice notes in the paperclip bubble.
- Chats open with their newest 60 messages, then the full history;
  marking read (and the Google Voice network call) waits until they're
  on screen. Cached pictures show at once, and one slow download no
  longer blocks the other images. Fixed a contacts reload race.
- Sandbox data gains filler chats, a named group and a 4,000-message chat.

Also: the Android app, Google Voice support, media, export, emoji and
the other work since the first commit, and a CLAUDE.md carrying the
privacy rule.
2026-11-06 02:19:56 -08:00

318 lines
14 KiB
TypeScript

import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import { MessageDb } from '../src/main/db'
import { sendWithRetry } from '../src/main/send'
import { classifyGvError, decodeBody, GVoice, GVoiceError, gvErrorMessage, readBody, sapisidHash, toE164, type Transport } from '../src/main/gvoice/client'
import { decode, encode, fromPblite, toPblite, type Schema } from '../src/main/gvoice/proto'
import * as S from '../src/main/gvoice/schema'
import { gvMessageId, GvSyncEngine, isGvMessageId, threadContact, toNewMessage } from '../src/main/gvoice/sync'
const SELF = '5415550100'
const sms = (id: string, ts: number, type: number, text: string, extra: Partial<S.GvMessage> = {}): S.GvMessage => ({
id,
timestamp: ts,
type,
text,
transactionId: 0,
...extra
})
const thread = (id: string, phoneNumbers: string[], messages: S.GvMessage[], paginationToken = ''): S.GvThread => ({
id,
read: true,
messages,
paginationToken,
contacts: [],
isText: true,
phoneNumbers
})
// A protobuf HTTP response, the way Google sends it (base64 in a length-prefixed text chunk).
function protoResponse(schema: Schema, msg: Record<string, unknown>): Response {
const b64 = Buffer.from(encode(schema, msg)).toString('base64')
return new Response(`${b64.length}\n${b64}`, {
headers: { 'content-type': 'text/plain; charset=utf-8', 'x-goog-safety-content-type': 'application/x-protobuf' }
})
}
describe('protobuf codec', () => {
it('round-trips nested and repeated fields through binary', () => {
const t = thread('t.+15415550199', ['+15415550199'], [
sms('a', 1_700_000_000_123, S.MessageType.SMS_IN, 'hi 👋', {
mms: {
text: 'pic',
subject: '',
senderPhoneNumber: '+15415550199',
participants: [],
attachments: [{ id: 'm1', mimeType: 'image/jpeg', status: 1, metadata: [{ size: 1, width: 640, height: 480 }] }]
}
})
])
const back = decode(S.Thread, encode(S.Thread, t as unknown as Record<string, unknown>)) as unknown as S.GvThread
expect(back.id).toBe('t.+15415550199')
expect(back.phoneNumbers).toEqual(['+15415550199'])
expect(back.messages[0].timestamp).toBe(1_700_000_000_123)
expect(back.messages[0].text).toBe('hi 👋')
expect(back.messages[0].mms!.attachments[0]).toMatchObject({ id: 'm1', metadata: [{ width: 640, height: 480 }] })
// Missing fields come back as defaults.
expect(back.paginationToken).toBe('')
expect(back.contacts).toEqual([])
})
it('skips unknown fields and reads packed repeated numbers', () => {
// field 99 (unknown varint), then field 1 = "x"; then a packed field 3 [1,2] against a repeated int schema
const buf = new Uint8Array([0x98, 0x06, 0x05, 0x0a, 0x01, 0x78, 0x1a, 0x02, 0x01, 0x02])
expect(decode({ s: { n: 1, t: 'string' }, nums: { n: 3, t: 'int', rep: true } }, buf)).toEqual({ s: 'x', nums: [1, 2] })
})
it('writes pblite the way the web client does', () => {
const out = toPblite(S.ReqSendSMS, {
text: 'yo',
threadId: 't.+15415550199',
recipients: [],
transactionId: { id: 42 },
media: { type: 2, data: new Uint8Array([1, 2, 3]) },
trackingData: { data: '!' }
})
expect(out).toEqual([null, null, null, null, 'yo', 't.+15415550199', null, null, [42], [2, 'AQID'], ['!']])
})
it('reads pblite with string int64s and a trailing sparse-field object', () => {
const r = fromPblite(S.RespSendSMS, [null, 'thread', null, { '4': '1700000000123', '3': 'item' }])
expect(r).toEqual({ threadId: 'thread', threadItemId: 'item', timestampMs: 1_700_000_000_123 })
})
})
describe('Google Voice client', () => {
it('computes SAPISIDHASH', () => {
expect(sapisidHash('abc123', 1_700_000_000_999)).toBe('SAPISIDHASH 1700000000_0af60f2c8319974dffd04c264464cd61b24a1ffd')
})
it('formats numbers as E.164', () => {
expect(toE164('5415550199')).toBe('+15415550199')
expect(toE164('447700900123')).toBe('+447700900123')
})
it('unwraps base64 protobuf in a text chunk', async () => {
const res = protoResponse(S.RespSendSMS, { threadId: 't.x', threadItemId: 'i', timestampMs: 5 })
expect(decodeBody(S.RespSendSMS, await readBody(res))).toEqual({ threadId: 't.x', threadItemId: 'i', timestampMs: 5 })
})
function fakeTransport(respond: (url: URL, init: RequestInit) => Response, cookie: string | undefined = 'sapi') {
const calls: Array<{ url: URL; init: RequestInit }> = []
const t: Transport = {
fetch: async (url, init) => {
const u = new URL(url)
calls.push({ url: u, init })
return respond(u, init)
},
cookie: async (name) => (name === 'SAPISID' ? cookie : undefined)
}
return { t, calls }
}
it('reads the GV number from the account', async () => {
const { t, calls } = fakeTransport(() =>
protoResponse(S.RespGetAccount, { account: { primaryDestinationId: '+15415550000', phones: [{ accountPhone: { phoneNumber: { e164: '+15415550100' } } }] } })
)
expect(await new GVoice(t).getAccount()).toBe('+15415550100')
const { url, init } = calls[0]
expect(url.pathname).toBe('/voice/v1/voiceclient/account/get')
expect(url.searchParams.get('alt')).toBe('proto')
expect(url.searchParams.get('key')).toBeTruthy()
const h = init.headers as Record<string, string>
expect(h['Authorization']).toMatch(/^SAPISIDHASH \d+_[0-9a-f]{40}$/)
expect(h['Content-Type']).toBe('application/json+protobuf')
expect(JSON.parse(init.body as string)).toEqual([null, 1])
})
it('sends recipients only when starting a new thread', async () => {
const { t, calls } = fakeTransport(() => protoResponse(S.RespSendSMS, { threadId: 't.+15415550199', threadItemId: 'i1', timestampMs: 1 }))
const gv = new GVoice(t)
await gv.sendSms({ threadId: 't.+15415550199', recipients: ['+15415550199'], text: 'a', transactionId: 7 })
await gv.sendSms({ threadId: '', recipients: ['+15415550199', '+15415550198'], text: 'b', transactionId: 8 })
const [first, second] = calls.map((c) => JSON.parse(c.init.body as string) as unknown[])
expect(first[6]).toBeNull()
expect(first[5]).toBe('t.+15415550199')
expect(second[6]).toEqual(['+15415550199', '+15415550198'])
expect(second[10]).toEqual(['!']) // unsigned
})
it("refuses attachments GV can't carry", async () => {
const { t } = fakeTransport(() => new Response(''))
await expect(new GVoice(t).sendSms({ threadId: 'x', recipients: [], text: '', transactionId: 1, media: { mime: 'video/mp4', data: new Uint8Array() } })).rejects.toThrow(
/only photos/
)
})
it('reports a dead sign-in as signed out', async () => {
const { t } = fakeTransport(() => new Response('nope', { status: 401 }))
const err = await new GVoice(t).listThreads().catch((e: GVoiceError) => e)
expect(err).toBeInstanceOf(GVoiceError)
expect((err as GVoiceError).signedOut).toBe(true)
const noCookie = fakeTransport(() => new Response(''), '')
expect(((await new GVoice(noCookie.t).listThreads().catch((e) => e)) as GVoiceError).signedOut).toBe(true)
})
it('classifies send failures for retrying', () => {
expect(classifyGvError(new GVoiceError('x', undefined, 'ERR_INTERNET_DISCONNECTED'))).toBe('safe')
expect(classifyGvError(new GVoiceError('x', undefined, 'ERR_CONNECTION_RESET'))).toBe('unknown')
expect(classifyGvError(new GVoiceError('x', 429))).toBe('safe')
expect(classifyGvError(new GVoiceError('x', 503))).toBe('unknown')
expect(classifyGvError(new GVoiceError('x', 401))).toBe('fatal')
expect(gvErrorMessage(new GVoiceError('x', undefined, 'ERR_NAME_NOT_RESOLVED'))).toMatch(/internet connection/)
})
})
describe('Google Voice messages', () => {
it('keeps message ids stable and out of voip.ms range', () => {
expect(gvMessageId('abc')).toBe(gvMessageId('abc'))
expect(gvMessageId('abc')).not.toBe(gvMessageId('abd'))
expect(isGvMessageId(gvMessageId('abc'))).toBe(true)
expect(Number.isSafeInteger(gvMessageId('zzz'))).toBe(true)
expect(isGvMessageId(987654321)).toBe(false)
})
it('maps threads to conversations', () => {
expect(threadContact({ phoneNumbers: ['+15415550199'] }, SELF)).toBe('5415550199')
expect(threadContact({ phoneNumbers: ['+15415550199', '+15415550101', '+15415550100'] }, SELF)).toBe('5415550101,5415550199')
})
it('converts texts, photos and group senders; skips calls', () => {
const inMsg = toNewMessage(sms('a', 10, S.MessageType.SMS_IN, 'hey'), SELF, '5415550199', false)!
expect(inMsg).toMatchObject({ did: SELF, contact: '5415550199', direction: 'in', body: 'hey', ts: 10 })
expect(inMsg.sender).toBeUndefined()
expect(toNewMessage(sms('b', 11, S.MessageType.SMS_OUT, 'yo'), SELF, '5415550199', false)!.direction).toBe('out')
expect(toNewMessage(sms('c', 12, S.MessageType.VOICEMAIL, ''), SELF, '5415550199', false)).toBeUndefined()
const photo = toNewMessage(
sms('d', 13, S.MessageType.SMS_IN, '', {
mms: {
text: 'look',
subject: '',
senderPhoneNumber: '+15415550101',
participants: [],
attachments: [
{ id: 'm1', mimeType: 'image/png', status: 1, metadata: [{ size: 2, width: 128, height: 96 }, { size: 1, width: 1280, height: 960 }] },
{ id: 'm2', mimeType: 'video/mp4', status: 3, metadata: [] }
]
}
}),
SELF,
'5415550101,5415550199',
true
)!
expect(photo).toMatchObject({ body: 'look', kind: 'mms', sender: '5415550101' })
expect(photo.media).toEqual([{ url: 'gv:m1', mime: 'image/png', width: 1280, height: 960 }])
})
})
describe('GvSyncEngine', () => {
let dir: string
let db: MessageDb
beforeEach(() => {
dir = fs.mkdtempSync(path.join(os.tmpdir(), 'voipms-gv-'))
db = new MessageDb(path.join(dir, 'messages.db'))
})
afterEach(() => {
db.close()
fs.rmSync(dir, { recursive: true, force: true })
})
// A fake GV account: threads listed newest first, each paged two messages at a time.
function fakeGv(threads: S.GvThread[]) {
return {
listThreads: async (token = '') => {
const start = Number(token || 0)
const page = threads.slice(start, start + 1)
return { threads: page.map((t) => ({ ...t, messages: t.messages.slice(0, 1) })), paginationToken: start + 1 < threads.length ? String(start + 1) : '' }
},
getThread: async (id: string, _count = 100, token = '') => {
const t = threads.find((x) => x.id === id)!
const start = Number(token || 0)
return { ...t, messages: t.messages.slice(start, start + 2), paginationToken: start + 2 < t.messages.length ? String(start + 2) : '' }
}
}
}
it('imports history, groups included, and keeps polling', async () => {
const one = thread('t.+15415550199', ['+15415550199'], [
sms('1c', 30, S.MessageType.SMS_IN, 'third'),
sms('1b', 20, S.MessageType.SMS_OUT, 'second'),
sms('1a', 10, S.MessageType.SMS_IN, 'first')
])
const group = thread('g.abc', ['+15415550199', '+15415550101'], [
sms('2a', 25, S.MessageType.SMS_IN, 'hi all', { mms: { text: 'hi all', subject: '', senderPhoneNumber: '+15415550101', participants: [], attachments: [] } })
])
const gv = fakeGv([one, group])
const engine = new GvSyncEngine(db, gv as unknown as GVoice, { did: SELF, pollSeconds: 60, backfillFloor: '1970-01-01' })
const done = new Promise<void>((resolve) => engine.on('status', (s) => s.backfillDone && resolve()))
engine.start()
await done
engine.stop()
expect(db.getConversationMessages(SELF, '5415550199').map((m) => m.body)).toEqual(['first', 'second', 'third'])
const g = db.getConversationMessages(SELF, '5415550101,5415550199')
expect(g).toHaveLength(1)
expect(g[0].sender).toBe('5415550101')
expect(db.getGvThread(SELF, '5415550101,5415550199')).toBe('g.abc')
const conv = db.listConversations().find((c) => c.contact.includes(','))!
expect(conv.lastSender).toBe('5415550101')
})
it('lets a polled copy of a sent message replace the pending one', async () => {
const tempId = db.insertPending({ did: SELF, contact: '5415550199', direction: 'out', body: 'on my way', ts: 1000 })
const t = thread('t.+15415550199', ['+15415550199'], [sms('x1', 1500, S.MessageType.SMS_OUT, 'on my way')])
const engine = new GvSyncEngine(db, fakeGv([t]) as unknown as GVoice, { did: SELF, pollSeconds: 60, backfillFloor: '2100-01-01' })
await engine.pollNow()
expect(db.getMessage(tempId)).toBeUndefined()
expect(db.getMessage(gvMessageId('x1'))?.status).toBe('delivered')
})
it("carries over GV's read state on import", async () => {
const read = thread('t.+15415550199', ['+15415550199'], [sms('r1', 10, S.MessageType.SMS_IN, 'seen')])
const unread = { ...thread('t.+15415550198', ['+15415550198'], [sms('u1', 11, S.MessageType.SMS_IN, 'new')]), read: false }
db.set('unread_floor', '0')
const gv = { listThreads: async () => ({ threads: [read, unread], paginationToken: '' }) }
const engine = new GvSyncEngine(db, gv as unknown as GVoice, { did: SELF, pollSeconds: 60, backfillFloor: '2100-01-01' })
await engine.pollNow()
const unreadOf = (contact: string): number => db.listConversations().find((c) => c.contact === contact)!.unread
expect(unreadOf('5415550199')).toBe(0)
expect(unreadOf('5415550198')).toBe(1)
})
it('goes to signed-out on 401 and leaves the rest alone', async () => {
const gv = { listThreads: async () => Promise.reject(new GVoiceError('signed out', 401)) }
const engine = new GvSyncEngine(db, gv as unknown as GVoice, { did: SELF, pollSeconds: 60, backfillFloor: '2100-01-01' })
await engine.pollNow()
expect(engine.getStatus().phase).toBe('signedOut')
})
})
describe('Google Voice sends', () => {
it('fail for good when signed out, with the reason', async () => {
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'voipms-gvsend-'))
const db = new MessageDb(path.join(dir, 'messages.db'))
const tempId = db.insertPending({ did: SELF, contact: '5415550199', direction: 'out', body: 'x', ts: 1 })
let calls = 0
await sendWithRetry(tempId, {
db,
attempt: async () => {
calls++
throw new GVoiceError('Google Voice signed out. Reconnect it in Settings.', 401)
},
checkSent: async () => undefined,
sleep: async () => undefined,
classify: classifyGvError,
describe: gvErrorMessage
})
expect(calls).toBe(1)
expect(db.getMessage(tempId)).toMatchObject({ status: 'failed', error: 'Google Voice signed out. Reconnect it in Settings.' })
db.close()
fs.rmSync(dir, { recursive: true, force: true })
})
})