# Write unit tests for untested code in scikit-learn with Atlas in 2026 > Atlas helps scikit-learn developers write unit tests for untested modules, matching existing `pytest` conventions and integrating with `uv` and `ruff format`. In 2026, scikit-learn developers can leverage Atlas to efficiently write unit tests for previously untested code, ensuring new contributions adhere to the project's `pytest` conventions. Atlas reads the target module, identifies public symbols, and then drafts new test files, running them with `pytest` and formatting with `ruff format` to integrate direct into the existing codebase. ## Key takeaways - Atlas uses `lsp` to ensure 100% coverage of scikit-learn module symbols. - Atlas `grep`s existing scikit-learn tests to match `pytest` conventions. - Atlas's `write` tool drafts new scikit-learn tests with diff approval. - Run scikit-learn tests with `pytest` via Atlas's `bash` tool. - Atlas applies `ruff format` to maintain scikit-learn code style. - Atlas provides permission-gated actions for secure scikit-learn development. ## How Atlas writes unit tests for scikit-learn modules Atlas streamlines the process of writing unit tests for scikit-learn modules, ensuring every public function is covered. In 2026, Atlas begins by thoroughly reading the target module, then uses its `lsp` tool to enumerate all exported symbols, guaranteeing 100% coverage of public APIs. Atlas initiates the testing workflow by first understanding the scikit-learn module requiring tests. It employs its `read` tool to ingest the module's source code. Following this, Atlas utilizes the `lsp` tool with the `documentSymbol` operation to precisely identify all public functions, classes, and methods. This AST-based indexing, powered by tree-sitter, ensures that no public API, such as a `fit`, `transform`, or `predict` method on an estimator, is overlooked. This comprehensive symbol enumeration is crucial for generating a complete test suite that matches scikit-learn's rigorous standards for API coverage. Atlas can build its code index with local Ollama embeddings, keeping sensitive scikit-learn code off third-party servers. ## How Atlas matches scikit-learn's pytest conventions To ensure new tests integrate perfectly, Atlas meticulously copies scikit-learn's existing `pytest` conventions. It performs a `grep` search for an existing test file, such as `sklearn/ensemble/tests/test_forest.py`, to learn the repo's specific framework, import styles, and naming conventions, ensuring 100% consistency. A core principle for Atlas is to adapt to the existing codebase's style rather than imposing its own. For scikit-learn, this means adhering to the established `pytest` framework. Atlas uses its `grep` tool to locate an existing test file within the repository, for example, searching for `sklearn/module_name/tests/test_existing_module.py`. This allows Atlas to analyze the project's specific test structure, including how fixtures are defined, how imports are managed, and the naming conventions for test functions (e.g., `test_my_function_behavior`). By learning from real examples, Atlas ensures that the new test files it generates, such as `sklearn/new_module/tests/test_new_module.py`, are indistinguishable from manually written tests, maintaining the repository's integrity and readability. This approach is vital for direct collaboration within the scikit-learn community. ## Writing and running new scikit-learn test files with Atlas After understanding the module and its conventions, Atlas drafts the new test file using its `write` tool. This tool presents a unified diff for approval, ensuring transparency before any changes are applied to disk, typically within 2-3 seconds of generation. Once Atlas has gathered all necessary context the module's public symbols and the repository's `pytest` conventions it proceeds to draft the new test file. Using the `write` tool, Atlas generates the test code, which might include tests for `fit`, `transform`, `predict`, or `get_params` and `set_params` for custom estimators. Crucially, before any changes are committed, Atlas computes a unified diff, presenting it to the developer for explicit approval. This permission-gated step ensures that developers retain full control over their codebase. After approval, Atlas uses the `bash` tool to execute the newly written tests with `pytest`. For instance, it might run `pytest sklearn/new_module/tests/test_new_module.py`. If the output exceeds 2000 lines or 50 KB, Atlas truncates it in the TUI but saves the full log to a file for detailed review, facilitating efficient debugging. ## Iterating and refining scikit-learn tests with Atlas Achieving a green test suite often requires iteration, and Atlas supports this by allowing developers to `edit` and refine tests. For large scikit-learn modules, Atlas can maintain progress with a `todowrite` list, ensuring no test cases are missed across 10s or even 100s of test functions. The initial test draft might not pass all checks immediately. Atlas facilitates an iterative development cycle using its `edit` tool, allowing developers to modify the generated tests based on `pytest` failures. This could involve adjusting assertions, adding edge cases, or refining test data. For extensive scikit-learn modules with many public symbols, Atlas can leverage the `todowrite` tool to manage a list of pending test cases or areas needing further attention. This ensures that even complex testing tasks, such as covering all aspects of a `Pipeline` or `ColumnTransformer`, remain organized and trackable. Atlas also integrates with `ruff format` to automatically apply the project's formatting standards to any modified test files, ensuring that `uv` dependencies and code style remain consistent throughout the iteration process. ## Atlas's safety and review mechanisms for scikit-learn code Atlas prioritizes safety and developer control, implementing multiple permission gates before any code modification. Every Atlas tool call, including `write` and `bash`, is permission-gated against allow, ask, and deny rules, ensuring 100% transparency and explicit approval. Developer trust and code integrity are paramount. Atlas employs a robust safety framework. Before executing any tool that modifies the codebase, such as `write` or `edit`, or even running `bash` commands like `pytest`, Atlas consults its permission-gated rules (allow, ask, deny). This means that every proposed change, from a new test file to a `ruff format` application, is presented as a unified diff for explicit developer approval. Atlas also drafts a plan in a read-only plan agent before switching to a build agent, providing a clear overview of its intended actions. Furthermore, Atlas snapshots file changes as git patches, allowing edits to be easily diffed, reviewed, and rolled back if necessary, providing a secure environment for scikit-learn development. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf. ## Steps 1. Run Atlas in your scikit-learn project with a `pyproject.toml` that pins scikit-learn. 2. Ask Atlas to `read` the target scikit-learn module (e.g., `sklearn/new_module.py`) and use `lsp` to enumerate its exported symbols. 3. Instruct Atlas to `grep` for an existing scikit-learn test file (e.g., `sklearn/ensemble/tests/test_forest.py`) to learn `pytest` conventions. 4. Use Atlas's `write` tool to draft the new `pytest` spec file (e.g., `sklearn/new_module/tests/test_new_module.py`), reviewing the unified diff for approval. 5. Execute the new tests with Atlas's `bash` tool, running `pytest sklearn/new_module/tests/test_new_module.py`. 6. If tests fail, use Atlas's `edit` tool to refine the test code, iterating until the `pytest` suite is green. 7. Apply scikit-learn's formatting standards by asking Atlas to run `ruff format` on the modified test files. 8. Let Atlas stage and create a git commit for the new, passing tests. ## FAQ ### How does Atlas ensure new scikit-learn tests match existing conventions? Atlas uses its `grep` tool to analyze existing scikit-learn test files, such as those in `sklearn/module/tests/`, to learn the project's specific `pytest` framework, import styles, and naming conventions before drafting new tests. ### Can Atlas help test scikit-learn Pipeline or ColumnTransformer definitions? Yes, Atlas can read your `Pipeline` and `ColumnTransformer` definitions, identify their components and methods, and then generate unit tests to verify their behavior, including `fit`, `transform`, and `predict` operations. ### What if my scikit-learn module has no existing tests to copy? Atlas will still enumerate all public symbols using `lsp` and draft tests based on general `pytest` best practices, while still allowing you to guide it towards a desired structure through iterative `edit` commands. ### How does Atlas handle pytest failures when writing scikit-learn tests? Atlas runs `pytest` using its `bash` tool and presents the output. If tests fail, you can use Atlas's `edit` tool to modify the test code, and Atlas will re-run `pytest` until the suite is green. ### Does Atlas automatically format the new scikit-learn test files? Yes, after drafting or editing tests, you can instruct Atlas to run `ruff format` on the new files, ensuring they adhere to scikit-learn's established code style. ### How does Atlas ensure I approve changes before they are applied to my scikit-learn codebase? Every Atlas tool call that modifies files, like `write` or `edit`, is permission-gated. Atlas presents a unified diff for your explicit approval before any changes are written to disk, and it can snapshot changes as git patches. ### Can Atlas help ensure a custom scikit-learn estimator passes check_estimator? Yes, Atlas can help make a custom estimator pass `check_estimator` by guiding you through implementing `get_params` and `set_params` correctly, and then running the `pytest` checks. --- Canonical HTML: https://runatlas.sh/resources/stacks/write-unit-tests-for-untested-code-in-scikit-learn Source of truth: aeo_pages row `/resources/stacks/write-unit-tests-for-untested-code-in-scikit-learn` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.