Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tools /test_coverage.py
| #!/usr/bin/env python3 | |
| """MyWork Test Coverage Analyzer — find untested tools and scaffold tests. | |
| Usage: | |
| mw test-coverage Show coverage summary | |
| mw test-coverage --detail Show per-file breakdown | |
| mw test-coverage --scaffold Generate missing test files | |
| mw test-coverage --json Output as JSON | |
| mw test-coverage --min N Fail if coverage % < N (for CI) | |
| """ | |
| import json | |
| import os | |
| import re | |
| import sys | |
| from pathlib import Path | |
| from typing import Dict, List, Tuple | |
| def get_project_root() -> Path: | |
| """Find project root (where tools/ lives).""" | |
| return Path(__file__).resolve().parent.parent | |
| def discover_tools(root: Path) -> List[str]: | |
| """Find all tool modules in tools/.""" | |
| tools_dir = root / "tools" | |
| skip = {"__init__", "__pycache__", "_template", "mw"} | |
| tools = [] | |
| for f in sorted(tools_dir.glob("*.py")): | |
| name = f.stem | |
| if name.startswith("_") and name != "_template": | |
| continue | |
| if name in skip: | |
| continue | |
| tools.append(name) | |
| return tools | |
| def discover_tests(root: Path) -> Dict[str, Path]: | |
| """Find all test files, mapped by the tool name they test.""" | |
| tests_dir = root / "tests" | |
| mapping = {} | |
| if not tests_dir.exists(): | |
| return mapping | |
| for f in sorted(tests_dir.glob("test_*.py")): | |
| # test_foo.py -> foo | |
| tool_name = f.stem[5:] # strip "test_" | |
| mapping[tool_name] = f | |
| return mapping | |
| def count_test_functions(test_file: Path) -> int: | |
| """Count test functions/methods in a test file.""" | |
| try: | |
| content = test_file.read_text() | |
| return len(re.findall(r'^\s*def\s+test_', content, re.MULTILINE)) | |
| except Exception: | |
| return 0 | |
| def count_functions(tool_file: Path) -> int: | |
| """Count public functions in a tool file.""" | |
| try: | |
| content = tool_file.read_text() | |
| return len(re.findall(r'^def\s+(?!_)\w+', content, re.MULTILINE)) | |
| except Exception: | |
| return 0 | |
| def analyze(root: Path) -> dict: | |
| """Full coverage analysis.""" | |
| tools = discover_tools(root) | |
| tests = discover_tests(root) | |
| tools_dir = root / "tools" | |
| covered = [] | |
| uncovered = [] | |
| details = [] | |
| for tool in tools: | |
| tool_path = tools_dir / f"{tool}.py" | |
| num_funcs = count_functions(tool_path) | |
| if tool in tests: | |
| num_tests = count_test_functions(tests[tool]) | |
| covered.append(tool) | |
| details.append({ | |
| "tool": tool, | |
| "has_test": True, | |
| "functions": num_funcs, | |
| "test_count": num_tests, | |
| "test_file": str(tests[tool].relative_to(root)), | |
| }) | |
| else: | |
| uncovered.append(tool) | |
| details.append({ | |
| "tool": tool, | |
| "has_test": False, | |
| "functions": num_funcs, | |
| "test_count": 0, | |
| "test_file": None, | |
| }) | |
| total = len(tools) | |
| pct = round(len(covered) / total * 100, 1) if total > 0 else 0 | |
| return { | |
| "total_tools": total, | |
| "covered": len(covered), | |
| "uncovered": len(uncovered), | |
| "coverage_pct": pct, | |
| "covered_list": covered, | |
| "uncovered_list": uncovered, | |
| "details": details, | |
| } | |
| def scaffold_test(root: Path, tool_name: str) -> str: | |
| """Generate a basic test file for a tool.""" | |
| tool_path = root / "tools" / f"{tool_name}.py" | |
| # Extract public functions | |
| funcs = [] | |
| try: | |
| content = tool_path.read_text() | |
| funcs = re.findall(r'^def\s+((?!_)\w+)', content, re.MULTILINE) | |
| except Exception: | |
| pass | |
| lines = [ | |
| f'#!/usr/bin/env python3', | |
| f'"""Tests for tools/{tool_name}.py"""', | |
| f'', | |
| f'import pytest', | |
| f'import sys', | |
| f'from pathlib import Path', | |
| f'', | |
| f'# Add tools to path', | |
| f'sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "tools"))', | |
| f'', | |
| ] | |
| # Try to import | |
| lines.append(f'try:') | |
| lines.append(f' import {tool_name}') | |
| lines.append(f'except ImportError:') | |
| lines.append(f' pytest.skip("Cannot import {tool_name}", allow_module_level=True)') | |
| lines.append(f'') | |
| if funcs: | |
| for func in funcs[:10]: # Cap at 10 to keep manageable | |
| lines.append(f'') | |
| lines.append(f'def test_{func}_exists():') | |
| lines.append(f' """Verify {func} is callable."""') | |
| lines.append(f' assert callable(getattr({tool_name}, "{func}", None))') | |
| else: | |
| lines.append(f'') | |
| lines.append(f'def test_module_imports():') | |
| lines.append(f' """Verify module can be imported."""') | |
| lines.append(f' assert {tool_name} is not None') | |
| lines.append(f'') | |
| return '\n'.join(lines) | |
| def print_bar(pct: float, width: int = 30) -> str: | |
| """Create a progress bar.""" | |
| filled = int(width * pct / 100) | |
| bar = '█' * filled + '░' * (width - filled) | |
| if pct >= 80: | |
| color = '\033[92m' # green | |
| elif pct >= 50: | |
| color = '\033[93m' # yellow | |
| else: | |
| color = '\033[91m' # red | |
| return f'{color}{bar}\033[0m {pct}%' | |
| def main(args: list = None) -> int: | |
| args = args or sys.argv[1:] | |
| root = get_project_root() | |
| show_detail = '--detail' in args or '-d' in args | |
| do_scaffold = '--scaffold' in args | |
| as_json = '--json' in args | |
| min_val = None | |
| if '--min' in args: | |
| idx = args.index('--min') | |
| if idx + 1 < len(args): | |
| try: | |
| min_val = float(args[idx + 1]) | |
| except ValueError: | |
| pass | |
| result = analyze(root) | |
| if as_json: | |
| print(json.dumps(result, indent=2)) | |
| if min_val and result['coverage_pct'] < min_val: | |
| return 1 | |
| return 0 | |
| # Pretty print | |
| pct = result['coverage_pct'] | |
| print() | |
| print('\033[1m 📊 Test Coverage Report\033[0m') | |
| print(' ' + '─' * 48) | |
| print(f' Tools: {result["total_tools"]}') | |
| print(f' Tested: \033[92m{result["covered"]}\033[0m') | |
| print(f' Untested: \033[91m{result["uncovered"]}\033[0m') | |
| print(f' Coverage: {print_bar(pct)}') | |
| print() | |
| if show_detail: | |
| print(' \033[1mPer-tool breakdown:\033[0m') | |
| print(f' {"Tool":<30} {"Tests":<8} {"Funcs":<8} {"Status"}') | |
| print(' ' + '─' * 58) | |
| for d in result['details']: | |
| status = '\033[92m✓\033[0m' if d['has_test'] else '\033[91m✗\033[0m' | |
| print(f' {d["tool"]:<30} {d["test_count"]:<8} {d["functions"]:<8} {status}') | |
| print() | |
| if result['uncovered_list']: | |
| print(f' \033[93mUntested tools ({result["uncovered"]}):\033[0m') | |
| for i, name in enumerate(result['uncovered_list']): | |
| if i < 15: | |
| print(f' • {name}') | |
| elif i == 15: | |
| print(f' ... and {len(result["uncovered_list"]) - 15} more') | |
| break | |
| print() | |
| if do_scaffold: | |
| tests_dir = root / 'tests' | |
| tests_dir.mkdir(exist_ok=True) | |
| created = 0 | |
| for name in result['uncovered_list']: | |
| test_path = tests_dir / f'test_{name}.py' | |
| if not test_path.exists(): | |
| content = scaffold_test(root, name) | |
| test_path.write_text(content) | |
| created += 1 | |
| print(f' \033[92m✓\033[0m Created tests/test_{name}.py') | |
| if created: | |
| print(f'\n \033[92mScaffolded {created} test files.\033[0m Run: pytest tests/') | |
| else: | |
| print(f' All test files already exist.') | |
| print() | |
| if min_val and pct < min_val: | |
| print(f' \033[91m✗ Coverage {pct}% is below minimum {min_val}%\033[0m') | |
| return 1 | |
| return 0 | |
| if __name__ == '__main__': | |
| sys.exit(main()) | |
Xet Storage Details
- Size:
- 7.89 kB
- Xet hash:
- 5c8ae8a3a05f091190ebc291020e1b95df33cdf170af50076898df740c6b27ce
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.