# Send Test Specialist to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "test-specialist",
    "name": "Test Specialist",
    "source": "tencent",
    "type": "skill",
    "category": "开发工具",
    "sourceUrl": "https://clawhub.ai/Veeramanikandanr48/test-specialist",
    "canonicalUrl": "https://clawhub.ai/Veeramanikandanr48/test-specialist",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/test-specialist",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=test-specialist",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "SKILL.md",
      "index.js",
      "package.json",
      "references/bug_analysis.md",
      "references/testing_patterns.md",
      "scripts/analyze_coverage.py"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "test-specialist",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-05-09T22:44:44.108Z",
      "expiresAt": "2026-05-16T22:44:44.108Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=test-specialist",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=test-specialist",
        "contentDisposition": "attachment; filename=\"test-specialist-0.1.0.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "test-specialist"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/test-specialist"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/test-specialist",
    "downloadUrl": "https://openagent3.xyz/downloads/test-specialist",
    "agentUrl": "https://openagent3.xyz/skills/test-specialist/agent",
    "manifestUrl": "https://openagent3.xyz/skills/test-specialist/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/test-specialist/agent.md"
  }
}
```
## Documentation

### Overview

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.

### 1. Writing Test Cases

Write comprehensive tests covering unit, integration, and end-to-end scenarios.

Unit Testing Approach

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 one behavior per test
Cover happy path, edge cases, and error conditions
Use descriptive test names that explain the scenario
Keep tests independent and isolated

Integration Testing Approach

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);
  });
});

End-to-End Testing Approach

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');
});

### 2. Systematic Bug Analysis

Apply structured debugging methodology to identify and fix issues.

Five-Step Analysis Process

Reproduction: Reliably reproduce the bug

Document exact steps to trigger
Identify required environment/state
Note expected vs actual behavior



Isolation: Narrow down the problem

Binary search through code path
Create minimal reproduction case
Remove unrelated dependencies



Root Cause Analysis: Determine underlying cause

Trace execution flow
Check assumptions and preconditions
Review recent changes (git blame)



Fix Implementation: Implement solution

Write failing test first (TDD)
Implement the fix
Verify test passes



Validation: Ensure completeness

Run full test suite
Test edge cases
Verify no regressions

Common Bug Patterns

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);
  });
});

### 3. Identifying Potential Issues

Proactively identify issues before they become bugs.

Security Vulnerabilities

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);
  });
});

Performance Issues

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);
});

Logic Errors

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);
});

### 4. Test Coverage Analysis

Use automated tools to identify gaps in test coverage.

Finding Untested Code

Run the provided script to identify source files without tests:

python3 scripts/find_untested_code.py src

The script will:

Scan source directory for all code files
Identify which files lack corresponding test files
Categorize untested files by type (components, services, utils, etc.)
Prioritize files that need testing most

Interpretation:

API/Services: High priority - test business logic and data operations
Models: High priority - test data validation and transformations
Hooks: Medium priority - test stateful behavior
Components: Medium priority - test complex UI logic
Utils: Low priority - test as needed for complex functions

Analyzing Coverage Reports

Run the coverage analysis script after generating coverage:

# Generate coverage (using Jest example)
npm test -- --coverage

# Analyze coverage gaps
python3 scripts/analyze_coverage.py coverage/coverage-final.json

The script identifies:

Files below coverage threshold (default 80%)
Statement, branch, and function coverage percentages
Priority files to improve

Coverage targets:

Critical paths: 90%+ coverage
Business logic: 85%+ coverage
UI components: 75%+ coverage
Utilities: 70%+ coverage

### 5. Test Maintenance and Quality

Ensure tests remain valuable and maintainable.

Test Code Quality Principles

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);
});

### Workflow Decision Tree

Follow this decision tree to determine the testing approach:

Adding new functionality?

Yes → Write tests first (TDD)

Write failing test
Implement feature
Verify test passes
Refactor


No → Go to step 2



Fixing a bug?

Yes → Apply bug analysis process

Reproduce the bug
Write failing test demonstrating bug
Fix the implementation
Verify test passes


No → Go to step 3



Improving test coverage?

Yes → Use coverage tools

Run find_untested_code.py to identify gaps
Run analyze_coverage.py on coverage reports
Prioritize critical paths
Write tests for untested code


No → Go to step 4



Analyzing code quality?

Yes → Systematic review

Check for security vulnerabilities
Test edge cases and error handling
Verify performance characteristics
Review error handling

### Recommended Stack

Unit/Integration Testing:

Jest or Vitest for test runner
Testing Library for React components
Supertest for API testing
MSW (Mock Service Worker) for API mocking

E2E Testing:

Playwright or Cypress
Page Object Model pattern

Coverage:

Istanbul (built into Jest/Vitest)
Coverage reports in JSON format

### Running Tests

# Run all tests
npm test

# Run 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

### Reference Documentation

For detailed patterns and techniques, refer to:

references/testing_patterns.md - Comprehensive testing patterns, best practices, and code examples
references/bug_analysis.md - In-depth bug analysis framework, common bug patterns, and debugging techniques

These references contain extensive examples and advanced techniques. Load them when:

Dealing with complex testing scenarios
Need specific pattern implementations
Debugging unusual issues
Seeking best practices for specific situations

### analyze_coverage.py

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:

Files below coverage threshold
Statement, branch, and function coverage percentages
Priority files to improve

### find_untested_code.py

Find source files without corresponding test files:

python3 scripts/find_untested_code.py [src-dir] [--pattern test|spec]

Output:

Total source and test file counts
Test file coverage percentage
Untested files categorized by type (API, services, components, etc.)
Recommendations for prioritization

### Best Practices Summary

Write tests first (TDD) when adding new features
Test behavior, not implementation - tests should survive refactoring
Keep tests independent - no shared state between tests
Use descriptive names - test names should explain the scenario
Cover edge cases - null, empty, boundary values, error conditions
Mock external dependencies - tests should be fast and reliable
Maintain high coverage - 80%+ for critical code
Fix failing tests immediately - never commit broken tests
Refactor tests - apply same quality standards as production code
Use tools - automate coverage analysis and gap identification
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: Veeramanikandanr48
- Version: 0.1.0
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-05-09T22:44:44.108Z
- Expires at: 2026-05-16T22:44:44.108Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/test-specialist)
- [Send to Agent page](https://openagent3.xyz/skills/test-specialist/agent)
- [JSON manifest](https://openagent3.xyz/skills/test-specialist/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/test-specialist/agent.md)
- [Download page](https://openagent3.xyz/downloads/test-specialist)