Testes Metodologia
137 testes end-to-end validam que cada SQL gerado corresponde exatamente ao output do Prisma
Como Validamos a Correção
Cada teste segue um processo rigoroso de 5 passos para garantir que o SQL gerado produza resultados idênticos ao Prisma
Gerar SQL a partir da Query do Prisma
Parseie os argumentos da query do Prisma e gere SQL equivalente usando os mesmos models e schema. O SQL gerado usa queries parametrizadas por segurança e performance.
Executar Ambas as Queries em Paralelo
Rode o SQL gerado diretamente via postgres.js ou better-sqlite3 e execute a mesma query via Prisma. Ambos atingem o mesmo estado do banco.
Normalizar Resultados
Lide com diferenças de tipos (BigInt vs Number, precisão Decimal, serialização de Date) e normalize a ordenação de chaves para comparação justa.
Verificação de Igualdade Profunda
Verifique correspondência exata: mesma contagem de linhas, mesmos valores, mesmas relações aninhadas, mesma ordenação. Qualquer diferença falha o teste.
Benchmark de Performance
Meça tempo de execução com 5 warmups e depois faça média de 10–50 iterações por teste. Compare com Prisma v6, Prisma v7 e Drizzle ORM.
Técnicas Avançadas de Validação
Normalização de Tipos de Dados
- • BigInt Conversion: JavaScript BigInt → Number for comparison
- • Decimal Handling: Prisma Decimal → Float with 10-digit precision
- • Date Normalization: All DateTime values → null (focus on data, not timestamps)
- • JSON Parsing: Automatic detection and parsing of JSON strings
- • Object Key Sorting: Alphabetical ordering for consistent comparison
Benchmark de Performance
- • Warmup Phase: 5 iterations to prime caches and JIT
- • Adaptive Iterations: 5-50 runs based on query complexity
- • Isolated Measurement: Each query type measured independently
- • Multi-ORM Comparison: Prisma v6, v7, Drizzle, Generated SQL
- • SQL Generation Time: Separate timing for query generation overhead
Cobertura Abrangente de Testes
Testes cobrem todas as operações de leitura do Prisma em múltiplos níveis de complexidade
Operações de Query
- findMany with complex filters
- findFirst with skip & pagination
- findUnique by ID & unique fields
- count with WHERE conditions
- aggregate (sum, avg, min, max)
- groupBy with HAVING clauses
Cenários Complexos
- Nested includes (4 levels deep)
- Relation filters (some/every/none)
- Distinct with window functions
- Cursor pagination
- Select + include combined
- Relation counts (_count)
Tipos de Filtro
- Comparison (lt/lte/gt/gte)
- Logical (AND/OR/NOT)
- String ops (contains/startsWith)
- NULL checks (is/isNot)
- IN/NOT IN arrays
- Case sensitivity modes
Testes PostgreSQL
- ✓ ILIKE case-insensitive searches
- ✓ JSON/JSONB operations
- ✓ Array field handling
- ✓ Composite type support
- ✓ Window function validation
- ✓ Transaction isolation testing
Testes SQLite
- ✓ LIKE pattern matching
- ✓ JSON1 extension validation
- ✓ Window function emulation
- ✓ DISTINCT optimization
- ✓ Subquery correlation
- ✓ Text affinity handling
Exemplo de Caso de Teste
Veja como validamos uma query aninhada complexa com relation filters
it('nested relation filter', () =>
runParityTest(
db,
benchmarkResults,
'findMany nested relation',
'Organization',
{
method: 'findMany',
where: {
projects: {
some: {
tasks: { some: { status: 'DONE' } }
}
}
}
},
() => db.prisma.organization.findMany({
where: {
projects: {
some: {
tasks: { some: { status: 'DONE' } }
}
}
},
orderBy: { id: 'asc' }
}),
)
)
// runParityTest internally:
// 1. Calls generateSQL() with the args
// 2. Executes generated SQL directly
// 3. Executes Prisma query
// 4. Normalizes both results
// 5. Deep equality check - fails if any difference
// 6. Benchmarks execution timeO que Acontece Durante a Execução do Teste
1. Geração de Query (Microssegundos)
A função generateSQL() parseia args do Prisma e cria SQL parametrizado. Este passo é benchmarkado separadamente para medir overhead de geração.
2. Execução em Paralelo (Milissegundos)
Ambas as queries atingem o mesmo estado do banco simultaneamente via Promise.all(), garantindo comparação justa e condições idênticas.
3. Normalização Profunda
Resultados passam por normalização recursiva: BigInt→Number, Decimal→Float(10), Date→null, JSON parse, key sorting. Isso garante precisão byte a byte.
4. Igualdade Estrita
Comparação via JSON stringify com tolerância zero. Qualquer diferença em contagem de linhas, valores, objetos aninhados ou ordenação falha com diff detalhado.
5. Medição de Performance
Após validação, 5–50 iterações medem tempo médio. Resultados incluem: Prisma v6, Prisma v7, Drizzle ORM, SQL gerado e overhead de geração.
Validação Multi-Versão
Cada teste roda em Prisma v6 e v7 para garantir compatibilidade entre versões:
Prisma v6 (6.16.3)
- • Direct PrismaClient usage
- • Legacy engine architecture
- • Baseline performance metrics
Prisma v7 (7.2.0)
- • Adapter-based architecture
- • @prisma/adapter-pg & adapter-better-sqlite3
- • New engine optimizations
Relatórios Automáticos de Benchmark
Todos os resultados de benchmark são gerados automaticamente e armazenados como JSON para transparência total:
benchmark-results/v6-postgres-latest.json benchmark-results/v7-postgres-latest.json benchmark-results/v6-sqlite-latest.json benchmark-results/v7-sqlite-latest.json Cada arquivo contém: nome do teste, tempo do Prisma, tempo do SQL gerado, tempo do Drizzle, speedup ratios e timestamp ISO.
Explore a Suíte Completa de Testes
Todos os 137 testes são open source. Revise o código, benchmarks e lógica de validação.