183 lines
6.2 KiB
TypeScript
183 lines
6.2 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
fieldErrors,
|
|
loginSchema,
|
|
newPasswordSchema,
|
|
passwordSchema,
|
|
signupSchema,
|
|
} from '@/auth/validation'
|
|
import { safeNextPath } from '@/auth/redirects'
|
|
import {
|
|
personalPatch,
|
|
personalSchema,
|
|
professionalSchema,
|
|
translateFieldError,
|
|
} from '@/account/validation'
|
|
|
|
describe('auth validation', () => {
|
|
it('password mirrors the server policy: 12 chars, lower, upper, digit', () => {
|
|
expect(passwordSchema.safeParse('Short1aA').success).toBe(false)
|
|
expect(passwordSchema.safeParse('alllowercase123').success).toBe(false)
|
|
expect(passwordSchema.safeParse('NoDigitsHereAtAll').success).toBe(false)
|
|
expect(passwordSchema.safeParse('CorrectHorse12').success).toBe(true)
|
|
})
|
|
|
|
it('reports one i18n key per field, first issue wins', () => {
|
|
const r = loginSchema.safeParse({ email: 'nope', password: '' })
|
|
expect(r.success).toBe(false)
|
|
if (!r.success) {
|
|
expect(fieldErrors(r.error)).toEqual({
|
|
email: 'auth.error.email_invalid',
|
|
password: 'auth.error.password_required',
|
|
})
|
|
}
|
|
})
|
|
|
|
it('signup flags a confirmation mismatch on the confirm field', () => {
|
|
const r = signupSchema.safeParse({
|
|
displayName: 'A',
|
|
email: 'a@b.co',
|
|
password: 'CorrectHorse12',
|
|
passwordConfirm: 'CorrectHorse13',
|
|
})
|
|
expect(r.success).toBe(false)
|
|
if (!r.success) {
|
|
expect(fieldErrors(r.error).passwordConfirm).toBe('auth.error.password_mismatch')
|
|
}
|
|
expect(
|
|
newPasswordSchema.safeParse({ password: 'CorrectHorse12', passwordConfirm: 'x' })
|
|
.success,
|
|
).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('safeNextPath', () => {
|
|
it('keeps same-origin paths and refuses anything else', () => {
|
|
expect(safeNextPath('/app/account')).toBe('/app/account')
|
|
expect(safeNextPath(null)).toBe('/app')
|
|
expect(safeNextPath('https://evil.test/')).toBe('/app')
|
|
expect(safeNextPath('//evil.test')).toBe('/app')
|
|
expect(safeNextPath('app')).toBe('/app')
|
|
})
|
|
|
|
it('refuses the backslash and control-character escapes the URL parser accepts', () => {
|
|
expect(safeNextPath('/\\evil.test')).toBe('/app')
|
|
expect(safeNextPath('/\t/evil.test')).toBe('/app')
|
|
expect(safeNextPath('/\n/evil.test/x')).toBe('/app')
|
|
expect(safeNextPath('/ /evil.test')).toBe('/%20/evil.test')
|
|
expect(safeNextPath('/app/account?tab=x#s')).toBe('/app/account?tab=x#s')
|
|
})
|
|
|
|
// R4.12 (D3): the URL parser's own normalisation turns these into `//evil.test`.
|
|
it('refuses dot segments that normalise into a protocol-relative path', () => {
|
|
for (const raw of [
|
|
'/..//evil.test',
|
|
'/.//evil.test',
|
|
'/a/..//evil.test',
|
|
'/a/b/../..//evil.test',
|
|
'/..\\\\evil.test',
|
|
'/x/..\\/evil.test',
|
|
'/%2e%2e//evil.test',
|
|
'/%2E%2E//evil.test',
|
|
'/.%2e//evil.test',
|
|
'/a/%2e%2e//evil.test',
|
|
'/.\t.//evil.test',
|
|
'/..//evil.test/app?next=/app#x',
|
|
]) {
|
|
expect(safeNextPath(raw), raw).toBe('/app')
|
|
}
|
|
})
|
|
|
|
it('refuses external schemes and escapes in every spelling', () => {
|
|
for (const raw of [
|
|
'///evil.test',
|
|
'/\\/evil.test',
|
|
'\\\\evil.test',
|
|
'javascript:alert(1)',
|
|
'/javascript:alert(1)//',
|
|
'https:/evil.test',
|
|
'data:text/html,x',
|
|
'',
|
|
]) {
|
|
const result = safeNextPath(raw)
|
|
expect(result.startsWith('//'), raw).toBe(false)
|
|
expect(new URL(result, 'http://site.invalid').origin, raw).toBe('http://site.invalid')
|
|
}
|
|
expect(safeNextPath('///evil.test')).toBe('/app')
|
|
expect(safeNextPath('javascript:alert(1)')).toBe('/app')
|
|
})
|
|
|
|
it('keeps encoded slashes literal and legitimate internal paths unchanged', () => {
|
|
expect(safeNextPath('/%2F%2Fevil.test')).toBe('/%2F%2Fevil.test')
|
|
expect(safeNextPath('/%5C%5Cevil.test')).toBe('/%5C%5Cevil.test')
|
|
expect(safeNextPath('/app')).toBe('/app')
|
|
expect(safeNextPath('/editor')).toBe('/editor')
|
|
expect(safeNextPath('/app//account')).toBe('/app//account')
|
|
expect(safeNextPath('/app/../app/account')).toBe('/app/account')
|
|
expect(safeNextPath('/app/account?next=//evil.test')).toBe('/app/account?next=//evil.test')
|
|
expect(safeNextPath('/../app')).toBe('/app')
|
|
expect(safeNextPath('/..')).toBe('/')
|
|
expect(safeNextPath('/..//evil.test', '/fallback')).toBe('/fallback')
|
|
})
|
|
|
|
it('returns a value that is itself accepted unchanged (idempotent)', () => {
|
|
for (const raw of ['/app/account?tab=x#s', '/a/../b', '/%2e%2e/app', '/app//x']) {
|
|
const once = safeNextPath(raw)
|
|
expect(safeNextPath(once), raw).toBe(once)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('account validation', () => {
|
|
it('turns empty optional fields into null and keeps display_name', () => {
|
|
const r = personalSchema.safeParse({
|
|
display_name: ' Alice ',
|
|
first_name: '',
|
|
last_name: 'Local',
|
|
phone: '',
|
|
})
|
|
expect(r.success).toBe(true)
|
|
if (r.success) {
|
|
expect(personalPatch(r.data)).toEqual({
|
|
display_name: 'Alice',
|
|
first_name: null,
|
|
last_name: 'Local',
|
|
phone: null,
|
|
})
|
|
}
|
|
})
|
|
|
|
it('checks phone E.164 and SIRET 14 digits (spaces tolerated)', () => {
|
|
const bad = personalSchema.safeParse({
|
|
display_name: 'A',
|
|
first_name: '',
|
|
last_name: '',
|
|
phone: '06 12',
|
|
})
|
|
expect(bad.success).toBe(false)
|
|
const siretOk = professionalSchema.safeParse({
|
|
professional_title: '',
|
|
practice_name: '',
|
|
siret: '123 456 789 01234',
|
|
})
|
|
expect(siretOk.success).toBe(true)
|
|
if (siretOk.success) expect(siretOk.data.siret).toBe('12345678901234')
|
|
const siretBad = professionalSchema.safeParse({
|
|
professional_title: '',
|
|
practice_name: '',
|
|
siret: '1234',
|
|
})
|
|
expect(siretBad.success).toBe(false)
|
|
if (!siretBad.success) {
|
|
expect(fieldErrors(siretBad.error).siret).toBe('account.error.siret_format')
|
|
}
|
|
})
|
|
|
|
it('translates a key|value message with its placeholder', () => {
|
|
const t = (k: string) => (k === 'account.error.too_long' ? 'Max {max}' : k)
|
|
expect(translateFieldError(t, 'account.error.too_long|80')).toBe('Max 80')
|
|
expect(translateFieldError(t, 'account.error.required')).toBe('account.error.required')
|
|
expect(translateFieldError(t, undefined)).toBeUndefined()
|
|
})
|
|
})
|