Files
accounted/extensions/general/enable-banking/lib/__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

307 lines
9.9 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
vi.mock('@/lib/cash-accounts/service', () => ({
normalizeIban: (iban?: string | null) => {
if (!iban) return null
const normalized = iban.replace(/\s+/g, '').toUpperCase()
return normalized || null
},
}))
import type { SupabaseClient } from '@supabase/supabase-js'
import {
fetchCrossCompanyAccountContext,
unclaimedAccountsFor,
} from '../session-sharing'
import type { StoredAccount } from '../../types'
interface TableResult {
data?: unknown
error?: { message: string } | null
}
type MockChain = Record<string, ReturnType<typeof vi.fn>> & {
then: (resolve: (v: unknown) => void) => void
}
/**
* Chainable mock resolving per table: every filter method returns the chain,
* awaiting it yields the preset result for that table. Chains are recorded so
* tests can assert which filters were applied (the mock does not filter).
*/
function makeSupabase(results: Record<string, TableResult>): {
supabase: SupabaseClient
chainsByTable: Map<string, MockChain[]>
} {
const chainsByTable = new Map<string, MockChain[]>()
const supabase = {
from: (table: string) => {
const result = results[table] ?? { data: [], error: null }
const chain = {} as MockChain
for (const m of ['select', 'eq', 'neq', 'in', 'not', 'is', 'order', 'limit', 'range']) {
chain[m] = vi.fn().mockReturnValue(chain)
}
chain.then = (resolve: (v: unknown) => void) =>
resolve({ data: result.data ?? null, error: result.error ?? null })
const bucket = chainsByTable.get(table)
if (bucket) bucket.push(chain)
else chainsByTable.set(table, [chain])
return chain
},
} as unknown as SupabaseClient
return { supabase, chainsByTable }
}
describe('fetchCrossCompanyAccountContext', () => {
beforeEach(() => {
vi.clearAllMocks()
})
it('claims enabled accounts of sibling companies, remembers deselections, resolves names', async () => {
const { supabase } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: {
data: [
{
id: 'conn-sibling',
company_id: 'company-2',
accounts_data: [
{ uid: 'a1', iban: 'SE11', currency: 'SEK', enabled: true },
{ uid: 'a2', iban: 'SE22', currency: 'SEK', enabled: false },
],
},
{
id: 'conn-own-other-row',
company_id: 'company-1',
// The active company's own account never becomes a claim; its
// enabled accounts are its standing set and its deselections are
// remembered.
accounts_data: [
{ uid: 'a3', iban: 'SE33', currency: 'SEK', enabled: true },
{ uid: 'a4', iban: 'SE44', currency: 'SEK', enabled: false },
],
},
],
},
cash_accounts: { data: [] },
companies: { data: [{ id: 'company-2', name: 'Sibling AB' }] },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context).not.toBeNull()
expect(context!.claims.get('SE11')).toEqual({
companyId: 'company-2',
companyName: 'Sibling AB',
})
expect(context!.claims.has('SE33')).toBe(false)
expect(context!.activeCompanyIbans).toEqual(new Set(['SE33']))
expect(context!.deselectedIbans).toEqual(new Set(['SE22', 'SE44']))
})
it("lets the active company's own standing state outrank a sibling claim", async () => {
// The bank-list renewal case: the active company's old row (about to be
// superseded) and its cash_accounts row still book the IBAN. A sibling
// claim on the same IBAN must not win, or a renewal arriving on a fresh
// row would switch a working feed off.
const { supabase } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: {
data: [
{
id: 'conn-sibling',
company_id: 'company-2',
accounts_data: [{ uid: 'a1', iban: 'SE11', currency: 'SEK', enabled: true }],
},
],
},
cash_accounts: {
data: [{ company_id: 'company-1', iban: 'SE11' }],
},
companies: { data: [] },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context!.claims.has('SE11')).toBe(false)
expect(context!.activeCompanyIbans.has('SE11')).toBe(true)
expect(context!.deselectedIbans.has('SE11')).toBe(false)
})
it('claims IBANs held by sibling companies via cash_accounts too', async () => {
const { supabase } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: { data: [] },
cash_accounts: { data: [{ company_id: 'company-2', iban: 'SE55' }] },
companies: { data: [] },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context!.claims.get('SE55')).toEqual({ companyId: 'company-2', companyName: null })
})
it('lets a claim outrank a remembered deselection for the same IBAN', async () => {
const { supabase } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: {
data: [
{
id: 'conn-a',
company_id: 'company-2',
accounts_data: [{ uid: 'a1', iban: 'SE11', currency: 'SEK', enabled: true }],
},
{
id: 'conn-b',
company_id: 'company-1',
accounts_data: [{ uid: 'a2', iban: 'SE11', currency: 'SEK', enabled: false }],
},
],
},
cash_accounts: { data: [] },
companies: { data: [] },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context!.claims.has('SE11')).toBe(true)
expect(context!.deselectedIbans.has('SE11')).toBe(false)
})
it('treats pending_selection rows asymmetrically: enabled accounts claim, disabled flags are ignored', async () => {
// An attach-created row is pending_selection with deliberately-offered
// enabled accounts and NO cash rows until its picker is saved: those must
// claim, or a second company can take the same physical account inside
// that window. Its disabled flags are unconfirmed callback output
// (including the guard's own fail-closed writes) and must NOT feed the
// deselection memory.
const { supabase, chainsByTable } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: {
data: [
{
id: 'conn-attached',
company_id: 'company-2',
status: 'pending_selection',
accounts_data: [
{ uid: 'a1', iban: 'SE11', currency: 'SEK', enabled: true },
{ uid: 'a2', iban: 'SE22', currency: 'SEK', enabled: false },
],
},
],
},
cash_accounts: { data: [] },
companies: { data: [] },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context!.claims.has('SE11')).toBe(true)
expect(context!.deselectedIbans.has('SE22')).toBe(false)
const connectionChain = chainsByTable.get('bank_connections')![0]
expect(connectionChain.in).toHaveBeenCalledWith('status', [
'active',
'pending_selection',
'expired',
'error',
])
// Paged reads must order on a unique column or rows can be silently
// skipped at page boundaries (a skipped row is a missed claim).
expect(connectionChain.order).toHaveBeenCalledWith('id')
expect(chainsByTable.get('cash_accounts')![0].order).toHaveBeenCalledWith('id')
})
it('reads cash_accounts for ALL member companies (active included)', async () => {
const { supabase, chainsByTable } = makeSupabase({
company_members: {
data: [{ company_id: 'company-1' }, { company_id: 'company-2' }],
},
bank_connections: { data: [] },
cash_accounts: { data: [] },
companies: { data: [] },
})
await fetchCrossCompanyAccountContext(supabase, 'user-1', 'company-1', 'conn-active')
const cashChain = chainsByTable.get('cash_accounts')![0]
expect(cashChain.in).toHaveBeenCalledWith('company_id', ['company-1', 'company-2'])
})
it('returns null when a lookup fails, so the caller can fail closed', async () => {
const { supabase } = makeSupabase({
bank_connections: { data: null, error: { message: 'boom' } },
})
const context = await fetchCrossCompanyAccountContext(
supabase,
'user-1',
'company-1',
'conn-active',
)
expect(context).toBeNull()
})
})
describe('unclaimedAccountsFor', () => {
it('strips stale claimed_by and deselected flags from offered accounts', () => {
const accounts: StoredAccount[] = [
{
uid: 'a1',
iban: 'SE11',
currency: 'SEK',
enabled: false,
ledger_account: '1938',
claimed_by_company_id: 'company-9',
claimed_by_company_name: 'Stale AB',
deselected_elsewhere: true,
},
]
const offered = unclaimedAccountsFor(accounts, new Set())
expect(offered).toHaveLength(1)
expect(offered[0].enabled).toBe(true)
expect(offered[0].ledger_account).toBeUndefined()
expect(offered[0].claimed_by_company_id).toBeUndefined()
expect(offered[0].claimed_by_company_name).toBeUndefined()
expect(offered[0].deselected_elsewhere).toBeUndefined()
})
})