Files
accounted/extensions/general/push-notifications/__tests__/notification-consent.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

311 lines
10 KiB
TypeScript

import { describe, it, expect, beforeAll, beforeEach, vi, type Mock } from 'vitest'
import type { SupabaseClient } from '@supabase/supabase-js'
/**
* Consent polarity for the cron send pipeline.
*
* The invariant under test: a notification_settings row that CANNOT BE READ
* (RLS failure, network error, schema drift) must mean DO NOT SEND, while a
* row that genuinely DOES NOT EXIST means the user never touched the toggles
* and the defaults apply. PostgREST distinguishes the two: `.maybeSingle()`
* yields `{ data: null, error: null }` for zero rows and a non-null `error`
* for a failed read. Collapsing both into "settings undefined" made every
* gate of the form `if (settings && !settings.x_enabled)` fail open: a user
* who had opted out would be notified anyway whenever the read failed.
*
* The stub below emulates PostgREST semantics (not the implementation) so the
* same tests are meaningful against both the old `.single()` reads and the
* shared readNotificationSettings() helper.
*/
vi.mock('web-push', () => ({
default: {
setVapidDetails: vi.fn(),
sendNotification: vi.fn().mockResolvedValue(undefined),
},
}))
const USER_ID = '11111111-1111-4111-8111-111111111111'
const SUBSCRIPTION = {
endpoint: 'https://push.example.test/v1/synthetic-endpoint',
p256dh: 'synthetic-p256dh',
auth: 'synthetic-auth',
}
const todayStr = () => {
const today = new Date()
today.setHours(0, 0, 0, 0)
return today.toISOString().split('T')[0]
}
/** A full notification_settings row; quiet window is zero-length so time of day never skips a send. */
function settingsRow(overrides: Record<string, unknown> = {}) {
return {
id: '22222222-2222-4222-8222-222222222222',
user_id: USER_ID,
tax_deadlines_enabled: true,
invoice_reminders_enabled: true,
quiet_start: '00:00',
quiet_end: '00:00',
email_enabled: true,
push_enabled: true,
period_locked_enabled: true,
period_year_closed_enabled: true,
invoice_sent_enabled: false,
receipt_extracted_enabled: true,
receipt_matched_enabled: true,
missing_underlag_enabled: true,
created_at: '2026-01-01T00:00:00Z',
updated_at: '2026-01-01T00:00:00Z',
...overrides,
}
}
interface StubConfig {
/** Rows in notification_settings for this user, or 'unreadable' to fail the read. */
settings: Record<string, unknown>[] | 'unreadable'
/** Rows the dedup check finds in notification_log, or 'unreadable' to fail the read. */
notificationLog?: Record<string, unknown>[] | 'unreadable'
deadlines?: Record<string, unknown>[]
invoices?: Record<string, unknown>[]
journalEntries?: Record<string, unknown>[]
subscriptions?: Record<string, unknown>[]
}
type Result = { data: unknown; error: unknown }
const READ_ERROR = {
code: '42501',
message: 'permission denied for table notification_settings',
}
const PGRST116 = {
code: 'PGRST116',
message: 'JSON object requested, multiple (or no) rows returned',
}
/** Every eq/in filter the stub saw, so tests can assert on query scope. */
let recordedFilters: Array<{ table: string; method: string; args: unknown[] }> = []
function makeSupabaseStub(config: StubConfig): SupabaseClient {
const rowsResult = (
rows: Record<string, unknown>[] | 'unreadable' | undefined,
method: 'single' | 'maybeSingle' | 'list'
): Result => {
if (rows === 'unreadable') return { data: null, error: READ_ERROR }
const list = rows ?? []
if (method === 'list') return { data: list, error: null }
if (list.length === 0) {
// PostgREST: .single() errors on zero rows, .maybeSingle() does not.
return method === 'single'
? { data: null, error: PGRST116 }
: { data: null, error: null }
}
return { data: list[0], error: null }
}
const from = vi.fn().mockImplementation((table: string) => {
let isWrite = false
const resultFor = (method: 'single' | 'maybeSingle' | 'list'): Result => {
if (isWrite) return { data: null, error: null }
switch (table) {
case 'notification_settings':
return rowsResult(config.settings, method)
case 'notification_log':
return rowsResult(config.notificationLog, method)
case 'deadlines':
return rowsResult(config.deadlines, 'list')
case 'invoices':
return rowsResult(config.invoices, 'list')
case 'journal_entries':
return rowsResult(config.journalEntries, 'list')
case 'push_subscriptions':
return rowsResult(config.subscriptions ?? [SUBSCRIPTION], 'list')
default:
// document_attachments, supplier_invoices, supplier_invoice_payments,
// journal_entry_no_doc_required: empty is the neutral answer.
return { data: [], error: null }
}
}
/* eslint-disable @typescript-eslint/no-explicit-any */
const chain: any = {
select: () => chain,
insert: () => {
isWrite = true
return chain
},
update: () => {
isWrite = true
return chain
},
eq: (...args: unknown[]) => {
recordedFilters.push({ table, method: 'eq', args })
return chain
},
in: (...args: unknown[]) => {
recordedFilters.push({ table, method: 'in', args })
return chain
},
not: () => chain,
order: () => chain,
range: () => chain,
limit: () => chain,
single: async () => resultFor('single'),
maybeSingle: async () => resultFor('maybeSingle'),
then: (resolve: (v: unknown) => void) => resolve(resultFor('list')),
}
/* eslint-enable @typescript-eslint/no-explicit-any */
return chain
})
return { from } as unknown as SupabaseClient
}
let sendTaxDeadlineNotifications: typeof import('../notification-scheduler').sendTaxDeadlineNotifications
let sendInvoiceNotifications: typeof import('../notification-scheduler').sendInvoiceNotifications
let sendMissingUnderlagNotifications: typeof import('../notification-scheduler').sendMissingUnderlagNotifications
let webpushSend: Mock
beforeAll(async () => {
// The sender module captures the VAPID keys at import time: set them before
// the dynamic import so the send path is actually exercised.
process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY = 'synthetic-vapid-public-key'
process.env.VAPID_PRIVATE_KEY = 'synthetic-vapid-private-key'
const scheduler = await import('../notification-scheduler')
sendTaxDeadlineNotifications = scheduler.sendTaxDeadlineNotifications
sendInvoiceNotifications = scheduler.sendInvoiceNotifications
sendMissingUnderlagNotifications = scheduler.sendMissingUnderlagNotifications
webpushSend = vi.mocked((await import('web-push')).default.sendNotification) as unknown as Mock
})
beforeEach(() => {
vi.clearAllMocks()
recordedFilters = []
})
const oneDeadline = () => [
{ id: 'dl-1', user_id: USER_ID, title: 'Momsdeklaration', due_date: todayStr() },
]
describe('tax deadline gate polarity', () => {
it('does NOT send when the settings read fails (unreadable means no consent)', async () => {
const supabase = makeSupabaseStub({ settings: 'unreadable', deadlines: oneDeadline() })
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
expect(result.skipped).toBe(1)
})
it('sends with defaults when no settings row exists', async () => {
const supabase = makeSupabaseStub({ settings: [], deadlines: oneDeadline() })
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).toHaveBeenCalledTimes(1)
expect(result.sent).toBe(1)
})
it('honours an explicit opt-out', async () => {
const supabase = makeSupabaseStub({
settings: [settingsRow({ tax_deadlines_enabled: false })],
deadlines: oneDeadline(),
})
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
expect(result.skipped).toBe(1)
})
it('honours push_enabled = false even when the category is on', async () => {
const supabase = makeSupabaseStub({
settings: [settingsRow({ push_enabled: false })],
deadlines: oneDeadline(),
})
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
})
it('still sends for an opted-in row', async () => {
const supabase = makeSupabaseStub({
settings: [settingsRow()],
deadlines: oneDeadline(),
})
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).toHaveBeenCalledTimes(1)
expect(result.sent).toBe(1)
})
it('does NOT send when the dedup log read fails (cannot prove not-a-duplicate)', async () => {
const supabase = makeSupabaseStub({
settings: [settingsRow()],
notificationLog: 'unreadable',
deadlines: oneDeadline(),
})
const result = await sendTaxDeadlineNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
})
})
describe('invoice gate polarity', () => {
it('does NOT send when the settings read fails', async () => {
const supabase = makeSupabaseStub({
settings: 'unreadable',
invoices: [
{
id: 'inv-1',
user_id: USER_ID,
invoice_number: 1001,
total: 1250,
currency: 'SEK',
due_date: todayStr(),
customer: { name: 'Synthetic Kund AB' },
},
],
})
const result = await sendInvoiceNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
expect(result.skipped).toBe(1)
})
it('only notifies on fakturor: proformas, delivery notes and quotes are never due', async () => {
const supabase = makeSupabaseStub({ settings: [settingsRow()], invoices: [] })
await sendInvoiceNotifications(supabase)
expect(recordedFilters).toContainEqual({
table: 'invoices',
method: 'eq',
args: ['document_type', 'invoice'],
})
})
})
describe('missing underlag gate polarity', () => {
it('does NOT send when the settings read fails', async () => {
const supabase = makeSupabaseStub({
settings: 'unreadable',
journalEntries: [{ id: 'je-1', user_id: USER_ID }],
})
const result = await sendMissingUnderlagNotifications(supabase)
expect(webpushSend).not.toHaveBeenCalled()
expect(result.sent).toBe(0)
expect(result.skipped).toBe(1)
})
})