Files
dbx-corm/tests/test_postgres_settings.py

258 lines
12 KiB
Python

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