Å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.
307 lines
9.9 KiB
TypeScript
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()
|
|
})
|
|
})
|