odoo-dev 0.3.1__tar.gz → 0.3.3__tar.gz

{odoo_dev-0.3.1 → odoo_dev-0.3.3}/.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.3/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: odoo-dev
+Version: 0.3.3
+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
+Project-URL: Issues, https://git.bemade.org/bemade/odoo-dev/-/issues
+License-Expression: LGPL-3.0
+Requires-Python: >=3.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# odoo-dev
+
+A CLI tool for managing Odoo development environments. Handles local Python setup, Docker containers, database operations, and more.
+
+It is the successor to the older `odoo-deploy` shell scripts — if you have notes for `odoo-deploy`, the rough mapping is: `odoo-dev docker start/stop/build` replaces the old `odoo-dev.sh start/stop/build`, and `odoo-dev run`/`test`/`shell` give you a local (venv-based) workflow that `odoo-deploy` didn't.
+
+## Installation
+
+```bash
+# Install with uv (recommended) — installs the published package from PyPI
+uv tool install odoo-dev
+
+# Or with pip
+pip install odoo-dev
+```
+
+Then make sure the install location is on your `PATH` (uv prints the path; usually `~/.local/bin`):
+
+```bash
+uv tool update-shell   # or: export PATH="$HOME/.local/bin:$PATH"
+```
+
+## Quick Start
+
+```bash
+# In your Odoo project directory
+cd my-odoo-project
+
+# Full setup: clone Odoo repos, create venv, install deps, configure VSCode
+odoo-dev setup
+
+# Or for community edition only
+odoo-dev setup --community
+```
+
+`setup` reads `ODOO_VERSION` / `PYTHON_VERSION` from a `.env` in the project root (or
+prompts for them and offers to save). It then clones the Odoo repos, builds a `.venv`,
+installs system dependencies, and generates `conf/odoo.conf`. It will offer to set up
+Docker at the end — answer "no" if you only want the local venv workflow.
+
+## Database setup (read this before your first `run`/`test`)
+
+The generated `conf/odoo.conf` connects as PostgreSQL user **`odoo`** over the local
+socket. You need a running PostgreSQL server and a matching role. `setup` installs
+PostgreSQL but does **not** start it or create the role, so on a fresh machine do this
+once:
+
+**macOS (Homebrew):**
+
+```bash
+brew services start postgresql@18          # start the server (use your installed version)
+createuser -s odoo                         # create the role odoo.conf expects
+# Homebrew's versioned postgres is keg-only; add its bin to PATH if psql/createuser aren't found:
+#   export PATH="$(brew --prefix postgresql@18)/bin:$PATH"
+```
+
+**Debian/Ubuntu:**
+
+```bash
+sudo systemctl start postgresql
+sudo -u postgres createuser -s odoo
+```
+
+You can change the DB user/password in `conf/odoo.conf` if you prefer a different role.
+
+## Commands
+
+### Local Development (default)
+
+```bash
+odoo-dev run                          # Start Odoo locally (default port 8069)
+odoo-dev run -d mydb -p 8070          # Pick a database and HTTP port
+odoo-dev run -d mydb -i base          # Initialize module(s) on start
+odoo-dev run -d mydb --dev reload     # With hot reload
+odoo-dev run --debug                  # With debugpy (VSCode attach on 5678)
+odoo-dev shell mydb                   # Open an Odoo shell
+odoo-dev update base -d mydb          # Update modules
+odoo-dev test my_module               # Run a module's tests (coverage on by default)
+odoo-dev test my_module --test-tags my_module --no-coverage
+odoo-dev test                         # Auto-discover & test all addons in addons/
+odoo-dev scaffold my_module           # Create a new module
+```
+
+> Note: the HTTP port flag is `-p` / `--port` (not `--http-port`).
+
+### Database Operations
+
+```bash
+odoo-dev db list                      # List databases
+odoo-dev db restore backup.zip        # Restore from backup (neutralized by default)
+odoo-dev db restore backup.zip mydb --no-neutralize
+odoo-dev db drop mydb                  # Drop database
+odoo-dev db neutralize mydb            # Disable emails/crons
+```
+
+### Docker (optional)
+
+```bash
+odoo-dev docker start                 # Start containers
+odoo-dev docker stop                  # Stop containers
+odoo-dev docker restart               # Restart containers
+odoo-dev docker logs                  # View logs
+odoo-dev docker build                 # Rebuild image
+odoo-dev docker shell mydb            # Shell in container
+odoo-dev docker psql                  # PostgreSQL shell
+```
+
+### Setup Commands
+
+```bash
+odoo-dev setup                        # Full setup
+odoo-dev setup --community            # Community edition only
+odoo-dev setup-venv                   # Just create the venv (no repo clone)
+odoo-dev vscode                       # Configure VSCode debugging
+```
+
+## Project Structure
+
+odoo-dev expects this project structure:
+
+```
+my-odoo-project/
+├── .env                 # Optional: ODOO_VERSION, PYTHON_VERSION
+├── addons/              # Your custom addons
+├── requirements.txt     # Project-specific Python deps
+├── odoo/                # Cloned by setup
+├── enterprise/          # Cloned by setup (unless --community)
+├── design-themes/       # Cloned by setup
+├── .venv/               # Created by setup
+└── conf/
+    └── odoo.conf        # Created by setup
+```
+
+## Configuration
+
+Create a `.env` file in your project root:
+
+```bash
+ODOO_VERSION=19.0
+PYTHON_VERSION=3.12
+```
+
+## Requirements
+
+- Python 3.12+
+- uv (recommended) or pip
+- Git
+- PostgreSQL (for local development — server + an `odoo` role; see "Database setup")
+- Docker (optional, for containerized development)
+
+## Development
+
+```bash
+# Clone and install for development
+git clone git@github.com:bemade/odoo-dev.git
+cd odoo-dev
+uv sync
+
+# Run tests
+uv run pytest                 # All tests
+uv run pytest -m "not slow"   # Fast tests only
+
+# Build
+uv build
+```
+
+## License
+
+LGPL-3. For complete license terms, visit https://www.gnu.org/licenses/lgpl-3.0.en.html

odoo_dev-0.3.3/README.md

@@ -0,0 +1,169 @@
+# odoo-dev
+
+A CLI tool for managing Odoo development environments. Handles local Python setup, Docker containers, database operations, and more.
+
+It is the successor to the older `odoo-deploy` shell scripts — if you have notes for `odoo-deploy`, the rough mapping is: `odoo-dev docker start/stop/build` replaces the old `odoo-dev.sh start/stop/build`, and `odoo-dev run`/`test`/`shell` give you a local (venv-based) workflow that `odoo-deploy` didn't.
+
+## Installation
+
+```bash
+# Install with uv (recommended) — installs the published package from PyPI
+uv tool install odoo-dev
+
+# Or with pip
+pip install odoo-dev
+```
+
+Then make sure the install location is on your `PATH` (uv prints the path; usually `~/.local/bin`):
+
+```bash
+uv tool update-shell   # or: export PATH="$HOME/.local/bin:$PATH"
+```
+
+## Quick Start
+
+```bash
+# In your Odoo project directory
+cd my-odoo-project
+
+# Full setup: clone Odoo repos, create venv, install deps, configure VSCode
+odoo-dev setup
+
+# Or for community edition only
+odoo-dev setup --community
+```
+
+`setup` reads `ODOO_VERSION` / `PYTHON_VERSION` from a `.env` in the project root (or
+prompts for them and offers to save). It then clones the Odoo repos, builds a `.venv`,
+installs system dependencies, and generates `conf/odoo.conf`. It will offer to set up
+Docker at the end — answer "no" if you only want the local venv workflow.
+
+## Database setup (read this before your first `run`/`test`)
+
+The generated `conf/odoo.conf` connects as PostgreSQL user **`odoo`** over the local
+socket. You need a running PostgreSQL server and a matching role. `setup` installs
+PostgreSQL but does **not** start it or create the role, so on a fresh machine do this
+once:
+
+**macOS (Homebrew):**
+
+```bash
+brew services start postgresql@18          # start the server (use your installed version)
+createuser -s odoo                         # create the role odoo.conf expects
+# Homebrew's versioned postgres is keg-only; add its bin to PATH if psql/createuser aren't found:
+#   export PATH="$(brew --prefix postgresql@18)/bin:$PATH"
+```
+
+**Debian/Ubuntu:**
+
+```bash
+sudo systemctl start postgresql
+sudo -u postgres createuser -s odoo
+```
+
+You can change the DB user/password in `conf/odoo.conf` if you prefer a different role.
+
+## Commands
+
+### Local Development (default)
+
+```bash
+odoo-dev run                          # Start Odoo locally (default port 8069)
+odoo-dev run -d mydb -p 8070          # Pick a database and HTTP port
+odoo-dev run -d mydb -i base          # Initialize module(s) on start
+odoo-dev run -d mydb --dev reload     # With hot reload
+odoo-dev run --debug                  # With debugpy (VSCode attach on 5678)
+odoo-dev shell mydb                   # Open an Odoo shell
+odoo-dev update base -d mydb          # Update modules
+odoo-dev test my_module               # Run a module's tests (coverage on by default)
+odoo-dev test my_module --test-tags my_module --no-coverage
+odoo-dev test                         # Auto-discover & test all addons in addons/
+odoo-dev scaffold my_module           # Create a new module
+```
+
+> Note: the HTTP port flag is `-p` / `--port` (not `--http-port`).
+
+### Database Operations
+
+```bash
+odoo-dev db list                      # List databases
+odoo-dev db restore backup.zip        # Restore from backup (neutralized by default)
+odoo-dev db restore backup.zip mydb --no-neutralize
+odoo-dev db drop mydb                  # Drop database
+odoo-dev db neutralize mydb            # Disable emails/crons
+```
+
+### Docker (optional)
+
+```bash
+odoo-dev docker start                 # Start containers
+odoo-dev docker stop                  # Stop containers
+odoo-dev docker restart               # Restart containers
+odoo-dev docker logs                  # View logs
+odoo-dev docker build                 # Rebuild image
+odoo-dev docker shell mydb            # Shell in container
+odoo-dev docker psql                  # PostgreSQL shell
+```
+
+### Setup Commands
+
+```bash
+odoo-dev setup                        # Full setup
+odoo-dev setup --community            # Community edition only
+odoo-dev setup-venv                   # Just create the venv (no repo clone)
+odoo-dev vscode                       # Configure VSCode debugging
+```
+
+## Project Structure
+
+odoo-dev expects this project structure:
+
+```
+my-odoo-project/
+├── .env                 # Optional: ODOO_VERSION, PYTHON_VERSION
+├── addons/              # Your custom addons
+├── requirements.txt     # Project-specific Python deps
+├── odoo/                # Cloned by setup
+├── enterprise/          # Cloned by setup (unless --community)
+├── design-themes/       # Cloned by setup
+├── .venv/               # Created by setup
+└── conf/
+    └── odoo.conf        # Created by setup
+```
+
+## Configuration
+
+Create a `.env` file in your project root:
+
+```bash
+ODOO_VERSION=19.0
+PYTHON_VERSION=3.12
+```
+
+## Requirements
+
+- Python 3.12+
+- uv (recommended) or pip
+- Git
+- PostgreSQL (for local development — server + an `odoo` role; see "Database setup")
+- Docker (optional, for containerized development)
+
+## Development
+
+```bash
+# Clone and install for development
+git clone git@github.com:bemade/odoo-dev.git
+cd odoo-dev
+uv sync
+
+# Run tests
+uv run pytest                 # All tests
+uv run pytest -m "not slow"   # Fast tests only
+
+# Build
+uv build
+```
+
+## License
+
+LGPL-3. For complete license terms, visit https://www.gnu.org/licenses/lgpl-3.0.en.html

{odoo_dev-0.3.1 → odoo_dev-0.3.3}/pyproject.toml

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

{odoo_dev-0.3.1 → odoo_dev-0.3.3}/src/odoo_dev/__init__.py

@@ -1,3 +1,3 @@
 """Odoo Development Environment Helper."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"

{odoo_dev-0.3.1 → odoo_dev-0.3.3}/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.1 → odoo_dev-0.3.3}/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.1 → odoo_dev-0.3.3}/tests/fixtures/odoo-empty/.gitignore

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

odoo_dev-0.3.3/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.1 → odoo_dev-0.3.3}/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."""
 

odoo_dev-0.3.1/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: odoo-dev
-Version: 0.3.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
-Project-URL: Issues, https://git.bemade.org/bemade/odoo-dev/-/issues
-License-Expression: LGPL-3.0
-Requires-Python: >=3.12
-Requires-Dist: pyyaml>=6.0
-Requires-Dist: rich>=13.0.0
-Requires-Dist: typer>=0.9.0
-Description-Content-Type: text/markdown
-
-# odoo-dev
-
-> **This repository has moved to GitHub: https://github.com/bemade/odoo-dev**
->
-> This GitLab repository is archived and no longer maintained.

odoo_dev-0.3.1/README.md

@@ -1,5 +0,0 @@
-# odoo-dev
-
-> **This repository has moved to GitHub: https://github.com/bemade/odoo-dev**
->
-> This GitLab repository is archived and no longer maintained.

odoo_dev-0.3.1/tests/fixtures/odoo-empty/.git

@@ -1 +0,0 @@
-gitdir: ../../../.git/modules/tests/fixtures/odoo-empty