chai 6.2.2

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/chai@6.2.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/chai@6.2.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:c2da6c419af99047f6405c04d47f064ee0a999e9c129b53f79fccc0d71fc6e00","contract":["expect validates type checks, nested properties, array inclusions, and deep equality","expect verifies thrown errors matching type and message","should interface attaches chainable assertions to Object.prototype","chai.use enables custom plugin assertions on Assertion prototype","assert provides classic TDD assertions including strictEqual, deepEqual, and throws","AssertionError is thrown on failed assertions"],"goal":"verify pkg:npm/chai@6.2.2","kind":"HOW","packages":["pkg:npm/chai@6.2.2"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/chai@6.2.2"],"schemaVersion":1,"subject":"pkg:npm/chai@6.2.2","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-chai",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-chai",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "chai": "6.2.2"
      }
    },
    "node_modules/chai": {
      "version": "6.2.2",
      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
      "license": "MIT",
      "engines": {
        "node": ">=18"
      }
    }
  }
}

{
  "name": "sample-chai",
  "version": "1.0.0",
  "description": "Clean-room verification of chai assertions, should interface, and plugin extensions",
  "type": "module",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "chai": "6.2.2"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/chai@6.2.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/chai@6.2.2"
  ]
}

import * as chai from 'chai';

const { expect, assert, AssertionError, use } = chai;

/**
 * Validates object properties and types using chai expect style.
 *
 * @param {Record<string, unknown>} target
 * @param {Record<string, string>} schema
 * @returns {boolean}
 */
export function validateObjectWithExpect(target, schema) {
  expect(target, 'target must be an object').to.be.an('object').that.is.not.null;
  for (const [key, typeStr] of Object.entries(schema)) {
    expect(target, `property ${key} must exist`).to.have.property(key);
    expect(typeof target[key], `property ${key} must have type ${typeStr}`).to.equal(typeStr);
  }
  return true;
}

/**
 * Validates value using chai should style.
 *
 * @param {any} value
 * @returns {boolean}
 */
export function setupAndValidateShould(value) {
  const should = chai.should();
  should.exist(value);
  value.should.be.an('object');
  return true;
}

/**
 * Registers a custom Chai plugin that adds a `.positiveNumber` chainable property.
 *
 * @returns {void}
 */
export function registerPositiveNumberPlugin() {
  use((chaiModule, utils) => {
    utils.addProperty(chaiModule.Assertion.prototype, 'positiveNumber', function () {
      const obj = this._obj;
      this.assert(
        typeof obj === 'number' && obj > 0,
        'expected #{this} to be a positive number',
        'expected #{this} to not be a positive number'
      );
    });
  });
}

/**
 * Performs assertions using chai assert style.
 *
 * @param {unknown} actual
 * @param {unknown} expected
 * @returns {boolean}
 */
export function validateWithAssert(actual, expected) {
  assert.isDefined(actual, 'actual should be defined');
  assert.deepEqual(actual, expected, 'actual and expected must match deeply');
  return true;
}

export { chai, expect, assert, AssertionError, use };

import * as chai from 'chai';
import {
  validateObjectWithExpect,
  setupAndValidateShould,
  registerPositiveNumberPlugin,
  validateWithAssert,
  expect,
  assert,
  AssertionError,
} from '../src/index.js';

async function runContract() {
  // 1. expect validates type checks, nested properties, array inclusions, and deep equality
  expect('sample-text').to.be.a('string').and.to.equal('sample-text');
  expect([1, 2, 3]).to.be.an('array').that.includes(2);
  expect({ a: { b: 42 } }).to.have.nested.property('a.b', 42);
  expect({ x: 1, y: [2, 3] }).to.deep.equal({ x: 1, y: [2, 3] });
  assert.isTrue(
    validateObjectWithExpect({ id: 10, name: 'chai' }, { id: 'number', name: 'string' }),
    'validateObjectWithExpect should pass'
  );

  // 2. expect verifies thrown errors matching type and message
  const throwingFn = () => {
    throw new RangeError('out of bounds index');
  };
  expect(throwingFn).to.throw(RangeError, /bounds/);

  // 3. should interface attaches chainable assertions to Object.prototype
  const should = chai.should();
  should.exist({ active: true });
  ({ status: 200, label: 'ok' }).should.have.property('status').equal(200);
  assert.isTrue(setupAndValidateShould({ ready: true }), 'setupAndValidateShould should pass');

  // 4. chai.use enables custom plugin assertions on Assertion prototype
  registerPositiveNumberPlugin();
  expect(100).to.be.a.positiveNumber;
  let pluginError = null;
  try {
    expect(-5).to.be.a.positiveNumber;
  } catch (err) {
    pluginError = err;
  }
  assert.isNotNull(pluginError, 'custom plugin should reject negative numbers');
  assert.instanceOf(pluginError, AssertionError, 'plugin error should be AssertionError');

  // 5. assert provides classic TDD assertions including strictEqual, deepEqual, and throws
  assert.strictEqual('val', 'val', 'strict equality check');
  assert.isAbove(10, 5, 'number range check');
  assert.isTrue(validateWithAssert({ k: 1 }, { k: 1 }), 'validateWithAssert should pass');
  assert.throws(() => {
    throw new Error('fail');
  }, Error, 'fail');

  // 6. AssertionError is thrown on failed assertions
  let caught = null;
  try {
    expect(1).to.equal(2);
  } catch (err) {
    caught = err;
  }
  assert.isNotNull(caught, 'expect failure must throw');
  assert.instanceOf(caught, AssertionError, 'thrown error must be instance of AssertionError');

  console.log('Contract assertions passed.');
}

runContract().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});