Garantia de Qualidade

Metodologia de Testes

A validação atual cobre leituras suportadas em PostgreSQL e SQLite, com relatórios de benchmark para Prisma v6, v7, v8, Drizzle e SQL gerado.

Suíte E2E
Atual
Paridade de consultas validada
Cobertura de Paridade
100%
Correspondência byte a byte
Engines de Banco
2
PostgreSQL e SQLite
Benchmarks de ORM
4
Prisma v6/v7/v8, Drizzle

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

  1. Gerar SQL a partir da Consulta Prisma

    Faz o parsing dos argumentos da consulta Prisma e gera SQL equivalente usando os mesmos models e schema. O SQL gerado usa consultas parametrizadas por segurança e performance.

  2. Executar Ambas as Consultas em Paralelo

    Executa o SQL gerado diretamente via postgres.js ou better-sqlite3 e a mesma consulta via Prisma. Ambas atingem o mesmo estado do banco.

  3. Normalizar Resultados

    Trata diferenças de tipo (BigInt vs Number, precisão de Decimal, serialização de Date) e normaliza a ordem das chaves dos objetos para uma comparação justa.

  4. Verificação de Igualdade Profunda

    Verifica se os resultados correspondem exatamente: mesmo número de linhas, mesmos valores de campo, mesmas relações aninhadas, mesma ordenação. Qualquer divergência falha o teste.

  5. Benchmark de Performance

    Mede o tempo de execução com 5 execuções de aquecimento e depois calcula a média de 10-50 iterações por teste. Compara com Prisma v6, Prisma v7, Prisma v8 e Drizzle ORM.

Técnicas Avançadas de Validação

Normalização de Tipos de Dados

Conversão de BigInt
BigInt do JavaScript → Number para comparação
Tratamento de Decimal
Decimal do Prisma → Float com precisão de 10 dígitos
Normalização de Datas
Todos os valores DateTime → null (foco nos dados, não em timestamps)
Parsing de JSON
Detecção e parsing automáticos de strings JSON
Ordenação de Chaves de Objeto
Ordem alfabética para comparação consistente

Benchmark de Performance

Fase de Aquecimento
5 iterações para aquecer caches e JIT
Iterações Adaptativas
5-50 execuções conforme a complexidade da consulta
Medição Isolada
Cada tipo de consulta medido de forma independente
Comparação Multi-ORM
Prisma v6, v7, v8, Drizzle, SQL gerado
Tempo de Geração de SQL
Medição separada do overhead de geração da consulta

Cobertura Abrangente de Testes

Testes cobrem todas as operações de leitura do Prisma em múltiplos níveis de complexidade

Operações de Consulta

  • findMany com filtros complexos
  • findFirst com skip e paginação
  • findUnique por ID e campos únicos
  • count com condições WHERE
  • aggregate (sum, avg, min, max)
  • groupBy com cláusulas HAVING

Cenários Complexos

  • Includes aninhados (4 níveis de profundidade)
  • Filtros de relação (some/every/none)
  • Distinct com window functions
  • Paginação por cursor
  • Select + include combinados
  • Contagem de relações (_count)

Tipos de Filtro

  • Comparação (lt/lte/gt/gte)
  • Lógicos (AND/OR/NOT)
  • Operações de string (contains/startsWith)
  • Verificações de NULL (is/isNot)
  • Arrays IN/NOT IN
  • Modos de sensibilidade a maiúsculas e minúsculas

Testes no PostgreSQL

  • Buscas sem distinção de maiúsculas e minúsculas com ILIKE
  • Operações JSON/JSONB
  • Tratamento de campos array
  • Suporte a tipos compostos
  • Validação de window functions
  • Testes de isolamento de transações

Testes no SQLite

  • Correspondência de padrões com LIKE
  • Validação da extensão JSON1
  • Emulação de window functions
  • Otimização de DISTINCT
  • Correlação de subconsultas
  • Tratamento de afinidade de texto

Exemplo de Caso de Teste

Veja como validamos uma consulta aninhada complexa com filtros de relação

tests/e2e/postgres.test.ts
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 internamente:
// 1. Chama generateSQL() com os args
// 2. Executa o SQL gerado diretamente
// 3. Executa a consulta Prisma
// 4. Normaliza ambos os resultados
// 5. Verificação de igualdade profunda - falha se houver qualquer diferença
// 6. Mede o tempo de execução

O que Acontece Durante a Execução do Teste

  1. 1Geração da Consulta (Microssegundos)

    A função generateSQL() faz o parsing dos args do Prisma e cria SQL parametrizado. Esta etapa tem benchmark separado para medir o overhead de geração da consulta.

  2. 2Execução em Paralelo (Milissegundos)

    Ambas as consultas atingem o mesmo estado do banco simultaneamente via Promise.all(), garantindo comparação justa e condições de dados idênticas.

  3. 3Normalização Profunda

    Os resultados passam por normalização recursiva: BigInt→Number, Decimal→Float(10), Date→null, parse de JSON, ordenação de chaves. Isso garante precisão na comparação byte a byte.

  4. 4Igualdade Estrita

    Comparação via JSON stringify com tolerância zero. Qualquer divergência em número de linhas, valores de campo, objetos aninhados ou ordenação falha o teste com saída de diff detalhada.

  5. 5Medição de Performance

    Após a validação, 5-50 iterações medem o tempo médio de execução. Os resultados incluem: Prisma v6, Prisma v7, Prisma v8, Drizzle ORM, SQL gerado e overhead de geração de SQL.

Validação Multi-Versão

Cada teste com benchmark roda no Prisma v6, v7 e v8, onde houver suporte:

Prisma v6 (6.19.3)

  • Uso direto do PrismaClient
  • Arquitetura de engine legada
  • Métricas de performance de referência

Prisma v7 (7.10.0)

  • Arquitetura baseada em adapters
  • @prisma/adapter-pg e adapter-better-sqlite3
  • Novas otimizações da engine

Prisma v8 (8.1.0-dev.1)

  • Cobertura da versão dev do Prisma v8
  • Arquitetura baseada em adapters
  • Paridade de benchmark em PostgreSQL e SQLite

Relatórios Automáticos de Benchmark

Todos os resultados de benchmark são gerados automaticamente e armazenados como JSON para transparência total:

Explore a Suíte Completa de Testes

A suíte de validação e os relatórios de benchmark são open source. Revise o código dos testes, os dados de benchmark e as verificações de paridade.