test-sync

jmagly's avatarfrom jmagly

Detect orphaned tests, obsolete assertions, and test-code misalignment. Use for test suite maintenance, cleanup, and traceability validation. Use when relevant to the task.

⭐51stars🔀4forks📁View on GitHub🕐Updated Jan 4, 2026

When & Why to Use This Skill

The Test Sync skill is a specialized developer tool designed to automate test suite maintenance and ensure perfect alignment between source code and test files. By identifying orphaned tests, obsolete assertions, and implementation-coupled 'test smells,' it helps engineering teams reduce technical debt and maintain a high-quality, reliable testing infrastructure. Based on UTRefactor research, this skill can assist in achieving up to an 89% reduction in test-related smells, making it essential for long-term codebase health.

Use Cases

  • Post-Refactoring Cleanup: Automatically detect and remove orphaned tests for modules or functions that were deleted or renamed during major code changes.
  • Test Suite Health Audits: Identify brittle, implementation-coupled tests that target private methods or internal states, which often cause unnecessary failures during safe refactors.
  • Traceability & Gap Analysis: Map existing tests to source files to pinpoint critical business logic that lacks corresponding test coverage or has become disconnected.
  • CI/CD Integration: Use automated sync reports to validate test suite integrity before releases, ensuring that no obsolete test code is promoted to production environments.
nametest-sync
descriptionDetect orphaned tests, obsolete assertions, and test-code misalignment. Use for test suite maintenance, cleanup, and traceability validation. Use when relevant to the task.

Test Sync Skill

Purpose

Maintain alignment between test files and source code. Detect orphaned tests (code deleted but tests remain), missing tests, and implementation-coupled tests. Based on UTRefactor research showing automated test maintenance can achieve 89% smell reduction.

Research Foundation

Concept Source Reference
Test Refactoring UTRefactor (ACM 2024) 89% smell reduction
Test Smells Meszaros (2007) "xUnit Test Patterns"
Test-Code Traceability IEEE TSE Test maintenance research

When This Skill Applies

  • After major refactoring
  • During test suite health audits
  • When tests fail for deleted code
  • Before releases (cleanup validation)
  • When test count seems disconnected from codebase

Trigger Phrases

Natural Language Action
"Find orphaned tests" Detect tests for deleted code
"Sync tests with code" Full alignment analysis
"Are my tests up to date?" Test-code sync check
"Clean up test suite" Find removable tests
"Test coverage gaps" Find missing tests

Sync Analysis Types

1. Orphaned Test Detection

Tests that reference deleted or renamed code:

def find_orphaned_tests(project_dir):
    """Find tests for code that no longer exists"""
    orphans = []

    for test_file in glob(f"{project_dir}/test/**/*.test.ts"):
        # Extract tested module from import/path
        tested_module = infer_tested_module(test_file)

        if not exists(tested_module):
            orphans.append({
                "test_file": test_file,
                "expected_source": tested_module,
                "status": "source_deleted"
            })

        # Check for unused test helpers
        for helper in extract_test_helpers(test_file):
            if not is_used_in_assertions(test_file, helper):
                orphans.append({
                    "test_file": test_file,
                    "item": helper,
                    "status": "unused_helper"
                })

    return orphans

2. Missing Test Detection

Source files without corresponding tests:

def find_missing_tests(project_dir):
    """Find source files without tests"""
    missing = []

    for src_file in glob(f"{project_dir}/src/**/*.ts"):
        if is_testable(src_file):  # Exclude types, index files
            test_file = get_test_path(src_file)
            if not exists(test_file):
                missing.append({
                    "source": src_file,
                    "expected_test": test_file,
                    "functions": extract_public_functions(src_file),
                    "priority": assess_priority(src_file)
                })

    return missing

3. Implementation-Coupled Test Detection

Tests that test implementation details rather than behavior:

COUPLING_PATTERNS = [
    # Testing private methods
    (r'\.\_\w+\(', "Tests private method"),

    # Testing internal state
    (r'\.__\w+', "Accesses internal state"),

    # Mocking too deeply
    (r'mock.*mock.*mock', "Over-mocking"),

    # Testing exact implementation
    (r'toHaveBeenCalledWith.*\{.*\{', "Assertion on implementation details"),
]

def find_coupled_tests(test_file):
    """Detect implementation-coupled tests"""
    content = read_file(test_file)
    issues = []

    for pattern, description in COUPLING_PATTERNS:
        matches = re.findall(pattern, content)
        if matches:
            issues.append({
                "pattern": pattern,
                "description": description,
                "count": len(matches),
                "risk": "Tests may break on safe refactors"
            })

    return issues

4. Test-Code Mapping

Verify traceability between tests and source:

def build_test_map(project_dir):
    """Build mapping of tests to source files"""
    mapping = {}

    for test_file in glob(f"{project_dir}/test/**/*.test.ts"):
        source_file = infer_source(test_file)
        imports = extract_imports(test_file)

        mapping[test_file] = {
            "inferred_source": source_file,
            "actual_imports": imports,
            "coverage": get_coverage_for(test_file),
            "alignment": "aligned" if source_file in imports else "misaligned"
        }

    return mapping

Output Format

## Test Sync Report

**Project**: my-project
**Analysis Date**: 2024-12-12
**Test Files**: 45
**Source Files**: 78

### Summary

| Category | Count | Action |
|----------|-------|--------|
| Orphaned tests | 3 | Delete |
| Missing tests | 8 | Create |
| Implementation-coupled | 5 | Refactor |
| Aligned | 37 | None |

### Orphaned Tests (Safe to Delete)

#### 1. `test/auth/legacy-login.test.ts`
**Status**: Source deleted
**Original Source**: `src/auth/legacy-login.ts` (deleted in commit abc123)
**Last Modified**: 45 days ago
**Action**: DELETE

```bash
rm test/auth/legacy-login.test.ts

2. test/utils/string-helpers.test.ts

Status: Function removed Details: Tests formatCurrency() which was removed Action: DELETE specific test, keep file

// Remove this test block:
describe('formatCurrency', () => { ... });

Missing Tests (Should Create)

1. src/payment/processor.ts (HIGH PRIORITY)

Reason: Payment processing - critical path Public Functions:

  • processPayment(amount, method) - No test
  • refundPayment(transactionId) - No test
  • validateCard(cardInfo) - No test

Suggested Test File: test/payment/processor.test.ts

// Scaffold
describe('PaymentProcessor', () => {
  describe('processPayment', () => {
    it('should process valid payment');
    it('should reject insufficient funds');
    it('should handle network errors');
  });

  describe('refundPayment', () => {
    it('should refund valid transaction');
    it('should reject invalid transaction');
  });
});

Implementation-Coupled Tests (Refactor)

1. test/api/user-service.test.ts:45

Issue: Tests private method _validateEmail Risk: Will break on internal refactoring Current:

it('should validate email', () => {
  expect(service._validateEmail('test@test.com')).toBe(true);
});

Suggested Fix:

it('should reject user with invalid email', () => {
  expect(() => service.createUser({ email: 'invalid' }))
    .toThrow('Invalid email');
});

Test-Code Mapping

Test File Source File Status
test/auth/login.test.ts src/auth/login.ts ✅ Aligned
test/user/profile.test.ts src/user/profile.ts ✅ Aligned
test/api/old-client.test.ts (deleted) ❌ Orphaned
(missing) src/payment/processor.ts ⚠️ Missing

Recommendations

  1. Immediate: Delete 3 orphaned test files
  2. This Sprint: Create tests for processor.ts (critical)
  3. Debt Reduction: Refactor 5 implementation-coupled tests
  4. Ongoing: Add test-sync to CI pipeline

CI Integration

Add to pre-commit or CI:

- name: Test Sync Check
  run: |
    npx test-sync --project . --strict
    # Fails if orphaned tests or missing critical tests

## Cleanup Actions

### Safe Deletions (Automated)

```bash
# Delete orphaned test files
rm test/auth/legacy-login.test.ts
rm test/utils/old-helpers.test.ts

# Remove orphaned test blocks
sed -i '/describe.*formatCurrency/,/^});$/d' test/utils/string.test.ts

Manual Review Required

  • Tests for code moved to different module
  • Tests that may cover shared utilities
  • Tests with unclear naming

Integration Points

  • Works with /check-traceability command
  • Reports to Test Architect
  • Feeds into test health metrics
  • Part of /project-health-check

Script Reference

test_sync.py

Run sync analysis:

python scripts/test_sync.py --project . --output report.md

cleanup_orphans.py

Remove orphaned tests:

python scripts/cleanup_orphans.py --project . --dry-run