mirror of
https://github.com/whekin/household-bot.git
synced 2026-03-31 18:54:03 +00:00
396 lines
10 KiB
TypeScript
396 lines
10 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import { randomUUID } from 'node:crypto'
|
|
|
|
import { eq } from 'drizzle-orm'
|
|
|
|
import { createFinanceCommandService } from '@household/application'
|
|
import {
|
|
createDbFinanceRepository,
|
|
createDbHouseholdConfigurationRepository
|
|
} from '@household/adapters-db'
|
|
import { createDbClient, schema } from '@household/db'
|
|
import type { ExchangeRateProvider } from '@household/ports'
|
|
|
|
import { createTelegramBot } from '../../apps/bot/src/bot'
|
|
import { createFinanceCommandsService } from '../../apps/bot/src/finance-commands'
|
|
import {
|
|
createPurchaseMessageRepository,
|
|
registerPurchaseTopicIngestion
|
|
} from '../../apps/bot/src/purchase-topic-ingestion'
|
|
|
|
const chatId = '-100123456'
|
|
const purchaseTopicId = 77
|
|
const commandChatIdNumber = -100123456
|
|
const exchangeRateProvider: ExchangeRateProvider = {
|
|
async getRate(input) {
|
|
if (input.baseCurrency === input.quoteCurrency) {
|
|
return {
|
|
baseCurrency: input.baseCurrency,
|
|
quoteCurrency: input.quoteCurrency,
|
|
rateMicros: 1_000_000n,
|
|
effectiveDate: input.effectiveDate,
|
|
source: 'nbg'
|
|
}
|
|
}
|
|
|
|
return {
|
|
baseCurrency: input.baseCurrency,
|
|
quoteCurrency: input.quoteCurrency,
|
|
rateMicros: 2_700_000n,
|
|
effectiveDate: input.effectiveDate,
|
|
source: 'nbg'
|
|
}
|
|
}
|
|
}
|
|
|
|
function unixSeconds(year: number, month: number, day: number): number {
|
|
return Math.floor(Date.UTC(year, month - 1, day, 12, 0, 0) / 1000)
|
|
}
|
|
|
|
function commandUpdate(params: {
|
|
updateId: number
|
|
fromUserId: string
|
|
fromName: string
|
|
text: string
|
|
unixTime: number
|
|
}) {
|
|
const commandToken = params.text.split(' ')[0] ?? params.text
|
|
|
|
return {
|
|
update_id: params.updateId,
|
|
message: {
|
|
message_id: params.updateId,
|
|
date: params.unixTime,
|
|
chat: {
|
|
id: commandChatIdNumber,
|
|
type: 'supergroup'
|
|
},
|
|
from: {
|
|
id: Number(params.fromUserId),
|
|
is_bot: false,
|
|
first_name: params.fromName
|
|
},
|
|
text: params.text,
|
|
entities: [
|
|
{
|
|
offset: 0,
|
|
length: commandToken.length,
|
|
type: 'bot_command'
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
function topicPurchaseUpdate(params: {
|
|
updateId: number
|
|
fromUserId: string
|
|
fromName: string
|
|
text: string
|
|
unixTime: number
|
|
}) {
|
|
return {
|
|
update_id: params.updateId,
|
|
message: {
|
|
message_id: params.updateId,
|
|
date: params.unixTime,
|
|
chat: {
|
|
id: commandChatIdNumber,
|
|
type: 'supergroup'
|
|
},
|
|
from: {
|
|
id: Number(params.fromUserId),
|
|
is_bot: false,
|
|
first_name: params.fromName
|
|
},
|
|
is_topic_message: true,
|
|
message_thread_id: purchaseTopicId,
|
|
text: params.text
|
|
}
|
|
}
|
|
}
|
|
|
|
function parseStatement(text: string): Map<string, string> {
|
|
const lines = text.split('\n').slice(1)
|
|
const amounts = new Map<string, string>()
|
|
|
|
for (const line of lines) {
|
|
const match = /^-\s(.+?):\s([+-]?\d+\.\d{2})\s(?:USD|GEL)$/.exec(line.trim())
|
|
if (!match) {
|
|
continue
|
|
}
|
|
|
|
amounts.set(match[1]!, match[2]!)
|
|
}
|
|
|
|
return amounts
|
|
}
|
|
|
|
async function loadE2eConfig(): Promise<{ databaseUrl: string }> {
|
|
const { e2eEnv } = await import('@household/config')
|
|
|
|
if (!e2eEnv.E2E_SMOKE_ALLOW_WRITE) {
|
|
throw new Error('Set E2E_SMOKE_ALLOW_WRITE=true to run e2e smoke test')
|
|
}
|
|
|
|
return {
|
|
databaseUrl: e2eEnv.DATABASE_URL
|
|
}
|
|
}
|
|
|
|
async function run(): Promise<void> {
|
|
const { databaseUrl } = await loadE2eConfig()
|
|
|
|
const ids = {
|
|
household: randomUUID(),
|
|
admin: randomUUID(),
|
|
bob: randomUUID(),
|
|
carol: randomUUID()
|
|
}
|
|
|
|
const telegram = {
|
|
admin: '900001',
|
|
bob: '900002',
|
|
carol: '900003'
|
|
}
|
|
|
|
let coreClient: ReturnType<typeof createDbClient> | undefined
|
|
let ingestionClient: ReturnType<typeof createPurchaseMessageRepository> | undefined
|
|
let financeRepositoryClient: ReturnType<typeof createDbFinanceRepository> | undefined
|
|
let householdConfigurationRepositoryClient:
|
|
| ReturnType<typeof createDbHouseholdConfigurationRepository>
|
|
| undefined
|
|
|
|
const bot = createTelegramBot('000000:test-token')
|
|
const replies: string[] = []
|
|
|
|
bot.botInfo = {
|
|
id: 999000,
|
|
is_bot: true,
|
|
first_name: 'Household Test Bot',
|
|
username: 'household_test_bot',
|
|
can_join_groups: true,
|
|
can_read_all_group_messages: false,
|
|
supports_inline_queries: false,
|
|
can_connect_to_business: false,
|
|
has_main_web_app: false,
|
|
has_topics_enabled: true,
|
|
allows_users_to_create_topics: false
|
|
}
|
|
|
|
bot.api.config.use(async (_prev, method, payload) => {
|
|
if (method === 'sendMessage') {
|
|
const p = payload as any
|
|
const messageText = typeof p?.text === 'string' ? p.text : ''
|
|
replies.push(messageText)
|
|
|
|
return {
|
|
ok: true,
|
|
result: {
|
|
message_id: replies.length,
|
|
date: Math.floor(Date.now() / 1000),
|
|
chat: {
|
|
id: commandChatIdNumber,
|
|
type: 'supergroup'
|
|
},
|
|
text: messageText
|
|
}
|
|
} as any
|
|
}
|
|
|
|
return { ok: true, result: true } as any
|
|
})
|
|
|
|
try {
|
|
coreClient = createDbClient(databaseUrl, {
|
|
max: 2,
|
|
prepare: false
|
|
})
|
|
|
|
ingestionClient = createPurchaseMessageRepository(databaseUrl)
|
|
financeRepositoryClient = createDbFinanceRepository(databaseUrl, ids.household)
|
|
householdConfigurationRepositoryClient = createDbHouseholdConfigurationRepository(databaseUrl)
|
|
const financeService = createFinanceCommandService({
|
|
householdId: ids.household,
|
|
repository: financeRepositoryClient.repository,
|
|
householdConfigurationRepository: householdConfigurationRepositoryClient.repository,
|
|
exchangeRateProvider
|
|
})
|
|
const financeCommands = createFinanceCommandsService({
|
|
householdConfigurationRepository: householdConfigurationRepositoryClient.repository,
|
|
financeServiceForHousehold: () => financeService
|
|
})
|
|
|
|
registerPurchaseTopicIngestion(
|
|
bot,
|
|
{
|
|
householdId: ids.household,
|
|
householdChatId: chatId,
|
|
purchaseTopicId
|
|
},
|
|
ingestionClient.repository
|
|
)
|
|
|
|
financeCommands.register(bot)
|
|
|
|
await coreClient.db.insert(schema.households).values({
|
|
id: ids.household,
|
|
name: 'E2E Smoke Household'
|
|
})
|
|
await coreClient.db.insert(schema.householdTelegramChats).values({
|
|
householdId: ids.household,
|
|
telegramChatId: chatId,
|
|
telegramChatType: 'supergroup',
|
|
title: 'E2E Smoke Household'
|
|
})
|
|
|
|
await coreClient.db.insert(schema.members).values([
|
|
{
|
|
id: ids.admin,
|
|
householdId: ids.household,
|
|
telegramUserId: telegram.admin,
|
|
displayName: 'Alice',
|
|
isAdmin: 1
|
|
},
|
|
{
|
|
id: ids.bob,
|
|
householdId: ids.household,
|
|
telegramUserId: telegram.bob,
|
|
displayName: 'Bob',
|
|
isAdmin: 0
|
|
},
|
|
{
|
|
id: ids.carol,
|
|
householdId: ids.household,
|
|
telegramUserId: telegram.carol,
|
|
displayName: 'Carol',
|
|
isAdmin: 0
|
|
}
|
|
])
|
|
|
|
let updateId = 1000
|
|
const march12 = unixSeconds(2026, 3, 12)
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/cycle_open 2026-03 USD',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/rent_set 700 USD 2026-03',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
await bot.handleUpdate(
|
|
topicPurchaseUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.bob,
|
|
fromName: 'Bob',
|
|
text: 'Bought soap 30 USD',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/utility_add electricity 120 USD',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/statement 2026-03',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
const firstStatement = replies.find((entry) => entry.startsWith('Statement for 2026-03'))
|
|
assert.ok(firstStatement, 'First statement message was not emitted')
|
|
|
|
const firstTotals = parseStatement(firstStatement)
|
|
assert.equal(firstTotals.get('Alice'), '283.34')
|
|
assert.equal(firstTotals.get('Bob'), '253.33')
|
|
assert.equal(firstTotals.get('Carol'), '283.33')
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/utility_add water 30 USD',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
await bot.handleUpdate(
|
|
commandUpdate({
|
|
updateId: ++updateId,
|
|
fromUserId: telegram.admin,
|
|
fromName: 'Alice',
|
|
text: '/statement 2026-03',
|
|
unixTime: march12
|
|
}) as never
|
|
)
|
|
|
|
const secondStatement = replies.at(-1)
|
|
assert.ok(secondStatement?.startsWith('Statement for 2026-03'), 'Second statement missing')
|
|
|
|
const secondTotals = parseStatement(secondStatement ?? '')
|
|
assert.equal(secondTotals.get('Alice'), '293.34')
|
|
assert.equal(secondTotals.get('Bob'), '263.33')
|
|
assert.equal(secondTotals.get('Carol'), '293.33')
|
|
|
|
const purchaseRows = await coreClient.db
|
|
.select({
|
|
status: schema.purchaseMessages.processingStatus,
|
|
amountMinor: schema.purchaseMessages.parsedAmountMinor,
|
|
senderMemberId: schema.purchaseMessages.senderMemberId
|
|
})
|
|
.from(schema.purchaseMessages)
|
|
.where(eq(schema.purchaseMessages.householdId, ids.household))
|
|
|
|
assert.equal(purchaseRows.length, 1, 'Expected one ingested purchase message')
|
|
assert.equal(purchaseRows[0]?.status, 'parsed')
|
|
assert.equal(purchaseRows[0]?.amountMinor, 3000n)
|
|
assert.equal(purchaseRows[0]?.senderMemberId, ids.bob)
|
|
|
|
console.log(
|
|
'E2E smoke passed: purchase ingestion, utility updates, and statements are deterministic'
|
|
)
|
|
} finally {
|
|
await Promise.allSettled([
|
|
coreClient
|
|
? coreClient.db.delete(schema.households).where(eq(schema.households.id, ids.household))
|
|
: undefined,
|
|
coreClient?.queryClient.end({ timeout: 5 }),
|
|
ingestionClient?.close(),
|
|
financeRepositoryClient?.close(),
|
|
householdConfigurationRepositoryClient?.close()
|
|
])
|
|
}
|
|
}
|
|
|
|
try {
|
|
await run()
|
|
} catch (error) {
|
|
console.error('E2E smoke failed', error)
|
|
process.exitCode = 1
|
|
}
|