mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:10:00 +08:00
## Description
This PR removes duplicated tests for the LangChain and LiteLLM
integrations. It changes no product code.
- **`tests/test_integrations/langchain/test_extended.py`** repeated
tests for:
- `HeadroomChatMessageHistory`
- `HeadroomDocumentCompressor`
- `HeadroomToolWrapper`
- the streaming metrics tracker
The per-module test files already cover all four. Line and branch
coverage of `headroom/integrations/langchain` is identical with and
without these tests.
- **The LiteLLM tests removed** only asserted `hasattr`, `callable` or
not-None on hooks that other tests in the same files call and await.
Refs #4136
## Type of Change
- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [x] Code refactoring (no functional changes)
## Changes Made
- `test_extended.py`: delete these classes:
- `TestHeadroomChatMessageHistory` (5 tests)
- `TestHeadroomDocumentCompressor` (7)
- `TestStreamingMetricsTracker` (8)
- 5 of the 6 `TestHeadroomToolWrapper` tests
- Kept from `TestHeadroomToolWrapper`:
`test_call_compresses_large_json`. It is the only LangChain test that
runs `compress_tool_result` unmocked. It is also the only test in this
set that reaches the non-JSON fallback in
`headroom/integrations/mcp/server.py:343-344`;
`tests/test_integrations/mcp` does not cover those lines.
- Also kept: `TestProviderDetection`,
`TestHeadroomLangSmithCallbackHandler` and
`TestAutoDetectProviderInChatModel`. They are the only coverage for
`providers.py` and `langsmith.py`.
- Moved, not deleted: `test_output_tokens` and
`test_messages_passthrough_under_threshold`. Every other memory and
streaming test passes a mock provider or patches `OpenAIProvider`; these
two were the only ones that ran the real default provider
(`OpenAIProvider().get_token_counter(model)`) end to end. They now live
next to their siblings:
-
`test_streaming.py::TestStreamingMetricsTrackerProperties::test_output_tokens_with_default_provider`
-
`test_memory.py::TestHeadroomChatMessageHistoryMessages::test_messages_below_threshold_with_default_provider`
- The `langchain_core` availability probe now imports the package
instead of 4 names that are no longer used.
- `tests/test_litellm_callback.py`: delete
`test_instantiates_without_error`,
`test_has_async_post_call_success_hook`,
`test_async_post_call_success_hook_is_callable` and
`test_async_pre_call_hook_still_works`. Still covered by:
- `test_async_post_call_success_hook_does_not_raise`;
- `test_all_current_litellm_async_hooks_present`;
- the route tests that await `async_pre_call_hook`.
- `tests/test_integrations/test_litellm_callback.py`: delete
`test_method_exists` and `test_method_is_coroutine`.
`test_returns_response_unchanged` awaits the same hook.
## Testing
- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`)
- [ ] New tests added for new functionality
- [x] Manual testing performed
### Test Output
```text
$ pytest tests/test_integrations/langchain/test_extended.py tests/test_litellm_callback.py tests/test_integrations/test_litellm_callback.py
origin/main: 59 passed
this branch: 28 passed (31 removed: 25 + 4 + 2)
$ pytest <the same 3 files> tests/test_integrations/langchain/test_memory.py tests/test_integrations/langchain/test_streaming.py
origin/main: 124 passed
this branch: 95 passed (29 fewer: 31 removed, 2 moved into test_memory.py / test_streaming.py)
# coverage evidence, on origin/main (coverage run --branch over tests/test_integrations/langchain, 244 passed / 21 skipped)
headroom/integrations/langchain/* with the 26 tests: 1150 stmts, 161 miss, 346 branches, 52 partial
headroom/integrations/langchain/* without the 26 tests: 1150 stmts, 161 miss, 346 branches, 52 partial
# the only difference outside langchain/ in that run: mcp/server.py 343-344, sqlite.py, compression_store.py, toin.py
# per-test check: mcp/server.py 343-344 come from test_call_compresses_large_json, which this branch keeps.
# The sqlite/compression_store/toin lines are side effects of real compression; their own test suites own them.
$ uvx ruff@0.16.8 check / format <3 touched files> -> All checks passed! / unchanged
```
## Real Behavior Proof
- Environment: macOS, Python 3.12, repo venv (langchain-core and litellm
installed).
- Exact command / steps:
- `python -m coverage run --branch -m pytest -p no:cov
tests/test_integrations/langchain`, with and without `--deselect` of the
four classes, then `coverage report -m` and a diff.
- `pytest-cov` breaks the litellm import (`KeyError:
'pydantic.root_model'`), so coverage was run directly.
- Observed result: identical numbers for
`headroom/integrations/langchain`. The one test that adds unique
coverage elsewhere is kept.
- Smoke harness (real proxy started from this checkout against a local
fake upstream; temp HOME and workspace, offline):
```text
branch: cleanup/cli-integrations-dedupe-integration-tests @ fc66c0bc
health: 200
POST /v1/messages -> HTTP200 smoke-ok
POST /v1/chat/completions -> HTTP200 smoke-ok
stats: requests=2 failed=0 tokens_saved=13574 savings_percent=99.82
proxy.log WARNING/ERROR lines (<tmp>/ws/logs/proxy-63921.log):
2 headroom.proxy - WARNING - event=proxy_offline_mode air-gap active — every connection Headroom initiates is refused (telemetry, update check, license reporter, model/tokenizer/binary/dataset downloads, remote Kompress, OTLP/Langfuse export, Copilot auth, subscription polling, OpenAI embedders, Headroom Cloud compression). Still allowed on purpose: forwarding your requests to the upstream you configured, operator-configured local endpoints, loopback health probes.
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch found no usable file for chopratejas/kompress-v2-base
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch refused for chopratejas/kompress-v2-base (HEADROOM_OFFLINE is set): HEADROOM_OFFLINE is set: refusing outbound network access for HuggingFace download of chopratejas/kompress-v2-base/onnx/kompress-int8-wo.onnx to huggingface.co. Unset HEADROOM_OFFLINE, or turn off the feature that needs this connection.
(smoke dir: <tmp>)
```
- Direct runtime command on this PR's own path (temp HOME,
HEADROOM_WORKSPACE_DIR and CODEX_HOME):
```text
$ python stream_run.py # real StreamingMetricsTracker and HeadroomChatMessageHistory, no provider passed
default-provider output_tokens: 9
default-provider history: ['Hello', 'Hi there!'] compressions: 0
```
- Not tested: n/a (tests only).
## Runtime Rollout Safety
- Rollout-managed feature(s): none.
- Minimum rollout channel: n/a, tests only.
- Stable/default behavior changed: no.
- Kill switch / disable path: n/a.
- Unsafe override required: no.
- Qualification impact: none.
- Rollback path: revert this commit.
## 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
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)
## Screenshots (if applicable)
N/A
## Additional Notes
Part of maintainer-requested cleanup #4136 (dead code, duplication,
debuggability), split into small PRs for review.
- This keeps one more test than the audit proposed (25 of 26 removed
from `test_extended.py`), for the reason above, and moves two of the 25
into the focused files so the default-provider path stays tested.
- mypy is unchecked because the PR changes no product code. Docs need no
change.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
<!-- devin-review-badge-begin -->
---
<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/4133"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
514 lines
19 KiB
Python
514 lines
19 KiB
Python
"""Tests for LangChain memory integration with automatic compression.
|
|
|
|
Tests cover:
|
|
1. HeadroomChatMessageHistory - Wrapper for chat message history with compression
|
|
2. Message conversion to/from OpenAI format
|
|
3. Rolling window compression behavior
|
|
4. Token counting and threshold detection
|
|
5. Compression statistics tracking
|
|
"""
|
|
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
# Check if LangChain is available
|
|
try:
|
|
from langchain_core.messages import (
|
|
AIMessage,
|
|
BaseMessage,
|
|
HumanMessage,
|
|
SystemMessage,
|
|
ToolMessage,
|
|
)
|
|
|
|
LANGCHAIN_AVAILABLE = True
|
|
except ImportError:
|
|
LANGCHAIN_AVAILABLE = False
|
|
|
|
# Skip all tests if LangChain not installed
|
|
pytestmark = pytest.mark.skipif(not LANGCHAIN_AVAILABLE, reason="LangChain not installed")
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_base_history():
|
|
"""Create a mock BaseChatMessageHistory."""
|
|
mock = MagicMock()
|
|
mock.messages = []
|
|
return mock
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_provider():
|
|
"""Create a mock provider with token counter."""
|
|
mock = MagicMock()
|
|
mock_counter = MagicMock()
|
|
mock_counter.count_text = MagicMock(side_effect=lambda text: len(text.split()))
|
|
mock.get_token_counter = MagicMock(return_value=mock_counter)
|
|
return mock
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_langchain_messages():
|
|
"""Sample LangChain messages for testing."""
|
|
return [
|
|
SystemMessage(content="You are a helpful assistant."),
|
|
HumanMessage(content="Hello, how are you?"),
|
|
AIMessage(content="I am doing well, thank you!"),
|
|
HumanMessage(content="What is the weather today?"),
|
|
AIMessage(content="I don't have access to weather data."),
|
|
]
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryInit:
|
|
"""Tests for HeadroomChatMessageHistory initialization."""
|
|
|
|
def test_init_defaults(self, mock_base_history):
|
|
"""Initialize with default settings."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
with patch("headroom.integrations.langchain.memory.OpenAIProvider"):
|
|
history = HeadroomChatMessageHistory(mock_base_history)
|
|
|
|
assert history._base is mock_base_history
|
|
assert history._threshold == 4000
|
|
assert history._keep_recent_turns == 5
|
|
assert history._model == "gpt-4o"
|
|
assert history._compression_count == 0
|
|
assert history._total_tokens_saved == 0
|
|
|
|
def test_init_custom_threshold(self, mock_base_history, mock_provider):
|
|
"""Initialize with custom compression threshold."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=8000,
|
|
keep_recent_turns=10,
|
|
model="gpt-4-turbo",
|
|
provider=mock_provider,
|
|
)
|
|
|
|
assert history._threshold == 8000
|
|
assert history._keep_recent_turns == 10
|
|
assert history._model == "gpt-4-turbo"
|
|
assert history._provider is mock_provider
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryMessages:
|
|
"""Tests for message access and compression."""
|
|
|
|
def test_messages_returns_empty_when_no_messages(self, mock_base_history, mock_provider):
|
|
"""messages property returns empty list when no messages."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
mock_base_history.messages = []
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
messages = history.messages
|
|
|
|
assert messages == []
|
|
|
|
def test_messages_returns_uncompressed_when_below_threshold(
|
|
self, mock_base_history, mock_provider, sample_langchain_messages
|
|
):
|
|
"""messages returns uncompressed when below token threshold."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
mock_base_history.messages = sample_langchain_messages
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=10000, # High threshold
|
|
provider=mock_provider,
|
|
)
|
|
|
|
messages = history.messages
|
|
|
|
# Should return all messages unchanged
|
|
assert len(messages) == len(sample_langchain_messages)
|
|
assert history._compression_count == 0
|
|
|
|
def test_messages_below_threshold_with_default_provider(self):
|
|
"""With no provider passed, the default provider counts tokens and
|
|
short histories pass through."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
base = MagicMock()
|
|
base.messages = [HumanMessage(content="Hello"), AIMessage(content="Hi there!")]
|
|
|
|
history = HeadroomChatMessageHistory(base, compress_threshold_tokens=10000)
|
|
messages = history.messages
|
|
|
|
assert [m.content for m in messages] == ["Hello", "Hi there!"]
|
|
assert history._compression_count == 0
|
|
|
|
def test_messages_compresses_when_over_threshold(self, mock_base_history, mock_provider):
|
|
"""messages applies compression when over token threshold."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
# Create messages that exceed threshold
|
|
mock_base_history.messages = [
|
|
SystemMessage(content="System " * 100),
|
|
HumanMessage(content="User " * 100),
|
|
AIMessage(content="Assistant " * 100),
|
|
]
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=10, # Very low threshold
|
|
provider=mock_provider,
|
|
)
|
|
|
|
# Mock _apply_compression to return fewer messages
|
|
with patch.object(history, "_apply_compression") as mock_apply:
|
|
mock_apply.return_value = [
|
|
SystemMessage(content="Compressed"),
|
|
]
|
|
|
|
_ = history.messages
|
|
|
|
mock_apply.assert_called_once()
|
|
assert history._compression_count == 1
|
|
|
|
def test_messages_tracks_tokens_saved(self, mock_base_history, mock_provider):
|
|
"""Compression tracks tokens saved."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
# Create messages that exceed threshold
|
|
mock_base_history.messages = [
|
|
SystemMessage(content="Word " * 50),
|
|
HumanMessage(content="Word " * 50),
|
|
]
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=10, # Very low threshold
|
|
provider=mock_provider,
|
|
)
|
|
|
|
# Mock _apply_compression to return fewer messages
|
|
with patch.object(history, "_apply_compression") as mock_apply:
|
|
mock_apply.return_value = [
|
|
SystemMessage(content="Short"),
|
|
]
|
|
|
|
_ = history.messages
|
|
|
|
# tokens_saved should increase
|
|
assert history._total_tokens_saved > 0
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryAddMessage:
|
|
"""Tests for add_message methods."""
|
|
|
|
def test_add_message(self, mock_base_history, mock_provider):
|
|
"""add_message delegates to base history."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
msg = HumanMessage(content="Hello")
|
|
history.add_message(msg)
|
|
|
|
mock_base_history.add_message.assert_called_once_with(msg)
|
|
|
|
def test_add_user_message(self, mock_base_history, mock_provider):
|
|
"""add_user_message delegates to base history."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
history.add_user_message("Hello")
|
|
|
|
mock_base_history.add_user_message.assert_called_once_with("Hello")
|
|
|
|
def test_add_ai_message(self, mock_base_history, mock_provider):
|
|
"""add_ai_message delegates to base history."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
history.add_ai_message("Response")
|
|
|
|
mock_base_history.add_ai_message.assert_called_once_with("Response")
|
|
|
|
def test_clear(self, mock_base_history, mock_provider):
|
|
"""clear delegates to base history."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
history.clear()
|
|
|
|
mock_base_history.clear.assert_called_once()
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryConversion:
|
|
"""Tests for message format conversion."""
|
|
|
|
def test_convert_to_openai_system_message(self, mock_base_history, mock_provider):
|
|
"""Convert SystemMessage to OpenAI format."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
messages = [SystemMessage(content="You are helpful.")]
|
|
result = history._convert_to_openai(messages)
|
|
|
|
assert len(result) == 1
|
|
assert result[0]["role"] == "system"
|
|
assert result[0]["content"] == "You are helpful."
|
|
|
|
def test_convert_to_openai_human_message(self, mock_base_history, mock_provider):
|
|
"""Convert HumanMessage to OpenAI format."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
messages = [HumanMessage(content="Hello")]
|
|
result = history._convert_to_openai(messages)
|
|
|
|
assert result[0]["role"] == "user"
|
|
assert result[0]["content"] == "Hello"
|
|
|
|
def test_convert_to_openai_ai_message(self, mock_base_history, mock_provider):
|
|
"""Convert AIMessage to OpenAI format."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
messages = [AIMessage(content="I can help.")]
|
|
result = history._convert_to_openai(messages)
|
|
|
|
assert result[0]["role"] == "assistant"
|
|
assert result[0]["content"] == "I can help."
|
|
|
|
def test_convert_to_openai_ai_message_with_tool_calls(self, mock_base_history, mock_provider):
|
|
"""Convert AIMessage with tool_calls to OpenAI format."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
messages = [
|
|
AIMessage(
|
|
content="Calling tool...",
|
|
tool_calls=[{"id": "call_1", "name": "search", "args": {"q": "test"}}],
|
|
)
|
|
]
|
|
result = history._convert_to_openai(messages)
|
|
|
|
assert result[0]["role"] == "assistant"
|
|
assert "tool_calls" in result[0]
|
|
assert result[0]["tool_calls"][0]["id"] == "call_1"
|
|
|
|
def test_convert_to_openai_tool_message(self, mock_base_history, mock_provider):
|
|
"""Convert ToolMessage to OpenAI format."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
messages = [ToolMessage(content='{"result": "data"}', tool_call_id="call_1")]
|
|
result = history._convert_to_openai(messages)
|
|
|
|
assert result[0]["role"] == "tool"
|
|
assert result[0]["tool_call_id"] == "call_1"
|
|
assert result[0]["content"] == '{"result": "data"}'
|
|
|
|
def test_convert_from_openai_system(self, mock_base_history, mock_provider):
|
|
"""Convert OpenAI system message back to LangChain."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
openai_msgs = [{"role": "system", "content": "System prompt"}]
|
|
result = history._convert_from_openai(openai_msgs)
|
|
|
|
assert len(result) == 1
|
|
assert isinstance(result[0], SystemMessage)
|
|
assert result[0].content == "System prompt"
|
|
|
|
def test_convert_from_openai_user(self, mock_base_history, mock_provider):
|
|
"""Convert OpenAI user message back to LangChain."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
openai_msgs = [{"role": "user", "content": "Hello"}]
|
|
result = history._convert_from_openai(openai_msgs)
|
|
|
|
assert isinstance(result[0], HumanMessage)
|
|
assert result[0].content == "Hello"
|
|
|
|
def test_convert_from_openai_assistant(self, mock_base_history, mock_provider):
|
|
"""Convert OpenAI assistant message back to LangChain."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
openai_msgs = [{"role": "assistant", "content": "Response"}]
|
|
result = history._convert_from_openai(openai_msgs)
|
|
|
|
assert isinstance(result[0], AIMessage)
|
|
assert result[0].content == "Response"
|
|
|
|
def test_convert_from_openai_assistant_with_tool_calls(self, mock_base_history, mock_provider):
|
|
"""Convert OpenAI assistant message with tool_calls back to LangChain."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
openai_msgs = [
|
|
{
|
|
"role": "assistant",
|
|
"content": "",
|
|
"tool_calls": [{"id": "call_1", "name": "search", "args": {}}],
|
|
}
|
|
]
|
|
result = history._convert_from_openai(openai_msgs)
|
|
|
|
assert isinstance(result[0], AIMessage)
|
|
# LangChain may add a 'type' field to tool_calls, so just check key fields
|
|
assert len(result[0].tool_calls) == 1
|
|
assert result[0].tool_calls[0]["id"] == "call_1"
|
|
assert result[0].tool_calls[0]["name"] == "search"
|
|
assert result[0].tool_calls[0]["args"] == {}
|
|
|
|
def test_convert_from_openai_tool(self, mock_base_history, mock_provider):
|
|
"""Convert OpenAI tool message back to LangChain."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(mock_base_history, provider=mock_provider)
|
|
|
|
openai_msgs = [{"role": "tool", "tool_call_id": "call_1", "content": '{"data": 1}'}]
|
|
result = history._convert_from_openai(openai_msgs)
|
|
|
|
assert isinstance(result[0], ToolMessage)
|
|
assert result[0].tool_call_id == "call_1"
|
|
assert result[0].content == '{"data": 1}'
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryTokenCounting:
|
|
"""Tests for token counting."""
|
|
|
|
def test_count_tokens(self, mock_base_history, mock_provider):
|
|
"""Count tokens using provider's tokenizer."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
provider=mock_provider,
|
|
model="gpt-4o",
|
|
)
|
|
|
|
messages = [
|
|
HumanMessage(content="Hello world"),
|
|
AIMessage(content="Hi there"),
|
|
]
|
|
|
|
count = history._count_tokens(messages)
|
|
|
|
# Mock counts words, so "Hello world" = 2, "Hi there" = 2
|
|
assert count == 4
|
|
mock_provider.get_token_counter.assert_called_with("gpt-4o")
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryStats:
|
|
"""Tests for compression statistics."""
|
|
|
|
def test_get_compression_stats_initial(self, mock_base_history, mock_provider):
|
|
"""Get initial compression stats."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=4000,
|
|
keep_recent_turns=5,
|
|
provider=mock_provider,
|
|
)
|
|
|
|
stats = history.get_compression_stats()
|
|
|
|
assert stats["compression_count"] == 0
|
|
assert stats["total_tokens_saved"] == 0
|
|
assert stats["threshold_tokens"] == 4000
|
|
assert stats["keep_recent_turns"] == 5
|
|
|
|
def test_get_compression_stats_after_compression(self, mock_base_history, mock_provider):
|
|
"""Get compression stats after compression."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
mock_base_history.messages = [
|
|
SystemMessage(content="Word " * 100),
|
|
HumanMessage(content="Word " * 100),
|
|
]
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=10,
|
|
provider=mock_provider,
|
|
)
|
|
|
|
# Mock _apply_compression
|
|
with patch.object(history, "_apply_compression") as mock_apply:
|
|
mock_apply.return_value = [SystemMessage(content="Short")]
|
|
|
|
_ = history.messages
|
|
|
|
stats = history.get_compression_stats()
|
|
|
|
assert stats["compression_count"] == 1
|
|
assert stats["total_tokens_saved"] > 0
|
|
|
|
|
|
class TestHeadroomChatMessageHistoryCompression:
|
|
"""Tests for rolling window compression."""
|
|
|
|
def test_apply_compression_calls_pipeline(self, mock_base_history, mock_provider):
|
|
"""_apply_compression uses TransformPipeline."""
|
|
from headroom.integrations.langchain.memory import HeadroomChatMessageHistory
|
|
|
|
history = HeadroomChatMessageHistory(
|
|
mock_base_history,
|
|
compress_threshold_tokens=1000,
|
|
keep_recent_turns=5,
|
|
provider=mock_provider,
|
|
)
|
|
|
|
messages = [
|
|
HumanMessage(content="Hello"),
|
|
AIMessage(content="Hi there"),
|
|
]
|
|
|
|
with patch("headroom.integrations.langchain.memory.TransformPipeline") as MockPipeline:
|
|
mock_instance = MagicMock()
|
|
mock_result = MagicMock()
|
|
mock_result.messages = [
|
|
{"role": "user", "content": "Hello"},
|
|
{"role": "assistant", "content": "Hi there"},
|
|
]
|
|
mock_instance.apply.return_value = mock_result
|
|
MockPipeline.return_value = mock_instance
|
|
|
|
result = history._apply_compression(messages)
|
|
|
|
MockPipeline.assert_called_once()
|
|
mock_instance.apply.assert_called_once()
|
|
|
|
# Result should be converted back to LangChain messages
|
|
assert all(isinstance(m, BaseMessage) for m in result)
|
|
|
|
|
|
class TestLangChainNotAvailable:
|
|
"""Tests for behavior when LangChain is not available."""
|
|
|
|
def test_check_raises_import_error(self):
|
|
"""_check_langchain_available raises ImportError when not available."""
|
|
from headroom.integrations.langchain.memory import _check_langchain_available
|
|
|
|
# When LangChain IS available, should not raise
|
|
try:
|
|
_check_langchain_available()
|
|
except ImportError:
|
|
pytest.fail("Should not raise when LangChain is available")
|