"""Settings compatibility, isolation from Google, migration and write conflicts.""" import copy import io import json import os import tempfile import unittest from contextlib import redirect_stderr, redirect_stdout from pathlib import Path from unittest.mock import MagicMock, patch import psycopg2 import main import settings_migrate as migration from settings_store import ( HEADER, PostgresSettingsStore, SettingsAlreadyInitialized, SettingsConflict, SettingsNotInitialized, config_to_rows, rows_to_config, settings_db_config, validate_rows, ) from test_google_resilience import request ROWS = [ HEADER.copy(), ["APP_SETTINGS", "shipping_fee", "3500"], ["GROUP_NAMES", "ORDER_SINGLE", "단품"], ["ORDER_SINGLE", "상품 B", "B-2", "상품 B", "2000", "1500"], ["ORDER_SINGLE", "---separator_1---"], ["ORDER_SINGLE", "상품 A", "A-1", "상품 A", "1000"], ["SMS_GIFT_RULES", "header_text", "안녕하세요\n주문 안내 😊"], ["EMPTY", "", ""], ] class CodecTests(unittest.TestCase): def test_order_separators_empty_sections_and_multiline_survive_roundtrip(self): restored = rows_to_config(config_to_rows(rows_to_config(ROWS))) self.assertEqual({s: dict(restored.items(s)) for s in restored.sections()}, {s: dict(rows_to_config(ROWS).items(s)) for s in restored.sections()}) self.assertEqual(list(rows_to_config(ROWS)["ORDER_SINGLE"]), ["상품 B", "---separator_1---", "상품 A"]) def test_invalid_or_empty_imports_are_rejected(self): for rows in ([], [HEADER], [[123]], [["APP_SETTINGS", "key", "a\x00b"]], {"a": 1}): with self.subTest(rows=rows), self.assertRaises(ValueError): validate_rows(rows) class DatabaseRoutingTests(unittest.TestCase): def test_settings_default_is_independent_of_itemcode_db(self): with patch.dict(os.environ, {"ITEMCODE_DB": "existing_codes"}, clear=True): self.assertEqual(settings_db_config()["dbname"], "corm_db") self.assertEqual(migration.build_store().db_config["dbname"], "corm_db") def test_explicit_settings_db_uses_existing_server_credentials(self): env = {"ITEMCODE_DB": "existing_codes", "SETTINGS_DB": "custom_corm", "POSTGRES_HOST": "shared-pg", "POSTGRES_PORT": "5433", "POSTGRES_USER": "app-user", "POSTGRES_PASSWORD": "test-only"} with patch.dict(os.environ, env, clear=True): config = settings_db_config() self.assertEqual(config, {"host": "shared-pg", "port": 5433, "dbname": "custom_corm", "user": "app-user", "password": "test-only"}) self.assertEqual(migration.build_store().db_config, config) def test_application_settings_store_has_separate_config(self): self.assertIsNot(main.SETTINGS_DB_CONFIG, main.DB_CONFIG) self.assertEqual(main._postgres_settings.db_config, main.SETTINGS_DB_CONFIG) class StoreTests(unittest.TestCase): def setUp(self): self.store = PostgresSettingsStore({"host": "test-db", "password": "test-only"}) self.connection = MagicMock() self.cursor = self.connection.cursor.return_value.__enter__.return_value self.connect = patch.object(self.store, "_connect", return_value=self.connection) self.connect.start() self.addCleanup(self.connect.stop) def test_read_closes_connection_and_preserves_version(self): self.cursor.fetchone.return_value = (copy.deepcopy(ROWS), 7) self.assertEqual(self.store.read(), (ROWS, 7)) self.connection.close.assert_called_once() def test_missing_data_or_table_does_not_return_empty_settings(self): self.cursor.fetchone.return_value = None with self.assertRaises(SettingsNotInitialized): self.store.read() self.cursor.execute.side_effect = psycopg2.errors.UndefinedTable() with self.assertRaises(SettingsNotInitialized): self.store.read() def test_write_uses_expected_version_and_parameterized_values(self): self.cursor.fetchone.return_value = (8,) self.assertEqual(self.store.write(ROWS, 7), 8) query, args = self.cursor.execute.call_args.args self.assertIn("AND version = %s", query) self.assertEqual(args[1], 7) self.assertEqual(args[0].adapted, ROWS) self.connection.__exit__.assert_called_once_with(None, None, None) def test_conflict_aborts_transaction(self): self.cursor.fetchone.return_value = None with self.assertRaises(SettingsConflict): self.store.write(ROWS, 7) self.assertIs(self.connection.__exit__.call_args.args[0], SettingsConflict) def test_import_never_overwrites_an_existing_document(self): self.cursor.fetchone.return_value = None with self.assertRaises(SettingsAlreadyInitialized): self.store.import_rows(ROWS, "test") self.assertIn("ON CONFLICT (id) DO NOTHING", self.cursor.execute.call_args.args[0]) self.assertIs(self.connection.__exit__.call_args.args[0], SettingsAlreadyInitialized) def test_import_readback_mismatch_aborts_before_commit(self): self.cursor.fetchone.side_effect = [(1,), ([HEADER],)] with self.assertRaises(RuntimeError): self.store.import_rows(ROWS, "test") self.assertIs(self.connection.__exit__.call_args.args[0], RuntimeError) class PostgresApiTests(unittest.IsolatedAsyncioTestCase): def setUp(self): manual = patch.object(main, "MANUAL_ORDERS_BACKEND", "google") manual.start() self.addCleanup(manual.stop) histories = patch.object(main, "HISTORY_BACKEND", "google") histories.start() self.addCleanup(histories.stop) self.backend = patch.object(main, "SETTINGS_BACKEND", "postgres") self.backend.start() self.addCleanup(self.backend.stop) self.store = MagicMock() self.store.read.return_value = (copy.deepcopy(ROWS), 7) self.store.write.return_value = 8 self.store_patch = patch.object(main, "_postgres_settings", self.store) self.store_patch.start() self.addCleanup(self.store_patch.stop) self.google = patch.object(main, "get_settings_worksheet", side_effect=AssertionError("Unexpected Google I/O")) self.google_mock = self.google.start() self.addCleanup(self.google.stop) async def test_config_reads_db_and_preserves_existing_api_order(self): status, headers, body = await request("GET", "/api/config") self.assertEqual(status, 200) data = json.loads(body) self.assertEqual(data["ORDER_SINGLE"]["__order"], ["상품 B", "---separator_1---", "상품 A"]) self.assertEqual(data["SMS_GIFT_RULES"]["header_text"], "안녕하세요\n주문 안내 😊") self.assertEqual(headers[b"x-settings-backend"], b"postgres") async def test_all_setting_endpoints_write_db_without_google(self): payloads = [ ("/api/app/settings", {"shipping_fee": "4000"}), ("/api/gift/settings", {"rules": {"header_text": "새 문구"}, "app_settings": {"shipping_fee": "4500"}}), ("/api/products/subgroup-name", {"group_key": "ORDER_SINGLE", "subgroup_index": 0, "name": "분류"}), ("/api/products/settings", { "groups": [{"old_code": "ORDER_SINGLE", "new_code": "ORDER_SINGLE", "name": "단품"}], "products": {"ORDER_SINGLE": [{"label": "상품", "code": "NEW", "name": "새 상품", "price": 5000}]}, }), ] for url, payload in payloads: with self.subTest(url=url): self.assertEqual((await request("POST", url, payload))[0], 200) self.assertEqual(self.store.write.call_args.args[1], 7) self.google_mock.assert_not_called() async def test_conflict_returns_409_and_db_failure_never_falls_back_to_google(self): self.store.write.side_effect = SettingsConflict("다른 요청이 변경했습니다.") self.assertEqual((await request("POST", "/api/app/settings", {"shipping_fee": "4000"}))[0], 409) self.store.read.side_effect = RuntimeError("database unavailable") self.assertEqual((await request("GET", "/api/config"))[0], 503) self.google_mock.assert_not_called() async def test_google_saturation_does_not_block_db_settings_reads_or_saves(self): with patch.object(main, "run_google_io", side_effect=AssertionError("Google pool unavailable")): self.assertEqual((await request("GET", "/api/config"))[0], 200) self.assertEqual((await request("POST", "/api/app/settings", {"font": "Arial"}))[0], 200) async def test_postgres_startup_does_not_refresh_google(self): with patch.dict(os.environ, {"SKIP_DB_INIT": "1"}), \ patch.object(main._settings_cache, "refresh_in_background") as refresh: await main.startup_event() refresh.assert_not_called() self.store.read.assert_called_once() async def test_startup_rejects_incomplete_migration(self): self.store.read.side_effect = SettingsNotInitialized("missing") with patch.dict(os.environ, {"SKIP_DB_INIT": "1"}), self.assertRaises(SettingsNotInitialized): await main.startup_event() class MigrationTests(unittest.TestCase): def setUp(self): self.directory = tempfile.TemporaryDirectory() self.addCleanup(self.directory.cleanup) self.backup = Path(self.directory.name) / "settings.json" self.store = MagicMock() self.store.read.return_value = (copy.deepcopy(ROWS), 1) self.store.import_rows.return_value = 1 for name, value in (("read_google_rows", (copy.deepcopy(ROWS), "google:test:설정")), ("build_store", self.store)): patched = patch.object(migration, name, return_value=value) patched.start() self.addCleanup(patched.stop) self.output = io.StringIO() def run_cli(self, args): with redirect_stdout(self.output), redirect_stderr(self.output): return migration.main(args) def test_dry_run_never_connects_to_or_writes_db(self): self.assertEqual(self.run_cli(["import"]), 0) migration.build_store.assert_not_called() def test_apply_backs_up_before_import_and_does_not_overwrite_backups(self): def check_backup(rows, source): self.assertEqual(migration.load_snapshot(self.backup)[0], rows) return 1 self.store.import_rows.side_effect = check_backup args = ["import", "--apply", "--backup", str(self.backup)] self.assertEqual(self.run_cli(args), 0) self.assertEqual(self.run_cli(args), 1) self.store.import_rows.assert_called_once() def test_apply_requires_backup_before_source_or_db_access(self): with self.assertRaises(SystemExit), redirect_stderr(self.output): migration.main(["import", "--apply"]) migration.read_google_rows.assert_not_called() migration.build_store.assert_not_called() def test_backup_checksum_rejects_modified_content(self): migration.save_snapshot(self.backup, ROWS, "test") payload = json.loads(self.backup.read_text(encoding="utf-8")) payload["rows"][1][2] = "9999" self.backup.write_text(json.dumps(payload), encoding="utf-8") with self.assertRaises(ValueError): migration.load_snapshot(self.backup) def test_verify_detects_order_or_cell_differences(self): self.assertEqual(self.run_cli(["verify"]), 0) self.store.read.return_value = (list(reversed(ROWS)), 1) self.assertEqual(self.run_cli(["verify"]), 1) self.store.import_rows.assert_not_called() def test_export_and_offline_import_need_no_google(self): self.assertEqual(self.run_cli(["export", "--output", str(self.backup)]), 0) self.assertEqual(self.run_cli(["import", "--input-file", str(self.backup)]), 0) migration.read_google_rows.assert_not_called() def test_errors_do_not_print_database_credentials(self): self.store.import_rows.side_effect = RuntimeError("password=secret-value") self.assertEqual(self.run_cli(["import", "--apply", "--backup", str(self.backup)]), 1) self.assertNotIn("secret-value", self.output.getvalue()) if __name__ == "__main__": unittest.main()