121 lines
5.5 KiB
Python
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()
|