Chai

Chai is an assertion library that plugs into any JavaScript test framework (Mocha, Jest, Vitest, and others) to provide readable, chainable assertions. Rather than locking you into one syntax, it ships three interchangeable styles — assert (classic TDD-style calls), expect, and should (both BDD-style chains) — so teams can pick whichever reads most naturally for their codebase.

Beyond the built-in assertions, Chai’s plugin architecture lets the community extend it with domain-specific matchers (chai-as-promised, sinon-chai, chai-http, and dozens more), which combined with its long track record and huge install base has made it a default assertion layer across the Node.js testing ecosystem.

What You Get

• Three assertion styles — assert, expect, should — importable individually or registered globally via chai/register-*
• A large built-in assertion vocabulary covering equality, type checks, object shape, array/collection membership, and more
• A documented plugin API for building custom matchers, with an ecosystem of existing plugins (chai-as-promised, sinon-chai, chai-http)
• Framework-agnostic design that works the same whether paired with Mocha, Jest, Vitest, or any other test runner
• Both Node.js and browser support from the same package, usable directly via a <script type="module"> tag
• A stable, decade-plus track record as one of the most widely depended-on assertion libraries in the npm ecosystem

Common Use Cases

• Writing expressive test assertions (expect(value).to.equal(x)) in a Mocha, Jest, or Vitest test suite
• Migrating a codebase between assertion styles (assert → expect → should) without changing test runners
• Extending assertions with a domain-specific plugin, such as asserting on HTTP responses (chai-http) or promise resolution (chai-as-promised)
• Sharing one assertion library across a monorepo’s Node.js backend tests and browser-run frontend tests

Under The Hood

Architecture - Chai’s lib/chai directory implements the three assertion styles (assert.js, interface/expect.js, interface/should.js) as thin adapters over a shared Assertion core (lib/chai/assertion.js) that holds the actual comparison logic and chainable-method registration (lib/chai/utils), so all three styles share one underlying implementation and stay behaviorally consistent. A separate plugin registration system (use()) lets third-party packages extend the Assertion prototype and the interfaces without modifying chai’s core, which is what enables the large external plugin ecosystem.

Tech Stack - Chai is published as a pure ESM package ("type": "module") with no required runtime dependencies for its core assertions (deep-equality and inspection are delegated to small companion packages from the chaijs org: deep-eql, loupe, check-error, pathval), keeping the dependency footprint minimal for a library this widely installed. Tests run via its own suite in test/ covering each interface style plus plugin registration and configuration behavior, executed with web-test-runner for browser-environment coverage alongside Node.js testing.

Code Quality - The separation between assertion styles and the shared Assertion core keeps the three interfaces from drifting out of sync, and companion packages (deep-eql, loupe) are maintained as focused single-purpose modules rather than being reimplemented inline. Test coverage is broad, spanning assert.js, expect.js, should.js, configuration.js, and plugins.js as separate suites, reflecting the maturity expected of a decade-old, extremely widely-used testing dependency. History.md and ReleaseNotes.md document a long, actively maintained release history rather than sporadic version bumps.

API Design - The three interchangeable styles (assert.equal(a, b), expect(a).to.equal(b), a.should.equal(b)) are chai’s signature ergonomic choice, letting teams pick the phrasing that reads best for their codebase without giving up any assertion coverage. The BDD styles (expect/should) use natural-language chaining (.to.be.an('array').that.includes(x)) that reads close to plain English, which is a major reason chai remains a common pairing with Mocha even though most modern test runners now ship their own basic assertions.