258 lines
12 KiB
Python
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()
|