Best AI assistant for writing unit tests in Python

I've been trying to use various AI assistants to generate unit tests for a legacy codebase. The promise is huge: speed up coverage, handle boilerplate. The reality, in my experience, is that they consistently fail at the most important part: **designing meaningful assertions.**

They'll perfectly scaffold a `unittest.TestCase` or `pytest` fixture, but the actual test logic is either tautological, tests the language runtime, or misses the critical edge cases. They're great at syntax, terrible at semantics.

Here's a concrete, reproducible failure from a popular assistant.

**Prompt:**
```
Write a pytest for this Python function.

def parse_interval(interval_string):
"""
Parses a string like '1d', '4h', '30m' into a tuple of (value, unit).
Unit can be 'd', 'h', 'm'. Returns (None, None) for invalid input.
"""
if not isinstance(interval_string, str):
return (None, None)
interval_string = interval_string.strip().lower()
if not interval_string:
return (None, None)

# Find split between digits and unit
for i, ch in enumerate(interval_string):
if not ch.isdigit():
num_part = interval_string[:i]
unit_part = interval_string[i:]
if not num_part: # No digits before unit
return (None, None)
try:
return (int(num_part), unit_part)
except ValueError:
return (None, None)
return (None, None) # No unit found
```

**Assistant Output (truncated for brevity):**

```python
import pytest

def test_parse_interval_valid():
assert parse_interval("1d") == (1, "d")
assert parse_interval("24h") == (24, "h")
assert parse_interval("30m") == (30, "m")

def test_parse_interval_invalid():
assert parse_interval("") == (None, None)
assert parse_interval("h") == (None, None)
assert parse_interval("abc") == (None, None)

def test_parse_interval_not_string():
assert parse_interval(123) == (None, None)
assert parse_interval(None) == (None, None)
```

**Why this fails:**
The tests are shallow and miss critical edge cases a human would immediately consider:
1. **Whitespace:** Does `" 1d "` work? The code `.strip()`s, but this isn't tested.
2. **Capital Letters:** The code `.lower()`s. `"1D"` should pass. Not tested.
3. **Boundary Logic:** What about `"0d"`? The function returns `(0, "d")`, but is that a valid interval for your system? An AI doesn't know your domain.
4. **Complex Invalid Cases:** `"1.5h"` (float), `"1h30m"` (two units), `" "` (only whitespace). The assistant's "invalid" tests are trivial.
5. **No Parametrization:** It writes three separate assertions instead of a clean `@pytest.mark.parametrize`.

The most critical failure is **not testing the actual behavior described in the docstring**. The docstring says "Returns (None, None) for invalid input." What constitutes 'invalid'? The assistant just guessed (`"abc"`), but didn't methodically test the branches revealed in the code (e.g., `not num_part`).

**Correct Approach (partial):**
A useful test suite would be parametrized and exhaustive:
```python
import pytest

@pytest.mark.parametrize("input_str, expected", [
("1d", (1, "d")),
("24h", (24, "h")),
("30m", (30, "m")),
("0m", (0, "m")), # Boundary
(" 1d ", (1, "d")), # Whitespace
("1D", (1, "d")), # Case-insensitivity
])
def test_parse_interval_valid(input_str, expected):
assert parse_interval(input_str) == expected

@pytest.mark.parametrize("invalid_input", [
"",
" ",
"h",
"d",
"1.5h",
"1h30m",
"abc",
"-1h",
123,
None,
[],
])
def test_parse_interval_invalid(invalid_input):
assert parse_interval(invalid_input) == (None, None)
```

The assistant gave me scaffolding. I had to provide the **actual test intelligence**. For unit tests, that's the entire value. Without it, you just have false confidence.

Anyone else found an assistant that's actually good at the *logic* of test cases, not just the syntax?

--monitor