Files
myrzx_bot/ranch_web/tests/test_store.py
T

121 lines
5.5 KiB
Python

"""Web persistence tests use disposable roots and synthetic sessions only."""
from dataclasses import replace
import json
import os
from pathlib import Path
import stat
import tempfile
import unittest
from ranch_assistant.api import Session
from ranch_web.store import WebStore, session_identity
class StoreTests(unittest.TestCase):
def setUp(self):
self.temp = self.enterContext(tempfile.TemporaryDirectory(prefix="ranch-web-store-test-"))
self.root = Path(self.temp) / "web"
self.store = WebStore(self.root)
self.addCleanup(self.store.close)
self.secure = self.store.secure("a" * 32)
def session(self):
return Session("https://offline.invalid/game/", "synthetic-private-token", account_id="fake-owner",
server_id=1, role_id=101, reqid=5, reqsid=9)
def test_fernet_credentials_and_session_survive_restart_without_plaintext(self):
self.secure.save_credentials("synthetic-account", "synthetic-password", True)
session = self.session()
identifier = self.secure.save(session, "测试角色")
self.secure.set_active(identifier)
self.store.close()
reopened = WebStore(self.root)
self.addCleanup(reopened.close)
secure = reopened.secure("a" * 32)
self.assertEqual(secure.load_credentials(), (True, "synthetic-account", "synthetic-password"))
self.assertEqual(secure.load(identifier), session)
self.assertEqual(secure.active(), identifier)
for path in self.root.rglob("*.fernet"):
raw = path.read_text(encoding="utf-8")
for secret in ("synthetic-account", "synthetic-password", session.token, session.key):
self.assertNotIn(secret, raw)
if os.name != "nt":
self.assertEqual(stat.S_IMODE((self.root / "web.key").stat().st_mode), 0o600)
def test_high_water_marks_never_regress(self):
session = self.session()
identifier = self.secure.save(session, "first")
stale = replace(session, reqid=0, reqsid=1)
self.secure.save(stale, "stale")
loaded = self.secure.load(identifier)
self.assertEqual((loaded.reqid, loaded.reqsid), (5, 9))
self.assertEqual((stale.reqid, stale.reqsid), (5, 9))
def test_sessions_are_separated_by_account_region_role_and_profile(self):
first = self.session()
sessions = [first, replace(first, account_id="other"), replace(first, server_id=2), replace(first, role_id=102)]
ids = [self.secure.save(value, "角色") for value in sessions]
self.assertEqual(len(set(ids)), 4)
other = self.store.secure("b" * 32)
self.assertEqual(other.entries(), [])
self.assertEqual(len(self.secure.entries()), 4)
self.assertEqual(set(self.secure.entries()[0]), {"session_id", "label", "saved_at"})
self.assertEqual(session_identity(first), ids[0])
def test_missing_or_different_key_is_reported_without_replacing_ciphertext(self):
self.secure.save(self.session(), "角色")
self.store.close()
original = next(self.secure.folder.glob("*.fernet")).read_bytes()
(self.root / "web.key").unlink()
with self.assertRaisesRegex(ValueError, "密钥"):
WebStore(self.root)
self.assertEqual(next(self.secure.folder.glob("*.fernet")).read_bytes(), original)
def test_tamper_and_path_traversal_are_rejected(self):
identifier = self.secure.save(self.session(), "角色")
path = self.secure.folder / (identifier + ".fernet")
record = json.loads(path.read_text(encoding="utf-8"))
record["protected"] = record["protected"][:-8] + "invalid!"
path.write_text(json.dumps(record), encoding="utf-8")
with self.assertRaisesRegex(ValueError, "加密"):
self.secure.load(identifier)
for bad in ("../other", "A" * 32, "", None):
with self.assertRaises(ValueError):
self.store.remove_profile(bad)
with self.assertRaises(ValueError):
self.secure.load("../credentials")
def test_only_one_instance_owns_the_root(self):
with self.assertRaisesRegex(RuntimeError, "另一个"):
WebStore(self.root)
def test_removal_preserves_siblings_and_shared_files(self):
sibling = self.store.secure("b" * 32)
sibling.save_credentials("b", "password-b")
shared = self.root / "shared-catalog.json"
shared.write_text("shared", encoding="utf-8")
self.secure.save(self.session(), "A")
self.store.remove_profile("a" * 32)
self.assertFalse(self.secure.profile_root.exists())
self.assertEqual(sibling.load_credentials(), (True, "b", "password-b"))
self.assertEqual(shared.read_text(encoding="utf-8"), "shared")
def test_link_inside_profile_blocks_entire_removal(self):
sibling = self.store.secure("b" * 32).profile_root
link = self.secure.profile_root / "sibling-link"
try:
link.symlink_to(sibling, target_is_directory=True)
except (OSError, NotImplementedError):
self.skipTest("Creating symlinks requires Windows privileges")
self.addCleanup(lambda: link.unlink(missing_ok=True))
ordinary = self.secure.profile_root / "keep.txt"
ordinary.write_text("keep", encoding="utf-8")
with self.assertRaisesRegex(ValueError, "链接"):
self.store.remove_profile("a" * 32)
self.assertTrue(ordinary.exists())
self.assertTrue(sibling.exists())
if __name__ == "__main__":
unittest.main()