Files
accounted/tests/pg/account-dimension-rules.pg.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

179 lines
6.3 KiB
TypeScript

import { describe, it, expect } from 'vitest'
import { randomUUID } from 'node:crypto'
import { getPool, withUserContext } from './setup'
import { seedCompany } from './fixtures'
// PR10 account_dimension_rules (20260703200000_account_dimension_rules.sql):
// RLS via user_company_ids() on all four operations, the adr_value_presence
// CHECK (required ⇔ no value), UNIQUE (company_id, account_number,
// dimension_id), value_id ON DELETE CASCADE, and the composite
// (dimension_id, company_id) FK that pins a rule's dimension to the same
// company.
async function seedWithDimensions() {
const seeded = await seedCompany()
await getPool().query(`SELECT public.ensure_company_dimensions($1)`, [seeded.companyId])
return seeded
}
async function getDimensionId(companyId: string, sieDimNo: number): Promise<string> {
const { rows } = await getPool().query(
`SELECT id FROM public.dimensions WHERE company_id = $1 AND sie_dim_no = $2`,
[companyId, sieDimNo],
)
return rows[0].id
}
async function insertValue(params: {
companyId: string
dimensionId: string
code: string
name?: string
}): Promise<string> {
const id = randomUUID()
await getPool().query(
`INSERT INTO public.dimension_values (id, company_id, dimension_id, code, name)
VALUES ($1, $2, $3, $4, $5)`,
[id, params.companyId, params.dimensionId, params.code, params.name ?? params.code],
)
return id
}
async function insertRule(params: {
companyId: string
dimensionId: string
ruleType: 'required' | 'default' | 'fixed'
accountNumber?: string
valueId?: string | null
}): Promise<string> {
const id = randomUUID()
await getPool().query(
`INSERT INTO public.account_dimension_rules
(id, company_id, account_number, dimension_id, rule_type, value_id)
VALUES ($1, $2, $3, $4, $5, $6)`,
[
id,
params.companyId,
params.accountNumber ?? '4010',
params.dimensionId,
params.ruleType,
params.valueId ?? null,
],
)
return id
}
describe('account_dimension_rules RLS', () => {
it('lets a member insert and read an own-company rule', async () => {
const { userId, companyId } = await seedWithDimensions()
const dimId = await getDimensionId(companyId, 6)
await withUserContext(userId, async (client) => {
await client.query(
`INSERT INTO public.account_dimension_rules
(company_id, account_number, dimension_id, rule_type)
VALUES ($1, '4010', $2, 'required')`,
[companyId, dimId],
)
const { rows } = await client.query(
`SELECT account_number, rule_type, value_id, is_active
FROM public.account_dimension_rules WHERE company_id = $1`,
[companyId],
)
expect(rows).toEqual([
{ account_number: '4010', rule_type: 'required', value_id: null, is_active: true },
])
})
})
it('hides other companies rules and blocks cross-company inserts', async () => {
const a = await seedWithDimensions()
const b = await seedWithDimensions()
const aDimId = await getDimensionId(a.companyId, 6)
await insertRule({ companyId: a.companyId, dimensionId: aDimId, ruleType: 'required' })
await withUserContext(b.userId, async (client) => {
// The outsider sees none of A's rules (and has none of their own).
const { rows } = await client.query(
`SELECT id FROM public.account_dimension_rules`,
)
expect(rows).toEqual([])
await expect(
client.query(
`INSERT INTO public.account_dimension_rules
(company_id, account_number, dimension_id, rule_type)
VALUES ($1, '5010', $2, 'required')`,
[a.companyId, aDimId],
),
).rejects.toThrow(/row-level security/)
})
})
})
describe('adr_value_presence CHECK', () => {
it('rejects a required rule that carries a value', async () => {
const { companyId } = await seedWithDimensions()
const dimId = await getDimensionId(companyId, 6)
const valueId = await insertValue({ companyId, dimensionId: dimId, code: 'P001' })
await expect(
insertRule({ companyId, dimensionId: dimId, ruleType: 'required', valueId }),
).rejects.toThrow(/adr_value_presence/)
})
it('rejects a default rule without a value', async () => {
const { companyId } = await seedWithDimensions()
const dimId = await getDimensionId(companyId, 6)
await expect(
insertRule({ companyId, dimensionId: dimId, ruleType: 'default', valueId: null }),
).rejects.toThrow(/adr_value_presence/)
})
})
describe('UNIQUE (company_id, account_number, dimension_id)', () => {
it('rejects a second rule for the same account and dimension', async () => {
const { companyId } = await seedWithDimensions()
const dimId = await getDimensionId(companyId, 6)
const valueId = await insertValue({ companyId, dimensionId: dimId, code: 'P001' })
await insertRule({ companyId, dimensionId: dimId, ruleType: 'default', valueId })
// Different rule_type, same (company, account, dimension) — still one slot.
await expect(
insertRule({ companyId, dimensionId: dimId, ruleType: 'required' }),
).rejects.toThrow(/duplicate|unique/)
})
})
describe('cascade behavior', () => {
it('deleting the dimension_value removes rules pinned to it (ON DELETE CASCADE)', async () => {
const { companyId } = await seedWithDimensions()
const dimId = await getDimensionId(companyId, 6)
const valueId = await insertValue({ companyId, dimensionId: dimId, code: 'P001' })
const ruleId = await insertRule({ companyId, dimensionId: dimId, ruleType: 'fixed', valueId })
// The value is unreferenced by posted lines, so the retention trigger
// allows the delete — and the rule must ride the cascade.
await getPool().query(`DELETE FROM public.dimension_values WHERE id = $1`, [valueId])
const { rows } = await getPool().query(
`SELECT id FROM public.account_dimension_rules WHERE id = $1`,
[ruleId],
)
expect(rows).toEqual([])
})
})
describe('composite (dimension_id, company_id) FK', () => {
it('rejects a rule whose dimension belongs to another company', async () => {
const a = await seedWithDimensions()
const b = await seedWithDimensions()
const aDimId = await getDimensionId(a.companyId, 6)
await expect(
insertRule({ companyId: b.companyId, dimensionId: aDimId, ruleType: 'required' }),
).rejects.toThrow(/foreign key/)
})
})