Å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.
255 lines
9.4 KiB
TypeScript
255 lines
9.4 KiB
TypeScript
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
|
import { NextResponse } from 'next/server'
|
|
|
|
const mockSupabase = {
|
|
auth: { getUser: vi.fn() },
|
|
from: vi.fn(),
|
|
rpc: vi.fn(),
|
|
}
|
|
|
|
vi.mock('@/lib/supabase/server', () => ({
|
|
createClient: () => Promise.resolve(mockSupabase),
|
|
}))
|
|
|
|
vi.mock('@/lib/company/context', () => ({
|
|
getActiveCompanyId: vi.fn().mockResolvedValue('company-1'),
|
|
}))
|
|
|
|
vi.mock('@/lib/auth/require-auth', () => ({
|
|
requireAuth: vi.fn(),
|
|
}))
|
|
|
|
// Deliberately NOT mocking @/lib/reports/vat-declaration: the test drives the
|
|
// real calculateVatDeclaration -> fetchVatAccountTotals path off the rpc mock,
|
|
// so the ruta assertions below prove the öre-exact projection end to end.
|
|
|
|
import { GET } from '../route'
|
|
import { requireAuth } from '@/lib/auth/require-auth'
|
|
import { rcInputTotalsFromDeclaration } from '@/lib/reports/vat-declaration'
|
|
import { runVatDeclarationChecks } from '@/lib/reports/vat-declaration-checks'
|
|
|
|
const mockUser = { id: 'user-1', email: 'test@test.se' }
|
|
|
|
/** Wire payload as returned by the get_vat_declaration_totals RPC. */
|
|
function rpcPayload() {
|
|
return {
|
|
totals: [
|
|
{ account_number: '3001', debit: 0, credit: 100000 },
|
|
{ account_number: '2611', debit: 0, credit: 25000 },
|
|
{ account_number: '2641', debit: 3200, credit: 0 },
|
|
],
|
|
settlement_shaped_entries: [],
|
|
source_type_counts: { invoice_created: 2, bank_transaction: 3, manual: 1 },
|
|
}
|
|
}
|
|
|
|
function makeRequest(query: string) {
|
|
return new Request(`http://localhost/api/reports/vat-declaration${query}`)
|
|
}
|
|
|
|
/**
|
|
* chart_of_accounts builder for fetchDynamicRuta05Accounts: which of the
|
|
* company's own class 3 accounts carry a "Standard moms" and therefore belong
|
|
* in ruta 05. Empty by default, i.e. a plain BAS chart.
|
|
*/
|
|
function chartBuilder(accounts: Array<{ account_number: string; default_vat_rate: number }> = []) {
|
|
const result = { data: accounts, error: null }
|
|
const b: Record<string, unknown> = {}
|
|
for (const m of ['select', 'eq', 'in', 'not', 'order']) b[m] = vi.fn().mockReturnValue(b)
|
|
b.range = vi.fn().mockResolvedValue(result)
|
|
b.then = (resolve: (v: unknown) => void) => resolve(result)
|
|
return b
|
|
}
|
|
|
|
describe('GET /api/reports/vat-declaration', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
vi.mocked(requireAuth).mockResolvedValue({
|
|
user: mockUser as never,
|
|
supabase: mockSupabase as never,
|
|
error: null,
|
|
})
|
|
mockSupabase.rpc.mockResolvedValue({ data: rpcPayload(), error: null })
|
|
mockSupabase.from.mockImplementation(() => chartBuilder())
|
|
})
|
|
|
|
it('returns 401 when not authenticated', async () => {
|
|
vi.mocked(requireAuth).mockResolvedValue({
|
|
user: null as never,
|
|
supabase: mockSupabase as never,
|
|
error: NextResponse.json({ error: 'Unauthorized' }, { status: 401 }),
|
|
})
|
|
const res = await GET(
|
|
makeRequest('?periodType=quarterly&year=2026&period=3'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(401)
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('returns 400 when required params are missing', async () => {
|
|
const res = await GET(makeRequest(''), { params: Promise.resolve({}) })
|
|
expect(res.status).toBe(400)
|
|
const body = await res.json()
|
|
expect(body.error.code).toBe('VAT_REPORT_MISSING_PARAMS')
|
|
})
|
|
|
|
it('returns 400 for an invalid periodType', async () => {
|
|
const res = await GET(
|
|
makeRequest('?periodType=weekly&year=2026&period=1'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(400)
|
|
const body = await res.json()
|
|
expect(body.error.code).toBe('VAT_REPORT_INVALID_PERIOD_TYPE')
|
|
})
|
|
|
|
it('returns 400 for an invalid year', async () => {
|
|
const res = await GET(
|
|
makeRequest('?periodType=monthly&year=1999&period=1'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(400)
|
|
const body = await res.json()
|
|
expect(body.error.code).toBe('VAT_REPORT_INVALID_YEAR')
|
|
})
|
|
|
|
it('returns 400 for out-of-range periods per period type', async () => {
|
|
for (const query of [
|
|
'?periodType=monthly&year=2026&period=13',
|
|
'?periodType=quarterly&year=2026&period=5',
|
|
'?periodType=yearly&year=2026&period=2',
|
|
]) {
|
|
const res = await GET(makeRequest(query), { params: Promise.resolve({}) })
|
|
expect(res.status).toBe(400)
|
|
const body = await res.json()
|
|
expect(body.error.code).toBe('VAT_REPORT_INVALID_PERIOD')
|
|
}
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('happy path quarterly: öre-exact rutor from a single RPC round trip', async () => {
|
|
const res = await GET(
|
|
makeRequest('?periodType=quarterly&year=2026&period=3'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(200)
|
|
const body = await res.json()
|
|
|
|
expect(body.data.rutor.ruta05).toBe(100000)
|
|
expect(body.data.rutor.ruta10).toBe(25000)
|
|
expect(body.data.rutor.ruta48).toBe(3200)
|
|
expect(body.data.rutor.ruta49).toBe(21800)
|
|
expect(body.data.breakdown.invoices.base25).toBe(100000)
|
|
expect(body.data.invoiceCount).toBe(2)
|
|
expect(body.data.transactionCount).toBe(3)
|
|
expect(body.data.periodLabel).toBe('Kvartal 3 2026')
|
|
|
|
// Regression guard: the dead company_settings round trip is gone and
|
|
// resolvePeriodDates makes no DB call for calendar quarters. The only
|
|
// table read left is chart_of_accounts, for the company's own ruta 05
|
|
// accounts (#1261).
|
|
expect(mockSupabase.from.mock.calls.map(([t]) => t)).toEqual(['chart_of_accounts'])
|
|
expect(mockSupabase.rpc).toHaveBeenCalledTimes(1)
|
|
expect(mockSupabase.rpc).toHaveBeenCalledWith(
|
|
'get_vat_declaration_totals',
|
|
expect.objectContaining({
|
|
p_company_id: 'company-1',
|
|
p_start: '2026-07-01',
|
|
p_end: '2026-09-30',
|
|
}),
|
|
)
|
|
})
|
|
|
|
it('happy path monthly: no period lookup, one RPC', async () => {
|
|
const res = await GET(
|
|
makeRequest('?periodType=monthly&year=2026&period=7'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(200)
|
|
const body = await res.json()
|
|
expect(body.data.rutor.ruta49).toBe(21800)
|
|
expect(body.data.periodLabel).toBe('Juli 2026')
|
|
|
|
expect(mockSupabase.from).not.toHaveBeenCalledWith('fiscal_periods')
|
|
expect(mockSupabase.rpc).toHaveBeenCalledTimes(1)
|
|
expect(mockSupabase.rpc).toHaveBeenCalledWith(
|
|
'get_vat_declaration_totals',
|
|
expect.objectContaining({ p_start: '2026-07-01', p_end: '2026-07-31' }),
|
|
)
|
|
})
|
|
|
|
// The declaration is what the momsdeklaration UI runs its local
|
|
// "Kontroll av underlaget" checks on, and that client has no ledger access of
|
|
// its own. Without the 2645/2647 pair on the response it could only compare
|
|
// rutor 30-32 against the ruta 48 aggregate, where ordinary debiterad ingående
|
|
// moms on 2641 hides a missing beräknad ingående moms completely.
|
|
describe('rcInputAccountTotals travels with the response', () => {
|
|
/** The masking ledger: 50 000 kr RC output, underlag booked, no 2645/2647. */
|
|
function maskedRcPayload() {
|
|
return {
|
|
totals: [
|
|
{ account_number: '4535', debit: 200000, credit: 0 }, // ruta 21 basis
|
|
{ account_number: '2614', debit: 0, credit: 50000 }, // ruta 30
|
|
{ account_number: '2641', debit: 60000, credit: 0 }, // ordinary input VAT
|
|
],
|
|
settlement_shaped_entries: [],
|
|
source_type_counts: {},
|
|
}
|
|
}
|
|
|
|
async function fetchDeclaration() {
|
|
const res = await GET(
|
|
makeRequest('?periodType=monthly&year=2026&period=1'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(200)
|
|
return (await res.json()).data
|
|
}
|
|
|
|
it('carries both accounts, zeros included, on an ordinary SEK period', async () => {
|
|
const data = await fetchDeclaration()
|
|
// The default fixture has no reverse charge at all: the pair is still
|
|
// present, so a client can tell "no RC activity" from "field missing".
|
|
expect(data.rcInputAccountTotals).toEqual({
|
|
'2645': { debit: 0, credit: 0 },
|
|
'2647': { debit: 0, credit: 0 },
|
|
})
|
|
expect(runVatDeclarationChecks(data.rutor, rcInputTotalsFromDeclaration(data))).toEqual([])
|
|
})
|
|
|
|
it('lets the client run the sharp RC input check off the response alone', async () => {
|
|
mockSupabase.rpc.mockResolvedValue({ data: maskedRcPayload(), error: null })
|
|
const data = await fetchDeclaration()
|
|
|
|
expect(data.rutor.ruta30).toBe(50000)
|
|
expect(data.rutor.ruta48).toBe(60000)
|
|
expect(data.rcInputAccountTotals['2645']).toEqual({ debit: 0, credit: 0 })
|
|
|
|
// Same call the momsdeklaration view makes.
|
|
const checks = runVatDeclarationChecks(data.rutor, rcInputTotalsFromDeclaration(data))
|
|
const mismatch = checks.find((c) => c.code === 'RC_INPUT_VAT_MISMATCH')
|
|
expect(mismatch?.status).toBe('WARNING')
|
|
// \s, not a literal space: sv-SE groups thousands with a no-break space.
|
|
expect(mismatch?.message).toMatch(/50\s000 kr saknas/)
|
|
|
|
// Ruta 48 alone: silent, which is the state the wiring replaced.
|
|
expect(runVatDeclarationChecks(data.rutor)).toEqual([])
|
|
})
|
|
})
|
|
|
|
it('returns the VAT_REPORT_GENERATION_FAILED envelope when the RPC errors', async () => {
|
|
mockSupabase.rpc.mockResolvedValue({
|
|
data: null,
|
|
error: { message: 'connection reset' },
|
|
})
|
|
const res = await GET(
|
|
makeRequest('?periodType=quarterly&year=2026&period=3'),
|
|
{ params: Promise.resolve({}) },
|
|
)
|
|
expect(res.status).toBe(500)
|
|
const body = await res.json()
|
|
expect(body.error.code).toBe('VAT_REPORT_GENERATION_FAILED')
|
|
})
|
|
})
|