mirror of
https://github.com/whekin/household-bot.git
synced 2026-03-31 16:14:02 +00:00
357 lines
11 KiB
TypeScript
357 lines
11 KiB
TypeScript
import { describe, expect, test } from 'bun:test'
|
|
|
|
import { createHouseholdOnboardingService } from '@household/application'
|
|
import type {
|
|
HouseholdConfigurationRepository,
|
|
HouseholdMemberRecord,
|
|
HouseholdTopicBindingRecord
|
|
} from '@household/ports'
|
|
|
|
import { createMiniAppAuthHandler, createMiniAppJoinHandler } from './miniapp-auth'
|
|
import { buildMiniAppInitData } from './telegram-miniapp-test-helpers'
|
|
|
|
function onboardingRepository(): HouseholdConfigurationRepository {
|
|
const household = {
|
|
householdId: 'household-1',
|
|
householdName: 'Kojori House',
|
|
telegramChatId: '-100123',
|
|
telegramChatType: 'supergroup',
|
|
title: 'Kojori House',
|
|
defaultLocale: 'ru' as const
|
|
}
|
|
let joinToken: string | null = 'join-token'
|
|
const members = new Map<string, HouseholdMemberRecord>()
|
|
let pending: {
|
|
householdId: string
|
|
householdName: string
|
|
telegramUserId: string
|
|
displayName: string
|
|
username: string | null
|
|
languageCode: string | null
|
|
householdDefaultLocale: 'ru'
|
|
} | null = null
|
|
|
|
return {
|
|
registerTelegramHouseholdChat: async () => ({
|
|
status: 'existing',
|
|
household
|
|
}),
|
|
getTelegramHouseholdChat: async () => household,
|
|
getHouseholdChatByHouseholdId: async () => household,
|
|
bindHouseholdTopic: async (input) =>
|
|
({
|
|
householdId: input.householdId,
|
|
role: input.role,
|
|
telegramThreadId: input.telegramThreadId,
|
|
topicName: input.topicName?.trim() || null
|
|
}) satisfies HouseholdTopicBindingRecord,
|
|
getHouseholdTopicBinding: async () => null,
|
|
findHouseholdTopicByTelegramContext: async () => null,
|
|
listHouseholdTopicBindings: async () => [],
|
|
clearHouseholdTopicBindings: async () => {},
|
|
listReminderTargets: async () => [],
|
|
upsertHouseholdJoinToken: async (input) => ({
|
|
householdId: household.householdId,
|
|
householdName: household.householdName,
|
|
token: input.token,
|
|
createdByTelegramUserId: input.createdByTelegramUserId ?? null
|
|
}),
|
|
getHouseholdJoinToken: async () =>
|
|
joinToken
|
|
? {
|
|
householdId: household.householdId,
|
|
householdName: household.householdName,
|
|
token: joinToken,
|
|
createdByTelegramUserId: null
|
|
}
|
|
: null,
|
|
getHouseholdByJoinToken: async (token) => (token === joinToken ? household : null),
|
|
upsertPendingHouseholdMember: async (input) => {
|
|
pending = {
|
|
householdId: household.householdId,
|
|
householdName: household.householdName,
|
|
telegramUserId: input.telegramUserId,
|
|
displayName: input.displayName,
|
|
username: input.username?.trim() || null,
|
|
languageCode: input.languageCode?.trim() || null,
|
|
householdDefaultLocale: household.defaultLocale
|
|
}
|
|
return pending
|
|
},
|
|
getPendingHouseholdMember: async () => pending,
|
|
findPendingHouseholdMemberByTelegramUserId: async () => pending,
|
|
ensureHouseholdMember: async (input) => {
|
|
const member = {
|
|
id: `member-${input.telegramUserId}`,
|
|
householdId: household.householdId,
|
|
telegramUserId: input.telegramUserId,
|
|
displayName: input.displayName,
|
|
status: input.status ?? 'active',
|
|
preferredLocale: input.preferredLocale ?? null,
|
|
householdDefaultLocale: household.defaultLocale,
|
|
rentShareWeight: 1,
|
|
isAdmin: input.isAdmin === true
|
|
}
|
|
members.set(input.telegramUserId, member)
|
|
return member
|
|
},
|
|
getHouseholdMember: async (_householdId, telegramUserId) => members.get(telegramUserId) ?? null,
|
|
listHouseholdMembers: async (householdId) =>
|
|
[...members.values()].filter((member) => member.householdId === householdId),
|
|
listHouseholdMembersByTelegramUserId: async (telegramUserId) => {
|
|
const member = members.get(telegramUserId)
|
|
return member ? [member] : []
|
|
},
|
|
listPendingHouseholdMembers: async () => (pending ? [pending] : []),
|
|
approvePendingHouseholdMember: async (input) => {
|
|
if (!pending || pending.telegramUserId !== input.telegramUserId) {
|
|
return null
|
|
}
|
|
|
|
const member: HouseholdMemberRecord = {
|
|
id: `member-${pending.telegramUserId}`,
|
|
householdId: household.householdId,
|
|
telegramUserId: pending.telegramUserId,
|
|
displayName: pending.displayName,
|
|
status: 'active',
|
|
preferredLocale: null,
|
|
householdDefaultLocale: household.defaultLocale,
|
|
rentShareWeight: 1,
|
|
isAdmin: input.isAdmin === true
|
|
}
|
|
members.set(pending.telegramUserId, member)
|
|
pending = null
|
|
return member
|
|
},
|
|
updateHouseholdDefaultLocale: async (_householdId, locale) => ({
|
|
...household,
|
|
defaultLocale: locale
|
|
}),
|
|
updateMemberPreferredLocale: async (_householdId, telegramUserId, locale) => {
|
|
const member = members.get(telegramUserId)
|
|
return member
|
|
? {
|
|
...member,
|
|
preferredLocale: locale
|
|
}
|
|
: null
|
|
},
|
|
updateHouseholdMemberDisplayName: async () => null,
|
|
updateHouseholdMemberRentShareWeight: async (_householdId, memberId, rentShareWeight) => {
|
|
const member = [...members.values()].find((entry) => entry.id === memberId)
|
|
return member
|
|
? {
|
|
...member,
|
|
rentShareWeight
|
|
}
|
|
: null
|
|
},
|
|
updateHouseholdMemberStatus: async (_householdId, memberId, status) => {
|
|
const member = [...members.values()].find((entry) => entry.id === memberId)
|
|
return member
|
|
? {
|
|
...member,
|
|
status
|
|
}
|
|
: null
|
|
},
|
|
listHouseholdMemberAbsencePolicies: async () => [],
|
|
upsertHouseholdMemberAbsencePolicy: async () => null,
|
|
getHouseholdBillingSettings: async (householdId) => ({
|
|
householdId,
|
|
settlementCurrency: 'GEL',
|
|
rentAmountMinor: null,
|
|
rentCurrency: 'USD',
|
|
rentDueDay: 20,
|
|
rentWarningDay: 17,
|
|
utilitiesDueDay: 4,
|
|
utilitiesReminderDay: 3,
|
|
timezone: 'Asia/Tbilisi'
|
|
}),
|
|
updateHouseholdBillingSettings: async (input) => ({
|
|
householdId: input.householdId,
|
|
settlementCurrency: 'GEL',
|
|
rentAmountMinor: input.rentAmountMinor ?? null,
|
|
rentCurrency: input.rentCurrency ?? 'USD',
|
|
rentDueDay: input.rentDueDay ?? 20,
|
|
rentWarningDay: input.rentWarningDay ?? 17,
|
|
utilitiesDueDay: input.utilitiesDueDay ?? 4,
|
|
utilitiesReminderDay: input.utilitiesReminderDay ?? 3,
|
|
timezone: input.timezone ?? 'Asia/Tbilisi'
|
|
}),
|
|
listHouseholdUtilityCategories: async () => [],
|
|
upsertHouseholdUtilityCategory: async (input) => ({
|
|
id: input.slug ?? 'utility-category-1',
|
|
householdId: input.householdId,
|
|
slug: input.slug ?? 'custom',
|
|
name: input.name,
|
|
sortOrder: input.sortOrder,
|
|
isActive: input.isActive
|
|
}),
|
|
promoteHouseholdAdmin: async () => null
|
|
}
|
|
}
|
|
|
|
describe('createMiniAppAuthHandler', () => {
|
|
test('returns an authorized session for a household member', async () => {
|
|
const authDate = Math.floor(Date.now() / 1000)
|
|
const repository = onboardingRepository()
|
|
await repository.ensureHouseholdMember({
|
|
householdId: 'household-1',
|
|
telegramUserId: '123456',
|
|
displayName: 'Stan',
|
|
isAdmin: true
|
|
})
|
|
const auth = createMiniAppAuthHandler({
|
|
allowedOrigins: ['http://localhost:5173'],
|
|
botToken: 'test-bot-token',
|
|
onboardingService: createHouseholdOnboardingService({
|
|
repository
|
|
})
|
|
})
|
|
|
|
const response = await auth.handler(
|
|
new Request('http://localhost/api/miniapp/session', {
|
|
method: 'POST',
|
|
headers: {
|
|
origin: 'http://localhost:5173',
|
|
'content-type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
initData: buildMiniAppInitData('test-bot-token', authDate, {
|
|
id: 123456,
|
|
first_name: 'Stan',
|
|
username: 'stanislav',
|
|
language_code: 'ru'
|
|
})
|
|
})
|
|
})
|
|
)
|
|
|
|
expect(response.status).toBe(200)
|
|
expect(response.headers.get('access-control-allow-origin')).toBe('http://localhost:5173')
|
|
expect(await response.json()).toMatchObject({
|
|
ok: true,
|
|
authorized: true,
|
|
member: {
|
|
displayName: 'Stan',
|
|
status: 'active',
|
|
isAdmin: true,
|
|
preferredLocale: null,
|
|
householdDefaultLocale: 'ru'
|
|
},
|
|
telegramUser: {
|
|
id: '123456',
|
|
firstName: 'Stan',
|
|
username: 'stanislav',
|
|
languageCode: 'ru'
|
|
}
|
|
})
|
|
})
|
|
|
|
test('returns onboarding state for a non-member with a valid household token', async () => {
|
|
const authDate = Math.floor(Date.now() / 1000)
|
|
const auth = createMiniAppAuthHandler({
|
|
allowedOrigins: ['http://localhost:5173'],
|
|
botToken: 'test-bot-token',
|
|
onboardingService: createHouseholdOnboardingService({
|
|
repository: onboardingRepository()
|
|
})
|
|
})
|
|
|
|
const response = await auth.handler(
|
|
new Request('http://localhost/api/miniapp/session', {
|
|
method: 'POST',
|
|
headers: {
|
|
origin: 'http://localhost:5173',
|
|
'content-type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
initData: buildMiniAppInitData('test-bot-token', authDate, {
|
|
id: 123456,
|
|
first_name: 'Stan'
|
|
}),
|
|
joinToken: 'join-token'
|
|
})
|
|
})
|
|
)
|
|
|
|
expect(response.status).toBe(200)
|
|
expect(await response.json()).toMatchObject({
|
|
ok: true,
|
|
authorized: false,
|
|
onboarding: {
|
|
status: 'join_required',
|
|
householdName: 'Kojori House',
|
|
householdDefaultLocale: 'ru'
|
|
}
|
|
})
|
|
})
|
|
|
|
test('creates a pending join request from the mini app', async () => {
|
|
const authDate = Math.floor(Date.now() / 1000)
|
|
const join = createMiniAppJoinHandler({
|
|
allowedOrigins: ['http://localhost:5173'],
|
|
botToken: 'test-bot-token',
|
|
onboardingService: createHouseholdOnboardingService({
|
|
repository: onboardingRepository()
|
|
})
|
|
})
|
|
|
|
const response = await join.handler(
|
|
new Request('http://localhost/api/miniapp/join', {
|
|
method: 'POST',
|
|
headers: {
|
|
origin: 'http://localhost:5173',
|
|
'content-type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
initData: buildMiniAppInitData('test-bot-token', authDate, {
|
|
id: 123456,
|
|
first_name: 'Stan'
|
|
}),
|
|
joinToken: 'join-token'
|
|
})
|
|
})
|
|
)
|
|
|
|
expect(response.status).toBe(200)
|
|
expect(await response.json()).toMatchObject({
|
|
ok: true,
|
|
authorized: false,
|
|
onboarding: {
|
|
status: 'pending',
|
|
householdName: 'Kojori House',
|
|
householdDefaultLocale: 'ru'
|
|
}
|
|
})
|
|
})
|
|
|
|
test('returns 400 for malformed JSON bodies', async () => {
|
|
const auth = createMiniAppAuthHandler({
|
|
allowedOrigins: ['http://localhost:5173'],
|
|
botToken: 'test-bot-token',
|
|
onboardingService: createHouseholdOnboardingService({
|
|
repository: onboardingRepository()
|
|
})
|
|
})
|
|
|
|
const response = await auth.handler(
|
|
new Request('http://localhost/api/miniapp/session', {
|
|
method: 'POST',
|
|
headers: {
|
|
origin: 'http://localhost:5173',
|
|
'content-type': 'application/json'
|
|
},
|
|
body: '{"initData":'
|
|
})
|
|
)
|
|
|
|
expect(response.status).toBe(400)
|
|
expect(await response.json()).toEqual({
|
|
ok: false,
|
|
error: 'Invalid JSON body'
|
|
})
|
|
})
|
|
})
|