331 lines
17 KiB
Python
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()
|