328 lines
11 KiB
TypeScript
328 lines
11 KiB
TypeScript
import { test } from '@japa/runner'
|
|
import testUtils from '@adonisjs/core/services/test_utils'
|
|
import RelanceTask from '#models/relance_task'
|
|
import CheckinTask from '#models/checkin_task'
|
|
import Invoice from '#models/invoice'
|
|
import Organization from '#models/organization'
|
|
import { hashCheckinToken } from '#services/checkin_token'
|
|
import { createTestUser, createTwoOrgs } from '../helpers/auth.js'
|
|
import { body, type ApiOk, type ApiOkPaged } from '../helpers/response.js'
|
|
import { DateTime } from 'luxon'
|
|
|
|
type InvoiceShape = {
|
|
id: string
|
|
organizationId: string
|
|
clientId: string
|
|
numero: string
|
|
amountTtcCents: number
|
|
status: string
|
|
rubisEarned: number
|
|
paidAt: string | null
|
|
}
|
|
|
|
type ClientShape = { id: string; name: string }
|
|
type PlanShape = { id: string; slug: string }
|
|
|
|
async function createClient(client: any, headers: Record<string, string>, name: string) {
|
|
const r = await client
|
|
.post('/api/v1/clients')
|
|
.headers(headers)
|
|
.json({ name, email: `${name.toLowerCase().replace(/\s+/g, '')}@spec.test` })
|
|
return body<ApiOk<ClientShape>>(r).data
|
|
}
|
|
|
|
async function getStandardPlan(client: any, headers: Record<string, string>) {
|
|
const r = await client.get('/api/v1/plans/standard-30j').headers(headers)
|
|
return body<ApiOk<PlanShape>>(r).data
|
|
}
|
|
|
|
test.group('Invoices — POST /invoices', (group) => {
|
|
group.each.setup(() => testUtils.db().withGlobalTransaction())
|
|
|
|
test('crée une facture (201) avec rubisEarned=1 (bonus saisie)', async ({ client, assert }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Boulangerie Spec')
|
|
|
|
const r = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: 'F-2026-T01',
|
|
amountTtcCents: 124000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
|
|
r.assertStatus(201)
|
|
const inv = body<ApiOk<InvoiceShape>>(r).data
|
|
assert.equal(inv.rubisEarned, 1)
|
|
assert.equal(inv.status, 'pending')
|
|
})
|
|
|
|
test('crée à la volée un client si nom non matché + email fourni', async ({ client, assert }) => {
|
|
const { bearer, accessToken } = await createTestUser()
|
|
|
|
const r = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientName: 'Nouveau Client',
|
|
clientEmail: 'nouveau@spec.test',
|
|
numero: 'F-2026-T02',
|
|
amountTtcCents: 50000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
|
|
r.assertStatus(201)
|
|
|
|
// Le client doit exister maintenant
|
|
const list = await client.get('/api/v1/clients').headers(bearer)
|
|
const names = body<ApiOk<Array<{ name: string }>>>(list).data.map((c) => c.name)
|
|
assert.include(names, 'Nouveau Client')
|
|
|
|
// assert le token est bien valide
|
|
assert.isString(accessToken)
|
|
})
|
|
|
|
test('refuse création client à la volée sans email (422 client_email_required)', async ({
|
|
client,
|
|
assert,
|
|
}) => {
|
|
const { bearer } = await createTestUser()
|
|
|
|
const r = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientName: 'Sans Email',
|
|
numero: 'F-2026-T03',
|
|
amountTtcCents: 50000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
|
|
r.assertStatus(422)
|
|
const errors = body<{ errors: Array<{ code: string }> }>(r).errors
|
|
assert.equal(errors[0].code, 'client_email_required')
|
|
})
|
|
|
|
test('schedule uniquement le check-in si planId est fourni', async ({ client, assert }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Avec Plan')
|
|
const plan = await getStandardPlan(client, bearer)
|
|
|
|
const r = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
planId: plan.id,
|
|
numero: 'F-2026-T04',
|
|
amountTtcCents: 50000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
|
|
r.assertStatus(201)
|
|
const inv = body<ApiOk<InvoiceShape>>(r).data
|
|
const tasks = await RelanceTask.query().where('invoice_id', inv.id)
|
|
const checkins = await CheckinTask.query().where('invoice_id', inv.id)
|
|
assert.lengthOf(tasks, 0)
|
|
assert.lengthOf(checkins, 1)
|
|
assert.equal(checkins[0].status, 'scheduled')
|
|
})
|
|
|
|
test('clic check-in pending programme les relances sans rafale passée', async ({
|
|
client,
|
|
assert,
|
|
}) => {
|
|
const { bearer, org } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Checkin Pending')
|
|
const plan = await getStandardPlan(client, bearer)
|
|
const dueDate = DateTime.now().minus({ days: 20 }).set({ hour: 9, minute: 0, second: 0 })
|
|
|
|
const created = await client
|
|
.post('/api/v1/invoices')
|
|
.headers(bearer)
|
|
.json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
planId: plan.id,
|
|
numero: 'F-2026-CHECKIN',
|
|
amountTtcCents: 50000,
|
|
issueDate: dueDate.minus({ days: 15 }).toISO(),
|
|
dueDate: dueDate.toISO(),
|
|
})
|
|
|
|
created.assertStatus(201)
|
|
const inv = body<ApiOk<InvoiceShape>>(created).data
|
|
const plain = 'pending-token-spec'
|
|
const checkin = await CheckinTask.query().where('invoice_id', inv.id).firstOrFail()
|
|
checkin.tokenHash = hashCheckinToken(plain)
|
|
checkin.status = 'sent'
|
|
checkin.sentAt = DateTime.now()
|
|
await checkin.save()
|
|
|
|
const beforeTasks = await RelanceTask.query().where('invoice_id', inv.id)
|
|
assert.lengthOf(beforeTasks, 0)
|
|
|
|
const pending = await client.get(`/api/v1/checkin/${plain}/pending`)
|
|
pending.assertStatus(200)
|
|
|
|
const invoice = await Invoice.findOrFail(inv.id)
|
|
const tasks = await RelanceTask.query()
|
|
.where('invoice_id', inv.id)
|
|
.preload('planStep')
|
|
.orderBy('send_at', 'asc')
|
|
|
|
assert.equal(invoice.organizationId, org.id)
|
|
assert.lengthOf(tasks, 3)
|
|
for (const t of tasks) assert.equal(t.status, 'scheduled')
|
|
assert.isAtMost(Math.abs(tasks[0].sendAt.diffNow('minutes').minutes), 2)
|
|
assert.isAbove(tasks[1].sendAt.toMillis(), tasks[0].sendAt.toMillis())
|
|
})
|
|
|
|
test('numéro unique par org (422 duplicate)', async ({ client }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Dup Test')
|
|
|
|
const payload = {
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: 'F-2026-DUP',
|
|
amountTtcCents: 50000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
}
|
|
|
|
await client.post('/api/v1/invoices').headers(bearer).json(payload)
|
|
const r2 = await client.post('/api/v1/invoices').headers(bearer).json(payload)
|
|
r2.assertStatus(422)
|
|
})
|
|
})
|
|
|
|
test.group('Invoices — POST /invoices/:id/mark-paid', (group) => {
|
|
group.each.setup(() => testUtils.db().withGlobalTransaction())
|
|
|
|
test('idempotent : 2e appel ne re-bumpe pas rubisEarned', async ({ client, assert }) => {
|
|
const { bearer, org } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Idem')
|
|
const created = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: 'F-2026-T10',
|
|
amountTtcCents: 100000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
const id = body<ApiOk<InvoiceShape>>(created).data.id
|
|
|
|
const first = await client.post(`/api/v1/invoices/${id}/mark-paid`).headers(bearer)
|
|
first.assertStatus(200)
|
|
const afterFirst = body<ApiOk<InvoiceShape>>(first).data
|
|
assert.equal(afterFirst.status, 'paid')
|
|
assert.equal(afterFirst.rubisEarned, 2) // 1 saisie + 1 encaissement
|
|
|
|
const second = await client.post(`/api/v1/invoices/${id}/mark-paid`).headers(bearer)
|
|
second.assertStatus(200)
|
|
assert.equal(body<ApiOk<InvoiceShape>>(second).data.rubisEarned, 2) // pas re-bumpé
|
|
|
|
// Org rubisCount n'a été incrémenté qu'une fois
|
|
const orgFresh = await Organization.findOrFail(org.id)
|
|
assert.equal(orgFresh.rubisCount, 1)
|
|
})
|
|
|
|
test('annule les RelanceTasks scheduled de la facture', async ({ client, assert }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Cancel Tasks')
|
|
const plan = await getStandardPlan(client, bearer)
|
|
|
|
const created = await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
planId: plan.id,
|
|
numero: 'F-2026-T11',
|
|
amountTtcCents: 100000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
const id = body<ApiOk<InvoiceShape>>(created).data.id
|
|
|
|
const plain = 'cancel-token-spec'
|
|
const checkin = await CheckinTask.query().where('invoice_id', id).firstOrFail()
|
|
checkin.tokenHash = hashCheckinToken(plain)
|
|
checkin.status = 'sent'
|
|
checkin.sentAt = DateTime.now()
|
|
await checkin.save()
|
|
|
|
const pending = await client.get(`/api/v1/checkin/${plain}/pending`)
|
|
pending.assertStatus(200)
|
|
|
|
const beforeTasks = await RelanceTask.query().where('invoice_id', id)
|
|
assert.lengthOf(beforeTasks, 3)
|
|
|
|
await client.post(`/api/v1/invoices/${id}/mark-paid`).headers(bearer)
|
|
|
|
const afterTasks = await RelanceTask.query().where('invoice_id', id)
|
|
for (const t of afterTasks) assert.equal(t.status, 'cancelled')
|
|
})
|
|
|
|
test('cross-org : user B ne peut pas mark-paid une facture de A (404)', async ({ client }) => {
|
|
const { a, b } = await createTwoOrgs()
|
|
const c = await createClient(client, a.bearer, 'Of A')
|
|
const created = await client.post('/api/v1/invoices').headers(a.bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: 'F-2026-XO1',
|
|
amountTtcCents: 50000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
const id = body<ApiOk<InvoiceShape>>(created).data.id
|
|
|
|
const r = await client.post(`/api/v1/invoices/${id}/mark-paid`).headers(b.bearer)
|
|
r.assertStatus(404)
|
|
})
|
|
})
|
|
|
|
test.group('Invoices — GET /invoices', (group) => {
|
|
group.each.setup(() => testUtils.db().withGlobalTransaction())
|
|
|
|
test('liste paginée + meta total/page', async ({ client, assert }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Liste Spec')
|
|
|
|
for (let i = 0; i < 3; i++) {
|
|
await client
|
|
.post('/api/v1/invoices')
|
|
.headers(bearer)
|
|
.json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: `F-2026-L${i}`,
|
|
amountTtcCents: 10000 + i,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
}
|
|
|
|
const r = await client.get('/api/v1/invoices').headers(bearer)
|
|
r.assertStatus(200)
|
|
const payload = body<ApiOkPaged<InvoiceShape[]>>(r)
|
|
assert.equal(payload.meta.total, 3)
|
|
assert.equal(payload.meta.page, 1)
|
|
})
|
|
|
|
test('GET /invoices/counts agrège par status', async ({ client, assert }) => {
|
|
const { bearer } = await createTestUser()
|
|
const c = await createClient(client, bearer, 'Counts Spec')
|
|
|
|
await client.post('/api/v1/invoices').headers(bearer).json({
|
|
clientId: c.id,
|
|
clientName: c.name,
|
|
numero: 'F-2026-C01',
|
|
amountTtcCents: 10000,
|
|
issueDate: '2026-04-01T09:00:00.000Z',
|
|
dueDate: '2026-05-01T09:00:00.000Z',
|
|
})
|
|
|
|
const r = await client.get('/api/v1/invoices/counts').headers(bearer)
|
|
r.assertStatus(200)
|
|
const c2 = body<ApiOk<{ all: number; pending: number }>>(r).data
|
|
assert.equal(c2.all, 1)
|
|
assert.equal(c2.pending, 1)
|
|
})
|
|
})
|