Files
accounted/extensions/general/enable-banking/__tests__/session-sharing.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

429 lines
16 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import type { SupabaseClient } from '@supabase/supabase-js'
import {
unclaimedAccountsFor,
findReusableSessions,
countLiveSiblings,
fanOutSessionRenewal,
remapAccountUids,
} from '../lib/session-sharing'
import type { StoredAccount } from '../types'
/**
* Thenable query stub: PostgREST chains terminate on await, not on a fixed
* method, so the same object has to answer .eq()/.neq()/.gt()/.in() and still
* resolve when awaited. Mirrors the stub in lib/cash-accounts/__tests__.
*/
/** A recorded builder call: the method name and the arguments it got. */
type RecordedCall = [string, unknown[]]
interface ChainStub {
calls: RecordedCall[]
[key: string]: unknown
}
function chainable(result: Record<string, unknown>): ChainStub {
const calls: RecordedCall[] = []
const chain = { calls } as ChainStub
for (const method of [
'select', 'eq', 'neq', 'not', 'is', 'in', 'gt', 'order', 'limit', 'update', 'insert',
]) {
chain[method] = vi.fn((...args: unknown[]) => {
calls.push([method, args])
return chain
})
}
chain.then = (onFulfilled: (value: unknown) => unknown) =>
Promise.resolve(result).then(onFulfilled)
chain.maybeSingle = vi.fn(() => Promise.resolve(result))
chain.single = vi.fn(() => Promise.resolve(result))
return chain
}
type MockClient = SupabaseClient & { used: Record<string, ChainStub[]> }
/** Per-table result queues; each from(table) shifts the next result. */
function makeSupabase(queues: Record<string, Array<Record<string, unknown>>>): MockClient {
const used: Record<string, ChainStub[]> = {}
const client = {
used,
from: vi.fn((table: string) => {
const queue = queues[table] ?? []
const result = queue.shift() ?? { data: [], error: null }
const chain = chainable(result)
;(used[table] ??= []).push(chain)
return chain
}),
}
return client as unknown as MockClient
}
const FUTURE = new Date(Date.now() + 30 * 24 * 3600 * 1000).toISOString()
function makeAccount(over: Partial<StoredAccount> = {}): StoredAccount {
return { uid: 'uid-1', iban: 'SE1122334455667788990011', currency: 'SEK', ...over }
}
beforeEach(() => {
vi.clearAllMocks()
})
describe('unclaimedAccountsFor', () => {
it('drops accounts whose IBAN a cash account already claims', () => {
const accounts = [
makeAccount({ uid: 'a', iban: 'SE1111111111111111111111' }),
makeAccount({ uid: 'b', iban: 'SE2222222222222222222222' }),
]
const result = unclaimedAccountsFor(accounts, new Set(['SE1111111111111111111111']))
expect(result.map(a => a.uid)).toEqual(['b'])
})
it('matches claimed IBANs regardless of spacing', () => {
const accounts = [makeAccount({ uid: 'a', iban: 'SE11 1111 1111 1111 1111 1111' })]
const result = unclaimedAccountsFor(accounts, new Set(['SE1111111111111111111111']))
expect(result).toEqual([])
})
it('never offers an account without an IBAN', () => {
// Identity is the IBAN. Without one we cannot prove the account is
// unclaimed, and two companies booking one physical account is worse than
// making the user authorize separately.
const accounts = [makeAccount({ uid: 'a', iban: undefined })]
expect(unclaimedAccountsFor(accounts, new Set())).toEqual([])
})
it('offers a repeated IBAN only once', () => {
// Some ASPSPs return one resource per balance type on the same account;
// offering it twice lets the picker map two rows onto one ledger and trip
// the (company_id, ledger_account) UNIQUE constraint on save.
const accounts = [
makeAccount({ uid: 'a', iban: 'SE3333333333333333333333' }),
makeAccount({ uid: 'b', iban: 'SE33 3333 3333 3333 3333 3333' }),
]
expect(unclaimedAccountsFor(accounts, new Set()).map(a => a.uid)).toEqual(['a'])
})
it('strips the source company ledger mapping and enables the account', () => {
const accounts = [makeAccount({ ledger_account: '1942', enabled: false })]
const [result] = unclaimedAccountsFor(accounts, new Set())
expect(result.ledger_account).toBeUndefined()
expect(result.enabled).toBe(true)
})
})
describe('findReusableSessions', () => {
it('returns a session with the accounts no company has claimed', async () => {
const supabase = makeSupabase({
bank_connections: [{
data: [{
id: 'conn-a', company_id: 'company-a', bank_name: 'Testbanken',
provider: 'testbanken-se', session_id: 'sess-1', psu_type: 'business',
consent_expires: FUTURE,
accounts_data: [
makeAccount({ uid: 'claimed', iban: 'SE1111111111111111111111' }),
makeAccount({ uid: 'free', iban: 'SE2222222222222222222222' }),
],
}],
error: null,
}],
cash_accounts: [{ data: [{ iban: 'SE1111111111111111111111' }], error: null }],
companies: [{ data: [{ id: 'company-a', name: 'Bolag A' }], error: null }],
})
const sessions = await findReusableSessions(supabase, 'user-1', 'company-b')
expect(sessions).toHaveLength(1)
expect(sessions[0].companyName).toBe('Bolag A')
expect(sessions[0].sessionId).toBe('sess-1')
expect(sessions[0].availableAccounts.map(a => a.uid)).toEqual(['free'])
})
it('offers nothing when every account is already claimed', async () => {
const supabase = makeSupabase({
bank_connections: [{
data: [{
id: 'conn-a', company_id: 'company-a', bank_name: 'Testbanken',
provider: 'testbanken-se', session_id: 'sess-1', psu_type: 'business',
consent_expires: FUTURE,
accounts_data: [makeAccount({ uid: 'claimed', iban: 'SE1111111111111111111111' })],
}],
error: null,
}],
cash_accounts: [{ data: [{ iban: 'SE1111111111111111111111' }], error: null }],
companies: [{ data: [{ id: 'company-a', name: 'Bolag A' }], error: null }],
})
expect(await findReusableSessions(supabase, 'user-1', 'company-b')).toEqual([])
})
it('stops offering an account another company already holds but has not mapped', async () => {
// The gap between attaching a company and that company finishing its
// picker: no cash_accounts row exists yet, so a claimed-ledger check alone
// would hand the same physical account to a third company.
const supabase = makeSupabase({
bank_connections: [
{
data: [{
id: 'conn-a', company_id: 'company-a', bank_name: 'Testbanken',
provider: 'testbanken-se', session_id: 'sess-1', psu_type: 'business',
consent_expires: FUTURE,
accounts_data: [makeAccount({ uid: 'free', iban: 'SE2222222222222222222222' })],
}],
error: null,
},
{
// Carrier pass: company-b already took that account on attach.
data: [
{ company_id: 'company-a', accounts_data: [makeAccount({ iban: 'SE2222222222222222222222' })] },
{ company_id: 'company-b', accounts_data: [makeAccount({ iban: 'SE2222222222222222222222' })] },
],
error: null,
},
],
cash_accounts: [{ data: [], error: null }],
companies: [{ data: [{ id: 'company-a', name: 'Bolag A' }], error: null }],
})
expect(await findReusableSessions(supabase, 'user-1', 'company-c')).toEqual([])
})
it('counts only enabled cash accounts as claimed', async () => {
// The connect callback mirrors EVERY account in the consent into
// cash_accounts, deselected ones included. Treating any row as a claim
// would mean the first company to connect speaks for the whole bank and
// nothing is ever free to offer, so the feature would never fire.
const supabase = makeSupabase({
bank_connections: [
{
data: [{
id: 'conn-a', company_id: 'company-a', bank_name: 'Testbanken',
provider: 'testbanken-se', session_id: 'sess-1', psu_type: 'business',
consent_expires: FUTURE,
accounts_data: [
makeAccount({ uid: 'deselected', iban: 'SE2222222222222222222222', enabled: false }),
],
}],
error: null,
},
{ data: [], error: null },
],
// The mirrored row exists but is disabled, so it holds nothing.
cash_accounts: [{ data: [], error: null }],
companies: [{ data: [{ id: 'company-a', name: 'Bolag A' }], error: null }],
})
const sessions = await findReusableSessions(supabase, 'user-1', 'company-b')
expect(sessions).toHaveLength(1)
expect(sessions[0].availableAccounts.map(a => a.uid)).toEqual(['deselected'])
// The enabled filter is what the query must ask for.
expect(supabase.used.cash_accounts[0].calls).toContainEqual(['eq', ['enabled', true]])
})
it('scopes the query to the user, other companies, and a live consent', async () => {
const supabase = makeSupabase({ bank_connections: [{ data: [], error: null }] })
await findReusableSessions(supabase, 'user-1', 'company-b')
const filters = supabase.used.bank_connections[0].calls
expect(filters).toContainEqual(['eq', ['user_id', 'user-1']])
expect(filters).toContainEqual(['eq', ['status', 'active']])
expect(filters).toContainEqual(['neq', ['company_id', 'company-b']])
expect(filters.some(([m, args]) => m === 'gt' && args[0] === 'consent_expires')).toBe(true)
})
it('offers nothing when the claimed-IBAN lookup fails', async () => {
// Fail closed: without the claimed set we cannot tell a free account from
// one another company already books to.
const supabase = makeSupabase({
bank_connections: [{
data: [{
id: 'conn-a', company_id: 'company-a', bank_name: 'Testbanken',
provider: 'testbanken-se', session_id: 'sess-1', psu_type: 'business',
consent_expires: FUTURE,
accounts_data: [makeAccount({ uid: 'free', iban: 'SE2222222222222222222222' })],
}],
error: null,
}],
cash_accounts: [{ data: null, error: { message: 'boom' } }],
companies: [{ data: [], error: null }],
})
// Nothing is offered: an unreadable claimed set cannot prove an account
// free, and offering one another company books to is the outcome this
// feature must never produce. The failure must also not throw and take the
// settings panel down with it, hence awaiting a value rather than a reject.
const sessions = await findReusableSessions(supabase, 'user-1', 'company-b')
expect(sessions).toEqual([])
})
it('returns an empty list when the session lookup fails', async () => {
const supabase = makeSupabase({
bank_connections: [{ data: null, error: { message: 'rls' } }],
})
expect(await findReusableSessions(supabase, 'user-1', 'company-b')).toEqual([])
})
})
describe('countLiveSiblings', () => {
it('counts the other non-revoked connections on the session', async () => {
const supabase = makeSupabase({ bank_connections: [{ count: 2, error: null }] })
const count = await countLiveSiblings(supabase, 'sess-1', 'conn-a')
expect(count).toBe(2)
const filters = supabase.used.bank_connections[0].calls
expect(filters).toContainEqual(['eq', ['session_id', 'sess-1']])
expect(filters).toContainEqual(['neq', ['id', 'conn-a']])
expect(filters).toContainEqual(['neq', ['status', 'revoked']])
})
it('reports a sibling when the count fails, so the session is never revoked', async () => {
const supabase = makeSupabase({
bank_connections: [{ count: null, error: { message: 'timeout' } }],
})
expect(await countLiveSiblings(supabase, 'sess-1', 'conn-a')).toBe(1)
})
})
describe('fanOutSessionRenewal', () => {
it('does nothing when the session did not actually change', async () => {
const supabase = makeSupabase({})
const result = await fanOutSessionRenewal(supabase, {
oldSessionId: 'sess-1',
newSessionId: 'sess-1',
consentExpires: FUTURE,
excludeConnectionId: 'conn-a',
})
expect(result.movedCount).toBe(0)
expect(supabase.from).not.toHaveBeenCalled()
})
it('revives a dead sibling and leaves a pending_selection one pending', async () => {
const supabase = makeSupabase({
bank_connections: [
{
data: [
{ id: 'conn-b', status: 'expired', accounts_data: [] },
{ id: 'conn-c', status: 'pending_selection', accounts_data: [] },
],
error: null,
},
{ error: null },
{ error: null },
],
})
const result = await fanOutSessionRenewal(supabase, {
oldSessionId: 'sess-old',
newSessionId: 'sess-new',
consentExpires: FUTURE,
excludeConnectionId: 'conn-a',
})
expect(result.movedCount).toBe(2)
// The connection that just re-authorized is already correct; touching it
// again would be a no-op at best and a status regression at worst.
expect(supabase.used.bank_connections[0].calls).toContainEqual(['neq', ['id', 'conn-a']])
const revived = supabase.used.bank_connections[1].calls
expect(revived).toContainEqual([
'update',
[{ session_id: 'sess-new', consent_expires: FUTURE, status: 'active', error_message: null }],
])
// Still owes an account selection, so it must not be flipped to active:
// that would skip the picker and sync nothing.
const stillPending = supabase.used.bank_connections[2].calls
expect(stillPending).toContainEqual([
'update',
[{ session_id: 'sess-new', consent_expires: FUTURE }],
])
})
it('re-points sibling accounts at the uids the new session issued', async () => {
// The uid churn is the subtle half of the renewal: carrying only the
// session id leaves siblings calling accounts the bank has retired.
const supabase = makeSupabase({
bank_connections: [
{
data: [{
id: 'conn-b',
status: 'active',
accounts_data: [
{ uid: 'old-uid', iban: 'SE4444444444444444444444', currency: 'SEK', ledger_account: '1930', enabled: true },
],
}],
error: null,
},
{ error: null },
{ error: null },
],
})
await fanOutSessionRenewal(supabase, {
oldSessionId: 'sess-old',
newSessionId: 'sess-new',
consentExpires: FUTURE,
excludeConnectionId: 'conn-a',
sessionAccounts: [{ uid: 'new-uid', iban: 'SE44 4444 4444 4444 4444 4444' }],
})
// The uid re-point is its own write, after the session move.
const update = supabase.used.bank_connections[2].calls.find(([m]) => m === 'update')
const payload = (update?.[1][0] ?? {}) as { accounts_data?: StoredAccount[] }
expect(payload.accounts_data?.[0].uid).toBe('new-uid')
// The company's own mapping choices survive the remap.
expect(payload.accounts_data?.[0].ledger_account).toBe('1930')
})
it('counts only the siblings that actually moved', async () => {
const supabase = makeSupabase({
bank_connections: [
{
data: [
{ id: 'conn-b', status: 'active', accounts_data: [] },
{ id: 'conn-c', status: 'active', accounts_data: [] },
],
error: null,
},
{ error: { message: 'boom' } },
{ error: null },
],
})
const result = await fanOutSessionRenewal(supabase, {
oldSessionId: 'sess-old',
newSessionId: 'sess-new',
consentExpires: FUTURE,
excludeConnectionId: 'conn-a',
})
expect(result.movedCount).toBe(1)
})
})
describe('remapAccountUids', () => {
it('matches on IBAN regardless of spacing and keeps everything else', () => {
const { accounts, remapped } = remapAccountUids(
[{ uid: 'old', iban: 'SE55 5555 5555 5555 5555 5555', currency: 'SEK', enabled: false, ledger_account: '1940' }],
[{ uid: 'new', iban: 'SE5555555555555555555555' }],
)
expect(remapped).toBe(1)
expect(accounts[0]).toMatchObject({ uid: 'new', enabled: false, ledger_account: '1940' })
})
it('leaves an account the new consent does not cover untouched', () => {
// Silently dropping a mapped account is worse than a visible sync error.
const { accounts, remapped, unmatched } = remapAccountUids(
[{ uid: 'old', iban: 'SE6666666666666666666666', currency: 'SEK' }],
[{ uid: 'new', iban: 'SE7777777777777777777777' }],
)
expect(remapped).toBe(0)
expect(unmatched).toBe(1)
expect(accounts[0].uid).toBe('old')
})
})