home / skills / openclaw / skills / test-writer

test-writer skill

/skills/lxgicstudios/test-writer

This skill generates real unit tests from your source files with framework support, providing actionable assertions and fast test coverage.

npx playbooks add skill openclaw/skills --skill test-writer

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
2.8 KB
---
name: test-writer
description: Generate unit tests from source files. Use when you need test coverage fast.
---

# Test Writer

You know that feeling when you finish building something and realize you haven't written a single test? Yeah. This tool takes your source files and generates real unit tests. Pick your framework, point it at your code, and get tests that actually cover your functions. Not placeholder garbage, real assertions based on what your code does.

**One command. Zero config. Just works.**

## Quick Start

```bash
npx ai-test-gen src/utils.ts
```

## What It Does

- Reads your source files and understands the function signatures and logic
- Generates unit tests with real assertions, not just empty describe blocks
- Supports Jest, Vitest, and Mocha out of the box
- Accepts glob patterns so you can test multiple files at once
- Writes output to a file or prints to stdout

## Usage Examples

```bash
# Generate Jest tests for a single file
npx ai-test-gen src/utils.ts

# Generate Vitest tests and save to a file
npx ai-test-gen src/helpers.ts --framework vitest -o tests/helpers.test.ts

# Test multiple files with a glob
npx ai-test-gen "src/**/*.ts" --framework mocha
```

## Best Practices

- **Start with utility functions** - Pure functions with clear inputs and outputs get the best generated tests. Start there, then move to more complex code.
- **Pick the right framework** - Use --framework to match what your project already uses. Mixing test frameworks is a headache nobody needs.
- **Review edge cases** - The generated tests cover the happy path well. Add your own edge cases for null inputs, empty arrays, and boundary conditions.
- **Use it as a starting point** - Generated tests are a great foundation. Tweak them to match your team's testing style.

## When to Use This

- You're adding tests to a project that has none
- You just wrote a bunch of utility functions and need coverage
- You want a starting point for tests instead of writing boilerplate from scratch
- Code review requires tests and you're short on time

## How It Works

The tool reads your source files and analyzes function signatures, types, and logic flow. It sends that context to an AI model that generates test cases with meaningful assertions. You pick the framework and it formats everything to match.

## Requirements

No install needed. Just run with npx. Node.js 18+ recommended.

```bash
npx ai-test-gen --help
```

## Part of the LXGIC Dev Toolkit

This is one of 110+ free developer tools built by LXGIC Studios. No paywalls, no sign-ups, no API keys on free tiers. Just tools that work.

**Find more:**
- GitHub: https://github.com/LXGIC-Studios
- Twitter: https://x.com/lxgicstudios
- Substack: https://lxgicstudios.substack.com
- Website: https://lxgic.dev

## License

MIT. Free forever. Use it however you want.

Overview

This skill generates unit tests from your source files so you get test coverage fast. It produces real assertions tailored to the code, supports multiple frameworks, and requires no configuration. Use it to bootstrap test suites or quickly add coverage to new code.

How this skill works

The tool parses your source files to extract function signatures, types, and control flow. It then uses an AI-based generator to produce concrete test cases with meaningful assertions formatted for the chosen framework (Jest, Vitest, or Mocha). You can target single files or globs, and output goes to stdout or to a test file.

When to use it

  • Adding tests to a codebase that currently has little or no coverage
  • Rapidly creating tests for utility and pure functions after development
  • Generating a starting test suite to satisfy code review or CI requirements
  • Bootstrapping tests across many files using glob patterns
  • When you need tests quickly and prefer to review and refine generated cases

Best practices

  • Start with pure utility functions — they yield the best automated tests
  • Match the framework to your project using the --framework option
  • Treat generated tests as a foundation: review and add edge-case assertions
  • Save output to a test file and integrate it into your existing test structure
  • Run generated tests locally before committing and refine for team style

Example use cases

  • Generate Jest tests for a single helper file to add immediate coverage
  • Produce Vitest test files for a new TypeScript utilities folder
  • Run against a glob to create tests for many modules at once
  • Create test scaffolding quickly when a reviewer requests unit tests
  • Seed a test suite for legacy functions to accelerate refactoring

FAQ

Which testing frameworks are supported?

Jest, Vitest, and Mocha are supported out of the box; choose one with --framework.

Do I need to configure anything?

No configuration is required. One command can generate tests, though you should review outputs and adjust for edge cases.