generating-cli-tests
Generate pytest tests for Typer CLI commands. Includes fixtures (temp_storage, sample_data), CliRunner patterns, confirmation handling (y/n/--force), and edge case coverage. Use when user asks to "write tests for", "test my CLI", "add test coverage", or any CLI + test request.
Best use case
generating-cli-tests is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generate pytest tests for Typer CLI commands. Includes fixtures (temp_storage, sample_data), CliRunner patterns, confirmation handling (y/n/--force), and edge case coverage. Use when user asks to "write tests for", "test my CLI", "add test coverage", or any CLI + test request.
Teams using generating-cli-tests should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/generating-cli-tests/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How generating-cli-tests Compares
| Feature / Agent | generating-cli-tests | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Generate pytest tests for Typer CLI commands. Includes fixtures (temp_storage, sample_data), CliRunner patterns, confirmation handling (y/n/--force), and edge case coverage. Use when user asks to "write tests for", "test my CLI", "add test coverage", or any CLI + test request.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Generating CLI Tests
Patterns for generating tests for Typer CLI commands.
## Workflow
1. Identify command type (Create/Read/Update/Delete/Bulk)
2. Ensure fixtures exist in `conftest.py`
3. Write tests using scenarios below
4. Run tests to verify
## Fixtures (conftest.py)
```python
import json
import pytest
from typer.testing import CliRunner
@pytest.fixture
def runner():
"""CLI test runner."""
return CliRunner()
@pytest.fixture
def temp_storage(tmp_path, monkeypatch):
"""Empty storage for testing."""
storage_dir = tmp_path / ".task"
storage_dir.mkdir()
storage_file = storage_dir / "tasks.json"
storage_file.write_text(json.dumps({"version": 1, "tasks": []}))
monkeypatch.setenv("TASK_STORAGE_PATH", str(storage_file))
return storage_file
@pytest.fixture
def sample_data(temp_storage):
"""Pre-populated storage."""
data = {
"version": 1,
"tasks": [
{"title": "First task", "done": False, "priority": "low", "created_at": "2025-01-01T10:00:00", "due_date": None},
{"title": "Second task", "done": True, "priority": "high", "created_at": "2025-01-01T11:00:00", "due_date": None},
]
}
temp_storage.write_text(json.dumps(data))
return data
```
## Test Structure (AAA)
```python
def test_<command>_<scenario>(runner, temp_storage):
# Arrange - via fixtures
# Act
result = runner.invoke(app, ["<command>", "<args>"])
# Assert
assert result.exit_code == 0
assert "<expected>" in result.output
```
## CliRunner Usage
```python
from typer.testing import CliRunner
from task.main import app
runner = CliRunner()
# Basic
result = runner.invoke(app, ["add", "New task"])
# With options
result = runner.invoke(app, ["add", "Task", "--priority", "high"])
# With confirmation
result = runner.invoke(app, ["clear", "1"], input="y\n") # Accept
result = runner.invoke(app, ["clear", "1"], input="n\n") # Decline
# Skip confirmation
result = runner.invoke(app, ["clear", "1", "--force"])
```
## Test Scenarios by Command Type
### Create/Add
```python
class TestAdd:
def test_adds_task(self, runner, temp_storage):
result = runner.invoke(app, ["add", "New task"])
assert result.exit_code == 0
assert "Added" in result.output
def test_with_priority(self, runner, temp_storage):
result = runner.invoke(app, ["add", "Task", "--priority", "high"])
assert result.exit_code == 0
def test_empty_title_shows_error(self, runner, temp_storage):
result = runner.invoke(app, ["add", ""])
assert result.exit_code == 2
```
### Read/List
```python
class TestList:
def test_shows_tasks(self, runner, sample_data):
result = runner.invoke(app, ["list"])
assert result.exit_code == 0
assert "First task" in result.output
def test_empty_state(self, runner, temp_storage):
result = runner.invoke(app, ["list"])
assert "No tasks" in result.output or "empty" in result.output.lower()
def test_with_filter(self, runner, sample_data):
result = runner.invoke(app, ["list", "--done"])
assert result.exit_code == 0
```
### Update/Done
```python
class TestDone:
def test_marks_done(self, runner, sample_data):
result = runner.invoke(app, ["done", "1"])
assert result.exit_code == 0
def test_not_found(self, runner, temp_storage):
result = runner.invoke(app, ["done", "999"])
assert result.exit_code == 1
assert "not found" in result.output.lower()
```
### Delete/Clear
```python
class TestClear:
def test_confirmed(self, runner, sample_data):
result = runner.invoke(app, ["clear", "1"], input="y\n")
assert result.exit_code == 0
assert "Deleted" in result.output
def test_declined(self, runner, sample_data):
result = runner.invoke(app, ["clear", "1"], input="n\n")
assert "Cancelled" in result.output
def test_force(self, runner, sample_data):
result = runner.invoke(app, ["clear", "1", "--force"])
assert result.exit_code == 0
def test_not_found(self, runner, temp_storage):
result = runner.invoke(app, ["clear", "999", "--force"])
assert result.exit_code == 1
```
## Edge Cases to Cover
| Category | Test Cases |
|----------|------------|
| Invalid Input | Empty string, wrong type, out of range |
| Not Found | ID doesn't exist |
| Boundary | Zero, negative, first/last item |
| State | Already done, empty storage |
| Confirmation | Accept (y), decline (n), force flag |
## Checklist
- [ ] Test file: `tests/test_<command>.py`
- [ ] Fixtures in `conftest.py`
- [ ] Uses `CliRunner` from `typer.testing`
- [ ] AAA structure (Arrange, Act, Assert)
- [ ] Tests exit codes: 0, 1, 2
- [ ] Destructive commands: tests y/n and `--force`
- [ ] Output assertions check expected messages
## Running Tests
```bash
uv run pytest # All tests
uv run pytest -v # Verbose
uv run pytest tests/test_add.py # Specific file
```Related Skills
generating-unit-tests
This skill enables Claude to automatically generate comprehensive unit tests from source code. It is triggered when the user requests unit tests, test cases, or test suites for specific files or code snippets. The skill supports multiple testing frameworks including Jest, pytest, JUnit, and others, intelligently detecting the appropriate framework or using one specified by the user. Use this skill when the user asks to "generate tests", "create unit tests", or uses the shortcut "gut" followed by a file path.
generating-test-reports
This skill generates comprehensive test reports with coverage metrics, trends, and stakeholder-friendly formats (HTML, PDF, JSON). It aggregates test results from various frameworks, calculates key metrics (coverage, pass rate, duration), and performs trend analysis. Use this skill when the user requests a test report, coverage analysis, failure analysis, or historical comparisons of test runs. Trigger terms include "test report", "coverage report", "testing trends", "failure analysis", and "historical test data".
generating-test-doubles
This skill uses the test-doubles-generator plugin to automatically create mocks, stubs, spies, and fakes for unit testing. It analyzes dependencies in the code and generates appropriate test doubles based on the chosen testing framework, such as Jest, Sinon, or others. Use this skill when you need to generate test doubles, mocks, stubs, spies, or fakes to isolate units of code during testing. Trigger this skill by requesting test double generation or using the `/gen-doubles` or `/gd` command.
generating-test-data
This skill enables Claude to generate realistic test data for software development. It uses the test-data-generator plugin to create users, products, orders, and custom schemas for comprehensive testing. Use this skill when you need to populate databases, simulate user behavior, or create fixtures for automated tests. Trigger phrases include "generate test data", "create fake users", "populate database", "generate product data", "create test orders", or "generate data based on schema". This skill is especially useful for populating testing environments or creating sample data for demonstrations.
generating-stored-procedures
This skill uses the stored-procedure-generator plugin to create production-ready stored procedures, functions, triggers, and custom database logic. It supports PostgreSQL, MySQL, and SQL Server. Use this skill when the user asks to "generate stored procedure", "create database function", "write a trigger", or needs help with "database logic", "optimizing database performance", or "ensuring transaction safety" in their database. The skill is activated by requests related to database stored procedures, functions, or triggers.
managing-snapshot-tests
This skill enables Claude to manage and update snapshot tests using intelligent diff analysis and selective updates. It is triggered when the user asks to analyze snapshot failures, update snapshots, or manage snapshot tests in general. It helps distinguish intentional changes from regressions, selectively update snapshots, and validate snapshot integrity. Use this when the user mentions "snapshot tests", "update snapshots", "snapshot failures", or requests to run "/snapshot-manager" or "/sm". It supports Jest, Vitest, Playwright, and Storybook frameworks.
running-smoke-tests
This skill runs smoke tests to verify critical application functionality. It executes pre-defined test suites that check system health, authentication, core features, and external integrations. Use this skill after deployments, upgrades, or significant configuration changes to ensure the application is operational. Trigger this skill using the terms "smoke test" or "st".
running-load-tests
Create and execute load tests for performance validation using k6, JMeter, and Artillery. Use when validating application performance under load conditions or identifying bottlenecks. Trigger with phrases like "run load test", "create stress test", or "validate performance under load".
tracking-regression-tests
This skill enables Claude to track and run regression tests, ensuring new changes don't break existing functionality. It is triggered when the user asks to "track regression", "run regression tests", or uses the shortcut "reg". The skill helps in maintaining code stability by identifying critical tests, automating their execution, and analyzing the impact of changes. It also provides insights into test history and identifies flaky tests. The skill uses the `regression-test-tracker` plugin.
generating-orm-code
This skill enables Claude to generate ORM models and database schemas. It is triggered when the user requests the creation of ORM models, database schemas, or wishes to generate code for interacting with databases. The skill supports various ORMs including TypeORM, Prisma, Sequelize, SQLAlchemy, Django ORM, Entity Framework, and Hibernate. Use this skill when the user mentions terms like "ORM model", "database schema", "generate entities", "create migrations", or specifies a particular ORM framework like "TypeORM entities" or "SQLAlchemy models". It facilitates both database-to-code and code-to-database schema generation.
running-mutation-tests
This skill enables Claude to validate test suite quality by performing mutation testing. It is triggered when the user asks to run mutation tests, analyze test effectiveness, or improve test coverage. The skill introduces code mutations, runs tests against the mutated code, and reports on the "survival rate" of the mutations, indicating the effectiveness of the test suite. Use this skill when the user requests to assess the quality of their tests using mutation testing techniques. Specific trigger terms include "mutation testing", "test effectiveness", "mutation score", and "surviving mutants".
running-integration-tests
This skill enables Claude to run and manage integration test suites. It automates environment setup, database seeding, service orchestration, and cleanup. Use this skill when the user asks to "run integration tests", "execute integration tests", or any command that implies running integration tests for a project, including specifying particular test suites or options like code coverage. It is triggered by phrases such as "/run-integration", "/rit", or requests mentioning "integration tests". The plugin handles database creation, migrations, seeding, and dependent service management.