Aseguramiento de calidad

Metodología de pruebas

La validación actual cubre las lecturas compatibles en PostgreSQL y SQLite, con informes de benchmark para Prisma v6, v7, v8, Drizzle y SQL generado.

Suite E2E
Actual
Paridad de consultas validada
Cobertura de paridad
100%
Coincidencia byte a byte
Motores de base de datos
2
PostgreSQL y SQLite
Benchmarks de ORM
4
Prisma v6/v7/v8, Drizzle

Cómo validamos la corrección

Cada prueba sigue un proceso riguroso de 5 pasos para asegurar que el SQL generado produce resultados idénticos a Prisma

  1. Generar SQL desde una consulta Prisma

    Parsea los argumentos de la consulta Prisma y genera SQL equivalente usando los mismos modelos y esquema. El SQL generado usa consultas parametrizadas para seguridad y rendimiento.

  2. Ejecutar ambas consultas en paralelo

    Ejecuta el SQL generado directamente con postgres.js o better-sqlite3, y ejecuta la misma consulta a través de Prisma. Ambas consultan el mismo estado de la base de datos.

  3. Normalizar resultados

    Maneja diferencias de tipos (BigInt vs Number, precisión Decimal, serialización de Date) y normaliza el orden de claves de objetos para una comparación justa.

  4. Comprobación de igualdad profunda

    Verifica que los resultados coinciden exactamente: mismo número de filas, mismos valores de campos, mismas relaciones anidadas, mismo orden. Cualquier diferencia falla la prueba.

  5. Benchmark de rendimiento

    Mide el tiempo de ejecución con 5 ejecuciones de calentamiento y luego promedia 10-50 iteraciones por prueba. Compara contra Prisma v6, Prisma v7, Prisma v8 y Drizzle ORM.

Técnicas avanzadas de validación

Normalización de tipos de datos

Conversión BigInt
BigInt de JavaScript → Number para comparación
Manejo de Decimal
Decimal de Prisma → Float con precisión de 10 dígitos
Normalización de fechas
Todos los valores DateTime → null (enfoque en datos, no timestamps)
Parseo JSON
Detección automática y parseo de strings JSON
Ordenación de claves
Orden alfabético para comparación consistente

Benchmarking de rendimiento

Fase de calentamiento
5 iteraciones para preparar caches y JIT
Iteraciones adaptativas
5-50 ejecuciones según complejidad de la consulta
Medición aislada
Cada tipo de consulta se mide de forma independiente
Comparación multi-ORM
Prisma v6, v7, v8, Drizzle, SQL generado
Tiempo de generación de SQL
Medición separada de la sobrecarga de generación de consultas

Cobertura de pruebas integral

Las pruebas cubren cada operación de lectura de Prisma en múltiples niveles de complejidad

Operaciones de consulta

  • findMany con filtros complejos
  • findFirst con skip y paginación
  • findUnique por ID y campos únicos
  • count con condiciones WHERE
  • aggregate (sum, avg, min, max)
  • groupBy con cláusulas HAVING

Escenarios complejos

  • Includes anidados (4 niveles de profundidad)
  • Filtros de relación (some/every/none)
  • Distinct con funciones de ventana
  • Paginación con cursor
  • Select + include combinados
  • Conteos de relación (_count)

Tipos de filtro

  • Comparación (lt/lte/gt/gte)
  • Lógicos (AND/OR/NOT)
  • Operaciones de string (contains/startsWith)
  • Comprobaciones NULL (is/isNot)
  • IN/NOT IN con arrays
  • Modos de sensibilidad a mayúsculas/minúsculas

Pruebas en PostgreSQL

  • Búsquedas case-insensitive con ILIKE
  • Operaciones JSON/JSONB
  • Manejo de campos array
  • Soporte para tipos compuestos
  • Validación de funciones de ventana
  • Pruebas de aislamiento de transacciones

Pruebas en SQLite

  • Coincidencia de patrones LIKE
  • Validación de la extensión JSON1
  • Emulación de funciones de ventana
  • Optimización DISTINCT
  • Correlación de subconsultas
  • Manejo de afinidad de texto

Ejemplo de caso de prueba

Mira cómo validamos una consulta anidada compleja con filtros de relación

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. Llama a generateSQL() con los args
// 2. Ejecuta el SQL generado directamente
// 3. Ejecuta la consulta Prisma
// 4. Normaliza ambos resultados
// 5. Comprobación de igualdad profunda - falla ante cualquier diferencia
// 6. Mide el tiempo de ejecución

Qué ocurre durante la ejecución de las pruebas

  1. 1Generación de consulta (microsegundos)

    La función generateSQL() parsea los args de Prisma y crea SQL parametrizado. Este paso se mide por separado para cuantificar la sobrecarga de generación de consultas.

  2. 2Ejecución paralela (milisegundos)

    Ambas consultas alcanzan el mismo estado de base de datos simultáneamente usando Promise.all(), garantizando comparación justa y condiciones de datos idénticas.

  3. 3Normalización profunda

    Los resultados pasan por normalización recursiva: BigInt→Number, Decimal→Float(10), Date→null, parseo JSON, ordenación de claves. Esto asegura comparación byte a byte.

  4. 4Igualdad estricta

    Comparación por JSON stringify con tolerancia cero. Cualquier diferencia en número de filas, valores de campos, objetos anidados u orden falla la prueba con un diff detallado.

  5. 5Medición de rendimiento

    Tras la validación, 5-50 iteraciones miden el tiempo medio de ejecución. Los resultados incluyen: Prisma v6, Prisma v7, Prisma v8, Drizzle ORM, SQL generado y sobrecarga de generación de SQL.

Validación multi-versión

Cada prueba con benchmark se ejecuta en Prisma v6, v7 y v8 donde es compatible:

Prisma v6 (6.19.3)

  • Uso directo de PrismaClient
  • Arquitectura legacy del engine
  • Métricas base de rendimiento

Prisma v7 (7.10.0)

  • Arquitectura basada en adapters
  • @prisma/adapter-pg y adapter-better-sqlite3
  • Nuevas optimizaciones del engine

Prisma v8 (8.1.0-dev.1)

  • Cobertura de la versión dev de Prisma v8
  • Arquitectura basada en adapters
  • Paridad de benchmarks en PostgreSQL y SQLite

Informes automáticos de benchmarks

Todos los resultados de benchmarks se generan automáticamente y se guardan como archivos JSON para transparencia total:

Explora la suite completa de pruebas

La suite de validación y los informes de benchmark son open source. Revisa el código de pruebas, los datos de benchmark y las comprobaciones de paridad.