This skill should be used when writing test cases, fixing bugs, analyzing code for potential issues, or improving test coverage for JavaScript/TypeScript applications. Use this for unit tests, integra
Real data. Real impact.
Growing
Developers
Per week
Open source
Skills give you superpowers. Install in 30 seconds.
Apply systematic testing methodologies and debugging techniques to JavaScript/TypeScript applications. This skill provides comprehensive testing strategies, bug analysis frameworks, and automated tools for identifying coverage gaps and untested code.
Write comprehensive tests covering unit, integration, and end-to-end scenarios.
Structure tests using the AAA pattern (Arrange-Act-Assert):
describe('ExpenseCalculator', () => { describe('calculateTotal', () => { test('sums expense amounts correctly', () => { // Arrange const expenses = [ { amount: 100, category: 'food' }, { amount: 50, category: 'transport' }, { amount: 25, category: 'entertainment' } ];// Act const total = calculateTotal(expenses); // Assert expect(total).toBe(175); }); test('handles empty expense list', () => { expect(calculateTotal([])).toBe(0); }); test('handles negative amounts', () => { const expenses = [ { amount: 100, category: 'food' }, { amount: -50, category: 'refund' } ]; expect(calculateTotal(expenses)).toBe(50); });}); });
Key principles:
Test how components work together, including database, API, and service interactions:
describe('ExpenseAPI Integration', () => { beforeAll(async () => { await database.connect(TEST_DB_URL); });afterAll(async () => { await database.disconnect(); });
beforeEach(async () => { await database.clear(); await seedTestData(); });
test('POST /expenses creates expense and updates total', async () => { const response = await request(app) .post('/api/expenses') .send({ amount: 50, category: 'food', description: 'Lunch' }) .expect(201);
expect(response.body).toMatchObject({ id: expect.any(Number), amount: 50, category: 'food' }); // Verify database state const total = await getTotalExpenses(); expect(total).toBe(50);}); });
Test complete user workflows using tools like Playwright or Cypress:
test('user can track expense from start to finish', async ({ page }) => { // Navigate to app await page.goto('/');// Add new expense await page.click('[data-testid="add-expense-btn"]'); await page.fill('[data-testid="amount"]', '50.00'); await page.selectOption('[data-testid="category"]', 'food'); await page.fill('[data-testid="description"]', 'Lunch'); await page.click('[data-testid="submit"]');
// Verify expense appears in list await expect(page.locator('[data-testid="expense-item"]')).toContainText('Lunch'); await expect(page.locator('[data-testid="total"]')).toContainText('$50.00'); });
Apply structured debugging methodology to identify and fix issues.
Reproduction: Reliably reproduce the bug
Isolation: Narrow down the problem
Root Cause Analysis: Determine underlying cause
Fix Implementation: Implement solution
Validation: Ensure completeness
Race Conditions:
// Test concurrent operations test('handles concurrent updates correctly', async () => { const promises = Array.from({ length: 100 }, () => incrementExpenseCount() );await Promise.all(promises); expect(getExpenseCount()).toBe(100); });
Null/Undefined Errors:
// Test null safety test.each([null, undefined, '', 0, false]) ('handles invalid input: %p', (input) => { expect(() => processExpense(input)).toThrow('Invalid expense'); });
Off-by-One Errors:
// Test boundaries explicitly describe('pagination', () => { test('handles empty list', () => { expect(paginate([], 1, 10)).toEqual([]); });test('handles single item', () => { expect(paginate([item], 1, 10)).toEqual([item]); });
test('handles last page with partial items', () => { const items = Array.from({ length: 25 }, (_, i) => i); expect(paginate(items, 3, 10)).toHaveLength(5); }); });
Proactively identify issues before they become bugs.
Test for common security issues:
describe('security', () => { test('prevents SQL injection', async () => { const malicious = "'; DROP TABLE expenses; --"; await expect( searchExpenses(malicious) ).resolves.not.toThrow(); });test('sanitizes XSS in descriptions', () => { const xss = '<script>alert("xss")</script>'; const expense = createExpense({ description: xss }); expect(expense.description).not.toContain('<script>'); });
test('requires authentication for expense operations', async () => { await request(app) .post('/api/expenses') .send({ amount: 50 }) .expect(401); }); });
Test for performance problems:
test('processes large expense list efficiently', () => { const largeList = Array.from({ length: 10000 }, (_, i) => ({ amount: i, category: 'test' }));const start = performance.now(); const total = calculateTotal(largeList); const duration = performance.now() - start;
expect(duration).toBeLessThan(100); // Should complete in <100ms expect(total).toBe(49995000); });
Use parameterized tests to catch edge cases:
test.each([ // [input, expected, description] [[10, 20, 30], 60, 'normal positive values'], [[0, 0, 0], 0, 'all zeros'], [[-10, 20, -5], 5, 'mixed positive and negative'], [[0.1, 0.2], 0.3, 'decimal precision'], [[Number.MAX_SAFE_INTEGER], Number.MAX_SAFE_INTEGER, 'large numbers'], ])('calculateTotal(%p) = %p (%s)', (amounts, expected, description) => { const expenses = amounts.map(amount => ({ amount, category: 'test' })); expect(calculateTotal(expenses)).toBeCloseTo(expected); });
Use automated tools to identify gaps in test coverage.
Run the provided script to identify source files without tests:
python3 scripts/find_untested_code.py src
The script will:
Interpretation:
Run the coverage analysis script after generating coverage:
# Generate coverage (using Jest example) npm test -- --coverageAnalyze coverage gaps
python3 scripts/analyze_coverage.py coverage/coverage-final.json
The script identifies:
Coverage targets:
Ensure tests remain valuable and maintainable.
DRY (Don't Repeat Yourself):
// Extract common setup function createTestExpense(overrides = {}) { return { amount: 50, category: 'food', description: 'Test expense', date: new Date('2024-01-01'), ...overrides }; }test('filters by category', () => { const expenses = [ createTestExpense({ category: 'food' }), createTestExpense({ category: 'transport' }), ]; // ... });
Clear test data:
// Bad: Magic numbers expect(calculateDiscount(100, 0.15)).toBe(85);// Good: Named constants const ORIGINAL_PRICE = 100; const DISCOUNT_RATE = 0.15; const EXPECTED_PRICE = 85; expect(calculateDiscount(ORIGINAL_PRICE, DISCOUNT_RATE)).toBe(EXPECTED_PRICE);
Avoid test interdependence:
// Bad: Tests depend on execution order let sharedState; test('test 1', () => { sharedState = { value: 1 }; }); test('test 2', () => { expect(sharedState.value).toBe(1); // Depends on test 1 });// Good: Independent tests test('test 1', () => { const state = { value: 1 }; expect(state.value).toBe(1); }); test('test 2', () => { const state = { value: 1 }; expect(state.value).toBe(1); });
Follow this decision tree to determine the testing approach:
Adding new functionality?
Fixing a bug?
Improving test coverage?
find_untested_code.pyanalyze_coverage.pyAnalyzing code quality?
Unit/Integration Testing:
E2E Testing:
Coverage:
# Run all tests npm testRun with coverage
npm test -- --coverage
Run specific test file
npm test -- ExpenseCalculator.test.ts
Run in watch mode
npm test -- --watch
Run E2E tests
npm run test:e2e
For detailed patterns and techniques, refer to:
references/testing_patterns.mdreferences/bug_analysis.mdThese references contain extensive examples and advanced techniques. Load them when:
Analyze Jest/Istanbul coverage reports to identify gaps:
python3 scripts/analyze_coverage.py [coverage-file]
Automatically finds common coverage file locations if not specified.
Output:
Find source files without corresponding test files:
python3 scripts/find_untested_code.py [src-dir] [--pattern test|spec]
Output:
No automatic installation available. Please visit the source repository for installation instructions.
View Installation Instructions
1,500+ AI skills, agents & workflows. Install in 30 seconds. Part of the Torly.ai family.
© 2026 Torly.ai. All rights reserved.