🧪 Quality Assurance

Testing Methodology

137 end-to-end tests validate every generated SQL query matches Prisma's output exactly

137
E2E Tests
Every query validated
100%
Parity Coverage
Byte-for-byte match
2
Database Engines
PostgreSQL & SQLite
3
ORM Benchmarks
Prisma v6/v7, Drizzle

ہم correctness کیسے validate کرتے ہیں

Generated SQL کے نتائج Prisma کے بالکل برابر ہوں — اس کے لیے ہر test ایک سخت 5-step process فالو کرتا ہے

1

Prisma Query سے SQL Generate کریں

Prisma query arguments parse کریں اور انہی models اور schema کے ساتھ equivalent SQL generate کریں۔ Generated SQL security اور performance کے لیے parameterized queries استعمال کرتا ہے۔

2

دونوں Queries Parallel میں Execute کریں

Generated SQL کو postgres.js یا better-sqlite3 سے direct چلائیں اور وہی query Prisma کے ذریعے execute کریں۔ دونوں ایک ہی database state کو hit کرتے ہیں۔

3

Results Normalize کریں

Type differences (BigInt vs Number, Decimal precision, Date serialization) handle کریں اور fair comparison کے لیے object key ordering normalize کریں۔

4

Deep Equality Check

نتائج بالکل یکساں ہونے چاہئیں: row count، field values، nested relations، ordering۔ کوئی mismatch ہو تو test fail۔

5

Performance Benchmark

5 warmup runs کے بعد ہر test پر 10–50 iterations کا average لیں۔ Prisma v6، Prisma v7 اور Drizzle ORM کے ساتھ compare کریں۔

Advanced Validation Techniques

Data Type Normalization

  • • 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

Performance Benchmarking

  • • 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

Comprehensive Test Coverage

Tests cover every Prisma read operation across multiple complexity levels

Query Operations

  • 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

Complex Scenarios

  • Nested includes (4 levels deep)
  • Relation filters (some/every/none)
  • Distinct with window functions
  • Cursor pagination
  • Select + include combined
  • Relation counts (_count)

Filter Types

  • Comparison (lt/lte/gt/gte)
  • Logical (AND/OR/NOT)
  • String ops (contains/startsWith)
  • NULL checks (is/isNot)
  • IN/NOT IN arrays
  • Case sensitivity modes

PostgreSQL Testing

  • ✓ ILIKE case-insensitive searches
  • ✓ JSON/JSONB operations
  • ✓ Array field handling
  • ✓ Composite type support
  • ✓ Window function validation
  • ✓ Transaction isolation testing

SQLite Testing

  • ✓ LIKE pattern matching
  • ✓ JSON1 extension validation
  • ✓ Window function emulation
  • ✓ DISTINCT optimization
  • ✓ Subquery correlation
  • ✓ Text affinity handling

Example Test Case

دیکھیں ہم relation filters کے ساتھ ایک complex nested query کو کیسے validate کرتے ہیں

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 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 time

Test execution کے دوران کیا ہوتا ہے

1. Query Generation (Microseconds)

generateSQL() Prisma args parse کر کے parameterized SQL بناتا ہے۔ یہ step الگ benchmark ہوتی ہے تاکہ query generation overhead ناپا جا سکے۔

2. Parallel Execution (Milliseconds)

دونوں queries Promise.all() کے ذریعے ایک ساتھ اسی database state کو hit کرتی ہیں، fair comparison اور identical conditions کے لیے۔

3. Deep Normalization

Results recursive normalization سے گزرتے ہیں: BigInt→Number, Decimal→Float(10), Date→null, JSON parse, key sorting۔ یہ byte-for-byte accuracy یقینی بناتا ہے۔

4. Strict Equality

JSON stringify comparison with zero tolerance۔ row count، field values، nested objects یا ordering میں کوئی فرق ہو تو detailed diff کے ساتھ fail۔

5. Performance Measurement

Validation کے بعد 5–50 iterations میں average execution time مانی جاتی ہے۔ نتائج میں Prisma v6، Prisma v7، Drizzle ORM، Generated SQL اور SQL generation overhead شامل ہیں۔

Multi-Version Validation

ہر test Prisma v6 اور v7 دونوں کے خلاف چلتا ہے تاکہ versions کے درمیان compatibility یقینی ہو:

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

Automated Benchmark Reports

تمام benchmark results خودکار طور پر generate ہو کر JSON files میں محفوظ ہوتے ہیں مکمل transparency کے لیے:

benchmark-results/v6-postgres-latest.json
benchmark-results/v7-postgres-latest.json
benchmark-results/v6-sqlite-latest.json
benchmark-results/v7-sqlite-latest.json

ہر file میں: test name, Prisma execution time, generated SQL time, Drizzle time, speedup ratios, اور ISO timestamp شامل ہیں۔

Full Test Suite دیکھیں

تمام 137 tests open source ہیں۔ Test code، benchmarks اور validation logic review کریں۔

View Test Suite → See Benchmarks