Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

improving-python-coverage

/improving-python-coverage

Uruchamia testy jednostkowe Pythona z pokryciem, analizuje raport i dopisuje wartościowe testy, zwiększając pokrycie o około 0,2 proc.

Repozytorium
streamlit ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Uruchamia testy jednostkowe Pythona z pokryciem, analizuje raport i dopisuje wartościowe testy, zwiększając pokrycie o około 0,2 proc.

Oryginalny opis (EN)

Runs Python unit tests with coverage, analyzes coverage reports, and implements meaningful tests to increase coverage by ~0.2%. Use when you want to systematically improve Python test coverage with high-value test cases.

Jak działa

  1. Workflow
  2. Test selection
  3. Test file location
  4. Notes
Sekcje z nagłówków SKILL.md, w oryginale · 96 linii, 712 słów
Podgląd SKILL.md
---
name: improving-python-coverage
description: Runs Python unit tests with coverage, analyzes coverage reports, and implements meaningful tests to increase coverage by ~0.2%. Use when you want to systematically improve Python test coverage with high-value test cases.
---

# Improving Python coverage

Increase Python unit test coverage by ~0.2% through meaningful tests that add real value.

**Be fully autonomous** — Do NOT stop or pause to ask for confirmation. Keep iterating (analyze → implement → verify) until the 0.2% coverage target is reached. If you encounter ambiguities about what to test, make a reasonable choice and proceed.

## Workflow

**Step 1: Run tests with coverage**

```bash
make python-tests  # ~3 min, creates .coverage file
```

Generate JSON report for analysis:

```bash
uv run coverage json -o coverage.json
```

The JSON contains per-file `missing_lines` arrays showing uncovered line numbers.

**Step 2: Analyze and prioritize**

Read `coverage.json` to find files with:
1. Large size + below-average `percent_covered` (high impact)
2. Core modules in `lib/streamlit/elements/` or `lib/streamlit/runtime/`
3. Pure utility functions

Skip: >97% coverage, `proto/*`, `vendor/*`, `static/*`, test files.

**Step 3: Implement tests (in subagent)**

Launch a subagent to implement tests for each prioritized file. Provide the subagent with:
- The target file path and its `missing_lines` from coverage
- Instructions to read the source, existing tests, and write new tests
- The test selection guidelines below

The subagent should:
1. Read source and existing tests at `lib/tests/streamlit/<path>/<module>_test.py`
2. Write tests for: conditional branches, error handling, edge cases, exception paths
3. Follow `lib/tests/AGENTS.md`: prefer pytest-style standalone functions over `unittest.TestCase` classes, use `@pytest.mark.parametrize` to consolidate tests that only differ in inputs/expected outputs, add numpydoc docstrings and type annotations
4. Run the new tests to verify they pass: `uv run pytest lib/tests/streamlit/path/to/module_test.py -v`

**Step 4: Verify and iterate**

```bash
uv run pytest lib/tests/streamlit/path/to/module_test.py -v  # Run new tests
make python-tests                                             # Measure progress
```

**Repeat steps 2-4 until coverage improves by ≥0.2%**, then run `make check`.

**Step 5: Simplify, review, and address feedback**

Once all tests pass and coverage target is met:

1. Run the `simplifying-local-changes` subagent to clean up and simplify the code changes. Wait for completion.
2. Run the `reviewing-local-changes` subagent to review the changes. Wait for completion and read the review output.
3. Address the review feedback: for each recommendation, implement it if valid and improves code quality; skip with brief reasoning if not applicable or would over-engineer.
4. Run /checking-changes to verify everything still passes after changes.

## Test selection

**DO test:** Conditional logic, error handling, edge cases (None, empty, zero, max), public API functions, complex branches.

**DON'T test:** Simple accessors, protobufs, implementation details, already well-covered code.

**Coverage exclusions:** Use `# pragma: no cover` sparingly for code that genuinely doesn't need testing. Always include a reason (e.g., `# pragma: no cover - defensive`):
- Platform-specific branches that can't run in CI (`# pragma: no cover - platform-specific`)
- Defensive code that should never execute (`# pragma: no cover - defensive`)
- Abstract method stubs or protocol definitions (`# pragma: no cover - abstract`)

**Integration dependencies:** Packages listed under `[dependency-groups] integration` in `pyproject.toml` (e.g., `pydantic`, `sympy`, `polars`, `sqlalchemy`) are only installed for integration tests, not regular unit tests. When writing tests that use these packages:
- Import them **inside the test function**, not at module top-level
- Add `@pytest.mark.require_integration` marker to the test
- This ensures tests gracefully skip when run outside the integration test environment

## Test file location

`lib/tests/streamlit/<package>/<module>_test.py` mirrors `lib/streamlit/<package>/<module>.py`

## Notes

- Quality > coverage numbers - skip tests that don't catch real bugs
- Target is 95%+ coverage per `lib/tests/AGENTS.md`
- Use `/checking-changes` after implementing tests
- Some code paths involving external libraries (e.g., database connectors, optional dependencies) are already covered by integration tests marked with `pytest.mark.require_integration`. These integration tests are **not** included in the coverage numbers from `make python-tests`. When analyzing missing lines, check whether the uncovered code is exercised by integration tests before adding unit tests or `# pragma: no cover` annotations.
- **Local vs CI coverage differences:** Code that is version-specific (Python version, library version) or uses integration dependencies may appear uncovered locally but is tested and covered in CI. Examples:
  - Python version-specific branches (e.g., `if sys.version_info >= (3, 14)`) run only on matching CI jobs
  - Library version-specific code (e.g., pandas 2.x vs 3.x behavior) is covered across CI matrix
  - Integration dependency tests (`@pytest.mark.require_integration`) run in separate CI jobs with those packages installed

  Before adding tests or `# pragma: no cover` for such code, verify whether it's already exercised in CI.

Wersje

W bazie nie ma innych skilli o nazwie improving-python-coverage.

Migawka bazy z 13.11.2026 · wersja paczki b71006de8e00 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100improving-frontend-coverage
    Uruchamia testy jednostkowe frontendu z pokryciem, analizuje raport i dopisuje wartościowe testy, zwiększając pokrycie o około 0,2 proc.
  • 90testing-python
    Wyznacza strategię testów dla Pythona 3.14+, gdy pisze się testy, ocenia pokrycie lub konfiguruje testy.
  • 100python-testing
    Projektuje i ocenia testy Python w pytest: pokrycie, testy kontraktowe, property testy i testy adapterów.
  • 100python-testing
    Pomaga pisać testy w Pythonie z pytest: jednostkowe i integracyjne, fixtury, mockowanie oraz pokrycie kodu.
  • 90Coverage Guard
    Sprawdza pokrycie testami, znajduje nieprzetestowany kod i dopisuje brakujące testy, dążąc do pełnego pokrycia.
  • 100unit-testing
    Pisze i aktualizuje testy jednostkowe dla nowego lub zmienionego kodu, uruchamia je z pokryciem i naprawia błędy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.