node-parity-test

Generate and execute paired tests comparing Node.js runtime behavior against system-under-test.

3|2|Updated May 12, 2026
One-click install
npx skills add https://github.com/kriscendobot/garden --skill node-parity-test
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: node-parity-test
Source: https://github.com/kriscendobot/garden/tree/main/skills/node-parity-test
Command: npx skills add https://github.com/kriscendobot/garden --skill node-parity-test

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill eliminates ambiguity in code behavior by replacing prose claims like "matches Node.js" with verifiable, programmatic parity tests that ensure your implementation and Node.js produce identical results.

Core Features & Use Cases

  • Parity Verification: Automatically validates that Node-adjacent code paths (loaders, linkers, resolvers) behave exactly like the Node.js runtime.
  • Regression Guarding: Prevents regressions by pinning both convergence (identical behavior) and divergence (intentional differences) cases in code.
  • Use Case: When implementing a custom module loader, use this skill to create a parity pair that runs the same fixture under your loader and plain Node.js, ensuring consistent behavior across both environments.

Quick Start

Use the node-parity-test skill to generate a parity test pair for the new module resolver implementation in the current package.

Frequently Asked Questions about node-parity-test

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I verify that a custom Node.js module loader matches native runtime behavior?

Node.js parity testing verifies custom module loaders by generating paired tests that execute shared fixtures under both your implementation and the native runtime to ensure behavioral convergence. It programmatically compares execution results to eliminate ambiguity in code behavior.

What is a parity test pair for Node-adjacent code paths?

A parity test pair is a programmatic test structure that runs identical fixtures across a custom Node.js environment and the native runtime. It validates that module linkers, loaders, and resolvers produce identical results, replacing prose claims with verifiable assertions.

Can I pin intentional behavioral divergences in my Node.js module resolver tests?

Yes, Node.js parity testing supports regression guarding by pinning both convergence and divergence cases in code. This captures intentional differences between your custom resolver and the native runtime, preventing accidental changes to expected behavioral mismatches.

Do I need shared fixtures and assertion modules to run Node.js parity tests?

Yes, Node.js parity testing requires shared fixtures and assertion modules to programmatically verify convergence or divergence across environments. These dependencies provide the baseline inputs and validation logic needed to compare your implementation against native runtime execution.

What's the best way to prevent regressions in custom Node.js module linkers?

Automated parity testing prevents regressions in custom Node.js module linkers by executing paired tests against the native runtime. It pins expected behaviors in code, ensuring that subsequent changes maintain consistent behavior across both environments.

When should I use parity tests instead of standard unit tests for Node.js loaders?

Use parity tests for Node.js loaders when you need to substantiate claims of matching native runtime behavior. Unlike standard unit tests, parity tests dynamically compare your code path execution against actual Node.js runtime execution using shared fixtures to verify exact convergence.