Mathieu Benoit
16aecc2d33
An IMAP/SMTP client in the menu, with its tests against real servers. Most of the work went into refusals: an application password is named only when the server actually refuses, an accented password is reported as never having left the machine, and a refusal is recognised by what the server SAYS rather than by matching its wording. A malformed date no longer takes the whole folder down, and a received email is never read as markup. --- FR --- Un client IMAP/SMTP dans le menu, avec ses tests contre de vrais serveurs. L'essentiel du travail porte sur les refus : le mot de passe d'application n'est nommé que lorsque le serveur refuse vraiment, un mot de passe accentué est signalé comme n'ayant jamais quitté la machine, et un refus se reconnaît à ce que le serveur DIT plutôt qu'à ses mots. Une date illisible n'emporte plus le dossier entier, et un courriel reçu n'est jamais lu comme du balisage. Assisted-by: Claude Opus 5
426 lines
15 KiB
Python
426 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
# © 2026 TechnoLibre (http://www.technolibre.ca)
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
|
|
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from script.todo.todo import (
|
|
ANDROID_DIR,
|
|
CONFIG_FILE,
|
|
CONFIG_OVERRIDE_FILE,
|
|
ENABLE_CRASH,
|
|
ERROR_LOG_PATH,
|
|
GRADLE_FILE,
|
|
LOGO_ASCII_FILE,
|
|
MOBILE_HOME_PATH,
|
|
STRINGS_FILE,
|
|
TODO,
|
|
VENV_ERPLIBRE,
|
|
)
|
|
from script.todo.version_manager import (
|
|
INSTALLED_ODOO_VERSION_FILE,
|
|
ODOO_VERSION_FILE,
|
|
VERSION_DATA_FILE,
|
|
get_odoo_version,
|
|
)
|
|
|
|
|
|
class TestTODOInit(unittest.TestCase):
|
|
def test_initial_attributes(self):
|
|
todo = TODO()
|
|
self.assertIsNone(todo.dir_path)
|
|
self.assertIsNone(todo.selected_file_path)
|
|
self.assertIsNotNone(todo.config_file)
|
|
self.assertIsNotNone(todo.execute)
|
|
self.assertIsNotNone(todo.kdbx_manager)
|
|
|
|
|
|
class TestFillHelpInfo(unittest.TestCase):
|
|
def setUp(self):
|
|
self.todo = TODO()
|
|
|
|
@patch("script.todo.todo.t")
|
|
def test_basic_help_info(self, mock_t):
|
|
mock_t.side_effect = lambda k: {
|
|
"command": "Command:",
|
|
"back": "Back",
|
|
}.get(k, k)
|
|
choices = [
|
|
{"prompt_description": "Option A"},
|
|
{"prompt_description": "Option B"},
|
|
]
|
|
result = self.todo.fill_help_info(choices)
|
|
self.assertIn("[1] Option A", result)
|
|
self.assertIn("[2] Option B", result)
|
|
self.assertIn("[0] Back", result)
|
|
|
|
@patch("script.todo.todo.t")
|
|
def test_with_prompt_description_key(self, mock_t):
|
|
mock_t.side_effect = lambda k: {
|
|
"command": "Command:",
|
|
"back": "Back",
|
|
"my_key": "Translated Description",
|
|
}.get(k, k)
|
|
choices = [
|
|
{
|
|
"prompt_description": "fallback",
|
|
"prompt_description_key": "my_key",
|
|
},
|
|
]
|
|
result = self.todo.fill_help_info(choices)
|
|
self.assertIn("[1] Translated Description", result)
|
|
|
|
@patch("script.todo.todo.t")
|
|
def test_empty_list(self, mock_t):
|
|
mock_t.side_effect = lambda k: {
|
|
"command": "Command:",
|
|
"back": "Back",
|
|
}.get(k, k)
|
|
result = self.todo.fill_help_info([])
|
|
self.assertIn("Command:", result)
|
|
self.assertIn("[0] Back", result)
|
|
self.assertNotIn("[1]", result)
|
|
|
|
|
|
class TestGetOdooVersion(unittest.TestCase):
|
|
def test_reads_version_data(self):
|
|
version_data = {
|
|
"odoo18.0_python3.12.10": {
|
|
"odoo_version": "18.0",
|
|
"python_version": "3.12.10",
|
|
"default": True,
|
|
"is_deprecated": False,
|
|
},
|
|
"odoo16.0_python3.10.18": {
|
|
"odoo_version": "16.0",
|
|
"python_version": "3.10.18",
|
|
"default": False,
|
|
"is_deprecated": False,
|
|
},
|
|
}
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
version_file = os.path.join(tmpdir, "version.json")
|
|
with open(version_file, "w") as f:
|
|
json.dump(version_data, f)
|
|
|
|
odoo_version_file = os.path.join(tmpdir, ".odoo-version")
|
|
with open(odoo_version_file, "w") as f:
|
|
f.write("18.0")
|
|
|
|
with patch(
|
|
"script.todo.version_manager.VERSION_DATA_FILE", version_file
|
|
), patch(
|
|
"script.todo.version_manager.INSTALLED_ODOO_VERSION_FILE",
|
|
os.path.join(tmpdir, "nonexistent.txt"),
|
|
), patch(
|
|
"script.todo.version_manager.ODOO_VERSION_FILE",
|
|
odoo_version_file,
|
|
):
|
|
versions, installed, odoo_current = get_odoo_version()
|
|
|
|
self.assertEqual(len(versions), 2)
|
|
self.assertEqual(odoo_current, "odoo18.0")
|
|
# Check erplibre_version was added
|
|
names = [v["erplibre_version"] for v in versions]
|
|
self.assertIn("odoo18.0_python3.12.10", names)
|
|
self.assertIn("odoo16.0_python3.10.18", names)
|
|
|
|
def test_installed_versions_read(self):
|
|
version_data = {
|
|
"odoo18.0_python3.12.10": {
|
|
"odoo_version": "18.0",
|
|
"python_version": "3.12.10",
|
|
"default": True,
|
|
"is_deprecated": False,
|
|
},
|
|
}
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
version_file = os.path.join(tmpdir, "version.json")
|
|
with open(version_file, "w") as f:
|
|
json.dump(version_data, f)
|
|
|
|
installed_file = os.path.join(tmpdir, "installed.txt")
|
|
with open(installed_file, "w") as f:
|
|
f.write("odoo18.0\nodoo16.0\n")
|
|
|
|
with patch(
|
|
"script.todo.version_manager.VERSION_DATA_FILE", version_file
|
|
), patch(
|
|
"script.todo.version_manager.INSTALLED_ODOO_VERSION_FILE",
|
|
installed_file,
|
|
), patch(
|
|
"script.todo.version_manager.ODOO_VERSION_FILE",
|
|
os.path.join(tmpdir, "nonexistent"),
|
|
):
|
|
versions, installed, odoo_current = get_odoo_version()
|
|
|
|
self.assertEqual(installed, ["odoo16.0", "odoo18.0"])
|
|
self.assertIsNone(odoo_current)
|
|
|
|
def test_no_version_data_raises(self):
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
version_file = os.path.join(tmpdir, "empty.json")
|
|
with open(version_file, "w") as f:
|
|
json.dump({}, f)
|
|
|
|
with patch(
|
|
"script.todo.version_manager.VERSION_DATA_FILE", version_file
|
|
):
|
|
with self.assertRaises(Exception):
|
|
get_odoo_version()
|
|
|
|
|
|
class TestOnDirSelected(unittest.TestCase):
|
|
@patch("script.todo.todo.todo_file_browser", create=True)
|
|
def test_sets_dir_path(self, mock_browser):
|
|
todo = TODO()
|
|
todo.on_dir_selected("/some/path")
|
|
self.assertEqual(todo.dir_path, "/some/path")
|
|
def test_with_command(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
dct = {"command": "./run.sh"}
|
|
todo.execute_from_configuration(dct)
|
|
todo.execute.exec_command_live.assert_called()
|
|
|
|
def test_makefile_cmd_ignored_when_flag(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
dct = {"makefile_cmd": "run_test"}
|
|
todo.execute_from_configuration(dct, ignore_makefile=True)
|
|
todo.execute.exec_command_live.assert_not_called()
|
|
|
|
def test_with_callback(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
callback = MagicMock()
|
|
dct = {"callback": callback}
|
|
todo.execute_from_configuration(dct)
|
|
callback.assert_called_once_with(dct)
|
|
|
|
def test_makefile_error_stops_execution(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo.execute.exec_command_live.return_value = 1
|
|
callback = MagicMock()
|
|
dct = {"makefile_cmd": "broken", "callback": callback}
|
|
todo.execute_from_configuration(dct)
|
|
callback.assert_not_called()
|
|
|
|
|
|
class TestConstants(unittest.TestCase):
|
|
def test_config_file_path(self):
|
|
self.assertEqual(CONFIG_FILE, "./script/todo/todo.json")
|
|
|
|
def test_config_override_path(self):
|
|
self.assertEqual(CONFIG_OVERRIDE_FILE, "./private/todo/todo.json")
|
|
|
|
def test_logo_path(self):
|
|
self.assertEqual(LOGO_ASCII_FILE, "./script/todo/logo_ascii.txt")
|
|
|
|
def test_venv_erplibre(self):
|
|
self.assertEqual(VENV_ERPLIBRE, ".venv.erplibre")
|
|
|
|
def test_file_error_path(self):
|
|
self.assertEqual(ERROR_LOG_PATH, ".erplibre.error.txt")
|
|
|
|
def test_version_data_file(self):
|
|
self.assertEqual(
|
|
VERSION_DATA_FILE,
|
|
os.path.join("conf", "supported_version_erplibre.json"),
|
|
)
|
|
|
|
def test_mobile_paths(self):
|
|
self.assertEqual(ANDROID_DIR, "android")
|
|
self.assertIn("mobile", MOBILE_HOME_PATH)
|
|
|
|
|
|
class TestDeployGitServer(unittest.TestCase):
|
|
def test_local_mode(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo._deploy_git_server(production_ready=False, action="init")
|
|
cmd = todo.execute.exec_command_live.call_args[0][0]
|
|
self.assertIn("--action init", cmd)
|
|
self.assertNotIn("--production-ready", cmd)
|
|
|
|
def test_production_mode(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo._deploy_git_server(production_ready=True, action="all")
|
|
cmd = todo.execute.exec_command_live.call_args[0][0]
|
|
self.assertIn("--production-ready", cmd)
|
|
self.assertIn("--action all", cmd)
|
|
|
|
|
|
class TestProcessKillGitDaemon(unittest.TestCase):
|
|
def test_calls_pkill(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo.process_kill_git_daemon()
|
|
cmd = todo.execute.exec_command_live.call_args[0][0]
|
|
self.assertIn("pkill", cmd)
|
|
self.assertIn("git daemon", cmd)
|
|
def test_success_path(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo.execute.exec_command_live.return_value = (0, ["OK"])
|
|
with patch("builtins.print") as mock_print:
|
|
todo.execute_unit_tests()
|
|
cmd = todo.execute.exec_command_live.call_args[0][0]
|
|
self.assertIn("unittest discover", cmd)
|
|
|
|
def test_failure_path(self):
|
|
todo = TODO()
|
|
todo.execute = MagicMock()
|
|
todo.execute.exec_command_live.return_value = (1, ["FAIL"])
|
|
with patch("builtins.print") as mock_print:
|
|
todo.execute_unit_tests()
|
|
def test_empty_kdbx_key(self):
|
|
todo = TODO()
|
|
result = todo.kdbx_manager.get_extra_command_user("")
|
|
self.assertEqual(result, "")
|
|
|
|
def test_none_kdbx_key(self):
|
|
todo = TODO()
|
|
result = todo.kdbx_manager.get_extra_command_user(None)
|
|
self.assertEqual(result, "")
|
|
|
|
def test_kdbx_not_available(self):
|
|
todo = TODO()
|
|
todo.kdbx_manager.get_kdbx = MagicMock(return_value=None)
|
|
result = todo.kdbx_manager.get_extra_command_user("some_key")
|
|
self.assertEqual(result, "")
|
|
|
|
|
|
class TestSelectDatabase(unittest.TestCase):
|
|
@patch("script.todo.database_manager.click")
|
|
def test_select_database_returns_name(self, mock_click):
|
|
todo = TODO()
|
|
todo.db_manager._execute = MagicMock()
|
|
todo.db_manager._execute.exec_command_live.return_value = (
|
|
0,
|
|
["db_test", "db_prod"],
|
|
)
|
|
mock_click.prompt.return_value = "1"
|
|
result = todo.db_manager.select_database()
|
|
self.assertEqual(result, "db_test")
|
|
|
|
@patch("script.todo.database_manager.click")
|
|
def test_select_database_returns_false_on_zero(self, mock_click):
|
|
todo = TODO()
|
|
todo.db_manager._execute = MagicMock()
|
|
todo.db_manager._execute.exec_command_live.return_value = (
|
|
0,
|
|
["db_test"],
|
|
)
|
|
mock_click.prompt.return_value = "0"
|
|
result = todo.db_manager.select_database()
|
|
self.assertFalse(result)
|
|
|
|
|
|
class TestRestoreFromDatabase(unittest.TestCase):
|
|
@patch("builtins.input")
|
|
def test_restore_by_filename(self, mock_input):
|
|
todo = TODO()
|
|
todo.db_manager._execute = MagicMock()
|
|
todo.db_manager._execute.exec_command_live.return_value = (
|
|
0,
|
|
[],
|
|
)
|
|
# status="1" (by filename), db name default, no neutralize
|
|
mock_input.side_effect = ["1", "", "n", "n"]
|
|
todo.db_manager.restore_from_database()
|
|
cmd = todo.db_manager._execute.exec_command_live.call_args_list[0][0][
|
|
0
|
|
]
|
|
self.assertIn("db_restore.py", cmd)
|
|
|
|
@patch("builtins.input")
|
|
def test_restore_with_neutralize(self, mock_input):
|
|
todo = TODO()
|
|
todo.db_manager._execute = MagicMock()
|
|
todo.db_manager._execute.exec_command_live.return_value = (
|
|
0,
|
|
[],
|
|
)
|
|
mock_input.side_effect = ["1", "mydb", "y", "n"]
|
|
todo.db_manager.restore_from_database()
|
|
cmd = todo.db_manager._execute.exec_command_live.call_args_list[0][0][
|
|
0
|
|
]
|
|
self.assertIn("--neutralize", cmd)
|
|
self.assertIn("mydb_neutralize", cmd)
|
|
|
|
|
|
class TestCreateBackupFromDatabase(unittest.TestCase):
|
|
@patch("script.todo.database_manager.click")
|
|
@patch("builtins.input")
|
|
def test_creates_backup_command(self, mock_input, mock_click):
|
|
todo = TODO()
|
|
todo.db_manager._execute = MagicMock()
|
|
todo.db_manager._execute.exec_command_live.return_value = (
|
|
0,
|
|
["test_db"],
|
|
)
|
|
mock_click.prompt.return_value = "1"
|
|
# backup name input
|
|
mock_input.return_value = "backup.zip"
|
|
todo.db_manager.create_backup_from_database()
|
|
cmd = todo.db_manager._execute.exec_command_live.call_args_list[-1][0][
|
|
0
|
|
]
|
|
self.assertIn("--backup", cmd)
|
|
self.assertIn("test_db", cmd)
|
|
|
|
|
|
class TestModuleLevelAbortExit(unittest.TestCase):
|
|
"""`click.exceptions.Abort` (raised by `click.prompt` on both Ctrl+C and
|
|
Ctrl+D/EOF - see click's own `termui.prompt_func`) is NOT a
|
|
`KeyboardInterrupt` subclass. Only the top-level menu's `click.prompt`
|
|
call is wrapped locally, inside `run()` (todo.py around line 149) -
|
|
every submenu (`prompt_assistant`, etc.) lets `Abort` propagate
|
|
uncaught. These tests drive the real script end to end (not a mock of
|
|
the dispatch chain) to prove the module-level guard around
|
|
`todo.run()` (todo.py around line 7159) now catches it too.
|
|
"""
|
|
|
|
def _run_todo(self, stdin_text):
|
|
repo_root = Path(__file__).resolve().parent.parent
|
|
python_bin = repo_root / ".venv.erplibre" / "bin" / "python3"
|
|
env = os.environ.copy()
|
|
with tempfile.TemporaryDirectory() as home_dir:
|
|
env["HOME"] = home_dir
|
|
return subprocess.run(
|
|
[str(python_bin), "script/todo/todo.py"],
|
|
cwd=repo_root,
|
|
input=stdin_text,
|
|
capture_output=True,
|
|
text=True,
|
|
env=env,
|
|
timeout=30,
|
|
)
|
|
|
|
def test_ctrl_d_in_a_submenu_exits_cleanly(self):
|
|
# "3" enters the Assistant submenu; the immediate EOF that follows
|
|
# raises Abort from a click.prompt() call that run() does not wrap.
|
|
result = self._run_todo("3\n")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertNotIn("Traceback", result.stderr)
|
|
self.assertNotIn("click.exceptions.Abort", result.stderr)
|
|
|
|
def test_ctrl_d_on_the_top_menu_still_exits_cleanly(self):
|
|
# Regression guard: the pre-existing local handler in run() must
|
|
# keep working once the module-level guard is added alongside it.
|
|
result = self._run_todo("")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertNotIn("Traceback", result.stderr)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|