odoo-dev 0.3.0__tar.gz → 0.3.2__tar.gz

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "Bash(ls:*)",
       "Bash(xargs:*)",
       "Bash(git commit:*)",
-      "Bash(git push:*)"
+      "Bash(git push:*)",
+      "Bash(python -m pytest tests/test_drop_database.py -v -m slow)"
     ]
   }
 }

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odoo-dev
-Version: 0.3.0
+Version: 0.3.2
 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-0.3.0 → odoo_dev-0.3.2}/pyproject.toml

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

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/src/odoo_dev/__init__.py

@@ -1,3 +1,3 @@
 """Odoo Development Environment Helper."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/src/odoo_dev/commands/run.py

@@ -480,28 +480,35 @@ def _drop_database(cfg, db_name: str) -> None:
     venv_python = cfg.venv_path / "bin" / "python"
 
     # Try odoo-bin db drop first
-    result = subprocess.run(
-        [
-            str(venv_python),
-            str(cfg.odoo_bin),
-            "-c",
-            str(cfg.config_file),
-            "db",
-            "drop",
-            db_name,
-        ],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode == 0:
-        return
+    try:
+        result = subprocess.run(
+            [
+                str(venv_python),
+                str(cfg.odoo_bin),
+                "-c",
+                str(cfg.config_file),
+                "db",
+                "drop",
+                db_name,
+            ],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return
+    except OSError:
+        pass
 
     # Fallback to dropdb
-    warning(f"odoo-bin db drop failed, falling back to dropdb...")
+    warning("odoo-bin db drop failed, falling back to dropdb...")
     from odoo_dev.commands.db import _parse_db_config
 
     db_config = _parse_db_config(cfg.config_file)
     env = {**os.environ, "PGPASSWORD": db_config["password"]}
+
+    # Terminate active connections first — dropdb will fail if any remain
+    _terminate_connections(db_name, db_config)
+
     result = subprocess.run(
         [
             "dropdb",
@@ -521,6 +528,25 @@ def _drop_database(cfg, db_name: str) -> None:
             warning(result.stderr.strip())
 
 
+def _terminate_connections(db_name: str, db_config: dict[str, str]) -> None:
+    """Terminate all active connections to a database."""
+    env = {**os.environ, "PGPASSWORD": db_config["password"]}
+    subprocess.run(
+        [
+            "psql",
+            "-h", db_config["host"],
+            "-p", db_config["port"],
+            "-U", db_config["user"],
+            "-d", "postgres",
+            "-c",
+            f"SELECT pg_terminate_backend(pid) FROM pg_stat_activity "
+            f"WHERE datname = '{db_name}' AND pid <> pg_backend_pid()",
+        ],
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
 def _get_addons_path(config_file) -> str:
     """Extract addons_path from odoo.conf."""
     for line in config_file.read_text().splitlines():

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/src/odoo_dev/commands/setup.py

@@ -98,18 +98,6 @@ def setup(
         "--clean",
         help="Clean up before setup (remove existing venv, etc.)",
     ),
-    db_user: str = typer.Option(
-        "odoo",
-        "-u",
-        "--db-user",
-        help="Database user for odoo.conf",
-    ),
-    master_password: str = typer.Option(
-        "admin",
-        "-w",
-        "--master-password",
-        help="Master (admin) password for odoo.conf",
-    ),
 ) -> None:
     """Complete setup: clone Odoo repos, configure VSCode, build image."""
     # Prompt for versions if not configured
@@ -138,13 +126,13 @@ def setup(
     warning(
         f"This will install system dependencies and Python {cfg.python_version} if needed"
     )
-    setup_venv(db_user=db_user, master_password=master_password)
+    setup_venv()
 
     # Prompt for Docker setup
     warning("\nDo you want to set up the Docker environment?")
     if typer.confirm("Continue with Docker setup?", default=True):
         # Set up Docker files first
-        _setup_docker_files(cfg, community_only=community, db_user=db_user, master_password=master_password)
+        _setup_docker_files(cfg, community_only=community)
 
         success("\nBuilding Docker image...")
         from odoo_dev.commands.docker import build
@@ -159,25 +147,15 @@ def setup(
     success("  - Debug with VSCode: Use the configured launch profiles")
 
 
-def setup_venv(
-    db_user: str = typer.Option(
-        "odoo",
-        "-u",
-        "--db-user",
-        help="Database user for odoo.conf",
-    ),
-    master_password: str = typer.Option(
-        "admin",
-        "-w",
-        "--master-password",
-        help="Master (admin) password for odoo.conf",
-    ),
-) -> None:
+def setup_venv() -> None:
     """Set up local Python virtual environment for development."""
     cfg = load_config()
 
+    # Initialize submodules before anything else
+    _init_submodules(cfg)
+
     # Create config file first
-    _setup_odoo_config(cfg, db_user=db_user, master_password=master_password)
+    _setup_odoo_config(cfg)
 
     success(f"Setting up Python virtual environment for Odoo {cfg.odoo_version}...")
 
@@ -242,49 +220,6 @@ def setup_venv(
         [*venv_pip, "pytest", "pytest-odoo", "debugpy", "manifestoo", "coverage"]
     )
 
-    # Install Python external dependencies declared in addon manifests (runtime + test)
-    if cfg.addons_dir.is_dir():
-        success("Installing addon Python dependencies from manifests...")
-        venv_python = cfg.venv_path / "bin" / "python"
-        # Runtime deps via manifestoo
-        result = subprocess.run(
-            [
-                str(venv_python),
-                "-m",
-                "manifestoo",
-                "--select-addons-dir",
-                str(cfg.addons_dir),
-                "list-external-dependencies",
-                "python",
-            ],
-            capture_output=True,
-            text=True,
-            env={**os.environ, "ODOO_VERSION": "", "ODOO_SERIES": ""},
-        )
-        all_python_deps: set[str] = set(result.stdout.split())
-        # Test deps via direct manifest scan (manifestoo doesn't read test_external_dependencies)
-        import ast
-        for manifest_path in cfg.addons_dir.glob("*/__manifest__.py"):
-            try:
-                manifest = ast.literal_eval(manifest_path.read_text())
-                test_deps = manifest.get("test_external_dependencies", {}).get("python", [])
-                all_python_deps.update(test_deps)
-            except Exception:
-                pass
-        python_deps = " ".join(all_python_deps)
-        if python_deps:
-            subprocess.run(
-                [
-                    "uv",
-                    "pip",
-                    "install",
-                    "--python",
-                    str(venv_python),
-                    *python_deps.split(),
-                ],
-                check=False,
-            )
-
     success("\nVirtual environment setup complete!")
     success(f"To activate: source {cfg.venv_path}/bin/activate")
 
@@ -341,7 +276,7 @@ def _init_submodules(cfg) -> None:
         warning(f"Submodule initialization had issues: {result.stderr}")
 
 
-def _setup_odoo_config(cfg, community_only: bool = False, db_user: str = "odoo", master_password: str = "admin") -> None:
+def _setup_odoo_config(cfg, community_only: bool = False) -> None:
     """Create odoo.conf configuration file."""
     conf_dir = cfg.project_dir / "conf"
     conf_file = conf_dir / "odoo.conf"
@@ -376,8 +311,8 @@ def _setup_odoo_config(cfg, community_only: bool = False, db_user: str = "odoo",
 
     config_content = f"""[options]
 addons_path = {",".join(addons_paths)}
-admin_passwd = {master_password}
-db_user = {db_user}
+admin_passwd = admin
+db_user = odoo
 db_password = odoo
 """
 
@@ -386,7 +321,7 @@ db_password = odoo
     success(f"Config file created at {conf_file}")
 
 
-def _setup_docker_files(cfg, community_only: bool = False, db_user: str = "odoo", master_password: str = "admin") -> None:
+def _setup_docker_files(cfg, community_only: bool = False) -> None:
     """Copy Docker templates to .odoo-deploy directory."""
     success("Setting up Docker files...")
 
@@ -406,10 +341,10 @@ def _setup_docker_files(cfg, community_only: bool = False, db_user: str = "odoo"
         success(f"Copied {filename}")
 
     # Create Docker odoo.conf
-    _setup_docker_odoo_config(cfg, community_only=community_only, db_user=db_user, master_password=master_password)
+    _setup_docker_odoo_config(cfg, community_only=community_only)
 
 
-def _generate_docker_odoo_conf(community_only: bool = False, db_user: str = "odoo", master_password: str = "admin") -> str:
+def _generate_docker_odoo_conf(community_only: bool = False) -> str:
     """Generate Docker-specific odoo.conf content."""
     # Build addons path for Docker (using /opt/project paths)
     addons_paths = [
@@ -430,10 +365,10 @@ def _generate_docker_odoo_conf(community_only: bool = False, db_user: str = "odo
 
     return f"""[options]
 addons_path = {",".join(addons_paths)}
-admin_passwd = {master_password}
+admin_passwd = admin
 db_host = db
 db_port = 5432
-db_user = {db_user}
+db_user = odoo
 db_password = odoo
 http_port = 8069
 gevent_port = 8072
@@ -451,7 +386,7 @@ data_dir = /opt/odoo-filestore
 """
 
 
-def _setup_docker_odoo_config(cfg, community_only: bool = False, db_user: str = "odoo", master_password: str = "admin") -> None:
+def _setup_docker_odoo_config(cfg, community_only: bool = False) -> None:
     """Create Docker-specific odoo.conf configuration file."""
     conf_file = cfg.docker_config_file
 
@@ -460,7 +395,7 @@ def _setup_docker_odoo_config(cfg, community_only: bool = False, db_user: str =
         return
 
     success("Creating Docker Odoo configuration file...")
-    conf_file.write_text(_generate_docker_odoo_conf(community_only=community_only, db_user=db_user, master_password=master_password))
+    conf_file.write_text(_generate_docker_odoo_conf(community_only=community_only))
     conf_file.chmod(0o600)
     success(f"Docker config file created at {conf_file}")
 

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/tests/fixtures/odoo-empty/.gitignore

@@ -75,3 +75,4 @@ tsconfig.json
 
 # Ctags
 /tags
+.odoo-data/

odoo_dev-0.3.2/tests/test_drop_database.py

@@ -0,0 +1,165 @@
+"""Integration tests for _drop_database.
+
+These tests verify that test databases are actually dropped after a test run.
+Requires a local PostgreSQL instance accessible via peer authentication.
+"""
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+
+def _pg_run(cmd: list[str], **kwargs) -> subprocess.CompletedProcess:
+    """Run a PostgreSQL command using peer auth on the local socket."""
+    return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
+
+
+def _db_exists(db_name: str) -> bool:
+    result = _pg_run(["psql", "-d", "postgres", "-tAc",
+                       f"SELECT 1 FROM pg_database WHERE datname = '{db_name}'"])
+    return result.stdout.strip() == "1"
+
+
+def _create_db(db_name: str) -> None:
+    result = _pg_run(["createdb", db_name])
+    assert result.returncode == 0, f"createdb failed: {result.stderr}"
+
+
+def _drop_db_force(db_name: str) -> None:
+    """Forcefully drop a database (for test cleanup)."""
+    _pg_run(["psql", "-d", "postgres", "-c",
+             f"DROP DATABASE IF EXISTS \"{db_name}\" WITH (FORCE)"])
+
+
+@dataclass
+class FakeConfig:
+    """Minimal config to satisfy _drop_database's interface."""
+    project_dir: Path
+    venv_path: Path
+    odoo_bin: Path
+    config_file: Path
+
+
+def _make_config(tmp_path: Path) -> FakeConfig:
+    """Create a fake config with an odoo.conf using peer auth.
+
+    Sets up a real python symlink but a fake odoo-bin that always exits 1,
+    so the odoo-bin drop method fails cleanly (nonzero exit) and the
+    dropdb fallback path is exercised — matching real-world behavior where
+    'odoo-bin db drop' fails.
+    """
+    conf = tmp_path / "conf"
+    conf.mkdir()
+    config_file = conf / "odoo.conf"
+    # Use peer auth (no password, local socket) matching the test environment
+    config_file.write_text(
+        "[options]\n"
+        "db_host = /var/run/postgresql\n"
+        "db_port = 5432\n"
+        f"db_user = {subprocess.run(['whoami'], capture_output=True, text=True).stdout.strip()}\n"
+        "db_password =\n"
+    )
+    # Create a venv with a real python and a fake odoo-bin that always fails
+    venv_path = tmp_path / ".venv"
+    venv_path.mkdir()
+    bin_dir = venv_path / "bin"
+    bin_dir.mkdir()
+    import sys
+    (bin_dir / "python").symlink_to(sys.executable)
+
+    fake_odoo_bin = tmp_path / "odoo-bin"
+    fake_odoo_bin.write_text("#!/usr/bin/env python3\nimport sys; sys.exit(1)\n")
+    fake_odoo_bin.chmod(0o755)
+
+    return FakeConfig(
+        project_dir=tmp_path,
+        venv_path=venv_path,
+        odoo_bin=fake_odoo_bin,
+        config_file=config_file,
+    )
+
+
+@pytest.mark.slow
+class TestDropDatabase:
+    """Verify _drop_database actually removes the database."""
+
+    def _unique_db(self) -> str:
+        return f"test_odoodev_{int(time.time() * 1000)}"
+
+    def test_drop_removes_database(self, tmp_path: Path):
+        """Basic case: database with no active connections is dropped."""
+        from odoo_dev.commands.run import _drop_database
+
+        db_name = self._unique_db()
+        cfg = _make_config(tmp_path)
+
+        _create_db(db_name)
+        assert _db_exists(db_name), "Precondition: database should exist"
+
+        try:
+            _drop_database(cfg, db_name)
+            assert not _db_exists(db_name), (
+                f"Database {db_name} still exists after _drop_database!"
+            )
+        finally:
+            _drop_db_force(db_name)
+
+    def test_drop_works_when_venv_missing(self, tmp_path: Path):
+        """When venv python doesn't exist, should fall back to dropdb
+        instead of crashing with FileNotFoundError."""
+        from odoo_dev.commands.run import _drop_database
+
+        db_name = self._unique_db()
+        cfg = _make_config(tmp_path)
+        # Remove the python symlink to simulate missing venv
+        (cfg.venv_path / "bin" / "python").unlink()
+
+        _create_db(db_name)
+        assert _db_exists(db_name), "Precondition: database should exist"
+
+        try:
+            _drop_database(cfg, db_name)
+            assert not _db_exists(db_name), (
+                f"Database {db_name} still exists after _drop_database!"
+            )
+        finally:
+            _drop_db_force(db_name)
+
+    def test_drop_removes_database_with_active_connections(self, tmp_path: Path):
+        """Simulates a lingering Odoo worker holding a connection open.
+
+        This is the primary failure mode: dropdb refuses to drop a database
+        that has active connections, and _drop_database doesn't terminate
+        them first.
+        """
+        from odoo_dev.commands.run import _drop_database
+
+        db_name = self._unique_db()
+        cfg = _make_config(tmp_path)
+
+        _create_db(db_name)
+        assert _db_exists(db_name), "Precondition: database should exist"
+
+        # Hold an active connection (simulates a lingering Odoo worker)
+        blocker = subprocess.Popen(
+            ["psql", "-d", db_name, "-c", "SELECT pg_sleep(300)"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        try:
+            # Give the connection a moment to establish
+            time.sleep(0.5)
+
+            _drop_database(cfg, db_name)
+            assert not _db_exists(db_name), (
+                f"Database {db_name} still exists after _drop_database! "
+                "Active connections were not terminated before drop."
+            )
+        finally:
+            blocker.terminate()
+            blocker.wait(timeout=5)
+            _drop_db_force(db_name)

{odoo_dev-0.3.0 → odoo_dev-0.3.2}/tests/test_setup.py

@@ -158,6 +158,56 @@ class TestSetupDockerFiles:
         assert cfg.docker_config_file.read_text() == "existing config"
 
 
+class TestInitSubmodules:
+    """Test _init_submodules is called correctly from setup_venv."""
+
+    def test_setup_venv_calls_init_submodules(self, tmp_path: Path):
+        """setup_venv should initialize submodules before setting up the venv."""
+        from unittest.mock import call, patch
+
+        cfg = _make_cfg(tmp_path)
+        # Create .gitmodules to trigger the submodule check
+        (tmp_path / ".gitmodules").write_text("[submodule]\n")
+
+        with patch("odoo_dev.commands.setup.load_config", return_value=cfg), \
+             patch("odoo_dev.commands.setup._init_submodules") as mock_init, \
+             patch("odoo_dev.commands.setup._setup_odoo_config"), \
+             patch("odoo_dev.commands.setup._install_system_dependencies"), \
+             patch("odoo_dev.commands.setup._update_python_path"), \
+             patch("subprocess.run", return_value=type("R", (), {"returncode": 0})()):
+            from odoo_dev.commands.setup import setup_venv
+            setup_venv()
+
+        mock_init.assert_called_once_with(cfg)
+
+    def test_init_submodules_skips_if_no_gitmodules(self, tmp_path: Path):
+        """_init_submodules should do nothing if .gitmodules does not exist."""
+        from odoo_dev.commands.setup import _init_submodules
+
+        cfg = _make_cfg(tmp_path)
+        with patch("subprocess.run") as mock_run:
+            _init_submodules(cfg)
+        mock_run.assert_not_called()
+
+    def test_init_submodules_runs_git_command(self, tmp_path: Path):
+        """_init_submodules should run git submodule update when .gitmodules exists."""
+        from odoo_dev.commands.setup import _init_submodules
+
+        cfg = _make_cfg(tmp_path)
+        (tmp_path / ".gitmodules").write_text("[submodule]\n")
+
+        with patch("subprocess.run", return_value=type("R", (), {"returncode": 0, "stderr": ""})()) as mock_run:
+            _init_submodules(cfg)
+
+        mock_run.assert_called_once()
+        args = mock_run.call_args[0][0]
+        assert "git" in args
+        assert "submodule" in args
+        assert "update" in args
+        assert "--init" in args
+        assert "--recursive" in args
+
+
 class TestVscodeSetup:
     """Test vscode() copies templates correctly."""