gOdoo-cli 1.0.5__tar.gz → 1.0.6__tar.gz

godoo_cli-1.0.6/.agents/skills/godoo-release-management/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: godoo-release-management
+description:
+  Prepare, review, merge, and verify gOdoo releases using the repository's version-bump and publication workflows.
+---
+
+# gOdoo release management
+
+Read `.github/workflows/README.md` and inspect the current release state before acting. Publish or merge only when
+explicitly authorized. Keep the release PR short-lived and coordinate other merges to preserve its intended scope.
+
+Dispatch `.github/workflows/version-bump.yml` against `main` with the selected bump type. The workflow creates
+`release/<version>` and its release PR; leave version changes to it and keep the PR limited to release preparation. Do
+not use long-lived `release` or `develop` branches for this workflow.
+
+The release PR description becomes the release notes. Never replace existing release text or remove its changelog
+summary. If additions are needed, replace the placeholder and preserve the generated changelog and remaining text.
+Review the notes, release-preparation diff, release label, source repository, target branch, title, branch name, package
+version, and available Quality results against the identities in `.github/workflows/README.md` before merging.
+
+After the authorized merge, verify publication to PyPI, the `v<version>` tag at the release merge commit, and the GitHub
+Release. If publication fails, inspect the failed step and existing PyPI, tag, and release state before retrying. Never
+move an existing release tag to repair publication. Report the released version, revision, validation, and any
+downstream adoption required.

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/AGENTS.md

@@ -10,8 +10,8 @@ coherent change.
   detects or orchestrates containers.
 - Load the matching skill under `.agents/skills/` for source-workspace or runtime work; load both only when a change
   crosses those boundaries.
-- Use `godoo-editor-validation` for VS Code diagnostics and development-flow checks, and `godoo-changeset-review` for
-  whole-changeset reviews.
+- Use `godoo-editor-validation` for VS Code diagnostics and development-flow checks, `godoo-changeset-review` for
+  whole-changeset reviews, and `godoo-release-management` for release preparation and publication.
 - Keep shared Docker validation sequential.
 
 ## Branches and releases
@@ -24,13 +24,6 @@ coherent change.
   Follow the existing merge strategy and commit conventions. Push and merge only within explicit authorization.
 - After merge, return to an updated `main` or start the next topic branch from current `origin/main`. Prune stale remote
   references and remove merged branches only after checking ancestry and worktree ownership; preserve unfinished work.
-- Leave package version changes to `.github/workflows/version-bump.yml`, dispatched against `main` with the chosen bump
-  type. It creates `release/<version>` and the release PR; keep that PR limited to preparing the release.
-- Review the release PR description and available Quality results before merging: its description becomes the release
-  notes. The release-labeled PR must target `main` and match the title, branch, and version identities documented in
-  `.github/workflows/README.md`. Publication uses the release merge commit for PyPI, the tag, and the GitHub Release.
-- Keep release PRs short-lived and coordinate other merges to preserve the intended release scope. Do not use a
-  long-lived `release` or `develop` branch for this workflow, or move an existing release tag to repair publication.
 
 ## Code and CLI
 

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gOdoo-cli
-Version: 1.0.5
+Version: 1.0.6
 Summary: Odoo lifecycle, Python dependency preflight, and shared Git workspaces.
 Project-URL: repository, https://github.com/OpenJKSoftware/gOdoo
 Author-email: Joshua Kreuder <Joshua_Kreuder@outlook.com>

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/docs/hooks.md

@@ -7,18 +7,21 @@ Ordinary restores and major upgrades share the same initialization flow.
 
 ## Choose the right mechanism
 
-| Work                                      | Mechanism                                                         | Runs when                                                           |
-| ----------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------- |
-| Versioned schema or data repair           | Addon `migrations/<version>/pre-*.py`, `post-*.py`, or `end-*.py` | An eligible installed-to-manifest version change occurs.            |
-| External migration roots                  | Explicit `--upgrade-path`                                         | Selected module updates invoke Odoo's loader.                       |
-| Cursor-based work before registry loading | Explicit `--pre-upgrade-script`                                   | An update selection exists; maps to native `--pre-upgrade-scripts`. |
-| Choose modules to install/update          | `prepare` hook                                                    | Each initialization attempt, before dependency preflight.           |
-| Bootstrap or restore setup                | `after_bootstrap` / `after_restore` hook                          | The matching initialization outcome applies.                        |
-| Recurring environment policy              | `after_reconcile` hook                                            | Reconciliation succeeds and declaration filters match.              |
+| Work                                      | Mechanism                                                         | Mechanism owner | Runs when                                                           |
+| ----------------------------------------- | ----------------------------------------------------------------- | --------------- | ------------------------------------------------------------------- |
+| Versioned schema or data repair           | Addon `migrations/<version>/pre-*.py`, `post-*.py`, or `end-*.py` | Odoo            | An eligible installed-to-manifest version change occurs.            |
+| External migration roots                  | Explicit `--upgrade-path`                                         | Odoo            | Selected module updates invoke Odoo's loader.                       |
+| Cursor-based work before registry loading | Explicit `--pre-upgrade-script`                                   | Odoo            | An update selection exists; maps to native `--pre-upgrade-scripts`. |
+| Choose modules to install/update          | `prepare` hook                                                    | gOdoo           | Each initialization attempt, unless completed with `once=True`.     |
+| Bootstrap or restore setup                | `after_bootstrap` / `after_restore` hook                          | gOdoo           | The matching initialization outcome applies.                        |
+| Recurring environment policy              | `after_reconcile` hook                                            | gOdoo           | Reconciliation succeeds and declaration filters match.              |
+
+Projects supply the migration scripts and hook implementations. gOdoo forwards the selected native migration options to
+Odoo and runs the lifecycle hooks.
 
 Native migration versions must be above the installed version and at or below the manifest version. Fresh installs need
 their own install behavior. There is no transition directory, version-pair selector, implicit module list, or hook
-implicit migration scheduler. Ordinary database hooks can opt into transactional one-shot completion with `once=True`.
+implicit migration scheduler. Hooks can opt into one-shot completion with `once=True`.
 
 ## Discover and select hooks
 
@@ -49,7 +52,7 @@ actual boolean. A missing predicate runs whenever eligible; an exception fails i
 | `phase`        | `prepare`, `after_bootstrap`, `after_restore`, or `after_reconcile`.                                                             |
 | `on`           | Tuple of `ready`, `bootstrapped`, and/or `restored`; defaults to all. Custom outcome filters are invalid for preparation.        |
 | `environments` | Optional tuple of exact `GODOO_ENVIRONMENT` values. Omitted means unrestricted; an allowlist never matches an unset environment. |
-| `once`         | Optional boolean, default false. Record successful database-hook completion; preparation hooks cannot use it.                    |
+| `once`         | Optional boolean, default false. Record successful completion for this hook in the database.                                     |
 
 Environment is a deployment input, never inferred from database contents.
 
@@ -67,10 +70,38 @@ def run(ctx):
     ctx.request_modules(update=["project_base"], install=["helpdesk"])
 ```
 
-Preparation runs without starting Odoo and recomputes requests on every retry. Its context exposes `environment` and
-`request_modules(update=..., install=...)`, with no `env`. Preparation must not mutate databases or external systems. No
-request means no implicit action; even `all` requires an explicit request. Upgrade paths and pre-upgrade scripts remain
-explicit CLI/environment inputs.
+Preparation runs without starting Odoo. Its context exposes `environment` and
+`request_modules(update=..., install=...)`, with no `env`. Pass module names as sequences of strings. Requests combine
+with CLI and environment selections before dependency preflight and native reconciliation.
+
+`install=[...]` in a recurring hook requests installation on each initialization. Modules already installed or queued
+for upgrade are skipped; other requested modules are passed to Odoo for installation. A module uninstalled later is
+requested again on the next initialization. Change or remove the request if that module should remain uninstalled.
+Preparation must not mutate databases or external systems. No request means no implicit action; even `all` requires an
+explicit request. Upgrade paths and pre-upgrade scripts remain explicit CLI/environment inputs.
+
+A one-time preparation hook requests modules until reconciliation succeeds and every requested install is verified:
+
+```python
+# hooks/11_install_feature.py
+from godoo_cli.runtime.hooks import Hook
+
+HOOK = Hook(id="project.install_feature", phase="prepare", once=True)
+
+
+def run(ctx):
+    ctx.request_modules(install=["helpdesk"])
+```
+
+Run `godoo runtime start --hooks-dir /path/to/hooks` to initialize and reconcile before launching Odoo. A standalone
+`runtime launch` only starts a prepared runtime and does not run hooks. Once completed, the hook is skipped even if an
+operator later uninstalls the module. Use a new hook ID for a new installation request. List module names explicitly;
+`install=["all"]` cannot be verified and is rejected in one-time preparation hooks.
+
+One-time preparation runs after bootstrap or restore, when gOdoo can read the database completion record, but before
+other database hooks and native reconciliation. Its dependencies are therefore checked after bootstrap or restore. If
+reconciliation or verification fails, the hook runs again on retry using its current code. Native Odoo work and the
+completion record are separate transactions, so an interruption after native work may cause a retry.
 
 ## Reconcile database state
 
@@ -154,15 +185,17 @@ retries; it is not a completion record.
 
 Use `Hook(id="project.repair.2026_10", phase="after_reconcile", once=True)` for a transactional one-shot repair. IDs are
 immutable: use a new ID for a new repair. The runner stores completion in `ir_config_parameter` under
-`godoo.hooks.once.<identity-hash>`, in the same transaction as the action. Unrestricted hooks complete globally in that
-database; environment-restricted hooks complete separately for each selected environment. Restores and baseline resets
-carry or rewind the records with the database. Declaration filters still apply, and duplicate IDs remain invalid.
-
-Completed hooks skip `needs_run`. A false predicate means the desired state is already satisfied and records completion
-atomically without running the action. An exception rolls back the action and its completion record. A later hook's
-failure preserves earlier committed repairs. Hooks that commit internally or change external systems still need their
-own idempotency: the runner cannot promise exactly-once external effects. Keep recurring environment policy repeatable,
-with state predicates, so ordinary drift is repaired after every controlled start.
+`godoo.hooks.once.<identity-hash>`. For database hooks, it is stored in the same transaction as the action. Unrestricted
+hooks complete globally in that database; environment-restricted hooks complete separately for each selected
+environment. Restores and baseline resets carry or rewind the records with the database. Declaration filters still
+apply, and duplicate IDs remain invalid.
+
+Completed hooks skip `needs_run`. For database hooks, a false predicate records completion atomically without running
+the action; an exception rolls back the action and its completion record. For preparation hooks, completion is recorded
+after successful reconciliation and verification. A later hook's failure preserves earlier committed repairs. Hooks that
+commit internally or change external systems still need their own idempotency: the runner cannot promise exactly-once
+external effects. Keep recurring environment policy repeatable, with state predicates, so ordinary drift is repaired
+after every controlled start.
 
 | Attempt                                        | Outcome visible to hooks                                                            |
 | ---------------------------------------------- | ----------------------------------------------------------------------------------- |

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/src/godoo_cli/__about__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/src/godoo_cli/commands/runtime/init.py

@@ -13,9 +13,21 @@ import typer
 
 from ...models import GodooConfig
 from ...runtime.archive import load_runtime_archive, prepare_archive_with_original_filestore
-from ...runtime.checksums import ModulePlan, module_states, pending_installs, plan_module_changes
+from ...runtime.checksums import (
+    ModulePlan,
+    module_states,
+    pending_installs,
+    plan_module_changes,
+    verify_installed_modules,
+)
 from ...runtime.dataset import resolve_runtime_dataset
-from ...runtime.hooks import discover_hooks, has_eligible_hooks, run_prepare_hooks
+from ...runtime.hooks import (
+    complete_prepare_hooks,
+    discover_hooks,
+    has_eligible_hooks,
+    pending_prepare_hooks,
+    run_prepare_hooks,
+)
 from ...runtime.lifecycle import (
     LifecycleBootstrapError,
     deployment_init,
@@ -423,10 +435,35 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
     plan: ModulePlan | None = None
     selected_updates = split_lifecycle_values(update_modules)
     selected_installs = split_lifecycle_values(install_modules)
+    requested_installs = list(selected_installs)
+    prepare_completion_keys: list[str] = []
 
     def plan_reconciliation(conf: GodooConfig) -> None:
         """Select native work under the lifecycle lock before any database hook."""
-        nonlocal plan, selected_updates, selected_installs
+        nonlocal plan, selected_updates, selected_installs, requested_installs, prepare_completion_keys
+        once_hooks, prepare_completion_keys = pending_prepare_hooks(conf, hooks, environment)
+        if once_hooks:
+            once_modules = run_prepare_hooks(once_hooks, environment, once=True)
+            once_updates = split_lifecycle_values(list(once_modules.update))
+            once_installs = split_lifecycle_values(list(once_modules.install))
+            if "all" in once_installs:
+                message = "One-time preparation hooks must name install modules explicitly; 'all' cannot be verified."
+                raise ValueError(message)
+            selected_updates = list(dict.fromkeys([*selected_updates, *once_updates]))
+            selected_installs = list(dict.fromkeys([*selected_installs, *once_installs]))
+            requested_installs = list(selected_installs)
+            _validate_pre_upgrade_options(
+                runtime_seed is not None or (persisted is not None and persisted["outcome"] == "restored"),
+                pre_upgrade_scripts,
+                selected_updates,
+                has_eligible_hooks(hooks, phase="after_restore", outcome="restored", environment=environment),
+            )
+            preflight_reconcile_dependencies(
+                conf,
+                selected_updates,
+                selected_installs,
+                ignore_missing_installed_modules=bool(pre_upgrade_scripts),
+            )
         if request.update_changed:
             plan = plan_module_changes(
                 conf, selected_updates, selected_installs, pre_upgrade_scripts=bool(pre_upgrade_scripts)
@@ -452,6 +489,10 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
         )
         if result == 0 and plan is not None:
             plan.finish(conf)
+        elif result == 0 and requested_installs:
+            verify_installed_modules(conf, requested_installs)
+        if result == 0:
+            complete_prepare_hooks(conf, prepare_completion_keys)
         return result
 
     try:
@@ -480,7 +521,7 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
     except LifecycleBootstrapError as error:
         LOGGER.exception("Native Odoo bootstrap failed during deployment initialization")
         return error.return_code
-    except (ValueError, RuntimeError, OSError, psycopg2.Error):
+    except (TypeError, ValueError, RuntimeError, OSError, psycopg2.Error):
         LOGGER.exception("Deployment initialization failed")
         return 1
     finally:

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/src/godoo_cli/runtime/checksums.py

@@ -8,7 +8,7 @@ import logging
 import os
 import re
 from collections.abc import Container, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from ..helpers.hashing import fingerprint, sha256_file
@@ -50,6 +50,21 @@ def pending_installs(states: dict[str, ModuleState], requested: list[str]) -> li
     )
 
 
+def verify_installed_modules(config: GodooConfig, requested: list[str]) -> None:
+    """Require every explicitly requested module to be installed after reconciliation."""
+    states = module_states(config)
+    missing = _missing_installs(states, requested)
+    if missing:
+        message = f"Requested modules were not installed: {', '.join(missing)}"
+        raise RuntimeError(message)
+
+
+def _missing_installs(states: dict[str, ModuleState], requested: list[str]) -> list[str]:
+    return sorted(
+        name for name in requested if name != "all" and states.get(name, ModuleState("unknown")).state != "installed"
+    )
+
+
 def _tree_hash(path: Path, *, core: bool = False) -> str:
     files = []
     for directory, folders, names in os.walk(path):
@@ -141,6 +156,7 @@ class ModulePlan:
     updates: list[str]
     installs: list[str]
     snapshot: dict[str, str]
+    requested_installs: list[str] = field(default_factory=list)
 
     def finish(self, config: GodooConfig) -> None:
         """Verify native completion and unchanged sources before saving this snapshot."""
@@ -149,11 +165,7 @@ class ModulePlan:
         if pending:
             message = f"Native reconciliation left unfinished modules: {', '.join(pending)}"
             raise RuntimeError(message)
-        missing_installs = sorted(
-            name
-            for name in self.installs
-            if name != "all" and states.get(name, ModuleState("unknown")).state != "installed"
-        )
+        missing_installs = _missing_installs(states, [*self.installs, *self.requested_installs])
         if missing_installs:
             message = f"Requested modules were not installed: {', '.join(missing_installs)}"
             raise RuntimeError(message)
@@ -217,4 +229,4 @@ def plan_module_changes(
         )
         raise RuntimeError(message)
     LOGGER.info("Source reconciliation selected updates=%s installs=%s", selected_updates, selected_installs)
-    return ModulePlan(selected_updates, selected_installs, snapshot)
+    return ModulePlan(selected_updates, selected_installs, snapshot, requested_installs=list(installs))

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/src/godoo_cli/runtime/hooks.py

@@ -45,9 +45,6 @@ class Hook:
         if type(self.once) is not bool:
             message = "Hook once must be a boolean."
             raise ValueError(message)
-        if self.phase == "prepare" and self.once:
-            message = "Preparation hooks cannot declare once=True."
-            raise ValueError(message)
         if self.phase == "prepare" and self.on != OUTCOMES:
             message = "Preparation hooks cannot filter by outcome."
             raise ValueError(message)
@@ -131,10 +128,14 @@ def has_eligible_hooks(hooks: Iterable[HookDefinition], *, phase: str, outcome:
     return any(_is_eligible(definition.hook, phase, outcome, environment) for definition in hooks)
 
 
-def run_prepare_hooks(hooks: Iterable[HookDefinition], environment: str | None) -> ModuleSelections:
+def run_prepare_hooks(
+    hooks: Iterable[HookDefinition], environment: str | None, *, once: bool = False
+) -> ModuleSelections:
     """Run eligible preparation hooks and collect their module requests."""
     context = _PrepareContext(environment=environment)
     for definition in hooks:
+        if definition.hook.once != once:
+            continue
         if not _is_eligible(definition.hook, "prepare", None, environment):
             LOGGER.info("Hook %s excluded by declaration.", definition.hook.id)
             continue
@@ -142,6 +143,46 @@ def run_prepare_hooks(hooks: Iterable[HookDefinition], environment: str | None)
     return ModuleSelections(update=_deduplicate(context._update), install=_deduplicate(context._install))
 
 
+def _completion_key(hook: Hook, environment: str | None) -> str:
+    scope = environment if hook.environments is not None else None
+    identity = json.dumps([hook.id, scope], separators=(",", ":"))
+    return "godoo.hooks.once." + hashlib.sha256(identity.encode()).hexdigest()
+
+
+def pending_prepare_hooks(
+    config: GodooConfig, hooks: Iterable[HookDefinition], environment: str | None
+) -> tuple[list[HookDefinition], list[str]]:
+    """Select eligible one-time preparation hooks not yet completed in this database."""
+    selected = [
+        definition
+        for definition in hooks
+        if definition.hook.once and _is_eligible(definition.hook, "prepare", None, environment)
+    ]
+    if not selected:
+        return [], []
+    keys = [_completion_key(definition.hook, environment) for definition in selected]
+    with config.db_connection.with_db(config.db_name, readonly=True).connect() as cursor:
+        cursor.execute(
+            "SELECT key FROM ir_config_parameter WHERE key = ANY(%s) AND value IS NOT NULL AND value != ''", [keys]
+        )
+        completed = {row[0] for row in cursor.fetchall()}
+    pending = [(definition, key) for definition, key in zip(selected, keys, strict=True) if key not in completed]
+    return [definition for definition, _key in pending], [key for _definition, key in pending]
+
+
+def complete_prepare_hooks(config: GodooConfig, keys: list[str]) -> None:
+    """Record verified one-time preparation hooks after native reconciliation."""
+    if not keys:
+        return
+    with config.db_connection.connect() as cursor:
+        for key in keys:
+            cursor.execute(
+                "INSERT INTO ir_config_parameter (key, value) VALUES (%s, %s) "
+                "ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value",
+                [key, "1"],
+            )
+
+
 def run_hook_phase(
     config: GodooConfig,
     hooks: Iterable[HookDefinition],
@@ -188,9 +229,7 @@ def _run_database_hook_batch(shell_env: Any, sources: Sequence[str], *, outcome:
                 completion_key = None
                 parameters = None
                 if definition.hook.once:
-                    scope = environment if definition.hook.environments is not None else None
-                    identity = json.dumps([definition.hook.id, scope], separators=(",", ":"))
-                    completion_key = "godoo.hooks.once." + hashlib.sha256(identity.encode()).hexdigest()
+                    completion_key = _completion_key(definition.hook, environment)
                     parameters = context.env["ir.config_parameter"].sudo()
                     if parameters.get_param(completion_key):
                         cursor.rollback()

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/tests/runtime/test_checksums.py

@@ -119,6 +119,17 @@ def test_pending_states_are_not_hidden_by_matching_hashes(runtime: tuple[GodooCo
         checksums.plan_module_changes(config, [], [])
 
 
+def test_explicit_installs_are_verified_even_when_already_installed_at_planning(
+    runtime: tuple[GodooConfig, Database, Path],
+) -> None:
+    config, database, _addons = runtime
+    plan = checksums.plan_module_changes(config, [], ["custom"])
+    assert plan.installs == []
+    database.states["custom"] = ModuleState("uninstalled")
+    with pytest.raises(RuntimeError, match="Requested modules were not installed: custom"):
+        plan.finish(config)
+
+
 @pytest.mark.parametrize("cleanup_removes_missing", [False, True])
 def test_missing_sources_require_real_cleanup_and_strict_rescan(
     runtime: tuple[GodooConfig, Database, Path], cleanup_removes_missing: bool

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/tests/runtime/test_hooks.py

@@ -356,6 +356,48 @@ def test_once_failure_rolls_back_action_and_receipt(
     assert values == {}
 
 
-def test_once_prepare_is_rejected() -> None:
-    with pytest.raises(ValueError, match="Preparation hooks cannot declare once"):
-        hooks.Hook(id="prepare", phase="prepare", once=True)
+def test_once_prepare_uses_database_completion_and_environment_scope(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from contextlib import contextmanager
+
+    values: dict[str, str] = {}
+
+    class Database:
+        def with_db(self, *_args: Any, **_kwargs: Any) -> Self:
+            return self
+
+        @contextmanager
+        def connect(self):
+            yield self
+
+        def execute(self, query: str, args: list[Any]) -> None:
+            if query.startswith("SELECT"):
+                self.rows = [(key,) for key in args[0] if values.get(key)]
+            else:
+                values[args[0]] = args[1]
+
+        def fetchall(self):
+            return self.rows
+
+    monkeypatch.setattr(GodooConfig, "db_connection", property(lambda _self: Database()))
+    decisions: list[str] = []
+    definition = hooks.HookDefinition(
+        hook=hooks.Hook(id="install.feature", phase="prepare", once=True, environments=("development", "review")),
+        source=tmp_path / "hook.py",
+        run=lambda ctx: ctx.request_modules(install=["sale"]),
+        needs_run=lambda _ctx: decisions.append("checked") or True,
+    )
+    config = _config(tmp_path)
+    selected, keys = hooks.pending_prepare_hooks(config, [definition], "development")
+    assert selected == [definition]
+    assert hooks.run_prepare_hooks(selected, "development", once=True).install == ("sale",)
+    hooks.complete_prepare_hooks(config, keys)
+    assert hooks.pending_prepare_hooks(config, [definition], "development") == ([], [])
+    hooks.run_prepare_hooks(
+        hooks.pending_prepare_hooks(config, [definition], "development")[0], "development", once=True
+    )
+    assert decisions == ["checked"]
+    assert hooks.pending_prepare_hooks(config, [definition], "review")[0] == [definition]
+    assert hooks.pending_prepare_hooks(config, [definition], "production") == ([], [])
+    assert keys[0] == hooks._completion_key(definition.hook, "development")

{godoo_cli-1.0.5 → godoo_cli-1.0.6}/tests/runtime/test_init_hooks.py

@@ -162,6 +162,7 @@ def test_prepare_hooks_merge_cli_and_environment_requests_on_every_init(
         "reconcile_modules",
         lambda _config, update, install, **_kwargs: reconciled.append((update, install)) or 0,
     )
+    monkeypatch.setattr(runtime_init, "verify_installed_modules", lambda *_args: None)
 
     def deployment(current: GodooConfig, **kwargs: object) -> tuple[LifecycleOutcome, int]:
         kwargs["preflight"](current)  # type: ignore[operator]
@@ -271,3 +272,151 @@ def test_checksum_checkpoint_precedes_post_hooks_and_is_not_saved_on_native_fail
     result = runtime_init.initialize_odoo_runtime(lambda: config, runtime_init.InitOptions(update_changed=True))
     assert result == (native_status or 9)
     assert events == ([] if native_status else ["checkpoint", "failing-post-hook"])
+
+
+def test_native_install_success_is_verified_without_update_changed(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from godoo_cli.models import OdooVersion
+
+    config = _config(tmp_path)
+    monkeypatch.setattr(runtime_init, "resolve_command_config", lambda **_kwargs: config)
+    monkeypatch.setattr(runtime_init, "require_odoo_version", lambda *_args: OdooVersion("Odoo", 19, 0))
+    monkeypatch.setattr(runtime_init, "x_sendfile_enabled", lambda *_args: False)
+    monkeypatch.setattr(runtime_init, "module_states", lambda _config: {})
+    monkeypatch.setattr(runtime_init, "reconcile_modules", lambda *_args, **_kwargs: 0)
+    monkeypatch.setattr(runtime_init, "reconcile_runtime", lambda conf, *, reconciler, **_kwargs: reconciler(conf))
+    verifications: list[list[str]] = []
+
+    def verify(_config: GodooConfig, requested: list[str]) -> None:
+        verifications.append(requested)
+        message = "Requested modules were not installed: helpdesk"
+        raise RuntimeError(message)
+
+    monkeypatch.setattr(runtime_init, "verify_installed_modules", verify)
+
+    def deploy(conf: GodooConfig, **callbacks: Any) -> tuple[LifecycleOutcome, int]:
+        callbacks["reconcile_preflight"](conf)
+        return LifecycleOutcome.READY, callbacks["reconciler"](conf)
+
+    monkeypatch.setattr(runtime_init, "deployment_init", deploy)
+    result = runtime_init.initialize_odoo_runtime(
+        lambda: config,
+        runtime_init.InitOptions(install_modules=["helpdesk"]),
+    )
+    assert result == 1
+    assert verifications == [["helpdesk"]]
+
+
+def test_once_prepare_retries_then_remains_complete_after_uninstall(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from godoo_cli.runtime import checksums
+
+    config = _config(tmp_path)
+    hook_dir = tmp_path / "hooks"
+    hook_dir.mkdir()
+    (hook_dir / "install.py").write_text(
+        "from godoo_cli.runtime.hooks import Hook\n"
+        "HOOK = Hook(id='install.helpdesk', phase='prepare', once=True)\n"
+        "def run(ctx): ctx.request_modules(install=['helpdesk'])\n",
+        encoding="utf-8",
+    )
+    completed: list[str] = []
+    calls: list[list[str]] = []
+    installed = False
+    monkeypatch.setattr(runtime_init, "resolve_command_config", lambda **_kwargs: config)
+    monkeypatch.setattr(runtime_init, "require_odoo_version", lambda *_args: SimpleNamespace(major=19, raw="19.0"))
+    monkeypatch.setattr(runtime_init, "x_sendfile_enabled", lambda *_args: False)
+    monkeypatch.setattr(runtime_init, "preflight_reconcile_dependencies", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(
+        runtime_init,
+        "pending_prepare_hooks",
+        lambda _conf, definitions, _environment: ([], []) if completed else (definitions, ["receipt"]),
+    )
+    monkeypatch.setattr(runtime_init, "complete_prepare_hooks", lambda _conf, keys: completed.extend(keys))
+    monkeypatch.setattr(runtime_init, "module_states", lambda _conf: {})
+    monkeypatch.setattr(
+        checksums,
+        "module_states",
+        lambda _conf: {"helpdesk": checksums.ModuleState("installed")} if installed else {},
+    )
+
+    def native(_conf: GodooConfig, _updates: list[str], installs: list[str], **_kwargs: Any) -> int:
+        nonlocal installed
+        calls.append(installs)
+        if len(calls) == 1:
+            return 1
+        if len(calls) == 2:
+            return 0
+        installed = True
+        return 0
+
+    monkeypatch.setattr(runtime_init, "reconcile_modules", native)
+    monkeypatch.setattr(runtime_init, "reconcile_runtime", lambda conf, *, reconciler, **_kwargs: reconciler(conf))
+
+    fail_post_hook = True
+
+    def deploy(conf: GodooConfig, **callbacks: Any) -> tuple[LifecycleOutcome, int]:
+        nonlocal fail_post_hook
+        callbacks["reconcile_preflight"](conf)
+        result = callbacks["reconciler"](conf)
+        if result == 0 and fail_post_hook:
+            fail_post_hook = False
+            return LifecycleOutcome.READY, 9
+        return LifecycleOutcome.READY, result
+
+    monkeypatch.setattr(runtime_init, "deployment_init", deploy)
+    request = runtime_init.InitOptions(hooks_dir=[hook_dir])
+    assert runtime_init.initialize_odoo_runtime(lambda: config, request) == 1
+    assert completed == []
+    assert runtime_init.initialize_odoo_runtime(lambda: config, request) == 1
+    assert completed == []
+    assert runtime_init.initialize_odoo_runtime(lambda: config, request) == 9
+    assert completed == ["receipt"]
+    installed = False
+    assert runtime_init.initialize_odoo_runtime(lambda: config, request) == 0
+    assert calls == [["helpdesk"], ["helpdesk"], ["helpdesk"], []]
+
+
+def test_once_prepare_update_cannot_start_restore_hook_before_pre_upgrade(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    config = _config(tmp_path)
+    hook_dir = tmp_path / "hooks"
+    hook_dir.mkdir()
+    (hook_dir / "prepare.py").write_text(
+        "from godoo_cli.runtime.hooks import Hook\n"
+        "HOOK = Hook(id='update', phase='prepare', once=True)\n"
+        "def run(ctx): ctx.request_modules(update=['base'])\n",
+        encoding="utf-8",
+    )
+    (hook_dir / "restore.py").write_text(
+        "from godoo_cli.runtime.hooks import Hook\n"
+        "HOOK = Hook(id='restore', phase='after_restore', on=('restored',))\n"
+        "def run(ctx): pass\n",
+        encoding="utf-8",
+    )
+    script = tmp_path / "pre.py"
+    script.write_text("def migrate(cr, version): pass\n", encoding="utf-8")
+    write_runtime_lifecycle(
+        runtime_readiness_marker(config.data_dir, config.db_name), config.db_name, outcome="restored"
+    )
+    monkeypatch.setattr(runtime_init, "resolve_command_config", lambda **_kwargs: config)
+    monkeypatch.setattr(runtime_init, "require_odoo_version", lambda *_args: SimpleNamespace(major=19, raw="19.0"))
+    monkeypatch.setattr(runtime_init, "x_sendfile_enabled", lambda *_args: False)
+    monkeypatch.setattr(
+        runtime_init,
+        "pending_prepare_hooks",
+        lambda _conf, definitions, _environment: ([item for item in definitions if item.hook.once], ["receipt"]),
+    )
+
+    def deploy(conf: GodooConfig, **callbacks: Any) -> tuple[LifecycleOutcome, int]:
+        callbacks["reconcile_preflight"](conf)
+        pytest.fail("pre-upgrade conflict must fail before database hooks")
+
+    monkeypatch.setattr(runtime_init, "deployment_init", deploy)
+    with pytest.raises(typer.BadParameter, match="after_restore hook"):
+        runtime_init.initialize_odoo_runtime(
+            lambda: config, runtime_init.InitOptions(hooks_dir=[hook_dir], pre_upgrade_scripts=[script])
+        )