jest-testing

mcclowes's avatarfrom mcclowes

Use when writing Jest tests - covers testing patterns for interpreters, parsers, and async code

⭐3stars🔀0forks📁View on GitHub🕐Updated Jan 1, 2026⬇️1downloads
[Testing and QA]

When & Why to Use This Skill

This Claude skill provides a comprehensive framework for writing high-quality Jest tests, specifically optimized for complex scenarios such as interpreters, parsers, and asynchronous code. It empowers developers to implement robust testing suites using industry best practices like the Arrange-Act-Assert pattern, ensuring high code reliability and maintainable software architecture.

Use Cases

  • Testing Interpreters and Parsers: Implementing structured test cases for validating expression evaluation, syntax parsing, and Abstract Syntax Tree (AST) consistency.
  • Asynchronous Code Validation: Writing reliable tests for async/await operations and promises to prevent race conditions and ensure correct execution flow.
  • Standardizing Test Suites: Applying core principles like Arrange-Act-Assert and descriptive naming conventions to improve the readability and maintainability of unit tests.
  • Snapshot Testing: Utilizing automated snapshots to ensure consistent output for code formatters and complex data structures over time.
namejest-testing
descriptionUse when writing Jest tests - covers testing patterns for interpreters, parsers, and async code

Jest Testing Best Practices

Quick Start

import { run } from "../src/api";

describe("interpreter", () => {
  it("evaluates arithmetic expressions", () => {
    expect(run("2 + 3")).toBe(5);
  });

  it("handles errors gracefully", () => {
    expect(() => run("undefined_var")).toThrow(/undefined/i);
  });
});

Core Principles

  • Arrange-Act-Assert: Structure tests clearly
  • One assertion focus: Test one behavior per test
  • Descriptive names: Use "should" or behavior-based naming
  • Isolation: Tests should not depend on each other

Testing Patterns

Interpreter Tests

describe("builtins", () => {
  describe("map", () => {
    it("transforms each element", () => {
      const code = `[1, 2, 3] /> map((x) -> x * 2)`;
      expect(run(code)).toEqual([2, 4, 6]);
    });

    it("passes index as second argument", () => {
      const code = `["a", "b"] /> map((x, i) -> i)`;
      expect(run(code)).toEqual([0, 1]);
    });
  });
});

Parser Tests

describe("parser", () => {
  it("parses pipe expressions", () => {
    const ast = parse("x /> fn");
    expect(ast.body[0]).toMatchObject({
      type: "ExprStmt",
      expression: {
        type: "PipeExpr",
        left: { type: "Identifier", name: "x" },
        right: { type: "Identifier", name: "fn" }
      }
    });
  });
});

Async Tests

it("resolves async operations", async () => {
  const result = await run(`
    let fetch = () -> delay(10) /> then(() -> "done") #async
    await fetch()
  `);
  expect(result).toBe("done");
});

Snapshot Tests

it("formats code consistently", () => {
  const formatted = format("let x=1+2");
  expect(formatted).toMatchSnapshot();
});

Configuration

// jest.config.js
module.exports = {
  preset: "ts-jest",
  testEnvironment: "node",
  testMatch: ["**/__tests__/**/*.test.ts"],
  collectCoverageFrom: ["src/**/*.ts", "!src/**/*.d.ts"],
};

Reference Files