Files
headroom/tests/test_code_aware_regressions.py
Mansurshakh JaparovandJerrettDavis 93279f3208 fix(smart-crusher): preserve unchanged JSON bytes (#4044)
## Description

Closes #3697.

An unchanged SmartCrusher result now keeps the original bytes and
reports no structural compression. Formatting-only savings come from the
existing Rust JsonMinifier, not from pretending the JSON value changed.

The minifier preserves duplicate keys, order, escapes and number
literals. A mixed result cannot use one section's CCR marker to hide
unmarked loss in another.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [x] Documentation update

## Changes Made

- Keep SmartCrusher's exact-byte no-op behavior; route actual whitespace
savings through JsonMinifier in Python and the eligible native live
zone.
- Keep all records and JSON literals; do not store originals or inject
CCR markers for lossless minification.
- Preserve mixed routing and reject uncovered lossy sections in both
tool-result formats. Explicit no-CCR behavior is unchanged.
- Replace incidental forwarding tests with native minification and
complete-record regressions; document the distinction.

## Testing

- [ ] Entire Python suite — not claimed.
- [x] Four consumer/native modules: `python -m pytest -q
tests/test_recursive_json.py tests/test_transforms_content_router.py
tests/test_transforms/test_smart_crusher_rust_parity.py
tests/test_transforms/test_smart_crusher_lossless_default.py`
- [x] Changed-file Ruff checks; normal commit hooks, including mypy and
commitlint.
- [x] Manual public-API runs, with and without the HTML extra.

### Test Output

Consumer/native modules:

```text
collected 136 items
============================= 136 passed in 36.43s =============================
```

Normal pre-push (fmt, clippy, 1,668 Rust tests with 3 ignored, native
build, Python checks, commitlint):

```text
======================== 180 passed, 1 warning in 8.35s ========================
✅ ci-precheck PASSED — safe to push.
To https://github.com/oxura/headroom.git
   64688217..0002af3e  HEAD -> fix/3697-unchanged-json-passthrough
```

The first push stopped on an inherited commit footer because
`origin/main` was stale. Fetching the actual upstream ref fixed the lint
range; the normal push then passed. No source merge, lint-rule change or
hook bypass.

Hosted checks on `0002af3e` now pass: all four Python shards, Windows
permissions, smoke tests, native wrappers, parity and Docker e2e.
[Checks](https://github.com/headroomlabs-ai/headroom/pull/4044/checks).

## Real Behavior Proof

- Environment: Linux x86-64, Python 3.13.14, Rust 1.95 and the actual
extension built from this checkout. No provider billing calls.
- Exact command / steps: the earlier localhost `/v1/compress` and
TransformPipeline runs exercised the original fix. For this follow-up,
call `ContentRouter.compress` on a data-only HTML page containing 60
complete records, with `smart_crusher_lossless_only=True`,
`smart_crusher_with_compaction=False`, and `enable_kompress=False`. Run
it once without trafilatura, then with the locked 2.0.0 extra. The new
public-API test contains the full input/config. Separately call
`route_embedded_json` on a compact array followed by a padded array,
with Unicode and CRLF surroundings.
- Observed result: both HTML modes keep all 60 records and the
surrounding markup, with no unrecoverable section. The unchanged first
JSON span does not stop the second span's compaction; surrounding text
stays exact. Final Codecov is 96%; the two remaining lines are the
deferred HTML fallback return. The real no-HTML-extra API run executed
both, and local coverage also exercises the unchanged-span branch.
- Not tested: live provider acceptance, invoices or production cache hit
rates. No native eligibility or admission gates changed.

## Runtime Rollout Safety

- Rollout-managed feature(s): none; existing JSON routing.
- Minimum rollout channel: unchanged.
- Stable/default behavior changed: eligible formatting savings return as
json_minifier; standalone SmartCrusher remains byte-exact on no-ops.
- Kill switch / disable path: existing routing configuration and
HEADROOM_LIVE_ZONE_DISABLE_ARMS.
- Unsafe override required: no.
- Qualification impact: no-op, formatting, structural and CCR paths
exercised separately.
- Rollback path: revert the minifier integration; no persistence
migration.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have made corresponding changes to the documentation
- [x] I did not edit CHANGELOG.md — release-please owns it

## Additional Notes

Addresses the [minifier
review](https://github.com/headroomlabs-ai/headroom/pull/4044#issuecomment-6157583285).
The maintainer’s main merge is retained. The latest follow-up only
changes consumer tests.

AI-assisted; no subagents.

---------

Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
2026-11-03 21:32:42 -06:00

146 lines
5.0 KiB
Python

"""Regression tests requested in review of PR #1668 (Go AST compression bugs
and CODE_AWARE token accounting) and PR #1670 (prefer_code_aware_for_code
default flip).
1. Go `statement_list` unwrapping — a Go function body no longer produces a
duplicated closing brace when truncated.
2. Multi-line Go signature (`) error {`) — the brace-bearing signature line
survives truncation instead of being silently dropped.
3. ContentRouter CODE_AWARE token accounting — compressed_tokens must come
from the same metric as original_tokens (the router's token estimator),
not the compressor's own (differently-scaled) estimator, or real savings
get misread as none.
4. prefer_code_aware_for_code defaults to True, both on the dataclass and via
the HEADROOM_PREFER_CODE_AWARE_FOR_CODE env var.
"""
from __future__ import annotations
import pytest
from headroom.proxy.server import HeadroomProxy, ProxyConfig
from headroom.transforms.code_compressor import (
CodeAwareCompressor,
CodeCompressorConfig,
_check_tree_sitter_available,
)
from headroom.transforms.content_router import (
CompressionStrategy,
ContentRouter,
ContentRouterConfig,
_estimate_tokens,
)
pytestmark = pytest.mark.skipif(
not _check_tree_sitter_available(),
reason="tree-sitter not installed (pip install headroom-ai[code])",
)
GO_FUNC = """package main
func Compute(
\ta int,
\tb int,
) error {
\tx := a + b
\ty := x * 2
\tz := y - a
\tw := z + b
\treturn nil
}
"""
def _compress_go(**config_overrides: object):
config = CodeCompressorConfig(
min_tokens_for_compression=0,
max_body_lines=2,
semantic_analysis=False,
**config_overrides,
)
compressor = CodeAwareCompressor(config)
return compressor.compress(GO_FUNC, language="go")
def test_go_statement_list_unwrap_no_duplicate_closing_brace() -> None:
"""Go wraps a block's statements in one `statement_list` node; treating
that as a single statement made its row range swallow the block's own
closing brace, producing a duplicate `}` in the compressed output."""
result = _compress_go()
closing_braces = [line for line in result.compressed.splitlines() if line.strip() == "}"]
assert len(closing_braces) == 1, (
f"expected exactly one closing brace line, got {len(closing_braces)}:\n{result.compressed}"
)
def test_go_multiline_signature_brace_preserved() -> None:
"""The multi-line signature's closing line (`) error {`) shares its row
with the brace instead of starting one of its own. Detecting the brace
via startswith("{") missed this and silently dropped the line; it must
survive truncation via endswith("{")."""
result = _compress_go()
assert result.compressed.count(") error {") == 1, (
f"multi-line signature line missing or duplicated:\n{result.compressed}"
)
class _FakeCodeCompressor:
def __init__(self, compressed: str) -> None:
self._compressed = compressed
def compress(self, content: str, language=None, context=""):
class _Result:
pass
r = _Result()
r.compressed = self._compressed
# Deliberately inflated/differently-scaled "own" token estimate —
# simulates a compressor whose internal counter isn't comparable to
# the router's own token estimate.
r.compressed_tokens = 10_000_000
return r
def test_content_router_code_aware_token_accounting_matches_router_estimate() -> None:
"""compressed_tokens must be derived from _estimate_tokens(result.compressed),
the same metric as original_tokens, not the compressor's own estimator.
Using the mismatched estimator made a real compression look like "no
savings" and forced a needless fallback to Kompress."""
original = "word " * 200 # 200 words
compressed_text = "word " * 50 # a real, large reduction
router = ContentRouter(ContentRouterConfig(enable_code_aware=True))
router._code_compressor = _FakeCodeCompressor(compressed_text)
compressed, compressed_tokens, strategy_chain, _reversible = router._apply_strategy_to_content(
original, CompressionStrategy.CODE_AWARE, context=""
)
assert compressed == compressed_text
assert compressed_tokens == _estimate_tokens(compressed_text)
assert strategy_chain == ["code_aware"], (
f"real compression must not trigger a Kompress fallback, got {strategy_chain}"
)
def test_prefer_code_aware_for_code_dataclass_defaults_true() -> None:
assert ContentRouterConfig().prefer_code_aware_for_code is True
def test_prefer_code_aware_for_code_env_var_defaults_true(monkeypatch) -> None:
monkeypatch.delenv("HEADROOM_PREFER_CODE_AWARE_FOR_CODE", raising=False)
config = ProxyConfig(
optimize=False,
cache_enabled=False,
rate_limit_enabled=False,
cost_tracking_enabled=False,
code_aware_enabled=False,
)
proxy = HeadroomProxy(config)
router = proxy.anthropic_pipeline.transforms[-1]
assert router.config.prefer_code_aware_for_code is True