"""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 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_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, "") 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", "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()