Files
myrzx_bot/ranch_web/tests/test_activity.py
T
2026-11-11 15:35:36 +08:00

331 lines
17 KiB
Python

"""Standalone activity tests: disposable files, stdlib, no service/game imports."""
from concurrent.futures import ThreadPoolExecutor
import json
import os
from pathlib import Path
import stat
import tempfile
import unittest
from unittest.mock import patch
from ranch_web.activity import ActivityLog, ActivityLogError, MAX_MESSAGE_CHARS
from ranch_web.log_categories import CATEGORIES
class ActivityTests(unittest.TestCase):
def setUp(self):
self.root = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="activity-test-")))
self.path = self.root / "profiles" / "account-a" / "activity.json"
self.watermark = self.path.with_name(self.path.name + ".seq")
def log(self, **kwargs):
return ActivityLog(self.path, **kwargs)
def append(self, log, message="safe lifecycle event", **kwargs):
return log.append({"message": message, **kwargs})
def test_creation_load_sequence_and_repeated_idle_reads_never_write(self):
with patch("ranch_web.activity.os.replace") as replace, patch("ranch_web.activity.os.fsync") as fsync:
log = self.log()
for _ in range(100):
self.assertEqual(log.load(), [])
self.assertEqual(log.sequence, 0)
replace.assert_not_called()
fsync.assert_not_called()
self.assertFalse(self.path.parent.exists())
def test_categories_and_error_level_persist_across_restart(self):
log = self.log(sequence_block_size=8)
for category in sorted(CATEGORIES):
self.append(log, "attributed operation", category=category, level="error")
for invalid in ("breakthrough", "unknown", "TOKEN_SECRET", {}, [], None):
self.assertEqual(self.append(log, category=invalid)["category"], "general")
debug = self.append(log, "transient categorized trace", category="gifts", debug=True)
restored = self.log(sequence_block_size=8)
self.assertEqual(restored.load(), log.load())
self.assertEqual({entry["category"] for entry in restored.load() if entry["level"] == "error"}, CATEGORIES)
self.assertGreater(self.append(restored, category="daily")["seq"], debug["seq"])
self.assertNotIn("TOKEN_SECRET", self.path.read_text(encoding="utf-8"))
def test_legacy_categories_are_conservative_and_loading_never_migrates(self):
self.path.parent.mkdir(parents=True)
messages = [("自动赠礼:请先选择物品", "gifts"), ("突破请求待核对", "ranch"),
("状态已刷新;自动赠礼:冷却中", "general"), ("事件已完成", "general"),
("已推进普通剧情并保存本地检查点", "general")]
record = {"schema": 1, "sequence": 20, "entries": [
{"seq": index, "message": message} for index, (message, _) in enumerate(messages, 1)]}
raw = json.dumps(record, ensure_ascii=False)
self.path.write_text(raw, encoding="utf-8")
with patch("ranch_web.activity.os.replace") as replace:
entries = self.log().load()
replace.assert_not_called()
self.assertEqual([entry["category"] for entry in entries], [category for _, category in messages])
self.assertEqual(self.path.read_text(encoding="utf-8"), raw)
def test_account_isolation_and_persistence(self):
log = self.log()
first = self.append(log, "account A operation", level="warning")
other_path = self.root / "profiles" / "account-b" / "activity.json"
other = ActivityLog(other_path)
self.assertEqual(other.load(), [])
self.assertEqual(other.sequence, 0)
second = self.append(other, "account B start")
self.assertEqual((first["seq"], second["seq"]), (1, 1))
self.assertEqual(ActivityLog(self.path).load(), [first])
self.assertEqual(ActivityLog(other_path).load(), [second])
self.assertEqual(first["level"], "warning")
def test_debug_only_tail_restart_startup_exceeds_browser_cursor(self):
log = self.log(sequence_block_size=8)
persisted = self.append(log, "persisted operation")
# More than one reservation block, with no final nondebug flush.
for number in range(23):
tail = self.append(log, "transient trace " + str(number), debug=True)
browser_cursor = log.sequence
self.assertEqual(browser_cursor, tail["seq"])
self.assertGreater(browser_cursor, persisted["seq"])
self.assertNotIn(b"transient trace", self.path.read_bytes())
restored = self.log(sequence_block_size=8)
self.assertEqual(restored.load(), [persisted])
# This becomes worker._log_sequence and therefore manager.logs().next.
self.assertGreaterEqual(restored.sequence, browser_cursor)
startup = self.append(restored, "startup")
self.assertGreater(startup["seq"], browser_cursor)
page = {"entries": [e for e in restored.load() if e["seq"] > browser_cursor],
"next": restored.sequence}
self.assertEqual(page, {"entries": [startup], "next": startup["seq"]})
following = self.append(restored, "following event")
self.assertEqual(following["seq"], startup["seq"] + 1)
def test_entirely_debug_run_survives_restart_without_snapshot(self):
log = self.log(sequence_block_size=8)
for _ in range(19):
self.append(log, "never persist this trace", debug=True)
cursor = log.sequence
self.assertFalse(self.path.exists())
self.assertTrue(self.watermark.exists())
restarted = self.log(sequence_block_size=8)
self.assertEqual(restarted.load(), [])
self.assertGreater(self.append(restarted, "startup")["seq"], cursor)
def test_caller_fallback_cursor_is_reserved_before_resuming_debug_events(self):
log = self.log()
self.append(log)
recovered = log.append({"message": "debug after recovery", "debug": True}, after_sequence=1000)
self.assertEqual(recovered["seq"], 1001)
self.assertGreaterEqual(json.loads(self.watermark.read_bytes())["sequence"], recovered["seq"])
self.assertGreater(self.append(self.log(), "startup")["seq"], recovered["seq"])
def test_failed_caller_cursor_reservation_can_retry_without_reusing_ids(self):
log = self.log()
self.append(log)
with patch.object(log, "_write", side_effect=ActivityLogError("Unable to save activity storage")):
with self.assertRaises(ActivityLogError):
log.append({"message": "not published", "debug": True}, after_sequence=1000)
self.assertEqual(log.sequence, 1)
self.assertEqual(log.append({"message": "recovery"}, after_sequence=1001)["seq"], 1002)
def test_invalid_caller_cursor_is_rejected(self):
for cursor in (True, -1, None, 1.0, 1 << 53):
with self.subTest(cursor=cursor), self.assertRaises(ValueError):
self.log().append({"message": "invalid cursor"}, after_sequence=cursor)
def test_debug_cost_is_small_watermark_per_block_no_snapshot_rewrite(self):
log = self.log(sequence_block_size=8)
self.append(log)
snapshot = self.path.read_bytes()
with patch("ranch_web.activity.os.replace", wraps=os.replace) as replace:
for _ in range(31):
self.append(log, "debug private detail", debug=True)
self.assertEqual(replace.call_count, 3)
self.assertTrue(all(Path(call.args[1]) == self.watermark for call in replace.call_args_list))
self.assertEqual(self.path.read_bytes(), snapshot)
self.assertLess(self.watermark.stat().st_size, 64)
self.assertNotIn(b"private detail", self.watermark.read_bytes())
def test_max_entries_and_highwater_survive_eviction(self):
log = self.log(max_entries=3, sequence_block_size=8)
entries = [self.append(log, str(n)) for n in range(12)]
self.assertEqual(log.load(), entries[-3:])
restarted = self.log(max_entries=2, sequence_block_size=8)
self.assertEqual(restarted.load(), entries[-2:])
self.assertGreater(self.append(restarted)["seq"], entries[-1]["seq"])
def test_hard_2000_entry_bound(self):
# Construct a valid oversized snapshot to test bounded recovery without
# manufacturing 2001 synchronous fsync operations in this unit suite.
self.path.parent.mkdir(parents=True)
rows = [{"seq": seq, "message": "short"} for seq in range(1, 2006)]
self.path.write_text(json.dumps({"schema": 1, "sequence": 2005, "entries": rows}), encoding="utf-8")
log = self.log()
self.assertEqual(len(log.load()), 2000)
last = self.append(log, "last")
rows = json.loads(self.path.read_bytes())["entries"]
self.assertEqual(len(rows), 2000)
self.assertEqual(rows[0]["seq"], 7)
self.assertEqual(rows[-1], last)
def test_unicode_message_and_total_encoded_byte_limits(self):
log = self.log(max_bytes=16384)
for _ in range(12):
last = self.append(log, "操作\n" * 16000)
self.assertEqual(len(last["message"]), MAX_MESSAGE_CHARS)
self.assertNotIn("\n", last["message"])
self.assertLessEqual(self.path.stat().st_size, 16384)
self.assertLess(len(log.load()), 12)
self.assertEqual(self.log(max_bytes=16384).load(), log.load())
self.assertEqual(log.load()[-1], last)
def test_caller_redaction_and_whitelist_exclude_credentials_payloads_paths(self):
secret, password, local_path = "synthetic-token-value", "synthetic-password", str(self.root)
def safe_text(value):
for sensitive in (secret, password, local_path):
value = value.replace(sensitive, "<redacted>")
return value
entry = {"message": safe_text("operation " + secret + " " + password + " " + local_path),
"token": secret, "password": password, "path": local_path,
"headers": {"Authorization": secret}, "request": {"body": password},
"response": {"raw": secret}, "seq": 90000, "id": 90000}
log = self.log()
saved = log.append(entry)
self.assertEqual(set(saved), {"time", "message", "category", "debug", "level", "id", "seq"})
self.assertEqual(saved["seq"], 1)
for filename in (self.path, self.watermark):
raw = filename.read_text(encoding="utf-8")
for sensitive in (secret, password, local_path, '"headers"', '"request"', '"response"'):
self.assertNotIn(sensitive, raw)
def test_output_copies_and_helper_integer_id(self):
log = self.log()
entry = self.append(log, "original")
entry["message"] = "mutated"
snapshot = log.load()
snapshot[0]["message"] = "also mutated"
self.assertEqual(log.load()[0]["message"], "original")
identifier = log.log("second")
self.assertIs(type(identifier), int)
self.assertEqual(identifier, log.sequence)
self.assertEqual(identifier, log.load()[-1]["id"])
def test_corrupt_snapshot_preserves_debug_cursor_via_watermark(self):
log = self.log(sequence_block_size=8)
self.append(log)
for _ in range(20):
self.append(log, debug=True)
old_cursor = log.sequence
for damaged in (b"{broken", b"\xff\xfe", b"[]", b"null", b'{"schema":99}'):
with self.subTest(damaged=damaged):
self.path.write_bytes(damaged)
restored = self.log(sequence_block_size=8)
self.assertEqual(restored.load(), [])
self.assertGreater(self.append(restored, "recovered")["seq"], old_cursor)
def test_corrupt_rows_and_metadata_are_tolerated_and_scrubbed(self):
self.path.parent.mkdir(parents=True)
rows = [None, 17, {"seq": True, "message": "bad"}, {"seq": -1, "message": "bad"},
{"seq": 5, "message": "five", "token": "discard-me"},
{"seq": 4, "message": "four", "debug": False},
{"seq": 6, "message": "debug", "debug": True},
{"seq": 7, "message": "wrong flag", "debug": "false"},
{"seq": 8, "message": []}, {"seq": 9, "message": "nine"}]
self.path.write_text(json.dumps({"schema": 1, "sequence": 20, "entries": rows}), encoding="utf-8")
self.watermark.write_text("broken", encoding="utf-8")
log = self.log()
self.assertEqual([entry["seq"] for entry in log.load()], [4, 5, 9])
self.assertEqual(log.sequence, 20)
self.assertEqual(self.append(log)["seq"], 21)
self.assertNotIn(b"discard-me", self.path.read_bytes())
def test_oversized_or_deeply_nested_corrupt_files_are_tolerated(self):
self.path.parent.mkdir(parents=True)
for damaged in (b" " * (2 * 1024 * 1024 + 1), b"[" * 2000 + b"]" * 2000):
self.path.write_bytes(damaged)
self.assertEqual(self.log().load(), [])
self.assertEqual(self.append(self.log())["seq"], 1)
def test_atomic_replace_failure_keeps_old_snapshot_and_hides_path(self):
log = self.log()
first = self.append(log)
old = self.path.read_bytes()
with patch("ranch_web.activity.os.replace", side_effect=OSError("PRIVATE " + str(self.path))):
with self.assertRaises(ActivityLogError) as raised:
self.append(log, "not published")
self.assertNotIn(str(self.root), str(raised.exception))
self.assertTrue(raised.exception.__suppress_context__)
self.assertEqual(self.path.read_bytes(), old)
self.assertEqual(log.sequence, first["seq"])
self.assertEqual(log.load(), [first])
self.assertEqual(list(self.path.parent.glob("*.tmp")), [])
self.assertEqual(self.append(log, "retry")["seq"], first["seq"] + 1)
def test_reservation_failure_does_not_publish_debug_sequence(self):
log = self.log()
with patch("ranch_web.activity.os.fsync", side_effect=OSError("PRIVATE " + str(self.path))):
with self.assertRaisesRegex(ActivityLogError, "Unable to save activity storage"):
self.append(log, debug=True)
self.assertEqual(log.sequence, 0)
self.assertFalse(self.path.exists())
self.assertFalse(self.watermark.exists())
self.assertEqual(list(self.path.parent.glob("*.tmp")), [])
def test_atomic_temp_permissions_and_replacement(self):
real_replace = os.replace
destinations = []
def inspect_replace(source, destination):
source, destination = Path(source), Path(destination)
self.assertEqual(source.parent, destination.parent)
json.loads(source.read_bytes()) # Always a complete JSON document.
if os.name != "nt":
self.assertEqual(stat.S_IMODE(source.stat().st_mode), 0o600)
destinations.append(destination)
return real_replace(source, destination)
with patch("ranch_web.activity.os.replace", side_effect=inspect_replace), \
patch("ranch_web.activity.os.chmod", wraps=os.chmod) as chmod:
self.append(self.log())
self.assertEqual(destinations, [self.watermark, self.path])
self.assertEqual([call.args[1] for call in chmod.call_args_list], [0o600, 0o600])
if os.name != "nt":
for path in (self.path, self.watermark):
self.assertEqual(stat.S_IMODE(path.stat().st_mode), 0o600)
def test_trace_level_is_not_persisted_even_without_debug_flag(self):
log = self.log()
entry = self.append(log, "transient", level="trace")
self.assertTrue(entry["debug"])
self.assertEqual(entry["level"], "debug")
self.assertEqual(log.load(), [])
self.assertFalse(self.path.exists())
def test_thread_safe_unique_sequences(self):
log = self.log(sequence_block_size=8)
with ThreadPoolExecutor(max_workers=8) as pool:
entries = list(pool.map(lambda _: self.append(log, debug=True), range(160)))
self.assertEqual(sorted(entry["seq"] for entry in entries), list(range(1, 161)))
self.assertEqual(log.sequence, 160)
self.assertGreater(self.append(self.log())["seq"], 160)
def test_validation_has_path_free_messages(self):
for options in ({"max_entries": 0}, {"max_entries": 2001}, {"max_entries": True},
{"max_bytes": 1}, {"max_bytes": 2097153}, {"sequence_block_size": 0}):
with self.subTest(options=options), self.assertRaises(ValueError):
self.log(**options)
for entry in (None, {}, {"message": self.path}, {"message": "safe", "debug": "false"}):
with self.subTest(entry=entry), self.assertRaises(ValueError) as raised:
self.log().append(entry)
self.assertNotIn(str(self.root), str(raised.exception))
def test_unreadable_storage_error_hides_path(self):
with patch("pathlib.Path.open", side_effect=PermissionError("PRIVATE " + str(self.path))):
with self.assertRaises(ActivityLogError) as raised:
self.log().load()
self.assertEqual(str(raised.exception), "Unable to read activity storage")
self.assertTrue(raised.exception.__suppress_context__)
if __name__ == "__main__":
unittest.main()