240 lines
7.9 KiB
TypeScript
240 lines
7.9 KiB
TypeScript
import {expect, test, describe, beforeEach, afterEach} from 'bun:test'
|
|
import {type TDate, type TSchema, Type} from "@sinclair/typebox"
|
|
import {type FileResult, fileSync} from 'tmp'
|
|
import fs from 'node:fs/promises'
|
|
|
|
import {read_date, read_object, read_type} from '../src/read_type'
|
|
import {parse} from '..'
|
|
|
|
beforeEach(() => process.env = {})
|
|
|
|
async function testing<T extends TSchema>(value: string | undefined, scheme: T, should_be_successful: boolean, data?: any) {
|
|
const key = 'DB_PORT'
|
|
if (value !== undefined) process.env[key] = value
|
|
|
|
const res = await read_type(scheme, key)
|
|
|
|
if (should_be_successful) {
|
|
expect(res).toEqual({ok: true, data})
|
|
} else {
|
|
expect(res).toEqual({ok: false})
|
|
}
|
|
}
|
|
|
|
// Most important function : read_object
|
|
describe('Object', () => {
|
|
test('basic', async () => {
|
|
const scheme = Type.Object({})
|
|
const res = await read_object(scheme)
|
|
expect(res).toEqual({ok: true, data: {}})
|
|
})
|
|
test('One level', async () => {
|
|
process.env = {
|
|
NAME: 'test',
|
|
PORT: '12',
|
|
TS: '2025-06-08 23:51:12'
|
|
}
|
|
const scheme = Type.Object({name: Type.String(), port: Type.Integer(), ts: Type.Date()})
|
|
const res = await read_object(scheme)
|
|
expect(res).toEqual({ok: true, data: {name: 'test', port: 12, ts: new Date('2025-06-08 23:51:12')}})
|
|
})
|
|
test('Two levels', async () => {
|
|
process.env = {
|
|
DB_PORT: '12',
|
|
DB_HOST: 'localhost',
|
|
THING_A: 'Hello!',
|
|
THING_B: '212',
|
|
NAME: 'Pascal',
|
|
AGE: '27',
|
|
}
|
|
const expected = {
|
|
name: 'Pascal',
|
|
age: 27,
|
|
db: {
|
|
port: 12,
|
|
host: 'localhost'
|
|
},
|
|
thing: {
|
|
a: 'Hello!',
|
|
b: 212,
|
|
}
|
|
}
|
|
|
|
const scheme = Type.Object({
|
|
name: Type.String(),
|
|
age: Type.Number(),
|
|
db: Type.Object({
|
|
port: Type.Integer(),
|
|
host: Type.String()
|
|
}),
|
|
thing: Type.Object({
|
|
a: Type.String(),
|
|
b: Type.Integer(),
|
|
})
|
|
})
|
|
|
|
const res = await read_object(scheme)
|
|
expect(res).toEqual({ok: true, data: expected})
|
|
|
|
const res2 = await parse(scheme)
|
|
expect(res2).toEqual(expected)
|
|
})
|
|
test('Three levels', async () => {
|
|
|
|
process.env = {
|
|
DB_HOST: 'localhost',
|
|
THING_A: 'Hello!',
|
|
AGE: '27',
|
|
THING_THANG_A: '2025-06-06 23:56:12'
|
|
}
|
|
const expected = {
|
|
age: 27,
|
|
db: {
|
|
host: 'localhost'
|
|
},
|
|
thing: {
|
|
a: 'Hello!',
|
|
thang: {
|
|
a: new Date('2025-06-06 23:56:12')
|
|
}
|
|
}
|
|
}
|
|
|
|
const scheme = Type.Object({
|
|
age: Type.Number(),
|
|
db: Type.Object({
|
|
host: Type.String()
|
|
}),
|
|
thing: Type.Object({
|
|
a: Type.String(),
|
|
thang: Type.Object({
|
|
a: Type.Date()
|
|
})
|
|
})
|
|
})
|
|
|
|
const res = await read_object(scheme)
|
|
expect(res).toEqual({ok: true, data: expected})
|
|
|
|
const res2 = await parse(scheme)
|
|
expect(res2).toEqual(expected)
|
|
})
|
|
})
|
|
|
|
// Read any from file
|
|
describe('from_file', () => {
|
|
let file: FileResult | undefined = undefined;
|
|
afterEach(() => {
|
|
file?.removeCallback()
|
|
file = undefined
|
|
})
|
|
|
|
async function testing<T extends TSchema>(value: string | undefined, scheme: T, should_be_successful: boolean, data?: any) {
|
|
file = fileSync()
|
|
|
|
const name = file.name
|
|
if (value !== undefined) {
|
|
await fs.writeFile(file.name, value)
|
|
} else {
|
|
file.removeCallback()
|
|
file = undefined
|
|
}
|
|
|
|
const key = 'DB_PORT'
|
|
process.env[key + '__FILE'] = name
|
|
|
|
const res = await read_type(scheme, key)
|
|
|
|
if (should_be_successful) {
|
|
expect(res).toEqual({ok: true, data})
|
|
} else {
|
|
expect(res).toEqual({ok: false})
|
|
}
|
|
}
|
|
|
|
test('basic string', () => testing('Coucou', Type.String(), true, 'Coucou'))
|
|
test('basic number', () => testing('12', Type.Integer(), true, 12))
|
|
test('file does not exist', () => testing(undefined, Type.String(), false))
|
|
test('Last empty line is trimmed', () => testing('Coucou\n\r\n ', Type.String(), true, 'Coucou'))
|
|
})
|
|
|
|
// Read generic types
|
|
describe('Integer', () => {
|
|
test('basic', () => testing('12', Type.Integer(), true, 12))
|
|
test('not present', () => testing(undefined, Type.Integer(), false))
|
|
test('optional', () => testing(undefined, Type.Optional(Type.Integer()), true))
|
|
test('default', () => testing(undefined, Type.Integer({default: 21}), true, 21))
|
|
test('string', () => testing('coucou', Type.Integer(), false))
|
|
test('min-max OK', () => testing('12', Type.Integer({minimum: 11, maximum: 13}), true, 12))
|
|
test('min-max KO', () => testing('10', Type.Integer({minimum: 11, maximum: 13}), false, 10))
|
|
})
|
|
describe('String', () => {
|
|
test('basic', () => testing('coucou', Type.String(), true, 'coucou'))
|
|
test('not present', () => testing(undefined, Type.String(), false))
|
|
test('optional', () => testing(undefined, Type.Optional(Type.String()), true, undefined))
|
|
test('default', () => testing(undefined, Type.String({default: 'yeet'}), true, 'yeet'))
|
|
test('Length min-max', () => testing('coucou', Type.String({maxLength: 7}), true, 'coucou'))
|
|
test('KO: Length min-max', () => testing('coucou', Type.String({maxLength: 5}), false))
|
|
})
|
|
describe('boolean', () => {
|
|
test('basic true', () => testing('true', Type.Boolean(), true, true))
|
|
test('basic 1', () => testing('1', Type.Boolean(), true, true))
|
|
test('not present', () => testing(undefined, Type.Boolean(), false))
|
|
test('optional', () => testing(undefined, Type.Optional(Type.Boolean()), true))
|
|
test('default', () => testing(undefined, Type.Boolean({default: false}), true, false))
|
|
})
|
|
describe('Enum', () => {
|
|
enum TestNumber {
|
|
A,
|
|
B,
|
|
C,
|
|
D
|
|
}
|
|
enum TestString {
|
|
A = "a",
|
|
B = "b",
|
|
}
|
|
|
|
test('basic number', () => testing('1', Type.Enum(TestNumber), true, TestNumber.B))
|
|
test('number out', () => testing('4', Type.Enum(TestNumber), false))
|
|
test('basic string', () => testing('a', Type.Enum(TestString), true, TestString.A))
|
|
test('string out', () => testing('c', Type.Enum(TestString), false))
|
|
test('number with transform', async () => {
|
|
const scheme = Type.Transform(Type.String())
|
|
.Decode(value => {
|
|
value = value.toLowerCase()
|
|
if (value === 'a') return TestNumber.A
|
|
if (value === 'b') return TestNumber.B
|
|
if (value === 'c') return TestNumber.C
|
|
if (value === 'c') return TestNumber.D
|
|
})
|
|
.Encode(value => {
|
|
if (value === 0) return 'A'
|
|
if (value === 1) return 'B'
|
|
if (value === 2) return 'C'
|
|
return 'D'
|
|
})
|
|
await testing('A', scheme, true, TestNumber.A)
|
|
})
|
|
})
|
|
|
|
// Read specific types
|
|
describe('Date', () => {
|
|
async function testing<T extends TDate>(value: string | undefined, scheme: T, should_be_successful: boolean, data?: any) {
|
|
const key = 'DB_PORT'
|
|
if (value !== undefined) process.env[key] = value
|
|
|
|
const res = await read_date(scheme, key)
|
|
|
|
if (should_be_successful) {
|
|
expect(res).toEqual({ok: true, data})
|
|
} else {
|
|
expect(res).toEqual({ok: false})
|
|
}
|
|
}
|
|
|
|
test('basic', () => testing('2025-06-08 22:40:17', Type.Date(), true, new Date('2025-06-08 22:40:17')))
|
|
test('optional', () => testing(undefined, Type.Optional(Type.Date()), true))
|
|
})
|
|
describe.todo('Array')
|
|
describe.todo('Tuple') |