feat: add model groups, verified registration and CNY credit grants
This commit is contained in:
1 parent
f5ba6cb255
commit
7a18db2123
40 files changed
+1980
-263
No files matched your search
@@ -0,0 +1,246 @@
|
||||
import base64
|
||||
import contextlib
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import uuid
|
||||
|
||||
from test_deploy import configuration, deploy, DIRECTORY
|
||||
|
||||
SPEC = importlib.util.spec_from_file_location("admin_credentials", DIRECTORY / "admin_credentials.py")
|
||||
maintenance = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(maintenance)
|
||||
|
||||
|
||||
class CredentialMaintenanceTests(unittest.TestCase):
|
||||
def test_password_format_matches_java_parameters(self):
|
||||
for password in ("x", "Test42!", "a'b\\c$#\"", "\u6d4b\u8bd5A1!"):
|
||||
with self.subTest(password=password):
|
||||
encoded = maintenance.password_hash(password, "local-test-pepper")
|
||||
name, iterations, salt, key = encoded.split("$")
|
||||
self.assertEqual((name, iterations), ("pbkdf2", "210000"))
|
||||
salt = base64.urlsafe_b64decode(salt + "==")
|
||||
self.assertEqual(len(salt), 16)
|
||||
actual = base64.urlsafe_b64decode(key + "=")
|
||||
self.assertEqual(len(actual), 32)
|
||||
expected = hashlib.pbkdf2_hmac("sha256", (password + "local-test-pepper").encode(), salt, 210000, 32)
|
||||
self.assertEqual(expected, actual)
|
||||
self.assertNotEqual(encoded, maintenance.password_hash(password, "local-test-pepper"))
|
||||
|
||||
def test_no_password_minimum_but_rejects_blank_and_control_characters(self):
|
||||
self.assertIn('ADMIN_PASSWORD="x"', maintenance.updated_environment("OTHER=value\n", "Owner", "x"))
|
||||
for password in ("", " ", "bad\nline", "bad\x00null", "admin123"):
|
||||
with self.subTest(password=password), self.assertRaises(maintenance.MaintenanceError):
|
||||
maintenance.updated_environment("OTHER=value\n", "Owner", password)
|
||||
|
||||
def test_database_target_guard_and_no_password_in_argv(self):
|
||||
api = configuration()["services"]["moyi-api"]["environment"]
|
||||
env = maintenance.postgres_environment(api, "moyi_control")
|
||||
self.assertEqual(env["PGDATABASE"], "moyi_control")
|
||||
with patch.object(maintenance, "run", return_value="ok") as runner:
|
||||
maintenance.query_database("psql", env, "SELECT 1;")
|
||||
args, kwargs = runner.call_args
|
||||
self.assertNotIn(api["SPRING_DATASOURCE_PASSWORD"], " ".join(args[0]))
|
||||
self.assertEqual(kwargs["env"]["PGPASSWORD"], api["SPRING_DATASOURCE_PASSWORD"])
|
||||
with self.assertRaisesRegex(maintenance.MaintenanceError, "target"):
|
||||
maintenance.postgres_environment(api, "other_app")
|
||||
api["SPRING_DATASOURCE_URL"] += "?sslmode=verify-full&sslrootcert=%2Fopt%2Fmoyi%2Fca.pem"
|
||||
env = maintenance.postgres_environment(api, "moyi_control")
|
||||
self.assertEqual(env["PGSSLMODE"], "verify-full")
|
||||
self.assertEqual(env["PGSSLROOTCERT"], "/opt/moyi/ca.pem")
|
||||
api["SPRING_DATASOURCE_URL"] += "&unknown=unsafe"
|
||||
with self.assertRaisesRegex(maintenance.MaintenanceError, "Unsupported"):
|
||||
maintenance.postgres_environment(api, "moyi_control")
|
||||
|
||||
def test_secret_tool_errors_are_not_echoed_and_stdin_is_not_inherited(self):
|
||||
with patch.object(maintenance.subprocess, "run", return_value=SimpleNamespace(returncode=1, stdout="secret", stderr="secret")) as runner:
|
||||
with self.assertRaises(maintenance.MaintenanceError) as error:
|
||||
maintenance.run(["docker", "compose"])
|
||||
self.assertNotIn("secret", str(error.exception))
|
||||
self.assertEqual(runner.call_args.kwargs["stdin"], subprocess.DEVNULL)
|
||||
|
||||
def test_owner_check_and_recovery_after_commit(self):
|
||||
owner = {"id": str(uuid.uuid4()), "account": "adimin", "status": "active"}
|
||||
for rows in ([], [owner, owner], [{**owner, "status": "disabled"}], [{**owner, "account": "other"}]):
|
||||
with patch.object(maintenance, "query_database", return_value=json.dumps(rows)):
|
||||
with self.assertRaises(maintenance.MaintenanceError):
|
||||
maintenance.read_owner("psql", {}, "adimin", "NewOwner")
|
||||
for account in ("adimin", "newowner"):
|
||||
with patch.object(maintenance, "query_database", side_effect=[json.dumps([{**owner, "account": account}]), "0"]):
|
||||
self.assertEqual(maintenance.read_owner("psql", {}, "adimin", "NewOwner")["id"], owner["id"])
|
||||
with patch.object(maintenance, "query_database", side_effect=[json.dumps([owner]), "1"]):
|
||||
with self.assertRaisesRegex(maintenance.MaintenanceError, "already used"):
|
||||
maintenance.read_owner("psql", {}, "adimin", "NewOwner")
|
||||
|
||||
def test_config_change_guard_preserves_other_settings(self):
|
||||
before = configuration()
|
||||
after = json.loads(json.dumps(before))
|
||||
after["services"]["moyi-api"]["environment"].update(ADMIN_ACCOUNT="Owner", ADMIN_PASSWORD="x")
|
||||
maintenance.validate_staged_config(before, after, "Owner", "x")
|
||||
after["services"]["moyi-api"]["environment"]["AUTH_PASSWORD_PEPPER"] = "changed"
|
||||
with self.assertRaises(maintenance.MaintenanceError):
|
||||
maintenance.validate_staged_config(before, after, "Owner", "x")
|
||||
|
||||
def test_environment_install_is_atomic(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / ".env.cloud"
|
||||
path.write_bytes(b"before")
|
||||
with patch.object(maintenance.os, "replace", side_effect=OSError("test")):
|
||||
with self.assertRaises(OSError):
|
||||
maintenance.install_environment(path, b"after")
|
||||
self.assertEqual(path.read_bytes(), b"before")
|
||||
maintenance.install_environment(path, b"after")
|
||||
self.assertEqual(path.read_bytes(), b"after")
|
||||
|
||||
@unittest.skipUnless(shutil.which("docker"), "Docker CLI required")
|
||||
def test_real_compose_password_quoting_preserves_every_other_setting(self):
|
||||
text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8")
|
||||
for old, new in {"CHANGE_ME_RDS_HOST": "rds.internal", "CHANGE_ME_RDS_PASSWORD": "test-db",
|
||||
"CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache",
|
||||
"GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64,
|
||||
"GENERATE_ADMIN_PASSWORD": "test-admin"}.items():
|
||||
text = text.replace(old, new)
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / ".env.cloud"
|
||||
maintenance.write_private(path, text.encode())
|
||||
before = deploy.load_config(path, "https")
|
||||
for password in ("x", "Test42!", "a'b\\c$#\"", "end\\", "$$literal${HOME}", "\u6d4b\u8bd5A1!", " spaced "):
|
||||
with self.subTest(password=password):
|
||||
path.write_text(maintenance.updated_environment(text, "TestOwner", password), encoding="utf-8")
|
||||
after = deploy.load_config(path, "https")
|
||||
maintenance.validate_staged_config(before, after, "TestOwner", password)
|
||||
|
||||
|
||||
@unittest.skipUnless(os.environ.get("MOYI_CREDENTIAL_TEST_PG_BIN"), "Isolated local PostgreSQL required")
|
||||
class CredentialDatabaseTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.psql = str(Path(os.environ["MOYI_CREDENTIAL_TEST_PG_BIN"]) / "psql.exe")
|
||||
self.name = "moyi_credentials_test_" + uuid.uuid4().hex
|
||||
self.env = {key: value for key, value in os.environ.items() if not key.startswith("PG")}
|
||||
self.env.update(PGHOST="127.0.0.1", PGPORT="55439", PGUSER="moyi_role_test", PGDATABASE="moyi_role_test")
|
||||
maintenance.query_database(self.psql, self.env, 'CREATE DATABASE "' + self.name + '";')
|
||||
self.env["PGDATABASE"] = self.name
|
||||
repo = DIRECTORY.parents[1]
|
||||
migrations = repo / "control-plane-java/src/main/resources/db/migration"
|
||||
maintenance.query_database(self.psql, self.env, (migrations / "V1__auth.sql").read_text() + (migrations / "V9__admin_roles.sql").read_text())
|
||||
self.owner = {"id": str(uuid.uuid4()), "account": "oldowner", "status": "active"}
|
||||
self.other = str(uuid.uuid4())
|
||||
self.session = str(uuid.uuid4())
|
||||
self.other_session = str(uuid.uuid4())
|
||||
maintenance.query_database(self.psql, self.env, f"""
|
||||
INSERT INTO public.users (id, account, account_kind, password_hash, display_name, role) VALUES
|
||||
('{self.owner['id']}', 'oldowner', 'username', 'old-hash', 'Original name', 'super_admin'),
|
||||
('{self.other}', 'ordinary', 'username', 'other-hash', 'Other name', 'user');
|
||||
INSERT INTO public.auth_sessions (id, token_hash, user_id, expires_at) VALUES
|
||||
('{self.session}', 'owner-token', '{self.owner['id']}', now() + interval '1 day'),
|
||||
('{self.other_session}', 'other-token', '{self.other}', now() + interval '1 day');
|
||||
INSERT INTO public.invitation_codes (id, code_hash, code_prefix, label, created_by) VALUES
|
||||
('{uuid.uuid4()}', 'invite-hash', 'invite', 'Owner relation', '{self.owner['id']}');
|
||||
""")
|
||||
|
||||
def tearDown(self):
|
||||
self.env["PGDATABASE"] = "moyi_role_test"
|
||||
maintenance.query_database(self.psql, self.env, 'DROP DATABASE "' + self.name + '";')
|
||||
|
||||
def query(self, sql):
|
||||
return maintenance.query_database(self.psql, self.env, sql)
|
||||
|
||||
def test_reset_preserves_identity_relations_other_users_and_revokes_owner_sessions(self):
|
||||
encoded = maintenance.password_hash("Test42!", "local-test-pepper")
|
||||
self.assertEqual(self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", encoded)), "OWNER_RESET_COMMITTED")
|
||||
data = json.loads(self.query("SELECT row_to_json(u) FROM public.users u WHERE role = 'super_admin'"))
|
||||
self.assertEqual(data["id"], self.owner["id"])
|
||||
self.assertEqual(data["account"], "newowner")
|
||||
self.assertEqual(data["password_hash"], encoded)
|
||||
self.assertEqual(data["display_name"], "Original name")
|
||||
self.assertEqual(self.query("SELECT count(*) FROM public.users"), "2")
|
||||
self.assertEqual(self.query("SELECT created_by FROM public.invitation_codes"), self.owner["id"])
|
||||
self.assertEqual(self.query(f"SELECT revoked_at IS NOT NULL FROM public.auth_sessions WHERE id = '{self.session}'"), "t")
|
||||
self.assertEqual(self.query(f"SELECT revoked_at IS NULL FROM public.auth_sessions WHERE id = '{self.other_session}'"), "t")
|
||||
self.assertEqual(self.query(f"SELECT password_hash FROM public.users WHERE id = '{self.other}'"), "other-hash")
|
||||
details = self.query("SELECT details FROM public.auth_audit_log WHERE event_type = 'user.credentials_reset'")
|
||||
self.assertNotIn("password", details)
|
||||
self.assertNotIn(encoded, details)
|
||||
self.assertIn("newowner", details)
|
||||
current = maintenance.read_owner(self.psql, self.env, "oldowner", "NewOwner")
|
||||
self.assertEqual(self.query(maintenance.reset_sql(self.name, current, "NewOwner", encoded)), "OWNER_RESET_COMMITTED")
|
||||
|
||||
def test_conflict_wrong_database_and_owner_drift_leave_everything_unchanged(self):
|
||||
for database, owner, account in ((self.name, self.owner, "ordinary"), ("wrong_database", self.owner, "NewOwner"),
|
||||
(self.name, {**self.owner, "account": "changed"}, "NewOwner")):
|
||||
with self.subTest(database=database, account=account):
|
||||
with self.assertRaises(maintenance.MaintenanceError):
|
||||
self.query(maintenance.reset_sql(database, owner, account, "new-hash"))
|
||||
self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "oldowner")
|
||||
self.assertEqual(self.query("SELECT count(*) FROM public.auth_audit_log"), "0")
|
||||
self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0")
|
||||
|
||||
def test_audit_failure_rolls_back_password_and_session_changes(self):
|
||||
self.query("ALTER TABLE public.auth_audit_log ADD CONSTRAINT test_reject_audit CHECK (event_type <> 'user.credentials_reset')")
|
||||
with self.assertRaises(maintenance.MaintenanceError):
|
||||
self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", "new-hash"))
|
||||
self.assertEqual(self.query("SELECT password_hash FROM public.users WHERE role = 'super_admin'"), "old-hash")
|
||||
self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0")
|
||||
|
||||
@unittest.skipUnless(shutil.which("docker"), "Docker CLI required for config parsing only")
|
||||
def test_real_backup_and_recovery_when_env_install_fails_after_commit(self):
|
||||
text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8")
|
||||
for old, new in {"jdbc:postgresql://CHANGE_ME_RDS_HOST:5432/moyi_control": "jdbc:postgresql://127.0.0.1:55439/" + self.name,
|
||||
"MOYI_DB_USERNAME=moyi_app": "MOYI_DB_USERNAME=moyi_role_test", "CHANGE_ME_RDS_PASSWORD": "test-only",
|
||||
"CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache",
|
||||
"GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64,
|
||||
"GENERATE_ADMIN_PASSWORD": "test-admin", "ADMIN_ACCOUNT=adimin": "ADMIN_ACCOUNT=oldowner"}.items():
|
||||
text = text.replace(old, new)
|
||||
pg_dump = str(Path(self.psql).with_name("pg_dump.exe"))
|
||||
real_run = maintenance.run
|
||||
docker_calls = []
|
||||
|
||||
def run_command(command, **kwargs):
|
||||
if command[0] == "docker":
|
||||
docker_calls.append(command)
|
||||
return ""
|
||||
return real_run(command, **kwargs)
|
||||
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
path = Path(temporary) / ".env.cloud"
|
||||
backups = Path(temporary) / "backups"
|
||||
maintenance.write_private(path, text.encode())
|
||||
cfg = deploy.load_config(path, "https")
|
||||
with patch.object(maintenance, "check_container", return_value=("test-container", ["docker", "compose"])), \
|
||||
patch.object(maintenance, "run", side_effect=run_command), patch.object(deploy, "smoke") as smoke, \
|
||||
contextlib.redirect_stdout(io.StringIO()):
|
||||
with patch.object(maintenance, "install_environment", side_effect=OSError("injected failure")):
|
||||
with self.assertRaises(OSError):
|
||||
maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name,
|
||||
self.psql, pg_dump, backups)
|
||||
self.assertEqual(path.read_bytes(), text.encode())
|
||||
self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "newowner")
|
||||
self.assertFalse(any(call[1] == "start" or "up" in call for call in docker_calls))
|
||||
smoke.assert_not_called()
|
||||
backup = next(backups.glob("owner-reset-*"))
|
||||
pg_restore = str(Path(self.psql).with_name("pg_restore.exe"))
|
||||
listing = real_run([pg_restore, "--list", str(backup / "moyi_control.dump")])
|
||||
self.assertIn("TABLE DATA public users", listing)
|
||||
real_run([pg_restore, "--file=" + os.devnull, str(backup / "moyi_control.dump")])
|
||||
maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name,
|
||||
self.psql, pg_dump, backups)
|
||||
smoke.assert_called_once()
|
||||
self.assertTrue(smoke.call_args.kwargs["login"])
|
||||
final = deploy.load_config(path, "https")
|
||||
maintenance.validate_staged_config(cfg, final, "NewOwner", "x")
|
||||
self.assertEqual(self.query("SELECT count(*) FROM public.users WHERE role = 'super_admin'"), "1")
|
||||
self.assertEqual(self.query("SELECT id FROM public.users WHERE role = 'super_admin'"), self.owner["id"])
|
||||
self.assertTrue(any("--force-recreate" in call and "--no-build" in call for call in docker_calls))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,66 @@
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from test_deploy import configuration, DIRECTORY
|
||||
|
||||
sys.path.insert(0, str(DIRECTORY))
|
||||
SPEC = importlib.util.spec_from_file_location("backup_database", DIRECTORY / "backup_database.py")
|
||||
backup_database = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(backup_database)
|
||||
|
||||
|
||||
class BackupTests(unittest.TestCase):
|
||||
def test_wrong_database_is_rejected_before_export(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
config = configuration()
|
||||
config["services"]["moyi-api"]["environment"]["SPRING_DATASOURCE_URL"] = "jdbc:postgresql://rds.internal:5432/another_app"
|
||||
deploy = SimpleNamespace(HERE=Path(root), preflight=lambda *args: config)
|
||||
with patch.object(backup_database.shutil, "which", side_effect=lambda name: name), \
|
||||
patch.object(backup_database, "check_container"), \
|
||||
patch.object(backup_database, "run") as command:
|
||||
with self.assertRaisesRegex(backup_database.MaintenanceError, "target"):
|
||||
backup_database.backup(deploy, "tunnel", Path(root) / "backups")
|
||||
command.assert_not_called()
|
||||
|
||||
def test_complete_marker_requires_successful_archive_validation(self):
|
||||
for corrupt in (False, True):
|
||||
with self.subTest(corrupt=corrupt), tempfile.TemporaryDirectory() as root:
|
||||
directory = Path(root)
|
||||
(directory / ".env.cloud").write_text("MOYI_SMTP_PASSWORD='test-only-secret'\n")
|
||||
deploy = SimpleNamespace(HERE=directory, preflight=lambda *args: configuration())
|
||||
seen = []
|
||||
|
||||
def command(argv, **kwargs):
|
||||
seen.append(argv)
|
||||
self.assertNotIn("test-only-rds-password", " ".join(argv))
|
||||
if argv[0] == "psql":
|
||||
return "moyi_control"
|
||||
if argv[0] == "pg_dump":
|
||||
Path(next(item[7:] for item in argv if item.startswith("--file="))).write_bytes(b"test archive")
|
||||
if argv[0] == "pg_restore" and corrupt:
|
||||
raise backup_database.MaintenanceError("Invalid archive")
|
||||
return ""
|
||||
|
||||
with patch.object(backup_database.shutil, "which", side_effect=lambda name: name), \
|
||||
patch.object(backup_database, "check_container"), patch.object(backup_database, "run", side_effect=command):
|
||||
if corrupt:
|
||||
with self.assertRaisesRegex(backup_database.MaintenanceError, "Invalid archive"):
|
||||
backup_database.backup(deploy, "tunnel", directory / "backups")
|
||||
self.assertEqual([], list((directory / "backups").rglob("backup-complete.json")))
|
||||
else:
|
||||
destination = backup_database.backup(deploy, "tunnel", directory / "backups")
|
||||
report = json.loads((destination / "backup-complete.json").read_text())
|
||||
self.assertEqual(report["database"], "moyi_control")
|
||||
self.assertEqual((destination / "env.cloud").read_bytes(), (directory / ".env.cloud").read_bytes())
|
||||
self.assertEqual(set(report["sha256"]), {"env.cloud", "moyi_control.dump"})
|
||||
self.assertEqual([argv[0] for argv in seen], ["psql", "pg_dump", "pg_restore"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -37,6 +37,12 @@ def configuration():
|
||||
|
||||
|
||||
class DeploymentTests(unittest.TestCase):
|
||||
def test_proxy_replaces_forwarding_headers_for_verification_limits(self):
|
||||
routes = (DIRECTORY / "nginx" / "routes.conf").read_text(encoding="utf-8")
|
||||
self.assertEqual(routes.count('proxy_set_header Forwarded "";'), 2)
|
||||
self.assertEqual(routes.count('proxy_set_header X-Forwarded-For $remote_addr;'), 2)
|
||||
self.assertNotIn('$proxy_add_x_forwarded_for', routes)
|
||||
|
||||
def test_login_smoke_requires_super_admin_and_checks_management(self):
|
||||
cfg = configuration()
|
||||
cfg["services"]["moyi-api"]["environment"]["ADMIN_ACCOUNT"] = "adimin"
|
||||
|
||||
Reference in new issue
Block a user