Configure Tests

/configure:tests

Check and configure testing frameworks against best practices (Vitest, Jest, pytest, cargo-nextest).

When to Use This Skill

Context

• Package.json: !find . -maxdepth 1 -name \'package.json\'
• Pyproject.toml: !find . -maxdepth 1 -name \'pyproject.toml\'
• Cargo.toml: !find . -maxdepth 1 -name \'Cargo.toml\'
• Test config files: !find . -maxdepth 1 \( -name 'vitest.config.*' -o -name 'jest.config.*' -o -name 'pytest.ini' -o -name '.nextest.toml' \)
• Pytest in pyproject: !grep -c 'tool.pytest' pyproject.toml
• Test directories: !find . -maxdepth 2 -type d \( -name 'tests' -o -name '__tests__' -o -name 'test' \)
• Test scripts in package.json: !grep -m5 -o '"test[^"]*"' package.json
• Coverage config: !grep -l 'coverage' vitest.config.* jest.config.*
• Project standards: !find . -maxdepth 1 -name '.project-standards.yaml' -type f

Modern testing stack preferences:

• JavaScript/TypeScript: Vitest (preferred) or Jest
• Python: pytest with pytest-cov
• Rust: cargo-nextest for improved performance

Parameters

Parse these from $ARGUMENTS:

Version Checking

CRITICAL: Before flagging outdated versions, verify latest releases:

1. Vitest: Check vitest.dev or GitHub releases 2. Jest: Check jestjs.io or npm 3. pytest: Check pytest.org or PyPI 4. cargo-nextest: Check nexte.st or GitHub releases

Use WebSearch or WebFetch to verify current versions before reporting outdated frameworks.

Execution

Execute this testing framework compliance check:

Step 1: Detect framework

Identify the project language and existing test framework:

If --framework flag is provided, use that value instead.

Step 2: Analyze current state

Read the detected framework's configuration and check completeness. For each framework, verify:

Vitest:

• Config file exists (vitest.config.ts or .js)
• globals: true configured for compatibility
• environment set appropriately (jsdom, happy-dom, node)
• Coverage configured with @vitest/coverage-v8 or @vitest/coverage-istanbul
• Watch mode exclusions configured

Jest:

• Config file exists (jest.config.js or .ts)
• testEnvironment configured
• Coverage configuration present
• Transform configured for TypeScript/JSX
• Module path aliases configured

pytest:

• pyproject.toml has [tool.pytest.ini_options] section
• testpaths configured
• addopts includes useful flags (-v, --strict-markers)
• markers defined for test categorization
• pytest-cov installed

cargo-nextest:

• .nextest.toml exists
• Profile configurations (default, ci)
• Retry policy configured
• Test groups defined if needed

Step 3: Report results

Print a compliance report with:

• Detected framework and version
• Configuration check results for each item
• Test organization (unit/integration/e2e directories)
• Package scripts status (test, test:watch, test:coverage)
• Overall issue count and recommendations

If --check-only, stop here.

Step 4: Apply fixes (if --fix or user confirms)

Install dependencies and create configuration using templates from REFERENCE.md:

1. Missing config: Create framework config file from template 2. Missing dependencies: Install required packages 3. Missing coverage: Add coverage configuration with 80% threshold 4. Missing scripts: Add test scripts to package.json 5. Missing test directories: Create standard test directory structure

Step 5: Set up test organization

Create standard test directory structure for the detected language. See directory structure patterns in REFERENCE.md.

Step 6: Configure CI/CD integration

Check for test commands in GitHub Actions workflows. If missing, add CI test commands using the CI templates from REFERENCE.md.

Step 7: Handle migration (if upgrading)

If migrating between frameworks (e.g., Jest to Vitest, unittest to pytest), follow the migration guide in REFERENCE.md.

Step 8: Update standards tracking

Update .project-standards.yaml:

standards_version: "2025.1"
last_configured: "<timestamp>"
components:
  tests: "2025.1"
  tests_framework: "<vitest|jest|pytest|nextest>"
  tests_coverage_threshold: 80
  tests_ci_integrated: true

For detailed configuration templates, migration guides, CI/CD integration examples, and directory structure patterns, see REFERENCE.md.

Agentic Optimizations

Error Handling

• No package.json found: Cannot configure JS/TS tests, skip or error
• Conflicting frameworks: Warn about multiple test configs, require manual resolution
• Missing dependencies: Offer to install required packages
• Invalid config syntax: Report parse error, offer to replace with template

See Also

• /configure:coverage - Configure coverage thresholds and reporting
• /configure:all - Run all compliance checks
• /test:run - Universal test runner
• /test:setup - Comprehensive testing infrastructure setup
• Vitest documentation: https://vitest.dev
• pytest documentation: https://docs.pytest.org
• cargo-nextest documentation: https://nexte.st

Testing Configuration Reference

Report Template

Testing Framework Compliance Report
====================================
Project: [name]
Language: [TypeScript | Python | Rust]
Framework: [Vitest 2.x | pytest 8.x | cargo-nextest 0.9.x]

Configuration:
  Config file             <file>                     EXISTS/MISSING
  Test directory          <dir>                      EXISTS/NON-STANDARD
  Coverage provider       <provider>                 CONFIGURED/MISSING
  Environment             <env>                      CONFIGURED/NOT SET
  Watch exclusions        <patterns>                 CONFIGURED/INCOMPLETE

Test Organization:
  Unit tests              <pattern>                  FOUND/NONE
  Integration tests       <dir>                      FOUND/N/A
  E2E tests               <dir>                      FOUND/N/A

Scripts:
  test command            package.json scripts       CONFIGURED/MISSING
  test:watch              package.json scripts       CONFIGURED/MISSING
  test:coverage           package.json scripts       CONFIGURED/MISSING

Overall: [X issues found]

Recommendations:
  - <recommendation>

Vitest Configuration

Install Dependencies

npm install --save-dev vitest @vitest/ui @vitest/coverage-v8
# or
bun add --dev vitest @vitest/ui @vitest/coverage-v8

vitest.config.ts Template

import { defineConfig } from 'vitest/config';
import { resolve } from 'path';

export default defineConfig({
  test: {
    // Enable globals for compatibility with Jest-style tests
    globals: true,

    // Test environment (jsdom for DOM testing, node for backend)
    environment: 'jsdom', // or 'node', 'happy-dom'

    // Setup files to run before tests
    setupFiles: ['./tests/setup.ts'],

    // Coverage configuration
    coverage: {
      provider: 'v8', // or 'istanbul'
      reporter: ['text', 'json', 'html', 'lcov'],
      exclude: [
        'node_modules/',
        'dist/',
        'tests/',
        '**/*.config.*',
        '**/*.d.ts',
      ],
      thresholds: {
        lines: 80,
        functions: 80,
        branches: 80,
        statements: 80,
      },
    },

    // Watch mode exclusions
    watchExclude: ['**/node_modules/**', '**/dist/**', '**/.next/**'],

    // Test timeout
    testTimeout: 10000,

    // Include/exclude patterns
    include: ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
    exclude: ['node_modules', 'dist', '.next', 'out'],
  },

  // Resolve aliases (if using path aliases)
  resolve: {
    alias: {
      '@': resolve(__dirname, './src'),
    },
  },
});

Package.json Scripts

{
  "scripts": {
    "test": "vitest run",
    "test:watch": "vitest",
    "test:ui": "vitest --ui",
    "test:coverage": "vitest run --coverage",
    "test:ci": "vitest run --coverage --reporter=junit --reporter=default"
  }
}

Jest Configuration

jest.config.ts Template

import type { Config } from 'jest';

const config: Config = {
  preset: 'ts-jest',
  testEnvironment: 'jsdom',
  roots: ['<rootDir>/src', '<rootDir>/tests'],
  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],

  transform: {
    '^.+\\.tsx?$': ['ts-jest', {
      tsconfig: 'tsconfig.json',
    }],
  },

  collectCoverageFrom: [
    'src/**/*.{js,jsx,ts,tsx}',
    '!src/**/*.d.ts',
    '!src/**/*.stories.tsx',
  ],

  coverageThresholds: {
    global: {
      lines: 80,
      functions: 80,
      branches: 80,
      statements: 80,
    },
  },

  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },

  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
};

export default config;

Python pytest Configuration

pyproject.toml Template

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py", "*_test.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]

addopts = [
    "-v",
    "--strict-markers",
    "--strict-config",
    "--cov=src",
    "--cov-report=term-missing",
    "--cov-report=html",
    "--cov-report=xml",
    "--cov-fail-under=80",
]

markers = [
    "unit: Unit tests",
    "integration: Integration tests",
    "e2e: End-to-end tests",
    "slow: Slow running tests",
]

[tool.coverage.run]
source = ["src"]
omit = [
    "*/tests/*",
    "*/migrations/*",
    "*/__init__.py",
]

[tool.coverage.report]
exclude_lines = [
    "pragma: no cover",
    "def __repr__",
    "if __name__ == .__main__.:",
    "raise AssertionError",
    "raise NotImplementedError",
    "if 0:",
    "if False:",
    "if TYPE_CHECKING:",
]

Install Dependencies

uv add --group dev pytest pytest-cov pytest-asyncio pytest-mock

Rust cargo-nextest Configuration

Install

cargo install cargo-nextest --locked

.nextest.toml Template

[profile.default]
retries = 0
fail-fast = false

# Run tests with all features enabled
test-threads = "num-cpus"

[profile.ci]
retries = 2
fail-fast = true
test-threads = 2

# JUnit output for CI
[profile.ci.junit]
path = "target/nextest/ci/junit.xml"

[profile.default.junit]
path = "target/nextest/default/junit.xml"

Optional cargo alias (.cargo/config.toml)

[alias]
test = "nextest run"

Test Directory Structures

JavaScript/TypeScript

tests/
├── setup.ts              # Test setup and global mocks
├── unit/                 # Unit tests
│   └── utils.test.ts
├── integration/          # Integration tests
│   └── api.test.ts
└── e2e/                  # E2E tests
    └── user-flow.test.ts

Python

tests/
├── conftest.py           # pytest fixtures and configuration
├── unit/                 # Unit tests
│   └── test_utils.py
├── integration/          # Integration tests
│   └── test_api.py
└── e2e/                  # E2E tests
    └── test_user_flow.py

Rust

tests/
├── integration_test.rs   # Integration tests
└── common/               # Shared test utilities
    └── mod.rs

CI/CD Integration Templates

JavaScript/TypeScript (Vitest)

- name: Run tests
  run: npm test -- --reporter=junit --reporter=default --coverage

- name: Upload coverage
  uses: codecov/codecov-action@v5
  with:
    files: ./coverage/lcov.info

Python (pytest)

- name: Run tests
  run: |
    uv run pytest --junitxml=junit.xml --cov-report=xml

- name: Upload coverage
  uses: codecov/codecov-action@v5
  with:
    files: ./coverage.xml

Rust (cargo-nextest)

- name: Install nextest
  uses: taiki-e/install-action@nextest

- name: Run tests
  run: cargo nextest run --profile ci --no-fail-fast

- name: Upload test results
  uses: actions/upload-artifact@v7
  with:
    name: test-results
    path: target/nextest/ci/junit.xml

Migration Guides

Jest to Vitest

1. Update dependencies:

   npm uninstall jest @types/jest
   npm install --save-dev vitest @vitest/ui @vitest/coverage-v8

2. Rename config file:

   mv jest.config.ts vitest.config.ts

3. Update test imports:

   // Before (Jest)
   import { describe, it, expect } from '@jest/globals';

   // After (Vitest with globals)
   // No import needed if globals: true in config

4. Update package.json scripts:

   {
     "scripts": {
       "test": "vitest run",
       "test:watch": "vitest"
     }
   }

unittest to pytest (Python)

1. Install pytest:

   uv add --group dev pytest pytest-cov

2. Convert test files:

   # Before (unittest)
   import unittest
   class TestExample(unittest.TestCase):
       def test_something(self):
           self.assertEqual(1, 1)

   # After (pytest)
   def test_something():
       assert 1 == 1

3. Convert assertions:

• self.assertEqual(a, b) -> assert a == b
• self.assertTrue(x) -> assert x
• self.assertRaises(Error) -> with pytest.raises(Error):