odoo-dev 1.2.0__tar.gz → 1.2.1__tar.gz

odoo_dev-1.2.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.2.1"
+}

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [1.2.1](https://github.com/bemade/odoo-dev/compare/v1.2.0...v1.2.1) (2026-07-14)
+
+
+### Bug Fixes
+
+* **test:** make full-suite runs work under a dev odoo.conf ([2a1b752](https://github.com/bemade/odoo-dev/commit/2a1b7527d29b3bf8bb776e41ce739b4864543b73))
+* **vendor:** bump clears stale version when pinning to a commit ([19544ba](https://github.com/bemade/odoo-dev/commit/19544bac55a3dded4b912cc9f2ac7226f5d72d61))
+* **vendor:** constrain `vendor update` to the pin's own major series ([5b58e26](https://github.com/bemade/odoo-dev/commit/5b58e2676de6c1b63a678d1dd365efca9e4c8b99))
+* **vendor:** migrate sets version only when the tag resolves to the pin ([ea59b1d](https://github.com/bemade/odoo-dev/commit/ea59b1d62c9844fb831925d9973b4ec179b803e6))
+
 ## [1.2.0](https://github.com/bemade/odoo-dev/compare/v1.1.0...v1.2.0) (2026-07-07)
 
 

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odoo-dev
-Version: 1.2.0
+Version: 1.2.1
 Summary: Odoo Development Environment Helper
 Project-URL: Homepage, https://git.bemade.org/bemade/odoo-dev
 Project-URL: Repository, https://git.bemade.org/bemade/odoo-dev

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "odoo-dev"
-version = "1.2.0"
+version = "1.2.1"
 description = "Odoo Development Environment Helper"
 readme = "README.md"
 requires-python = ">=3.12"

odoo_dev-1.2.1/src/odoo_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Odoo Development Environment Helper."""
+
+__version__ = "1.2.1"  # x-release-please-version

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/commands/run.py

@@ -235,17 +235,18 @@ def test(
             break
 
     # Auto-load exclusions from repo_deps.yaml when not explicitly provided
-    if exclude is None and repo_deps_file is not None:
+    no_ci_modules: list[str] = []
+    if repo_deps_file is not None:
         try:
             import yaml
 
             data = yaml.safe_load(repo_deps_file.read_text()) or {}
-            no_ci = data.get("no_ci", [])
-            if no_ci:
-                exclude = ",".join(no_ci)
-                info(f"Excluding (from {repo_deps_file} no_ci): {exclude}")
+            no_ci_modules = list(data.get("no_ci", []) or [])
         except Exception:
-            pass
+            no_ci_modules = []
+    if exclude is None and no_ci_modules:
+        exclude = ",".join(no_ci_modules)
+        info(f"Excluding (from {repo_deps_file} no_ci): {exclude}")
 
     # Verify setup
     if not cfg.venv_path.exists():
@@ -376,6 +377,9 @@ def test(
             "--stop-after-init",
             "--http-port",
             str(http_port),
+            # No need to fork prefork workers for a stop-after-init install.
+            "--workers",
+            "0",
         ],
     )
 
@@ -422,11 +426,36 @@ def test(
                 "--stop-after-init",
                 "--http-port",
                 str(http_port),
+                # HttpCase needs the threaded server (ThreadedServer.httpd);
+                # a prefork/multi-worker conf raises
+                # "'PreforkServer' object has no attribute 'httpd'" in
+                # setUpClass. Force single-process regardless of odoo.conf.
+                "--workers",
+                "0",
+                # A restrictive dbfilter in odoo.conf (e.g. `dbfilter = ^rwi$`)
+                # never matches the ephemeral test DB, so HttpCase requests get
+                # "dbfilter rejects it; logging session out" -> auth='user'
+                # routes 404 and JSON endpoints return non-JSON. Scope the
+                # filter to this run's test DB so the test server serves it.
+                f"--db-filter=^{db_name}$",
             ]
         )
 
-        if test_tags:
-            test_cmd.extend(["--test-tags", test_tags])
+        # Excluding no_ci modules from the tested-module *list* is not enough:
+        # they still install as transitive deps, and Odoo's button_upgrade
+        # cascades 'to upgrade' to downstream dependents of any upgraded target
+        # module (`-u modules`). A no_ci module that depends on a tested module
+        # thus gets re-upgraded and its post_install tests run. Exclude their
+        # tests explicitly via Odoo test-tags. The TagsSelector auto-adds
+        # '+standard' when only '-' filters are present, so this keeps running
+        # every standard test except those belonging to a no_ci module.
+        effective_test_tags = test_tags
+        if effective_test_tags is None and no_ci_modules:
+            effective_test_tags = ",".join(f"-/{m}" for m in no_ci_modules)
+            info(f"Excluding no_ci module tests via --test-tags: {effective_test_tags}")
+
+        if effective_test_tags:
+            test_cmd.extend(["--test-tags", effective_test_tags])
 
         result = subprocess.run(test_cmd)
         test_exit_code = result.returncode

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/commands/vendor.py

@@ -18,6 +18,7 @@ from odoo_dev.utils.console import error, info, success
 from odoo_dev.vendor.develop import (
     DevelopError,
     develop_state,
+    ensure_addons_path,
     start_develop,
     stop_develop,
 )
@@ -159,6 +160,14 @@ def migrate_cmd(
 
     lock, unused = migrate_repo(cfg.project_dir, addons=addon or None, deinit=deinit)
     success(f"Migrated {len(lock.entries)} addon(s) to vendored/ (see addons.lock).")
+
+    # Wire vendored/ into the local conf's addons_path. A fresh `setup` adds it,
+    # but `setup` won't overwrite an existing conf, so a repo vendored for the
+    # first time would otherwise leave Odoo unable to find the new addons
+    # ("invalid module names, ignored"). Local conf only — never Docker/CI.
+    if cfg.config_file.exists() and cfg.vendored_dir.is_dir():
+        if ensure_addons_path(cfg.config_file, str(cfg.vendored_dir)):
+            info(f"Added {cfg.vendored_dir} to {cfg.config_file} addons_path.")
     if unused:
         info("")
         if deinit:

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/vendor/develop.py

@@ -167,6 +167,21 @@ def remove_addons_path(conf_file: Path, path: str) -> None:
     _write_addons_path(conf_file, [p for p in read_addons_path(conf_file) if p != path])
 
 
+def ensure_addons_path(conf_file: Path, path: str) -> bool:
+    """Append ``path`` to the conf's addons_path if it isn't already listed.
+
+    Idempotent; returns True only when it actually added the entry. Used by
+    ``vendor migrate`` to wire ``vendored/`` into a conf that predates vendoring
+    (``setup`` adds it for fresh confs but never overwrites an existing one).
+    """
+    paths = read_addons_path(conf_file)
+    if path in paths:
+        return False
+    paths.append(path)
+    _write_addons_path(conf_file, paths)
+    return True
+
+
 # --- overlay / gitignore / state ------------------------------------------------
 
 

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/vendor/edit.py

@@ -76,8 +76,15 @@ def bump_addon(
     entry = lock.entries[name]
     sha = _resolve_pin(name, entry.source, version, commit, entry.branch, cache_dir)
     entry.commit = sha
-    if version is not None:
-        entry.version = version
+    # ``version`` is the tag-intent metadata, and ``vendor check``'s moved-tag
+    # tripwire (verify.py) requires ``<name>/<version>`` to still resolve to
+    # ``commit``. A ``--commit`` / branch-HEAD bump moves the pin off the tagged
+    # commit, so the old ``version`` is now stale and would (correctly) fail the
+    # tripwire. Set it to whatever the bump was keyed on: the new tag for a
+    # ``--version`` bump, or ``None`` for a raw ``--commit`` / branch bump — a
+    # commit pin carries no version metadata (matching how ``migrate`` renders
+    # untagged pins).
+    entry.version = version
     lock.entries[name] = entry
     lock.dump(project_dir / "addons.lock")
     sync_addons(project_dir, lock, cache_dir=cache_dir, names=[name])

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/vendor/migrate.py

@@ -2,7 +2,9 @@
 
 Reads the ``addons/<addon>`` symlinks that point into ``.repos/*`` submodules,
 derives a per-addon pin (submodule remote URL = source, submodule HEAD = commit,
-manifest version -> version when a matching ``<addon>/<version>`` tag exists),
+manifest version -> version ONLY when the ``<addon>/<version>`` tag resolves to
+the pinned commit; a commit that isn't the tagged release (a pin behind or ahead
+of the tag, or any intermediate commit) is left commit-only, no version),
 writes ``addons.lock``, materializes ``vendored/<addon>/`` from the submodule,
 and removes the now-redundant symlink. Client-private real dirs under ``addons/``
 are left untouched; only symlinks into submodules are migrated. Submodule removal
@@ -19,6 +21,7 @@ from typing import Iterable, Optional
 
 from odoo_dev.utils.manifest import manifest_path, read_version
 from odoo_dev.vendor.lock import LockEntry, Lockfile
+from odoo_dev.vendor.sources import tag_resolves_to
 from odoo_dev.vendor.sync import sync_addons
 
 
@@ -63,16 +66,6 @@ def _submodule_head(project_dir: Path, sub_path: str) -> str:
     ).stdout.strip()
 
 
-def _tag_exists(repo: Path, tag: str) -> bool:
-    return (
-        subprocess.run(
-            ["git", "-C", str(repo), "rev-parse", f"refs/tags/{tag}"],
-            capture_output=True,
-        ).returncode
-        == 0
-    )
-
-
 def plan_migration(project_dir: Path, addons: Optional[Iterable[str]] = None) -> list:
     """Return a list of planned pins without changing anything.
 
@@ -118,7 +111,13 @@ def plan_migration(project_dir: Path, addons: Optional[Iterable[str]] = None) ->
         mf = manifest_path(real)
         if mf is not None:
             v = read_version(mf.read_text())
-            if v is not None and _tag_exists(sub_root, f"{name}/{v}"):
+            # Only claim a ``version`` when the tag actually points at the pinned
+            # commit. Checking mere tag EXISTENCE was wrong: the same manifest
+            # version can live at several commits (the tag is cut at one of
+            # them), so a pin at any other commit with that version would carry a
+            # ``version`` whose tag resolves elsewhere — tripping ``vendor
+            # check``'s moved-tag guard. A non-release pin is commit-only.
+            if v is not None and tag_resolves_to(sub_root, f"{name}/{v}", commit):
                 version = v
         plans.append(
             dict(

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/src/odoo_dev/vendor/update.py

@@ -24,27 +24,46 @@ def _version_key(v: str) -> tuple:
     return tuple(int(p) if p.isdigit() else 0 for p in v.replace("-", ".").split("."))
 
 
+def _series(v: str) -> str:
+    """The major-series segment of a version — the cross-series guard.
+
+    An Odoo addon carries both ``18.0.*`` and ``19.0.*`` version tags in its source;
+    version-tracking must stay within the pin's own series (``18`` vs ``19``), since
+    moving across Odoo series is a deliberate migration, never an auto-update.
+    """
+    return v.split(".", 1)[0]
+
+
 def list_addon_versions(
-    source: str, addon: str, cache_dir: Optional[Path] = None
+    source: str,
+    addon: str,
+    cache_dir: Optional[Path] = None,
+    series: Optional[str] = None,
 ) -> list[str]:
-    """All ``<addon>/<version>`` tag versions present in ``source``."""
+    """``<addon>/<version>`` tag versions in ``source``, optionally same-series only."""
     repo = _ensure_clone(source, cache_dir)
     r = subprocess.run(
         ["git", "-C", str(repo), "tag", "-l", f"{addon}/*"],
         capture_output=True,
         text=True,
     )
-    return [
+    versions = [
         t.split("/", 1)[1]
         for t in r.stdout.split()
         if t.startswith(f"{addon}/") and "/" in t
     ]
+    if series is not None:
+        versions = [v for v in versions if _series(v) == series]
+    return versions
 
 
 def latest_version(
-    source: str, addon: str, cache_dir: Optional[Path] = None
+    source: str,
+    addon: str,
+    cache_dir: Optional[Path] = None,
+    series: Optional[str] = None,
 ) -> Optional[str]:
-    versions = list_addon_versions(source, addon, cache_dir)
+    versions = list_addon_versions(source, addon, cache_dir, series)
     return max(versions, key=_version_key) if versions else None
 
 
@@ -65,8 +84,8 @@ def find_updates(
     for name, e in lock.entries.items():
         if only is not None and name not in only:
             continue
-        if e.version:  # version-tracked
-            latest = latest_version(e.source, name, cache_dir)
+        if e.version:  # version-tracked (within the pin's own major series)
+            latest = latest_version(e.source, name, cache_dir, series=_series(e.version))
             if latest and _version_key(latest) > _version_key(e.version):
                 updates.append(
                     {

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/tests/test_vendor_develop.py

@@ -14,6 +14,7 @@ import pytest
 from odoo_dev.vendor.develop import (
     DevelopError,
     develop_state,
+    ensure_addons_path,
     read_addons_path,
     start_develop,
     stop_develop,
@@ -187,3 +188,39 @@ def test_two_addons_share_overlay(tmp_path):
     stop_develop(proj, "shared_addon", conf_file=conf)
     assert str(dev / "overlay") in read_addons_path(conf)
     assert [p.name for p in (dev / "overlay").iterdir()] == ["other_addon"]
+
+
+# --- ensure_addons_path: wiring vendored/ into a pre-existing conf --------------
+
+
+def test_ensure_addons_path_appends_when_missing(tmp_path: Path):
+    """A conf that predates vendoring gets vendored/ appended (returns True)."""
+    conf = tmp_path / "odoo.conf"
+    conf.write_text("[options]\naddons_path = /p/odoo/addons,/p/addons\n")
+    vendored = str(tmp_path / "vendored")
+
+    assert ensure_addons_path(conf, vendored) is True
+    paths = read_addons_path(conf)
+    assert paths[-1] == vendored
+    assert paths[:2] == ["/p/odoo/addons", "/p/addons"]
+
+
+def test_ensure_addons_path_is_idempotent(tmp_path: Path):
+    """A second call is a no-op (returns False, no duplicate entry)."""
+    conf = tmp_path / "odoo.conf"
+    conf.write_text("[options]\naddons_path = /p/addons\n")
+    vendored = str(tmp_path / "vendored")
+
+    assert ensure_addons_path(conf, vendored) is True
+    assert ensure_addons_path(conf, vendored) is False
+    assert read_addons_path(conf).count(vendored) == 1
+
+
+def test_ensure_addons_path_inserts_line_when_absent(tmp_path: Path):
+    """A conf with no addons_path line gets one created under [options]."""
+    conf = tmp_path / "odoo.conf"
+    conf.write_text("[options]\nadmin_passwd = x\n")
+    vendored = str(tmp_path / "vendored")
+
+    assert ensure_addons_path(conf, vendored) is True
+    assert read_addons_path(conf) == [vendored]

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/tests/test_vendor_edit.py

@@ -99,6 +99,39 @@ def test_bump_moves_pin_and_rematerializes(tmp_path):
     assert verify(proj, lock, cache_dir=tmp_path / "c") == []
 
 
+def _untagged_commit(repo: Path) -> str:
+    """A commit that is NOT a version tag (a between-releases pin target)."""
+    (repo / "shared_addon" / "m.py").write_text("v = 3\n")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", "v3-untagged")
+    return _git(repo, "rev-parse", "HEAD")
+
+
+def test_bump_by_commit_clears_stale_version(tmp_path):
+    """A ``--commit`` bump moves the pin off the tagged commit, so it must clear
+    the now-stale ``version`` — otherwise ``vendor check``'s moved-tag tripwire
+    (correctly) fails because ``<name>/<old-version>`` no longer resolves to the
+    new pin. Regression for the bug where ``bump`` left ``version`` untouched.
+    """
+    repo = _source_repo(tmp_path)
+    proj = tmp_path / "client"
+    proj.mkdir()
+    add_addon(
+        proj, "shared_addon", str(repo), version="18.0.1.0.0", cache_dir=tmp_path / "c"
+    )
+    sha = _untagged_commit(repo)
+
+    entry = bump_addon(proj, "shared_addon", commit=sha, cache_dir=tmp_path / "c")
+
+    assert entry.commit == sha
+    assert entry.version is None, "commit bump must clear the stale version tag"
+    assert (proj / "vendored" / "shared_addon" / "m.py").read_text() == "v = 3\n"
+    lock = Lockfile.load(proj / "addons.lock")
+    assert "version" not in (lock.entries["shared_addon"].to_dict())
+    # The moved-tag tripwire must NOT fire (it would if version stayed stale).
+    assert verify(proj, lock, cache_dir=tmp_path / "c") == []
+
+
 def test_bump_unknown_addon_raises(tmp_path):
     proj = tmp_path / "client"
     proj.mkdir()

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/tests/test_vendor_migrate.py

@@ -92,6 +92,51 @@ def test_plan_leaves_version_none_when_no_tag(tmp_path):
     assert plans[0]["version"] is None
 
 
+def _source_repo_tag_behind_head(tmp_path: Path) -> Path:
+    """Source where the ``<addon>/<version>`` tag sits at an OLDER commit than
+    HEAD, and HEAD's manifest still carries that same version (no bump between).
+    Mirrors the real case: a pin at an intermediate commit that no release tag
+    points at, even though the manifest version string matches a tag.
+    """
+    repo = tmp_path / "sale-workflow"
+    (repo / "shared_addon" / "models").mkdir(parents=True)
+    (repo / "shared_addon" / "__manifest__.py").write_text(
+        "{'name': 'shared', 'version': '18.0.2.0.0'}\n"
+    )
+    (repo / "shared_addon" / "models" / "m.py").write_text("z = 3\n")
+    _git(repo, "init", "-q")
+    _git(repo, "config", "user.email", "t@t")
+    _git(repo, "config", "user.name", "t")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", "init")
+    c1 = _git(repo, "rev-parse", "HEAD")
+    _git(repo, "tag", "shared_addon/18.0.2.0.0", c1)  # tag at the OLDER commit
+    # A later commit with the SAME manifest version — the pin target.
+    (repo / "shared_addon" / "models" / "m.py").write_text("z = 4\n")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", "later, same version")
+    return repo
+
+
+def test_plan_omits_version_when_tag_points_elsewhere(tmp_path):
+    """Regression: a pin that is NOT the tagged commit (same manifest version at
+    several commits) must be commit-only. Checking mere tag EXISTENCE wrote a
+    ``version`` whose tag resolved to a different commit, tripping ``vendor
+    check``'s moved-tag guard. The full migrate+verify must be clean.
+    """
+    source = _source_repo_tag_behind_head(tmp_path)
+    head = _git(source, "rev-parse", "HEAD")
+    client = _client_repo(tmp_path, source)  # submodule pins source HEAD
+    plans = plan_migration(client)
+    assert plans[0]["commit"] == head
+    assert plans[0]["version"] is None  # tag resolves to the older commit, not HEAD
+
+    migrate_repo(client, deinit=False)
+    lock = Lockfile.load(client / "addons.lock")
+    assert lock.entries["shared_addon"].version is None
+    assert verify(client, lock) == []  # no moved-tag failure
+
+
 def test_migrate_materializes_removes_symlink_and_verifies(tmp_path):
     source, sha = _source_repo(tmp_path, tag="shared_addon/18.0.2.0.0")
     client = _client_repo(tmp_path, source)

{odoo_dev-1.2.0 → odoo_dev-1.2.1}/tests/test_vendor_update.py

@@ -121,3 +121,28 @@ def test_find_updates_skips_bare_commit_pin(tmp_path):
     _cut_version(repo, "18.0.1.1.0", 2)
     # A bare-commit pin (no version, no branch) is deliberately fixed.
     assert find_updates(proj, Lockfile.load(proj / "addons.lock"), cache_dir=tmp_path / "c2") == []
+
+
+def test_find_updates_stays_in_series(tmp_path):
+    repo = _source(tmp_path)
+    proj = tmp_path / "client"
+    proj.mkdir()
+    add_addon(proj, "shared", str(repo), version="18.0.1.0.0", cache_dir=tmp_path / "c")
+    # A newer 18.0 release AND a cross-series 19.0 tag both exist upstream
+    # (as after baselining both branches). Must NOT jump 18.0 -> 19.0.
+    _cut_version(repo, "18.0.1.1.0", 2)
+    _git(repo, "tag", "shared/19.0.0.1.0")
+    updates = find_updates(
+        proj, Lockfile.load(proj / "addons.lock"), cache_dir=tmp_path / "c2"
+    )
+    assert updates == [
+        {"name": "shared", "kind": "version", "current": "18.0.1.0.0", "latest": "18.0.1.1.0"}
+    ]
+
+
+def test_latest_version_series_filter(tmp_path):
+    repo = _source(tmp_path)
+    _cut_version(repo, "18.0.1.1.0", 2)
+    _git(repo, "tag", "shared/19.0.5.0.0")
+    assert latest_version(str(repo), "shared", tmp_path / "c", series="18") == "18.0.1.1.0"
+    assert latest_version(str(repo), "shared", tmp_path / "c", series="19") == "19.0.5.0.0"

odoo_dev-1.2.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.2.0"
-}

odoo_dev-1.2.0/src/odoo_dev/__init__.py

@@ -1,3 +0,0 @@
-"""Odoo Development Environment Helper."""
-
-__version__ = "1.2.0"  # x-release-please-version