Files
accounted/lib/sales-orders/__tests__/create-invoice-from-order.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

608 lines
24 KiB
TypeScript

/**
* pickLines (pure) and createInvoiceFromSalesOrder (queued mock, with the
* invoice builder mocked).
*
* createInvoiceFromSalesOrder queue order: loadSalesOrder (sales_orders
* select, invoiced rpc), customers select, invoices insert, invoice_items
* insert, then loadSalesOrder again. On an items-insert failure the two
* rollback deletes (invoice_items, invoices) come before the failure returns.
*/
import { describe, it, expect, vi, beforeEach } from 'vitest'
import type { SupabaseClient } from '@supabase/supabase-js'
import { createQueuedMockSupabase } from '@/tests/helpers'
import { IDS, invoicedRow, makeOrderCustomer, makeSalesOrder, makeSalesOrderItem } from './fixtures'
const mockBuildInvoiceWriteData = vi.fn()
vi.mock('@/lib/invoices/build-invoice-write', () => ({
buildInvoiceWriteData: (...args: unknown[]) => mockBuildInvoiceWriteData(...args),
}))
import { createInvoiceFromSalesOrder, deliveryDateFor, pickLines } from '../create-invoice-from-order'
const { supabase, enqueue, reset, findCall } = createQueuedMockSupabase()
const sb = supabase as unknown as SupabaseClient
function orderWith(items = [makeSalesOrderItem()], overrides = {}) {
return makeSalesOrder({ status: 'confirmed', confirmed_at: '2026-09-01T10:00:00Z', items, ...overrides })
}
describe('pickLines', () => {
const order = makeSalesOrder({
items: [
makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 5, invoiced_qty: 2, remaining_qty: 8 }),
makeSalesOrderItem({ id: IDS.item2, sort_order: 1, quantity: 4, delivered_qty: 0, invoiced_qty: 4, remaining_qty: 0 }),
makeSalesOrderItem({ id: IDS.item3, sort_order: 2, line_type: 'text', quantity: 0, delivered_qty: 0 }),
],
})
it('refuses an explicit pick above the remaining quantity', () => {
const result = pickLines(order, { lines: [{ sales_order_item_id: IDS.item1, quantity: 9 }] })
expect(result).toMatchObject({
ok: false,
code: 'SALES_ORDER_OVER_INVOICED',
details: { sales_order_item_id: IDS.item1, remaining_qty: 8, requested_qty: 9 },
})
})
it('accepts an explicit pick at exactly the remaining quantity', () => {
const result = pickLines(order, { lines: [{ sales_order_item_id: IDS.item1, quantity: 8 }] })
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.picked).toHaveLength(1)
expect(result.picked[0]).toMatchObject({ quantity: 8, item: { id: IDS.item1 } })
})
it('derives remaining from quantity - invoiced_qty when remaining_qty is absent', () => {
const bare = makeSalesOrder({ items: [makeSalesOrderItem({ id: IDS.item1, quantity: 10, invoiced_qty: 7 })] })
expect(pickLines(bare, { lines: [{ sales_order_item_id: IDS.item1, quantity: 4 }] })).toMatchObject({
ok: false,
code: 'SALES_ORDER_OVER_INVOICED',
details: { remaining_qty: 3 },
})
})
it('refuses an explicit pick of a text row or an unknown line', () => {
expect(pickLines(order, { lines: [{ sales_order_item_id: IDS.item3, quantity: 1 }] })).toMatchObject({
ok: false,
code: 'SALES_ORDER_LINE_NOT_FOUND',
})
expect(pickLines(order, { lines: [{ sales_order_item_id: IDS.unknownItem, quantity: 1 }] })).toMatchObject({
ok: false,
code: 'SALES_ORDER_LINE_NOT_FOUND',
details: { sales_order_item_id: IDS.unknownItem },
})
})
it('mode remaining (default) picks everything not yet invoiced', () => {
const result = pickLines(order, {})
expect(result.ok).toBe(true)
if (!result.ok) return
// item2 is fully invoiced, the text row never counts.
expect(result.picked.map((p) => [p.item.id, p.quantity])).toEqual([[IDS.item1, 8]])
})
it('mode delivered picks delivered minus invoiced, capped at remaining', () => {
const result = pickLines(order, { mode: 'delivered' })
expect(result.ok).toBe(true)
if (!result.ok) return
// item1: delivered 5 - invoiced 2 = 3
expect(result.picked.map((p) => [p.item.id, p.quantity])).toEqual([[IDS.item1, 3]])
})
it('mode delivered never goes negative when more is invoiced than delivered', () => {
const advance = makeSalesOrder({
items: [
makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 1, invoiced_qty: 5 }),
makeSalesOrderItem({ id: IDS.item2, sort_order: 1, quantity: 10, delivered_qty: 6, invoiced_qty: 5 }),
],
})
const result = pickLines(advance, { mode: 'delivered' })
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.picked.map((p) => [p.item.id, p.quantity])).toEqual([[IDS.item2, 1]])
})
it('returns SALES_ORDER_NOTHING_TO_INVOICE when every line is fully invoiced', () => {
const done = makeSalesOrder({
items: [makeSalesOrderItem({ id: IDS.item1, quantity: 4, invoiced_qty: 4, remaining_qty: 0 })],
})
expect(pickLines(done, {})).toMatchObject({ ok: false, code: 'SALES_ORDER_NOTHING_TO_INVOICE' })
expect(pickLines(done, { mode: 'delivered' })).toMatchObject({ ok: false, code: 'SALES_ORDER_NOTHING_TO_INVOICE' })
})
it('returns SALES_ORDER_NOTHING_TO_INVOICE in delivered mode when nothing was delivered', () => {
const undelivered = makeSalesOrder({ items: [makeSalesOrderItem({ quantity: 4, delivered_qty: 0 })] })
expect(pickLines(undelivered, { mode: 'delivered' })).toMatchObject({
ok: false,
code: 'SALES_ORDER_NOTHING_TO_INVOICE',
})
})
it('treats an empty explicit lines array like no picks', () => {
const result = pickLines(order, { lines: [] })
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.picked.map((p) => p.item.id)).toEqual([IDS.item1])
})
it('sums duplicate picks of the same line into one invoice line', () => {
const result = pickLines(order, {
lines: [
{ sales_order_item_id: IDS.item1, quantity: 3 },
{ sales_order_item_id: IDS.item1, quantity: 5 },
],
})
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.picked).toHaveLength(1)
expect(result.picked[0]).toMatchObject({ quantity: 8, item: { id: IDS.item1 } })
})
it('refuses duplicate picks whose SUM exceeds the remaining quantity', () => {
// 5 and 4 each fit within the remaining 8; together they do not.
const result = pickLines(order, {
lines: [
{ sales_order_item_id: IDS.item1, quantity: 5 },
{ sales_order_item_id: IDS.item1, quantity: 4 },
],
})
expect(result).toMatchObject({
ok: false,
code: 'SALES_ORDER_OVER_INVOICED',
details: { sales_order_item_id: IDS.item1, remaining_qty: 8, requested_qty: 9 },
})
})
it('accepts a pick equal to a float remainder (7.5 ordered, 6.9 invoiced, pick 0.6)', () => {
// 7.5 - 6.9 is 0.5999999999999996 in doubles; the pick must still fit.
const fractional = makeSalesOrder({
items: [makeSalesOrderItem({ id: IDS.item1, quantity: 7.5, invoiced_qty: 6.9 })],
})
const explicit = pickLines(fractional, { lines: [{ sales_order_item_id: IDS.item1, quantity: 0.6 }] })
expect(explicit.ok).toBe(true)
if (!explicit.ok) return
expect(explicit.picked[0].quantity).toBe(0.6)
const remaining = pickLines(fractional, {})
expect(remaining.ok).toBe(true)
if (!remaining.ok) return
expect(remaining.picked[0].quantity).toBe(0.6)
})
it('rounds a summed fractional pick before comparing it to the remainder', () => {
const fractional = makeSalesOrder({
items: [makeSalesOrderItem({ id: IDS.item1, quantity: 1, invoiced_qty: 0.7 })],
})
// 0.1 + 0.2 = 0.30000000000000004 in doubles; remaining is exactly 0.3.
const result = pickLines(fractional, {
lines: [
{ sales_order_item_id: IDS.item1, quantity: 0.1 },
{ sales_order_item_id: IDS.item1, quantity: 0.2 },
],
})
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.picked[0].quantity).toBe(0.3)
})
})
describe('deliveryDateFor', () => {
it('is the latest per-line last_delivery_date when every pick is covered by deliveries', () => {
const picked = [
{
item: makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 5, invoiced_qty: 2, last_delivery_date: '2026-08-20' }),
quantity: 3,
},
{
item: makeSalesOrderItem({ id: IDS.item2, quantity: 4, delivered_qty: 4, invoiced_qty: 0, last_delivery_date: '2026-08-30' }),
quantity: 4,
},
]
expect(deliveryDateFor(picked)).toBe('2026-08-30')
})
it('is null when a pick exceeds what was delivered but not yet invoiced (advance invoice)', () => {
const picked = [
{
// delivered 5 - invoiced 2 = 3 available; picking 4 reaches undelivered quantity.
item: makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 5, invoiced_qty: 2, last_delivery_date: '2026-08-20' }),
quantity: 4,
},
]
expect(deliveryDateFor(picked)).toBeNull()
expect(
deliveryDateFor([
{ item: makeSalesOrderItem({ quantity: 10, delivered_qty: 0, last_delivery_date: null }), quantity: 1 },
]),
).toBeNull()
})
it('is null when any covered line lacks a per-line delivery date', () => {
const picked = [
{
item: makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 5, invoiced_qty: 0, last_delivery_date: '2026-08-20' }),
quantity: 5,
},
{
// Delivered before per-line dates existed: no date to anchor on.
item: makeSalesOrderItem({ id: IDS.item2, quantity: 4, delivered_qty: 4, invoiced_qty: 0, last_delivery_date: null }),
quantity: 4,
},
]
expect(deliveryDateFor(picked)).toBeNull()
})
it('tolerates float drift in the covered check (7.5 delivered, 6.9 invoiced, pick 0.6)', () => {
const picked = [
{
item: makeSalesOrderItem({ id: IDS.item1, quantity: 7.5, delivered_qty: 7.5, invoiced_qty: 6.9, last_delivery_date: '2026-08-30' }),
quantity: 0.6,
},
]
expect(deliveryDateFor(picked)).toBe('2026-08-30')
})
})
const okBuild = {
ok: true,
invoiceFields: {
customer_id: IDS.customer,
invoice_date: '2026-09-02',
due_date: '2026-10-02',
currency: 'SEK',
subtotal: 800,
vat_amount: 200,
total: 1000,
vat_treatment: 'standard_25',
},
items: [
{
sort_order: 0,
line_type: 'product',
description: 'Konsulttimme',
quantity: 8,
unit: 'h',
unit_price: 100,
line_total: 800,
vat_rate: 25,
vat_amount: 200,
sales_order_item_id: IDS.item1,
},
],
}
describe('createInvoiceFromSalesOrder', () => {
beforeEach(() => {
vi.clearAllMocks()
reset()
mockBuildInvoiceWriteData.mockResolvedValue(okBuild)
})
const params = { companyId: IDS.company, userId: IDS.user, orderId: IDS.order }
it('returns SALES_ORDER_NOT_FOUND for a missing order', async () => {
enqueue({ data: null })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'SALES_ORDER_NOT_FOUND' })
expect(mockBuildInvoiceWriteData).not.toHaveBeenCalled()
})
it('refuses invoicing an order that is not confirmed', async () => {
enqueue({ data: makeSalesOrder({ status: 'draft' }) })
enqueue({ data: [] })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({
ok: false,
code: 'SALES_ORDER_INVALID_STATE',
details: { status: 'draft', action: 'invoice' },
})
expect(mockBuildInvoiceWriteData).not.toHaveBeenCalled()
})
it('refuses when nothing remains to invoice', async () => {
enqueue({ data: orderWith([makeSalesOrderItem({ id: IDS.item1, quantity: 4 })]) })
enqueue({ data: [invoicedRow(IDS.item1, 4)] })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'SALES_ORDER_NOTHING_TO_INVOICE' })
expect(findCall('invoices', 'insert')).toBeUndefined()
})
it('fails closed with SALES_ORDER_INVOICE_FX_RATE_UNAVAILABLE when a foreign-currency order gets no Riksbanken rate', async () => {
enqueue({ data: orderWith([makeSalesOrderItem()], { currency: 'EUR' }) })
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
// The builder leaves exchange_rate NULL on a miss; booking that 1:1 as
// kronor is exactly what convertToInvoice refuses, so this path must too.
mockBuildInvoiceWriteData.mockResolvedValue({
...okBuild,
invoiceFields: { ...okBuild.invoiceFields, currency: 'EUR', exchange_rate: null, exchange_rate_date: null, total_sek: null },
})
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'SALES_ORDER_INVOICE_FX_RATE_UNAVAILABLE', details: { currency: 'EUR' } })
expect(findCall('invoices', 'insert')).toBeUndefined()
})
it('still creates the invoice for a foreign-currency order when the rate is present', async () => {
enqueue({ data: orderWith([makeSalesOrderItem()], { currency: 'EUR' }) })
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
enqueue({ data: { id: IDS.invoice, status: 'draft', invoice_number: null, sales_order_id: IDS.order } })
enqueue({ data: null })
enqueue({ data: orderWith() })
enqueue({ data: [invoicedRow(IDS.item1, 10)] })
mockBuildInvoiceWriteData.mockResolvedValue({
...okBuild,
invoiceFields: { ...okBuild.invoiceFields, currency: 'EUR', exchange_rate: 11.45, exchange_rate_date: '2026-09-02' },
})
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result.ok).toBe(true)
expect(findCall('invoices', 'insert')![0]).toMatchObject({ currency: 'EUR', exchange_rate: 11.45 })
})
it('returns CUSTOMER_NOT_FOUND when the raw customer row is gone', async () => {
enqueue({ data: orderWith() })
enqueue({ data: [] })
enqueue({ data: null })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'CUSTOMER_NOT_FOUND', details: { customerId: IDS.customer } })
})
it('creates an unnumbered draft linked to the order, each line carrying its sales_order_item_id', async () => {
enqueue({
data: orderWith(
[
makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 0, discount_percent: 10 }),
makeSalesOrderItem({ id: IDS.item3, sort_order: 1, line_type: 'text', description: 'Tack', quantity: 0 }),
],
{ order_number: 'OR-7', your_reference: 'Anna', last_delivery_date: '2026-08-30' },
),
})
enqueue({ data: [invoicedRow(IDS.item1, 2)] })
enqueue({ data: makeOrderCustomer({ default_payment_terms: 20 }) })
enqueue({ data: { id: IDS.invoice, status: 'draft', invoice_number: null, sales_order_id: IDS.order } })
enqueue({ data: null }) // invoice_items insert
enqueue({ data: orderWith() }) // reload
enqueue({ data: [invoicedRow(IDS.item1, 10)] })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: { invoice_date: '2026-09-02' } })
expect(result.ok).toBe(true)
if (!result.ok) return
expect(result.invoice.id).toBe(IDS.invoice)
expect(result.order.invoicing_progress).toBe('full')
// Builder input: the remaining 8 of item1, the text row carried along,
// sales_order_item_id on the product line, due date from customer terms,
// no delivery date because nothing was delivered.
const buildArg = mockBuildInvoiceWriteData.mock.calls[0][0] as {
documentType: string
input: { items: Record<string, unknown>[]; due_date: string; delivery_date: unknown; notes?: string; your_reference?: string }
}
expect(buildArg.documentType).toBe('invoice')
expect(buildArg.input.due_date).toBe('2026-09-22')
expect(buildArg.input.delivery_date).toBeNull()
expect(buildArg.input.notes).toBe('Kundorder OR-7')
expect(buildArg.input.your_reference).toBe('Anna')
expect(buildArg.input.items).toEqual([
expect.objectContaining({
line_type: 'product',
quantity: 8,
unit_price: 100,
discount_percent: 10,
vat_rate: 25,
sales_order_item_id: IDS.item1,
}),
expect.objectContaining({ line_type: 'text', description: 'Tack', quantity: 0 }),
])
const invoiceInsert = findCall('invoices', 'insert')![0] as Record<string, unknown>
expect(invoiceInsert).toMatchObject({
user_id: IDS.user,
company_id: IDS.company,
invoice_number: null,
status: 'draft',
sales_order_id: IDS.order,
subtotal: 800,
total: 1000,
})
const itemRows = findCall('invoice_items', 'insert')![0] as Record<string, unknown>[]
expect(itemRows).toHaveLength(1)
for (const row of itemRows) {
expect(row.invoice_id).toBe(IDS.invoice)
expect(row.sales_order_item_id).toBe(IDS.item1)
}
expect(findCall('invoices', 'delete')).toBeUndefined()
})
it('sets delivery_date from the picked lines when the pick is covered by deliveries', async () => {
// The header last_delivery_date is display-only and deliberately later
// than the line's date: the invoice must take the LINE date.
enqueue({
data: orderWith(
[makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 4, last_delivery_date: '2026-08-30' })],
{ last_delivery_date: '2026-09-01' },
),
})
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({ data: null })
enqueue({ data: orderWith() })
enqueue({ data: [] })
const result = await createInvoiceFromSalesOrder(sb, {
...params,
input: { mode: 'delivered', due_date: '2026-09-30' },
})
expect(result.ok).toBe(true)
const buildArg = mockBuildInvoiceWriteData.mock.calls[0][0] as { input: { delivery_date: unknown; due_date: string; items: { quantity: number }[] } }
expect(buildArg.input.delivery_date).toBe('2026-08-30')
expect(buildArg.input.due_date).toBe('2026-09-30')
expect(buildArg.input.items[0].quantity).toBe(4)
})
it('leaves delivery_date null when the pick reaches undelivered quantity (advance invoice)', async () => {
enqueue({
data: orderWith(
[makeSalesOrderItem({ id: IDS.item1, quantity: 10, delivered_qty: 4, last_delivery_date: '2026-08-30' })],
{ last_delivery_date: '2026-08-30' },
),
})
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({ data: null })
enqueue({ data: orderWith() })
enqueue({ data: [] })
// mode remaining: all 10, of which only 4 were delivered.
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: { due_date: '2026-09-30' } })
expect(result.ok).toBe(true)
const buildArg = mockBuildInvoiceWriteData.mock.calls[0][0] as { input: { delivery_date: unknown; items: { quantity: number }[] } }
expect(buildArg.input.delivery_date).toBeNull()
expect(buildArg.input.items[0].quantity).toBe(10)
})
it('refuses with SALES_ORDER_CUSTOMER_VAT_CHANGED when the customer type differs from the order snapshot', async () => {
enqueue({
data: orderWith([makeSalesOrderItem()], {
customer_type_snapshot: 'swedish_business',
customer_vat_validated_snapshot: false,
}),
})
enqueue({ data: [] })
// Since validated as an EU business: the frozen 25 % line would pass the
// permitted-set gate but is no longer what the customer should be charged.
enqueue({
data: makeOrderCustomer({ customer_type: 'eu_business', vat_number: 'DE123456789', vat_number_validated: true }),
})
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({
ok: false,
code: 'SALES_ORDER_CUSTOMER_VAT_CHANGED',
details: {
snapshot: { customer_type: 'swedish_business', vat_number_validated: false },
current: { customer_type: 'eu_business', vat_number_validated: true },
},
})
expect(mockBuildInvoiceWriteData).not.toHaveBeenCalled()
expect(findCall('invoices', 'insert')).toBeUndefined()
})
it('refuses when only the VAT-number validation flag changed since the snapshot', async () => {
enqueue({
data: orderWith([makeSalesOrderItem()], {
customer_type_snapshot: 'eu_business',
customer_vat_validated_snapshot: false,
}),
})
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer({ customer_type: 'eu_business', vat_number_validated: true }) })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'SALES_ORDER_CUSTOMER_VAT_CHANGED' })
expect(mockBuildInvoiceWriteData).not.toHaveBeenCalled()
})
it('treats a null validation snapshot as false and passes when the customer still matches', async () => {
enqueue({
data: orderWith([makeSalesOrderItem()], {
customer_type_snapshot: 'swedish_business',
customer_vat_validated_snapshot: null,
}),
})
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer({ customer_type: 'swedish_business', vat_number_validated: null as unknown as boolean }) })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({ data: null })
enqueue({ data: orderWith() })
enqueue({ data: [] })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result.ok).toBe(true)
expect(mockBuildInvoiceWriteData).toHaveBeenCalledTimes(1)
})
it('passes without a snapshot check when the order carries no customer_type_snapshot (pre-snapshot orders)', async () => {
enqueue({
data: orderWith([makeSalesOrderItem()], { customer_type_snapshot: null, customer_vat_validated_snapshot: null }),
})
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer({ customer_type: 'eu_business', vat_number_validated: true }) })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({ data: null })
enqueue({ data: orderWith() })
enqueue({ data: [] })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result.ok).toBe(true)
expect(mockBuildInvoiceWriteData).toHaveBeenCalledTimes(1)
expect(findCall('invoices', 'insert')).toBeDefined()
})
it('propagates a builder domain failure without inserting', async () => {
enqueue({ data: orderWith() })
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
mockBuildInvoiceWriteData.mockResolvedValue({
ok: false,
code: 'INVOICE_CREATE_VAT_RULE_VIOLATION',
details: { attemptedRate: 25 },
})
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'INVOICE_CREATE_VAT_RULE_VIOLATION', details: { attemptedRate: 25 } })
expect(findCall('invoices', 'insert')).toBeUndefined()
})
it('deletes the draft and maps the over-invoice trigger when the line insert fails', async () => {
enqueue({ data: orderWith() })
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({
data: null,
error: { message: 'SALES_ORDER_OVER_INVOICED: line d1000000 would exceed ordered quantity', code: 'P0001' },
})
enqueue({ data: null }) // invoice_items delete
enqueue({ data: null }) // invoices delete
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result).toMatchObject({ ok: false, code: 'SALES_ORDER_OVER_INVOICED' })
expect(findCall('invoice_items', 'delete')).toBeDefined()
expect(findCall('invoice_items', 'eq')).toEqual(['invoice_id', IDS.invoice])
expect(findCall('invoices', 'delete')).toBeDefined()
expect(findCall('invoices', 'eq')).toEqual(['id', IDS.invoice])
})
it('deletes the draft and returns the raw DB error when the line insert fails for another reason', async () => {
enqueue({ data: orderWith() })
enqueue({ data: [] })
enqueue({ data: makeOrderCustomer() })
enqueue({ data: { id: IDS.invoice, status: 'draft' } })
enqueue({ data: null, error: { message: 'null value in column "description"', code: '23502' } })
enqueue({ data: null })
enqueue({ data: null })
const result = await createInvoiceFromSalesOrder(sb, { ...params, input: {} })
expect(result.ok).toBe(false)
expect('dbError' in result && result.dbError).toMatchObject({ code: '23502' })
expect(findCall('invoices', 'delete')).toBeDefined()
})
})