Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tests /test_badge.py
| """ | |
| Comprehensive tests for badge.py (mw badge command). | |
| Tests badge generation, version detection, and README updating. | |
| """ | |
| import os | |
| import sys | |
| import tempfile | |
| from pathlib import Path | |
| import pytest | |
| # Add tools directory to path | |
| TOOLS_DIR = Path(__file__).parent.parent / "tools" | |
| sys.path.insert(0, str(TOOLS_DIR)) | |
| import badge | |
| def temp_project_root(tmp_path): | |
| """Create a temporary project with various config files.""" | |
| # Create pyproject.toml | |
| (tmp_path / "pyproject.toml").write_text(""" | |
| [project] | |
| name = "test-project" | |
| version = "3.0.0" | |
| requires-python = ">=3.9" | |
| """) | |
| # Create LICENSE | |
| (tmp_path / "LICENSE").write_text(""" | |
| MIT License | |
| Copyright (c) 2024 Test Author | |
| """) | |
| # Create tools directory with some Python code | |
| tools_dir = tmp_path / "tools" | |
| tools_dir.mkdir() | |
| (tools_dir / "__init__.py").write_text("") | |
| (tools_dir / "mw.py").write_text(""" | |
| def cmd_help(): | |
| pass | |
| def cmd_status(): | |
| pass | |
| def cmd_version(): | |
| pass | |
| def cmd_test(): | |
| pass | |
| """) | |
| # Create tests directory with some tests | |
| tests_dir = tmp_path / "tests" | |
| tests_dir.mkdir() | |
| (tests_dir / "__init__.py").write_text("") | |
| (tests_dir / "test_example.py").write_text(""" | |
| def test_example_one(): | |
| assert True | |
| def test_example_two(): | |
| assert 1 + 1 == 2 | |
| def test_example_three(): | |
| pass | |
| """) | |
| # Create README.md | |
| (tmp_path / "README.md").write_text(""" | |
| # Test Project | |
| A test project for badge generation. | |
| <!-- badges-start --> | |
| <!-- badges-end --> | |
| ## Features | |
| - Feature 1 | |
| - Feature 2 | |
| """) | |
| return tmp_path | |
| class TestVersionDetection: | |
| """Test version detection from various config files.""" | |
| def test_detect_version_pyproject_toml(self, temp_project_root): | |
| version = badge.detect_version(temp_project_root) | |
| assert version == "3.0.0" | |
| def test_detect_version_package_json(self, tmp_path): | |
| (tmp_path / "package.json").write_text('{"version": "2.5.1"}') | |
| version = badge.detect_version(tmp_path) | |
| assert version == "2.5.1" | |
| def test_detect_version_version_file(self, tmp_path): | |
| (tmp_path / "VERSION").write_text("1.2.3\n") | |
| version = badge.detect_version(tmp_path) | |
| assert version == "1.2.3" | |
| def test_detect_version_dot_version_file(self, tmp_path): | |
| """Test .version file support (common in many projects).""" | |
| (tmp_path / ".version").write_text("2.4.5\n") | |
| version = badge.detect_version(tmp_path) | |
| assert version == "2.4.5" | |
| def test_detect_version_dot_version_multiline(self, tmp_path): | |
| """Test .version file with multiple lines (only first line used).""" | |
| (tmp_path / ".version").write_text("3.0.0-beta\nignored\nmore ignored\n") | |
| version = badge.detect_version(tmp_path) | |
| assert version == "3.0.0-beta" | |
| def test_detect_version_no_config(self, tmp_path): | |
| version = badge.detect_version(tmp_path) | |
| assert version is None | |
| class TestTestCounting: | |
| """Test test function counting.""" | |
| def test_count_tests(self, temp_project_root): | |
| count = badge.count_tests(temp_project_root) | |
| assert count == 3 | |
| def test_count_tests_no_tests_dir(self, tmp_path): | |
| count = badge.count_tests(tmp_path) | |
| assert count == 0 | |
| class TestCommandCounting: | |
| """Test command counting from mw.py.""" | |
| def test_count_commands(self, temp_project_root): | |
| count = badge.count_commands(temp_project_root) | |
| assert count == 4 # help, status, version, test | |
| def test_count_commands_no_mw_py(self, tmp_path): | |
| count = badge.count_commands(tmp_path) | |
| assert count == 0 | |
| class TestLOCCounting: | |
| """Test lines of code counting.""" | |
| def test_count_loc(self, temp_project_root): | |
| loc = badge.count_loc(temp_project_root) | |
| assert loc > 0 | |
| def test_count_loc_empty_project(self, tmp_path): | |
| loc = badge.count_loc(tmp_path) | |
| assert loc == 0 | |
| class TestLicenseDetection: | |
| """Test license type detection.""" | |
| def test_detect_license_mit(self, temp_project_root): | |
| lic = badge.detect_license(temp_project_root) | |
| assert lic == "MIT" | |
| def test_detect_license_apache(self, tmp_path): | |
| (tmp_path / "LICENSE").write_text(""" | |
| Apache License | |
| Version 2.0 | |
| """) | |
| lic = badge.detect_license(tmp_path) | |
| assert lic == "Apache-2.0" | |
| def test_detect_license_gpl(self, tmp_path): | |
| (tmp_path / "LICENSE").write_text(""" | |
| GNU GPL | |
| Version 3, 29 June 2007 | |
| """) | |
| lic = badge.detect_license(tmp_path) | |
| assert lic == "GPL-3.0" | |
| def test_detect_license_no_file(self, tmp_path): | |
| lic = badge.detect_license(tmp_path) | |
| assert lic == "unknown" | |
| def test_detect_license_custom(self, tmp_path): | |
| (tmp_path / "LICENSE").write_text(""" | |
| Copyright 2024 Me | |
| All rights reserved. | |
| """) | |
| lic = badge.detect_license(tmp_path) | |
| assert lic == "custom" | |
| class TestPythonVersionDetection: | |
| """Test Python version detection.""" | |
| def test_detect_python_version(self, temp_project_root): | |
| version = badge.detect_python_version(temp_project_root) | |
| assert version == ">=3.9" | |
| def test_detect_python_version_no_pyproject(self, tmp_path): | |
| version = badge.detect_python_version(tmp_path) | |
| assert version is None | |
| class TestBadgeURLGeneration: | |
| """Test shields.io URL generation.""" | |
| def test_shields_url_basic(self): | |
| url = badge.shields_url("version", "v3.0.0", "blue") | |
| assert "version-v3.0.0-blue" in url | |
| assert "img.shields.io" in url | |
| def test_shields_url_custom_style(self): | |
| url = badge.shields_url("tests", "150", "green", "for-the-badge") | |
| assert "style=for-the-badge" in url | |
| def test_shields_url_special_chars(self): | |
| url = badge.shields_url("lines of code", "10k+", "informational") | |
| assert "lines%20of%20code" in url | |
| class TestBadgeGeneration: | |
| """Test badge generation for all badge types.""" | |
| def test_generate_badges_version(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| version_badge = next((b for b in badges if b['name'] == 'version'), None) | |
| assert version_badge is not None | |
| assert version_badge['value'] == 'v3.0.0' | |
| assert version_badge['color'] == 'blue' | |
| def test_generate_badges_python(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| py_badge = next((b for b in badges if b['name'] == 'python'), None) | |
| assert py_badge is not None | |
| assert py_badge['value'] == '>=3.9' | |
| def test_generate_badges_tests(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| test_badge = next((b for b in badges if b['name'] == 'tests'), None) | |
| assert test_badge is not None | |
| assert test_badge['value'] == '3' | |
| # With only 3 tests, should be yellow (<50) | |
| assert test_badge['color'] == 'yellow' | |
| def test_generate_badges_commands(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| cmd_badge = next((b for b in badges if b['name'] == 'commands'), None) | |
| assert cmd_badge is not None | |
| assert cmd_badge['value'] == '4' | |
| assert cmd_badge['color'] == 'purple' | |
| def test_generate_badges_loc(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| loc_badge = next((b for b in badges if b['name'] == 'loc'), None) | |
| assert loc_badge is not None | |
| assert loc_badge['value'] is not None | |
| assert loc_badge['color'] == 'informational' | |
| def test_generate_badges_license(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| lic_badge = next((b for b in badges if b['name'] == 'license'), None) | |
| assert lic_badge is not None | |
| assert lic_badge['value'] == 'MIT' | |
| assert lic_badge['color'] == 'green' | |
| def test_generate_badges_platform(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| platform_badge = next((b for b in badges if b['name'] == 'platform'), None) | |
| assert platform_badge is not None | |
| assert "linux | macOS | windows" in platform_badge['value'] | |
| assert platform_badge['color'] == 'lightgrey' | |
| def test_generate_badges_count(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| # Should have version, python, tests, commands, loc, license, platform | |
| assert len(badges) >= 6 | |
| class TestBadgeFormatting: | |
| """Test badge output formatting.""" | |
| def test_format_badges_md(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| md = badge.format_badges_md(badges) | |
| assert ' == len(badges) | |
| def test_format_badges_html(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| html = badge.format_badges_html(badges) | |
| assert '<img src="' in html | |
| assert 'alt=' in html | |
| assert html.count('<img') == len(badges) | |
| class TestReadmeUpdate: | |
| """Test README.md updating with badges.""" | |
| def test_update_readme_with_markers(self, temp_project_root): | |
| badges = badge.generate_badges(temp_project_root) | |
| result = badge.update_readme(temp_project_root, badges) | |
| assert result is True | |
| readme_content = (temp_project_root / "README.md").read_text() | |
| assert '<!-- badges-start -->' in readme_content | |
| assert '<!-- badges-end -->' in readme_content | |
| assert '![' in readme_content # Badge images present | |
| def test_update_readme_no_markers(self, tmp_path): | |
| # Create README without markers | |
| (tmp_path / "README.md").write_text("# Simple Project\n\nContent here\n") | |
| (tmp_path / "pyproject.toml").write_text('[project]\nname = "test"\nversion = "1.0.0"\n') | |
| badges = badge.generate_badges(tmp_path) | |
| result = badge.update_readme(tmp_path, badges) | |
| assert result is True | |
| readme_content = (tmp_path / "README.md").read_text() | |
| # Should have inserted badges after heading | |
| assert '<!-- badges-start -->' in readme_content | |
| def test_update_readme_no_readme(self, tmp_path): | |
| badges = badge.generate_badges(tmp_path) | |
| result = badge.update_readme(tmp_path, badges) | |
| assert result is False | |
| class TestBadgeColors: | |
| """Test badge color selection based on values.""" | |
| def test_test_count_color_high(self, tmp_path): | |
| # Create project with many tests | |
| tests_dir = tmp_path / "tests" | |
| tests_dir.mkdir() | |
| test_content = "\n".join([f"def test_{i}(): pass" for i in range(150)]) | |
| (tests_dir / "test_many.py").write_text(test_content) | |
| (tmp_path / "pyproject.toml").write_text('[project]\nname = "test"\nversion = "1.0.0"\n') | |
| badges = badge.generate_badges(tmp_path) | |
| test_badge = next((b for b in badges if b['name'] == 'tests'), None) | |
| assert test_badge is not None | |
| assert test_badge['color'] == 'brightgreen' # >= 100 tests | |
| def test_test_count_color_medium(self, tmp_path): | |
| # Create project with medium tests | |
| tests_dir = tmp_path / "tests" | |
| tests_dir.mkdir() | |
| test_content = "\n".join([f"def test_{i}(): pass" for i in range(75)]) | |
| (tests_dir / "test_medium.py").write_text(test_content) | |
| (tmp_path / "pyproject.toml").write_text('[project]\nname = "test"\nversion = "1.0.0"\n') | |
| badges = badge.generate_badges(tmp_path) | |
| test_badge = next((b for b in badges if b['name'] == 'tests'), None) | |
| assert test_badge is not None | |
| assert test_badge['color'] == 'green' # >= 50 tests | |
| def test_loc_formatting_k(self, tmp_path): | |
| # Create project with large LOC (mocked) | |
| (tmp_path / "pyproject.toml").write_text('[project]\nname = "test"\nversion = "1.0.0"\n') | |
| tools_dir = tmp_path / "tools" | |
| tools_dir.mkdir() | |
| # Create a file with many lines | |
| (tools_dir / "large.py").write_text("\n".join([f"line_{i}" for i in range(12000)])) | |
| badges = badge.generate_badges(tmp_path) | |
| loc_badge = next((b for b in badges if b['name'] == 'loc'), None) | |
| assert loc_badge is not None | |
| assert 'k+' in loc_badge['value'] or str(loc_badge['value']).isdigit() | |
| class TestEdgeCases: | |
| """Test edge cases and error handling.""" | |
| def test_empty_project(self, tmp_path): | |
| badges = badge.generate_badges(tmp_path) | |
| # Should still work, just with fewer badges | |
| assert isinstance(badges, list) | |
| # Platform badge should always be present | |
| assert any(b['name'] == 'platform' for b in badges) | |
| def test_malformed_pyproject(self, tmp_path): | |
| (tmp_path / "pyproject.toml").write_text("this is not valid toml [[[") | |
| version = badge.detect_version(tmp_path) | |
| assert version is None | |
| def test_malformed_package_json(self, tmp_path): | |
| (tmp_path / "package.json").write_text("{invalid json}") | |
| version = badge.detect_version(tmp_path) | |
| assert version is None | |
| def test_zero_tests(self, tmp_path): | |
| (tmp_path / "pyproject.toml").write_text('[project]\nname = "test"\nversion = "1.0.0"\n') | |
| tests_dir = tmp_path / "tests" | |
| tests_dir.mkdir() | |
| (tests_dir / "empty.py").write_text("# No tests here") | |
| badges = badge.generate_badges(tmp_path) | |
| # Tests badge should not appear when count is 0 | |
| assert not any(b['name'] == 'tests' for b in badges) | |
| class TestCLIThroughSubprocess: | |
| """Integration tests via CLI subprocess.""" | |
| def test_badge_generate_runs(self): | |
| import subprocess | |
| result = subprocess.run( | |
| [sys.executable, str(TOOLS_DIR / "badge.py"), "generate"], | |
| capture_output=True, | |
| text=True, | |
| timeout=5 | |
| ) | |
| # Should run without error | |
| assert result.returncode in (0, 1) | |
| def test_badge_help(self): | |
| import subprocess | |
| result = subprocess.run( | |
| [sys.executable, str(TOOLS_DIR / "badge.py"), "help"], | |
| capture_output=True, | |
| text=True, | |
| timeout=5 | |
| ) | |
| assert result.returncode == 0 | |
| assert "Badge Generator" in result.stdout | |
Xet Storage Details
- Size:
- 14.4 kB
- Xet hash:
- 1b4b55d0009326a1dcebce8e9dea6ad4d400d708a1625f2964a798b696471552
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.