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()