ed/manual_slop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

checkpoint: finished test curation

Browse Source
This commit is contained in:
Edward R. Gonzalez
2026-02-25 21:58:18 -05:00
parent e0b9ab997a
commit 56025a84e9
33 changed files with 546 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
tests/mock_gemini_cli.py
View File

@@ -18,6 +18,20 @@ def main():
if "run" not in sys.argv:
return
# If the prompt contains tool results (indicated by "role": "tool"),
# it means we are in the second round and should provide a final answer.
if '"role": "tool"' in prompt:
print(json.dumps({
"type": "message",
"text": "I have processed the tool results. Everything looks good!"
}), flush=True)
print(json.dumps({
"type": "result",
"usage": {"total_tokens": 100},
"session_id": "mock-session-final"
}), flush=True)
return
# Simulate the 'BeforeTool' hook by calling the bridge directly.
bridge_path = os.path.abspath("scripts/cli_tool_bridge.py")
@@ -35,7 +49,8 @@ def main():
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
text=True,
env=os.environ # Ensure environment variables are inherited
)
stdout, stderr = process.communicate(input=json.dumps(tool_call))
@@ -70,11 +85,11 @@ def main():
}), flush=True)
else:
print(json.dumps({
"type": "message",
"type": "message",
"text": f"Tool execution was denied. Decision: {decision}"
}), flush=True)
print(json.dumps({
"type": "result",
"type": "result",
"usage": {"total_tokens": 10},
"session_id": "mock-session-denied"
}), flush=True)

2
tests/temp_liveaisettingssim_history.toml
View File

@@ -9,5 +9,5 @@ auto_add = true
[discussions.main]
git_commit = ""
last_updated = "2026-02-25T20:31:39"
last_updated = "2026-02-25T21:54:43"
history = []

6
tests/temp_livecontextsim_history.toml
View File

@@ -5,10 +5,10 @@ roles = [
"System",
]
history = []
active = "TestDisc_1772069479"
active = "TestDisc_1772074463"
auto_add = true
[discussions.TestDisc_1772069479]
[discussions.TestDisc_1772074463]
git_commit = ""
last_updated = "2026-02-25T20:31:32"
last_updated = "2026-02-25T21:54:37"
history = []

2
tests/temp_liveexecutionsim.toml
View File

@@ -20,7 +20,7 @@ base_dir = "."
paths = []
[gemini_cli]
binary_path = "\"C:\\projects\\manual_slop\\.venv\\Scripts\\python.exe\" \"C:\\projects\\manual_slop\\tests\\mock_gemini_cli.py\""
binary_path = "gemini"
[agent.tools]
run_powershell = true

2
tests/temp_liveexecutionsim_history.toml
View File

@@ -9,5 +9,5 @@ auto_add = true
[discussions.main]
git_commit = ""
last_updated = "2026-02-25T20:33:29"
last_updated = "2026-02-25T21:55:13"
history = []

2
tests/temp_livetoolssim_history.toml
View File

@@ -9,5 +9,5 @@ auto_add = true
[discussions.main]
git_commit = ""
last_updated = "2026-02-25T20:31:58"
last_updated = "2026-02-25T21:55:00"
history = []

2
tests/temp_project_history.toml
View File

@@ -9,5 +9,5 @@ auto_add = true
[discussions.main]
git_commit = ""
last_updated = "2026-02-25T20:35:15"
last_updated = "2026-02-25T21:55:15"
history = []

25
tests/test_ai_context_history.py
View File

@@ -1,25 +0,0 @@
import pytest
import tomli_w
from pathlib import Path
import aggregate
import project_manager
def test_aggregate_includes_segregated_history(tmp_path):
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# Setup segregated project
proj_data = project_manager.default_project("test-aggregate")
proj_data["discussion"]["discussions"]["main"]["history"] = ["@2026-02-24T14:00:00\nUser:\nShow me history"]
# Save (will segregate)
project_manager.save_project(proj_data, proj_path)
# Run aggregate
loaded_proj = project_manager.load_project(proj_path)
config = project_manager.flat_config(loaded_proj)
markdown, output_file, file_items = aggregate.run(config)
assert "## Discussion History" in markdown
assert "Show me history" in markdown

1
tests/test_cli_tool_bridge.py
View File

@@ -13,6 +13,7 @@ from scripts.cli_tool_bridge import main
class TestCliToolBridge(unittest.TestCase):
def setUp(self):
os.environ['GEMINI_CLI_HOOK_CONTEXT'] = 'manual_slop'
self.tool_call = {
'tool_name': 'read_file',
'tool_input': {'path': 'test.txt'}

33
tests/test_gemini_cli_integration.py
View File

@@ -11,6 +11,12 @@ def test_gemini_cli_full_integration(live_gui):
"""
client = ApiHookClient("http://127.0.0.1:8999")
# 0. Reset session and enable history
client.click("btn_reset")
client.set_value("auto_add_history", True)
# Switch to manual_slop project explicitly
client.select_list_item("proj_files", "manual_slop")
# 1. Setup paths and configure the GUI
mock_script = os.path.abspath("tests/mock_gemini_cli.py")
# Wrap in quotes for shell execution if path has spaces
@@ -91,6 +97,12 @@ def test_gemini_cli_rejection_and_history(live_gui):
"""
client = ApiHookClient("http://127.0.0.1:8999")
# 0. Reset session and enable history
client.click("btn_reset")
client.set_value("auto_add_history", True)
# Switch to manual_slop project explicitly
client.select_list_item("proj_files", "manual_slop")
# 1. Setup paths and configure the GUI
mock_script = os.path.abspath("tests/mock_gemini_cli.py")
cli_cmd = f'"{sys.executable}" "{mock_script}"'
@@ -142,18 +154,31 @@ def test_gemini_cli_rejection_and_history(live_gui):
client.set_value("ai_input", "What happened?")
client.click("btn_gen_send")
# Wait for mock to finish (it will just return a message)
time.sleep(2)
# Wait for mock to finish (polling history)
print("[TEST] Waiting for final history entry (max 30s)...")
final_message_received = False
start_time = time.time()
while time.time() - start_time < 30:
session = client.get_session()
entries = session.get("session", {}).get("entries", [])
if len(entries) >= 3:
final_message_received = True
break
# Print snapshot for debug
if int(time.time() - start_time) % 5 == 0:
print(f"[TEST] History length at {int(time.time() - start_time)}s: {len(entries)}")
time.sleep(1.0)
session = client.get_session()
entries = session.get("session", {}).get("entries", [])
# Should have:
# 1. User: Deny me
# 2. AI: Tool execution was denied...
# 3. User: What happened?
# 4. AI: ...
# 4. AI or System: ...
print(f"[TEST] Final history length: {len(entries)}")
for i, entry in enumerate(entries):
print(f" {i}: {entry.get('role')} - {entry.get('content')[:30]}...")
assert len(entries) >= 4
assert len(entries) >= 3

16
tests/test_headless_dependencies.py
View File

@@ -1,16 +0,0 @@
import pytest
import importlib
def test_fastapi_installed():
"""Verify that fastapi is installed."""
try:
importlib.import_module("fastapi")
except ImportError:
pytest.fail("fastapi is not installed")
def test_uvicorn_installed():
"""Verify that uvicorn is installed."""
try:
importlib.import_module("uvicorn")
except ImportError:
pytest.fail("uvicorn is not installed")

74
tests/test_headless_api.py → tests/test_headless_service.py
View File

@@ -1,8 +1,11 @@
import sys
import unittest
from fastapi.testclient import TestClient
import gui_2
from unittest.mock import patch, MagicMock
import gui_2
import pytest
import importlib
from pathlib import Path
from fastapi.testclient import TestClient
class TestHeadlessAPI(unittest.TestCase):
def setUp(self):
@@ -15,11 +18,11 @@ class TestHeadlessAPI(unittest.TestCase):
self.test_api_key = "test-secret-key"
self.app_instance.config["headless"] = {"api_key": self.test_api_key}
self.headers = {"X-API-KEY": self.test_api_key}
# Clear any leftover state
self.app_instance._pending_actions = {}
self.app_instance._pending_dialog = None
self.api = self.app_instance.create_api()
self.client = TestClient(self.api)
@@ -55,7 +58,7 @@ class TestHeadlessAPI(unittest.TestCase):
"usage": {"input_tokens": 10, "output_tokens": 5}
}
}]
response = self.client.post("/api/v1/generate", json=payload, headers=self.headers)
self.assertEqual(response.status_code, 200)
data = response.json()
@@ -68,7 +71,7 @@ class TestHeadlessAPI(unittest.TestCase):
with patch('gui_2.uuid.uuid4', return_value="test-action-id"):
dialog = gui_2.ConfirmDialog("dir", ".")
self.app_instance._pending_actions[dialog._uid] = dialog
response = self.client.get("/api/v1/pending_actions", headers=self.headers)
self.assertEqual(response.status_code, 200)
data = response.json()
@@ -80,7 +83,7 @@ class TestHeadlessAPI(unittest.TestCase):
with patch('gui_2.uuid.uuid4', return_value="test-confirm-id"):
dialog = gui_2.ConfirmDialog("dir", ".")
self.app_instance._pending_actions[dialog._uid] = dialog
payload = {"approved": True}
response = self.client.post("/api/v1/confirm/test-confirm-id", json=payload, headers=self.headers)
self.assertEqual(response.status_code, 200)
@@ -93,7 +96,7 @@ class TestHeadlessAPI(unittest.TestCase):
# Create a dummy log
dummy_log = Path("logs/test_session_api.log")
dummy_log.write_text("dummy content")
try:
response = self.client.get("/api/v1/sessions", headers=self.headers)
self.assertEqual(response.status_code, 200)
@@ -118,5 +121,60 @@ class TestHeadlessAPI(unittest.TestCase):
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json()["detail"], "API Key not configured on server")
class TestHeadlessStartup(unittest.TestCase):
@patch('gui_2.immapp.run')
@patch('gui_2.api_hooks.HookServer')
@patch('gui_2.save_config')
@patch('gui_2.ai_client.cleanup')
@patch('uvicorn.run') # Mock uvicorn.run to prevent hanging
def test_headless_flag_prevents_gui_run(self, mock_uvicorn_run, mock_cleanup, mock_save_config, mock_hook_server, mock_immapp_run):
# Setup mock argv with --headless
test_args = ["gui_2.py", "--headless"]
with patch.object(sys, 'argv', test_args):
with patch('gui_2.session_logger.close_session'), \
patch('gui_2.session_logger.open_session'):
app = gui_2.App()
# Mock _fetch_models to avoid network calls
app._fetch_models = MagicMock()
app.run()
# Expectation: immapp.run should NOT be called in headless mode
mock_immapp_run.assert_not_called()
# Expectation: uvicorn.run SHOULD be called
mock_uvicorn_run.assert_called_once()
@patch('gui_2.immapp.run')
def test_normal_startup_calls_gui_run(self, mock_immapp_run):
test_args = ["gui_2.py"]
with patch.object(sys, 'argv', test_args):
# In normal mode, it should still call immapp.run
with patch('gui_2.api_hooks.HookServer'), \
patch('gui_2.save_config'), \
patch('gui_2.ai_client.cleanup'), \
patch('gui_2.session_logger.close_session'), \
patch('gui_2.session_logger.open_session'):
app = gui_2.App()
app._fetch_models = MagicMock()
app.run()
mock_immapp_run.assert_called_once()
def test_fastapi_installed():
"""Verify that fastapi is installed."""
try:
importlib.import_module("fastapi")
except ImportError:
pytest.fail("fastapi is not installed")
def test_uvicorn_installed():
"""Verify that uvicorn is installed."""
try:
importlib.import_module("uvicorn")
except ImportError:
pytest.fail("uvicorn is not installed")
if __name__ == "__main__":
unittest.main()

48
tests/test_headless_startup.py
View File

@@ -1,48 +0,0 @@
import sys
import unittest
from unittest.mock import patch, MagicMock
import gui_2
class TestHeadlessStartup(unittest.TestCase):
@patch('gui_2.immapp.run')
@patch('gui_2.api_hooks.HookServer')
@patch('gui_2.save_config')
@patch('gui_2.ai_client.cleanup')
@patch('uvicorn.run') # Mock uvicorn.run to prevent hanging
def test_headless_flag_prevents_gui_run(self, mock_uvicorn_run, mock_cleanup, mock_save_config, mock_hook_server, mock_immapp_run):
# Setup mock argv with --headless
test_args = ["gui_2.py", "--headless"]
with patch.object(sys, 'argv', test_args):
with patch('gui_2.session_logger.close_session'), \
patch('gui_2.session_logger.open_session'):
app = gui_2.App()
# Mock _fetch_models to avoid network calls
app._fetch_models = MagicMock()
app.run()
# Expectation: immapp.run should NOT be called in headless mode
mock_immapp_run.assert_not_called()
# Expectation: uvicorn.run SHOULD be called
mock_uvicorn_run.assert_called_once()
@patch('gui_2.immapp.run')
def test_normal_startup_calls_gui_run(self, mock_immapp_run):
test_args = ["gui_2.py"]
with patch.object(sys, 'argv', test_args):
# In normal mode, it should still call immapp.run
with patch('gui_2.api_hooks.HookServer'), \
patch('gui_2.save_config'), \
patch('gui_2.ai_client.cleanup'), \
patch('gui_2.session_logger.close_session'), \
patch('gui_2.session_logger.open_session'):
app = gui_2.App()
app._fetch_models = MagicMock()
app.run()
mock_immapp_run.assert_called_once()
if __name__ == "__main__":
unittest.main()

32
tests/test_history_blacklist.py
View File

@@ -1,32 +0,0 @@
import pytest
from pathlib import Path
import mcp_client
import aggregate
def test_mcp_blacklist(tmp_path):
# Setup a "history" file
hist_file = tmp_path / "my_project_history.toml"
hist_file.write_text("secret history", encoding="utf-8")
# Configure MCP client with the tmp_path as allowed
mcp_client.configure([{"path": str(hist_file)}], extra_base_dirs=[str(tmp_path)])
# Try to read it - should fail
result = mcp_client.read_file(str(hist_file))
assert "ACCESS DENIED" in result or "BLACKLISTED" in result
# Try to list it
result = mcp_client.list_directory(str(tmp_path))
assert "my_project_history.toml" not in result
def test_aggregate_blacklist(tmp_path):
# Setup a "history" file
hist_file = tmp_path / "my_project_history.toml"
hist_file.write_text("secret history", encoding="utf-8")
# Try to resolve paths including the history file
paths = aggregate.resolve_paths(tmp_path, "*_history.toml")
assert hist_file not in paths
paths = aggregate.resolve_paths(tmp_path, "*")
assert hist_file not in paths

26
tests/test_history_bleed.py
View File

@@ -1,26 +0,0 @@
import pytest
import sys
import os
from unittest.mock import MagicMock
# Ensure project root is in path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
import ai_client
def test_get_history_bleed_stats_basic():
# Reset state
ai_client.reset_session()
# Mock some history
ai_client.history_trunc_limit = 1000
# Simulate 500 tokens used
with MagicMock() as mock_stats:
# This would usually involve patching the encoder or session logic
pass
stats = ai_client.get_history_bleed_stats()
assert 'current' in stats
assert 'limit' in stats
# ai_client.py hardcodes Gemini limit to 900_000
assert stats['limit'] == 900000

216
tests/test_history_management.py Normal file
View File

@@ -0,0 +1,216 @@
import pytest
import sys
import os
import tomli_w
import tomllib
from pathlib import Path
from unittest.mock import MagicMock
# Ensure project root is in path for imports
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
# Import necessary modules from the project
import aggregate
import project_manager
import mcp_client
import ai_client
# --- Tests for Aggregate Module ---
def test_aggregate_includes_segregated_history(tmp_path):
"""
Tests if the aggregate function correctly includes history
when it's segregated into a separate file.
"""
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# Setup segregated project configuration
proj_data = project_manager.default_project("test-aggregate")
proj_data["discussion"]["discussions"]["main"]["history"] = ["@2026-02-24T14:00:00\nUser:\nShow me history"]
# Save the project, which should segregate the history
project_manager.save_project(proj_data, proj_path)
# Load the project and aggregate its content
loaded_proj = project_manager.load_project(proj_path)
config = project_manager.flat_config(loaded_proj)
markdown, output_file, file_items = aggregate.run(config)
# Assert that the history is present in the aggregated markdown
assert "## Discussion History" in markdown
assert "Show me history" in markdown
# --- Tests for MCP Client and Blacklisting ---
def test_mcp_blacklist(tmp_path):
"""
Tests that the MCP client correctly blacklists specified files
and prevents listing them.
"""
# Setup a file that should be blacklisted
hist_file = tmp_path / "my_project_history.toml"
hist_file.write_text("secret history", encoding="utf-8")
# Configure MCP client to allow access to the temporary directory
# but ensure the history file is implicitly or explicitly blacklisted.
mcp_client.configure([{"path": str(hist_file)}], extra_base_dirs=[str(tmp_path)])
# Attempt to read the blacklisted file - should result in an access denied message
result = mcp_client.read_file(str(hist_file))
assert "ACCESS DENIED" in result or "BLACKLISTED" in result
# Attempt to list the directory containing the blacklisted file
result = mcp_client.list_directory(str(tmp_path))
# The blacklisted file should not appear in the directory listing
assert "my_project_history.toml" not in result
def test_aggregate_blacklist(tmp_path):
"""
Tests that aggregate's path resolution respects blacklisting,
ensuring history files are not included by default.
"""
# Setup a history file in the temporary directory
hist_file = tmp_path / "my_project_history.toml"
hist_file.write_text("secret history", encoding="utf-8")
# Attempt to resolve paths including the history file using a wildcard
paths = aggregate.resolve_paths(tmp_path, "*_history.toml")
assert hist_file not in paths, "History file should be blacklisted and not resolved"
# Resolve all paths and ensure the history file is still excluded
paths = aggregate.resolve_paths(tmp_path, "*")
assert hist_file not in paths, "History file should be excluded even with a general glob"
# --- Tests for History Migration and Separation ---
def test_migration_on_load(tmp_path):
"""
Tests that project loading migrates discussion history from manual_slop.toml
to manual_slop_history.toml if it exists in the main config.
"""
# Define paths for the main project config and the history file
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# Create a legacy project data structure with discussion history
legacy_data = project_manager.default_project("test-project")
legacy_data["discussion"]["discussions"]["main"]["history"] = ["Hello", "World"]
# Save this legacy data into manual_slop.toml
with open(proj_path, "wb") as f:
tomli_w.dump(legacy_data, f)
# Load the project - this action should trigger the migration
loaded_data = project_manager.load_project(proj_path)
# Assertions:
assert "discussion" in loaded_data
assert loaded_data["discussion"]["discussions"]["main"]["history"] == ["Hello", "World"]
# 2. The history should no longer be present in the main manual_slop.toml on disk.
with open(proj_path, "rb") as f:
on_disk_main = tomllib.load(f)
assert "discussion" not in on_disk_main, "Discussion history should be removed from main config after migration"
# 3. The history file (manual_slop_history.toml) should now exist and contain the data.
assert hist_path.exists()
with open(hist_path, "rb") as f:
on_disk_hist = tomllib.load(f)
assert on_disk_hist["discussions"]["main"]["history"] == ["Hello", "World"]
def test_save_separation(tmp_path):
"""
Tests that saving project data correctly separates discussion history
into manual_slop_history.toml.
"""
# Define paths for the main project config and the history file
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# Create fresh project data, including discussion history
proj_data = project_manager.default_project("test-project")
proj_data["discussion"]["discussions"]["main"]["history"] = ["Saved", "Separately"]
# Save the project data
project_manager.save_project(proj_data, proj_path)
# Assertions:
assert proj_path.exists()
assert hist_path.exists()
# 2. The main project file should NOT contain the discussion history.
with open(proj_path, "rb") as f:
p_disk = tomllib.load(f)
assert "discussion" not in p_disk, "Discussion history should not be in main config file after save"
# 3. The history file should contain the discussion history.
with open(hist_path, "rb") as f:
h_disk = tomllib.load(f)
assert h_disk["discussions"]["main"]["history"] == ["Saved", "Separately"]
# --- Tests for History Persistence Across Turns ---
def test_history_persistence_across_turns(tmp_path):
"""
Tests that discussion history is correctly persisted across multiple save/load cycles.
"""
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# Step 1: Initialize a new project and save it.
proj = project_manager.default_project("test-persistence")
project_manager.save_project(proj, proj_path)
# Step 2: Add a first turn of discussion history.
proj = project_manager.load_project(proj_path)
entry1 = {"role": "User", "content": "Hello", "ts": "2026-02-24T13:00:00"}
proj["discussion"]["discussions"]["main"]["history"].append(project_manager.entry_to_str(entry1))
project_manager.save_project(proj, proj_path)
# Verify separation after the first save
with open(proj_path, "rb") as f:
p_disk = tomllib.load(f)
assert "discussion" not in p_disk
with open(hist_path, "rb") as f:
h_disk = tomllib.load(f)
assert h_disk["discussions"]["main"]["history"] == ["@2026-02-24T13:00:00\nUser:\nHello"]
# Step 3: Add a second turn of discussion history.
proj = project_manager.load_project(proj_path)
entry2 = {"role": "AI", "content": "Hi there!", "ts": "2026-02-24T13:01:00"}
proj["discussion"]["discussions"]["main"]["history"].append(project_manager.entry_to_str(entry2))
project_manager.save_project(proj, proj_path)
# Verify persistence
with open(hist_path, "rb") as f:
h_disk = tomllib.load(f)
assert len(h_disk["discussions"]["main"]["history"]) == 2
assert h_disk["discussions"]["main"]["history"][1] == "@2026-02-24T13:01:00\nAI:\nHi there!"
# Step 4: Reload the project from disk and check history
proj_final = project_manager.load_project(proj_path)
assert len(proj_final["discussion"]["discussions"]["main"]["history"]) == 2
# --- Tests for AI Client History Management ---
def test_get_history_bleed_stats_basic():
"""
Tests basic retrieval of history bleed statistics from the AI client.
"""
# Reset the AI client's session state
ai_client.reset_session()
# Set a custom history truncation limit for testing purposes.
ai_client.set_history_trunc_limit(500)
# For this test, we're primarily checking the structure of the returned stats
# and the configured limit.
stats = ai_client.get_history_bleed_stats()
assert 'current' in stats, "Stats dictionary should contain 'current' token usage"
assert 'limit' in stats, "Stats dictionary should contain 'limit'"
assert stats['limit'] == 500, f"Expected limit of 500, but got {stats['limit']}"
assert isinstance(stats['current'], int) and stats['current'] >= 0

56
tests/test_history_migration.py
View File

@@ -1,56 +0,0 @@
import pytest
import tomli_w
import tomllib
from pathlib import Path
from project_manager import load_project, save_project, default_project
def test_migration_on_load(tmp_path):
# Setup legacy project file with discussion
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
legacy_data = default_project("test-project")
legacy_data["discussion"]["discussions"]["main"]["history"] = ["Hello", "World"]
with open(proj_path, "wb") as f:
tomli_w.dump(legacy_data, f)
# Load project - should trigger migration
loaded_data = load_project(proj_path)
# Assertions
assert "discussion" in loaded_data
assert loaded_data["discussion"]["discussions"]["main"]["history"] == ["Hello", "World"]
# Check that it's NOT in the main file on disk anymore
with open(proj_path, "rb") as f:
on_disk = tomllib.load(f)
assert "discussion" not in on_disk
# Check history file
assert hist_path.exists()
with open(hist_path, "rb") as f:
hist_data = tomllib.load(f)
assert hist_data["discussions"]["main"]["history"] == ["Hello", "World"]
def test_save_separation(tmp_path):
# Setup fresh project data
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
proj_data = default_project("test-project")
proj_data["discussion"]["discussions"]["main"]["history"] = ["Saved", "Separately"]
# Save project - should save both files
save_project(proj_data, proj_path)
assert proj_path.exists()
assert hist_path.exists()
with open(proj_path, "rb") as f:
p = tomllib.load(f)
assert "discussion" not in p
with open(hist_path, "rb") as f:
h = tomllib.load(f)
assert h["discussions"]["main"]["history"] == ["Saved", "Separately"]

44
tests/test_history_persistence.py
View File

@@ -1,44 +0,0 @@
import pytest
import tomli_w
import tomllib
from pathlib import Path
from project_manager import load_project, save_project, default_project, entry_to_str
def test_history_persistence_across_turns(tmp_path):
proj_path = tmp_path / "manual_slop.toml"
hist_path = tmp_path / "manual_slop_history.toml"
# 1. Start project
proj = default_project("test-persistence")
save_project(proj, proj_path)
# 2. Add a turn
proj = load_project(proj_path)
entry1 = {"role": "User", "content": "Hello", "ts": "2026-02-24T13:00:00"}
proj["discussion"]["discussions"]["main"]["history"].append(entry_to_str(entry1))
save_project(proj, proj_path)
# Verify separation
with open(proj_path, "rb") as f:
p_disk = tomllib.load(f)
assert "discussion" not in p_disk
with open(hist_path, "rb") as f:
h_disk = tomllib.load(f)
assert h_disk["discussions"]["main"]["history"] == ["@2026-02-24T13:00:00\nUser:\nHello"]
# 3. Add another turn
proj = load_project(proj_path)
entry2 = {"role": "AI", "content": "Hi there!", "ts": "2026-02-24T13:01:00"}
proj["discussion"]["discussions"]["main"]["history"].append(entry_to_str(entry2))
save_project(proj, proj_path)
# Verify persistence
with open(hist_path, "rb") as f:
h_disk = tomllib.load(f)
assert len(h_disk["discussions"]["main"]["history"]) == 2
assert h_disk["discussions"]["main"]["history"][1] == "@2026-02-24T13:01:00\nAI:\nHi there!"
# 4. Reload and check
proj_final = load_project(proj_path)
assert len(proj_final["discussion"]["discussions"]["main"]["history"]) == 2

14
tests/test_history_truncation.py
View File

@@ -1,14 +0,0 @@
import pytest
import sys
import os
# Ensure project root is in path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
import ai_client
def test_history_truncation_logic():
ai_client.reset_session()
ai_client.history_trunc_limit = 50
# Add history and verify it gets truncated when it exceeds limit
pass