- ALWAYS write tests before implementing functionality. This helps ensure the code meets requirements and avoids unnecessary complexity.

- When implementing a new feature, first write a failing test that describes the desired behavior.

- Tests should be specific and focused on one piece of functionality.

- After implementing changes, run the full test suite and code quality checks to catch any regressions.

- Test classes should be at the root level of the test file, not nested within other test classes, to ensure proper test discovery and organization.

- When running pytest for a specific test class, use the format `pytest path/to/test.py::TestClassName -v`

- For efficiency, run only the specific tests you need:

- For a single test: `pytest path/to/test.py::TestClass::test_name`

- For a test in a nested class: `pytest path/to/test.py::TestClass::TestNestedClass::test_name`

- For a parameterized test: `pytest path/to/test.py::test_name`

- Structure tests with explicit comments to improve readability:

```python

def test_something(self):

# Arrange - set up test data and conditions

# Act - perform the action being tested

# Assert - verify the results

```

- Avoid code duplication in error handling paths. When you see similar error handling repeated, consider consolidating the logic:

1. Collect all items to process up front

2. Use a single loop to handle common operations and error cases

3. Consolidate status messages or logging

- Keep docstrings focused on interface behavior, not implementation details

- Never make changes unrelated to the current task or failing test

- Keep a clear separation between interface documentation (docstrings) and implementation notes (comments)

- Run pre-commit checks after making changes to ensure code quality and formatting standards are met

- Never include type information in docstrings when it's already present in type annotations

- ALWAYS run pre-commit checks after any code changes are considered complete:

1. Run `uv run pre-commit run --all-files`

2. If any checks modify files, run the checks again to ensure everything is clean

3. Never consider a change complete until all pre-commit checks pass

- Use `contextlib.suppress` instead of empty try-except blocks:

```python

# Instead of:

try:

do_something()

except SomeError:

pass

# Use:

from contextlib import suppress

with suppress(SomeError):

do_something()

```

- Display user feedback messages:

1. Use present tense ("Removing..." not "Removed...")

2. Show messages as soon as possible, don't wait until after the operation

3. Use a flag like `first_removal` to ensure messages are shown exactly once

tool.remove_pyproject_configs()

"""Get the pyproject configurations for the tool.

"""Remove all pyproject.toml configurations associated with this tool.

# Collect all keys to remove

keys_to_remove = [

config.id_keys for config in self.get_pyproject_configs()

] + self.get_pyproject_id_keys()

# Try to remove the first key to trigger the message

for keys in keys_to_remove:

remove_config_value(keys)

def get_pyproject_id_keys(self) -> list[list[str]]:

return [["tool", "deptry"]]

def test_use_deptry_removes_config(self, tmp_path: Path):

"""Test that use_deptry removes the tool's config when removing."""

# Arrange

pyproject = tmp_path / "pyproject.toml"

pyproject.write_text("""[tool.deptry]

""")

# Act

with change_cwd(tmp_path):

use_deptry(remove=True)

# Assert

assert "[tool.deptry]" not in pyproject.read_text()

# Assert

out, _ = capfd.readouterr()

assert out == (

"✔ Ensuring pre-commit hooks are uninstalled.\n"

"✔ Removing '.pre-commit-config.yaml'.\n"

"✔ Removing dependency 'pre-commit' from the 'dev' group in 'pyproject.toml'.\n"

"☐ Run 'uv export --no-dev --output-file=requirements.txt' to write \n'requirements.txt'.\n"

)

# Assert

out, _ = capfd.readouterr()

assert out == (

"✔ Ensuring pre-commit hooks are uninstalled.\n"

"✔ Removing '.pre-commit-config.yaml'.\n"

"✔ Removing dependency 'pre-commit' from the 'dev' group in 'pyproject.toml'.\n"

"✔ Adding dependency 'pyproject-fmt' to the 'dev' group in 'pyproject.toml'.\n"

"☐ Run 'pyproject-fmt pyproject.toml' to run pyproject-fmt.\n"

)

from usethis._tool import ALL_TOOLS, DeptryTool, Tool

class TestDeptryTool:

"""Tests for DeptryTool."""

def test_get_pyproject_id_keys(self):

"""Test that get_pyproject_id_keys returns the correct keys."""

# Arrange

tool = DeptryTool()

# Act

result = tool.get_pyproject_id_keys()

# Assert

assert result == [["tool", "deptry"]]

def test_remove_pyproject_configs_removes_deptry_section(self, tmp_path: Path):

"""Test that remove_pyproject_configs removes the deptry section."""

# Arrange

pyproject = tmp_path / "pyproject.toml"

pyproject.write_text("""[tool.deptry]

""")

# Act

with change_cwd(tmp_path):

tool = DeptryTool()

tool.remove_pyproject_configs()

# Assert

assert "[tool.deptry]" not in pyproject.read_text()

assert "ignore_missing" not in pyproject.read_text()

def test_config_keys_are_subkeys_of_id_keys(self):

"""Test that all config keys are subkeys of id keys."""

# Arrange

tool = DeptryTool()

# Act

id_keys = tool.get_pyproject_id_keys()

configs = tool.get_pyproject_configs()

# Assert

for config in configs:

# For each config, check if its keys are a subset of any id_keys

assert any(config.id_keys[: len(id_key)] == id_key for id_key in id_keys), (

f"Config keys {config.id_keys} not covered by ID keys {id_keys}"

)

def test_all_tools_config_keys_are_subkeys_of_id_keys(tool: Tool):

"""Test that all tools' config keys are subkeys of their ID keys."""

id_keys = tool.get_pyproject_id_keys()

configs = tool.get_pyproject_configs()

for config in configs:

# For each config, check if its keys are a subset of any id_keys

assert any(config.id_keys[: len(id_key)] == id_key for id_key in id_keys), (

f"Config keys {config.id_keys} not covered by ID keys in {tool.name}"

)