Skip to content

Send and receive SMS messages using your Android phone programmatically via a simple HTTP API

18.1 KB
Raw Blame
import assert from 'node:assert/strict'
import { test } from 'node:test'
import { createPinia, setActivePinia } from 'pinia'
import { computed, ref } from 'vue'
import type {
  EntitiesContact,
  EntitiesMessageThread,
} from '../../shared/types/api'
import { useThreadsStore } from './threads'

function thread(id: string, unreadCount: number): EntitiesMessageThread {
  return {
    id,
    unread_count: unreadCount,
    owner: '+18005550199',
    contact: '+18005550100',
    color: 'indigo',
    is_archived: false,
    last_message_content: 'Hello',
    last_message_id: 'message-id',
    status: 'received',
    created_at: '2026-10-27T10:00:00Z',
    updated_at: '2026-10-27T10:00:00Z',
    order_timestamp: '2026-10-27T10:00:00Z',
    user_id: 'user-id',
  }
}

function setupStore() {
  const calls: { path: string; params?: Record<string, unknown> }[] = []
  let responseThreads = [thread('unread', 2), thread('read', 0)]
  const individualThreads = new Map<string, EntitiesMessageThread>()
  let nextLookup: Promise<{ data: EntitiesMessageThread }> | undefined
  let nextResponse: Promise<{ data: EntitiesMessageThread[] }> | undefined
  const phones = {
    owner: '+18005550199',
    phones: [],
    getHeartbeat: async () => [],
  }
  Object.assign(globalThis, {
    ref,
    computed,
    useApi: () => ({
      apiFetch: async (
        path: string,
        options: {
          params?: Record<string, unknown>
          method?: string
        } = {},
      ) => {
        calls.push({ path, params: options.params })
        if (options.method === 'PUT') {
          responseThreads = responseThreads.map((item) =>
            item.id === 'unread' ? { ...item, unread_count: 0 } : item,
          )
          return { data: thread('unread', 0) }
        }
        if (path === '/v1/messages') return { data: [] }
        if (
          (!options.method || options.method === 'GET') &&
          path.startsWith('/v1/message-threads/')
        ) {
          if (nextLookup) {
            const pending = nextLookup
            nextLookup = undefined
            return pending
          }
          const item = individualThreads.get(path.split('/').at(-1) ?? '')
          if (!item)
            throw Object.assign(new Error('Thread not found'), { status: 404 })
          return { data: item }
        }
        const pending = nextResponse
        nextResponse = undefined
        if (pending) return pending
        const skip = Number(options.params?.skip ?? 0)
        const limit = Number(options.params?.limit ?? 20)
        return {
          data: responseThreads.slice(skip, skip + limit),
        }
      },
    }),
    usePhonesStore: () => phones,
    useNotificationsStore: () => ({ addNotification: () => {} }),
  })
  setActivePinia(createPinia())
  return {
    store: useThreadsStore(),
    phones,
    calls,
    respondWith: (threads: EntitiesMessageThread[]) => {
      responseThreads = threads
    },
    respondToLookup: (item: EntitiesMessageThread) => {
      individualThreads.set(item.id, item)
    },
    deferLookup: (response: Promise<{ data: EntitiesMessageThread }>) => {
      nextLookup = response
    },
    deferNextLoad: (response: Promise<{ data: EntitiesMessageThread[] }>) => {
      nextResponse = response
    },
  }
}

function contact(
  name: string,
  phoneNumbers = ['+18005550100'],
): EntitiesContact {
  return {
    id: 'contact-id',
    name,
    phone_numbers: phoneNumbers,
    emails: [],
    properties: {},
    user_id: 'user-id',
    created_at: '2026-10-27T10:00:00Z',
    updated_at: '2026-10-27T11:00:00Z',
  }
}

async function setupReadConversationHistory() {
  const fixture = setupStore()
  const other = { ...thread('other', 1), contact: '+18005550101' }
  fixture.respondWith([thread('unread', 1), other])
  await fixture.store.loadThreads()
  fixture.store.setThreadId('unread')
  fixture.store.unreadOnly = true
  await fixture.store.resetThreadUnreadCount('unread')
  fixture.respondWith([other])
  await fixture.store.loadThreads()
  await fixture.store.loadThreadMessages('other')
  return fixture
}

test('Unread requests server-side filtering within the API limit', async () => {
  const { store, calls } = setupStore()
  store.unreadOnly = true
  store.archivedThreads = true

  await store.loadThreads()

  assert.equal(calls[0]?.params?.unread_only, true)
  assert.equal(calls[0]?.params?.is_archived, true)
  assert.equal(calls[0]?.params?.owner, '+18005550199')
  assert.equal(calls[0]?.params?.limit, 20)
})

test('marking a thread read hides it from Unread without closing it', async () => {
  const { store, calls, respondWith } = setupStore()
  await store.loadThreads()
  store.setThreadId('unread')
  store.unreadOnly = true

  await store.resetThreadUnreadCount('unread')

  assert.ok(store.visibleThreads)
  assert.deepEqual(store.visibleThreads, [])
  assert.equal(store.currentThread?.id, 'unread')
  assert.equal(store.currentThread.unread_count, 0)

  respondWith([])
  await store.loadThreads()
  assert.equal(store.currentThread?.id, 'unread')
  await store.loadThreadMessages('unread')
  assert.equal(calls.at(-1)?.path, '/v1/messages')
})

test('switching back to All restores read conversations', async () => {
  const { store } = setupStore()
  await store.loadThreads()
  store.unreadOnly = true

  assert.ok(store.visibleThreads)
  assert.deepEqual(
    store.visibleThreads.map((item) => item.id),
    ['unread'],
  )

  store.unreadOnly = false
  await store.loadThreads()
  assert.deepEqual(
    store.visibleThreads.map((item) => item.id),
    ['unread', 'read'],
  )
})

test('resetting the store clears the filter and retained conversation', async () => {
  const { store, respondWith } = setupStore()
  await store.loadThreads()
  store.setThreadId('unread')
  store.unreadOnly = true
  respondWith([])
  await store.loadThreads()

  store.resetState()

  assert.equal(store.unreadOnly, false)
  assert.equal(store.currentThread, null)
  assert.deepEqual(store.threads, [])
})

test('an older polling response cannot overwrite a newer unread-filter load', async () => {
  const { store, respondWith, deferNextLoad } = setupStore()
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)
  const oldLoad = store.loadThreads()
  store.unreadOnly = true
  respondWith([thread('unread', 2)])
  await store.loadThreads()

  pending.resolve({ data: [thread('read', 0)] })
  await oldLoad

  assert.deepEqual(
    store.threads.map((item) => item.id),
    ['unread'],
  )
})

test('All does not retain a conversation removed from the server list', async () => {
  const { store, respondWith } = setupStore()
  await store.loadThreads()
  store.setThreadId('unread')
  respondWith([])

  await store.loadThreads()

  assert.equal(store.currentThread, null)
})

for (const scenario of [
  {
    name: 'adding a contact refreshes a retained read conversation',
    existing: undefined,
    saved: contact('New contact'),
    expectedName: 'New contact',
  },
  {
    name: 'editing a contact refreshes a retained read conversation',
    existing: contact('Old name'),
    saved: contact('Updated name'),
    expectedName: 'Updated name',
  },
  {
    name: 'removing the conversation number clears its retained contact',
    existing: contact('Old name'),
    saved: contact('Updated name', ['+18005550101']),
    expectedName: undefined,
  },
]) {
  test(scenario.name, async () => {
    const { store, respondWith } = setupStore()
    respondWith([
      { ...thread('unread', 1), contact_details: scenario.existing },
    ])
    await store.loadThreads()
    store.setThreadId('unread')
    store.unreadOnly = true
    await store.resetThreadUnreadCount('unread')
    respondWith([])
    await store.loadThreads()

    await store.loadThreads([scenario.saved])

    assert.equal(store.currentThread?.id, 'unread')
    assert.equal(
      store.currentThread.contact_details?.name,
      scenario.expectedName,
    )
    assert.deepEqual(store.visibleThreads, [])
  })
}

test('a late poll cannot restore unread counts after mark-read succeeds', async () => {
  const { store, deferNextLoad } = setupStore()
  await store.loadThreads()
  store.setThreadId('unread')
  store.unreadOnly = true
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)
  store.loadingThreads = true
  const poll = store.loadThreads()

  await store.resetThreadUnreadCount('unread')
  pending.resolve({ data: [thread('unread', 2)] })
  await poll

  assert.equal(store.currentThread?.unread_count, 0)
  assert.deepEqual(store.visibleThreads, [])
  assert.equal(store.loadingThreads, false)
})

test('refreshing an overlapping read preserves messages received after the read', async () => {
  const { store, deferNextLoad, respondWith } = setupStore()
  await store.loadThreads()
  store.setThreadId('unread')
  store.unreadOnly = true
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)
  const poll = store.loadThreads()

  await store.resetThreadUnreadCount('unread')
  respondWith([
    {
      ...thread('unread', 1),
      last_message_id: 'new-inbound-message',
      last_message_content: 'Received after mark-read',
    },
  ])
  pending.resolve({ data: [thread('unread', 2)] })
  await poll

  assert.equal(store.currentThread?.unread_count, 1)
  assert.equal(store.currentThread.last_message_id, 'new-inbound-message')
  assert.equal(store.visibleThreads.length, 1)
  assert.equal(store.loadingThreads, false)
})

test('Back navigation restores an earlier read conversation in Unread', async () => {
  const { store, calls } = await setupReadConversationHistory()

  store.setThreadId('unread')

  assert.equal(store.currentThread?.id, 'unread')
  assert.equal(store.currentThread.unread_count, 0)
  await store.loadThreadMessages('unread')
  assert.equal(calls.at(-1)?.params?.contact, '+18005550100')
  assert.deepEqual(
    store.visibleThreads.map((item) => item.id),
    ['other'],
  )
})

test('saved contacts refresh previously opened read conversations too', async () => {
  const { store } = await setupReadConversationHistory()
  await store.loadThreads([contact('Alice')])

  store.setThreadId('unread')

  assert.equal(store.currentThread?.contact_details?.name, 'Alice')
})

for (const action of ['reset', 'delete', 'archive', 'owner', 'view']) {
  test(`navigation cache does not restore conversations after ${action}`, async () => {
    const { store, phones, respondWith } = await setupReadConversationHistory()
    if (action === 'reset') store.resetState()
    if (action === 'delete') await store.deleteThread('unread')
    if (action === 'archive') {
      await store.updateThread({ threadId: 'unread', isArchived: true })
    }
    if (action === 'owner' || action === 'view') {
      if (action === 'owner') phones.owner = '+18005550198'
      if (action === 'view') store.archivedThreads = true
      respondWith([])
      await store.loadThreads()
    }

    store.setThreadId('unread')

    assert.equal(store.currentThread, null)
    assert.equal(store.hasThreadId('unread'), false)
  })
}

function manyThreads(count: number) {
  return Array.from({ length: count }, (_, index) => ({
    ...thread(`page-${index}`, 1),
    contact: `+1800555${String(index).padStart(4, '0')}`,
  }))
}

for (const count of [0, 19, 20, 21]) {
  test(`Load More is available when the last page is full (${count})`, async () => {
    const { store, respondWith } = setupStore()
    respondWith(manyThreads(count))

    await store.loadThreads()

    assert.equal(store.threads.length, Math.min(count, 20))
    assert.equal(store.hasMoreThreads, count >= 20)
  })
}

test('Load More expands the loaded list and disappears on the final page', async () => {
  const { store, respondWith, calls } = setupStore()
  respondWith(manyThreads(45))
  await store.loadThreads()

  await store.loadMoreThreads()
  assert.equal(store.threads.length, 40)
  assert.equal(store.hasMoreThreads, true)
  await store.loadMoreThreads()
  assert.equal(store.threads.length, 45)
  assert.equal(new Set(store.threads.map((item) => item.id)).size, 45)
  assert.equal(store.hasMoreThreads, false)
  assert.equal(store.loadingMoreThreads, false)
  const completedCalls = calls.length
  await store.loadMoreThreads()
  assert.equal(calls.length, completedCalls)
})

for (const count of [20, 40]) {
  test(`an empty final page hides Load More without losing ${count} loaded threads`, async () => {
    const { store, respondWith } = setupStore()
    respondWith(manyThreads(count))
    await store.loadThreads()
    if (count === 40) await store.loadMoreThreads()
    assert.equal(store.threads.length, count)
    assert.equal(store.hasMoreThreads, true)

    await store.loadMoreThreads()

    assert.equal(store.threads.length, count)
    assert.equal(store.hasMoreThreads, false)
    assert.equal(store.loadingMoreThreads, false)
  })
}

test('polling preserves loaded pages and changing filters resets them', async () => {
  const { store, respondWith } = setupStore()
  respondWith(manyThreads(45))
  await store.loadThreads()
  await store.loadMoreThreads()

  await store.loadThreads()
  assert.equal(store.threads.length, 40)

  store.unreadOnly = true
  await store.loadThreads()
  assert.equal(store.threads.length, 20)
  await store.loadMoreThreads()
  store.archivedThreads = true
  await store.loadThreads()
  assert.equal(store.threads.length, 20)
})

test('switching phones resets loaded pages', async () => {
  const { store, respondWith, phones } = setupStore()
  respondWith(manyThreads(45))
  await store.loadThreads()
  await store.loadMoreThreads()

  phones.owner = '+18005550198'
  await store.loadThreads()

  assert.equal(store.threads.length, 20)
})

test('Load More failure preserves rows and permits a retry', async () => {
  const { store, respondWith, deferNextLoad } = setupStore()
  respondWith(manyThreads(45))
  await store.loadThreads()
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)

  const loading = store.loadMoreThreads()
  pending.reject(new Error('Network failed'))
  await assert.rejects(loading, /Network failed/)

  assert.equal(store.threads.length, 20)
  assert.equal(store.hasMoreThreads, true)
  assert.equal(store.loadingMoreThreads, false)
  await store.loadMoreThreads()
  assert.equal(store.threads.length, 40)
})

test('new activity does not close an open conversation pushed beyond the loaded page', async () => {
  const { store, respondWith } = setupStore()
  const existing = manyThreads(45)
  respondWith(existing)
  await store.loadThreads()
  store.setThreadId('page-19')
  respondWith([thread('newest', 1), ...existing])

  await store.loadThreads()

  assert.equal(store.currentThread?.id, 'page-19')
  await store.loadThreadMessages('page-19')
})

test('a second Load More click is ignored while the first is running', async () => {
  const { store, respondWith, deferNextLoad } = setupStore()
  const existing = manyThreads(65)
  respondWith(existing)
  await store.loadThreads()
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)

  const loading = store.loadMoreThreads()
  assert.equal(store.loadingMoreThreads, true)
  await store.loadMoreThreads()
  pending.resolve({ data: existing.slice(0, 20) })
  await loading

  assert.equal(store.threads.length, 40)
  assert.equal(store.loadingMoreThreads, false)
})

test('changing filters cancels an older Load More result', async () => {
  const { store, respondWith, deferNextLoad } = setupStore()
  const existing = manyThreads(45)
  respondWith(existing)
  await store.loadThreads()
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread[] }>()
  deferNextLoad(pending.promise)

  const loading = store.loadMoreThreads()
  assert.equal(store.loadingMoreThreads, true)
  store.unreadOnly = true
  await store.loadThreads()
  pending.resolve({ data: existing.slice(0, 20) })
  await loading

  assert.equal(store.threads.length, 20)
  assert.equal(store.loadingMoreThreads, false)
  await store.loadMoreThreads()
  assert.equal(store.threads.length, 40)
})

test('a cold deep link resolves an older conversation independently of page one', async () => {
  const { store, respondWith, respondToLookup, calls } = setupStore()
  const rows = manyThreads(65)
  const requested = {
    ...thread('page-60', 0),
    contact: '+18005550060',
    contact_details: contact('Older contact', ['+18005550060']),
  }
  respondWith(rows)
  respondToLookup(requested)
  store.setThreadId(requested.id)

  await store.fetchThread(requested.id)
  await store.loadThreads()
  store.setThreadId(requested.id)

  assert.equal(store.threads.length, 20)
  assert.equal(store.currentThread?.id, requested.id)
  assert.equal(store.currentThread.contact_details?.name, 'Older contact')
  await store.loadThreadMessages(requested.id)
  assert.equal(calls.at(-1)?.params?.contact, requested.contact)
  assert.equal(
    calls.filter((call) => call.path === '/v1/message-threads').length,
    1,
  )
})

test('individual lookup preserves a real 404 instead of searching every page', async () => {
  const { store, calls } = setupStore()

  await assert.rejects(store.fetchThread('missing'), { status: 404 })

  assert.equal(calls.length, 1)
  assert.equal(calls[0]?.path, '/v1/message-threads/missing')
})

test('a successfully fetched conversation remains selectable independently of list metadata', async () => {
  const { store, respondWith, respondToLookup } = setupStore()
  respondWith(manyThreads(19))
  const requested = thread('directly-requested', 0)
  respondToLookup(requested)
  await store.loadThreads()
  assert.equal(store.hasMoreThreads, false)

  await store.fetchThread(requested.id)
  store.setThreadId(requested.id)

  assert.equal(store.currentThread?.id, requested.id)
  assert.equal(store.threads.length, 19)
})

test('resetting the session cancels an older individual lookup', async () => {
  const { store, deferLookup } = setupStore()
  const pending = Promise.withResolvers<{ data: EntitiesMessageThread }>()
  deferLookup(pending.promise)
  const loading = store.fetchThread('old-session')

  store.resetState()
  pending.resolve({ data: thread('old-session', 0) })

  await assert.rejects(loading, { name: 'AbortError' })
  store.unreadOnly = true
  store.setThreadId('old-session')
  assert.equal(store.currentThread, null)
})