pytest-neon 2.1.2__tar.gz → 2.1.4__tar.gz

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/CLAUDE.md

@@ -81,15 +81,9 @@ Tests in `tests/` use `pytester` for testing pytest plugins. The plugin itself c
 
 ## Publishing
 
-Use the GitHub Actions release workflow:
+**Always use the GitHub Actions release workflow** - do not manually bump versions:
 1. Go to Actions → Release → Run workflow
 2. Choose patch/minor/major
 3. Workflow bumps version, commits, tags, and publishes to PyPI
 
-Or manually:
-```bash
-uv build
-uv publish --token $PYPI_TOKEN
-```
-
 Package name on PyPI: `pytest-neon`

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-neon
-Version: 2.1.2
+Version: 2.1.4
 Summary: Pytest plugin for Neon database branch isolation in tests
 Project-URL: Homepage, https://github.com/ZainRizvi/pytest-neon
 Project-URL: Repository, https://github.com/ZainRizvi/pytest-neon

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-neon"
-version = "2.1.2"
+version = "2.1.4"
 description = "Pytest plugin for Neon database branch isolation in tests"
 readme = "README.md"
 license = "MIT"

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/src/pytest_neon/__init__.py

@@ -9,7 +9,7 @@ from pytest_neon.plugin import (
     neon_engine,
 )
 
-__version__ = "2.1.2"
+__version__ = "2.1.4"
 __all__ = [
     "NeonBranch",
     "neon_branch",

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/src/pytest_neon/plugin.py

@@ -67,6 +67,50 @@ def _get_xdist_worker_id() -> str:
     return os.environ.get("PYTEST_XDIST_WORKER", "main")
 
 
+def _sanitize_branch_name(name: str) -> str:
+    """
+    Sanitize a string for use in Neon branch names.
+
+    Only allows alphanumeric characters, hyphens, and underscores.
+    All other characters (including non-ASCII) are replaced with hyphens.
+    """
+    import re
+
+    # Replace anything that's not alphanumeric, hyphen, or underscore with hyphen
+    sanitized = re.sub(r"[^a-zA-Z0-9_-]", "-", name)
+    # Collapse multiple hyphens into one
+    sanitized = re.sub(r"-+", "-", sanitized)
+    # Remove leading/trailing hyphens
+    sanitized = sanitized.strip("-")
+    return sanitized
+
+
+def _get_git_branch_name() -> str | None:
+    """
+    Get the current git branch name (sanitized), or None if not in a git repo.
+
+    Used to include the git branch in Neon branch names, making it easier
+    to identify which git branch/PR created orphaned test branches.
+
+    The branch name is sanitized to replace special characters with hyphens.
+    """
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            branch = result.stdout.strip()
+            return _sanitize_branch_name(branch) if branch else None
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
 def _get_schema_fingerprint(connection_string: str) -> tuple[tuple[Any, ...], ...]:
     """
     Get a fingerprint of the database schema for change detection.
@@ -110,6 +154,30 @@ class NeonBranch:
     parent_id: str | None = None
 
 
+def _get_default_branch_id(neon: NeonAPI, project_id: str) -> str | None:
+    """
+    Get the default/primary branch ID for a project.
+
+    This is used as a safety check to ensure we never accidentally
+    perform destructive operations (like password reset) on the
+    production branch.
+
+    Returns:
+        The branch ID of the default branch, or None if not found.
+    """
+    try:
+        response = neon.branches(project_id=project_id)
+        for branch in response.branches:
+            # Check both 'default' and 'primary' flags for compatibility
+            if getattr(branch, "default", False) or getattr(branch, "primary", False):
+                return branch.id
+    except Exception:
+        # If we can't fetch branches, don't block - the safety check
+        # will be skipped but tests can still run
+        pass
+    return None
+
+
 def pytest_addoption(parser: pytest.Parser) -> None:
     """Add Neon-specific command line options and ini settings."""
     group = parser.getgroup("neon", "Neon database branching")
@@ -279,8 +347,21 @@ def _create_neon_branch(
 
     neon = NeonAPI(api_key=api_key)
 
+    # Cache the default branch ID for safety checks (only fetch once per session)
+    if not hasattr(config, "_neon_default_branch_id"):
+        config._neon_default_branch_id = _get_default_branch_id(neon, project_id)  # type: ignore[attr-defined]
+
     # Generate unique branch name
-    branch_name = f"pytest-{os.urandom(4).hex()}{branch_name_suffix}"
+    # Format: pytest-[git branch (first 15 chars)]-[random]-[suffix]
+    # This helps identify orphaned branches by showing which git branch created them
+    random_suffix = os.urandom(2).hex()  # 2 bytes = 4 hex chars
+    git_branch = _get_git_branch_name()
+    if git_branch:
+        # Truncate git branch to 15 chars to keep branch names reasonable
+        git_prefix = git_branch[:15]
+        branch_name = f"pytest-{git_prefix}-{random_suffix}{branch_name_suffix}"
+    else:
+        branch_name = f"pytest-{random_suffix}{branch_name_suffix}"
 
     # Build branch creation payload
     branch_config: dict[str, Any] = {"name": branch_name}
@@ -341,6 +422,18 @@ def _create_neon_branch(
 
     host = endpoint.host
 
+    # SAFETY CHECK: Ensure we never reset password on the default/production branch
+    # This should be impossible since we just created this branch, but we check
+    # defensively to prevent catastrophic mistakes if there's ever a bug
+    default_branch_id = getattr(config, "_neon_default_branch_id", None)
+    if default_branch_id and branch.id == default_branch_id:
+        raise RuntimeError(
+            f"SAFETY CHECK FAILED: Attempted to reset password on default branch "
+            f"{branch.id}. This should never happen - the plugin creates new "
+            f"branches and should never operate on the default branch. "
+            f"Please report this bug at https://github.com/ZainRizvi/pytest-neon/issues"
+        )
+
     # Reset password to get the password value
     # (newly created branches don't expose password)
     password_response = neon.role_password_reset(
@@ -502,10 +595,10 @@ def _wait_for_operations(
                 op_data = response.json().get("operation", {})
                 status = op_data.get("status")
 
-                if status == "error":
+                if status == "failed":
                     err = op_data.get("error", "unknown error")
                     raise RuntimeError(f"Operation {op_id} failed: {err}")
-                if status not in ("finished", "skipped"):
+                if status not in ("finished", "skipped", "cancelled"):
                     still_pending.append(op_id)
             except requests.RequestException:
                 # On network error, assume still pending and retry

pytest_neon-2.1.4/tests/test_branch_name_prefix.py

@@ -0,0 +1,328 @@
+"""Tests for git branch name in Neon branch names."""
+
+import contextlib
+from unittest.mock import MagicMock, patch
+
+from neon_api.schema import EndpointState
+
+
+class TestSanitizeBranchName:
+    """Tests for _sanitize_branch_name helper."""
+
+    def test_replaces_slashes(self):
+        """Replaces forward slashes with hyphens."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("feature/my-branch") == "feature-my-branch"
+
+    def test_replaces_multiple_special_chars(self):
+        """Replaces various special characters with hyphens."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("feat@user#123") == "feat-user-123"
+
+    def test_collapses_multiple_hyphens(self):
+        """Collapses multiple consecutive hyphens into one."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("feature//branch") == "feature-branch"
+        assert _sanitize_branch_name("a---b") == "a-b"
+
+    def test_strips_leading_trailing_hyphens(self):
+        """Removes leading and trailing hyphens."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("/feature/") == "feature"
+        assert _sanitize_branch_name("--branch--") == "branch"
+
+    def test_preserves_valid_chars(self):
+        """Preserves alphanumeric chars, hyphens, and underscores."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("my-branch_v1") == "my-branch_v1"
+
+    def test_replaces_dots(self):
+        """Replaces dots with hyphens."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("v1.0.0") == "v1-0-0"
+
+    def test_replaces_non_ascii(self):
+        """Replaces non-ASCII characters with hyphens."""
+        from pytest_neon.plugin import _sanitize_branch_name
+
+        assert _sanitize_branch_name("feature-über") == "feature-ber"
+        assert _sanitize_branch_name("日本語branch") == "branch"
+        assert _sanitize_branch_name("test™") == "test"
+
+
+class TestGetGitBranchName:
+    """Tests for _get_git_branch_name helper."""
+
+    def test_returns_branch_name_in_git_repo(self):
+        """Returns git branch name when in a git repo."""
+        from pytest_neon.plugin import _get_git_branch_name
+
+        # We're running in a git repo, so this should return something
+        result = _get_git_branch_name()
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_returns_none_when_git_fails(self):
+        """Returns None when git command fails."""
+        from pytest_neon.plugin import _get_git_branch_name
+
+        with patch("subprocess.run") as mock_run:
+            mock_run.return_value = MagicMock(returncode=1, stdout="")
+            result = _get_git_branch_name()
+            assert result is None
+
+    def test_returns_none_when_git_not_found(self):
+        """Returns None when git is not installed."""
+        from pytest_neon.plugin import _get_git_branch_name
+
+        with patch("subprocess.run") as mock_run:
+            mock_run.side_effect = FileNotFoundError()
+            result = _get_git_branch_name()
+            assert result is None
+
+    def test_returns_none_on_timeout(self):
+        """Returns None when git command times out."""
+        import subprocess
+
+        from pytest_neon.plugin import _get_git_branch_name
+
+        with patch("subprocess.run") as mock_run:
+            mock_run.side_effect = subprocess.TimeoutExpired(cmd="git", timeout=5)
+            result = _get_git_branch_name()
+            assert result is None
+
+
+class TestBranchNameWithGitBranch:
+    """Tests for branch name generation with git branch."""
+
+    def test_branch_name_includes_git_branch(self):
+        """Branch name includes git branch when in a repo."""
+        from pytest_neon.plugin import _create_neon_branch
+
+        mock_request = MagicMock()
+        mock_config = MagicMock()
+        mock_request.config = mock_config
+
+        def mock_getoption(name, default=None):
+            if name == "neon_api_key":
+                return "test-api-key"
+            if name == "neon_project_id":
+                return "test-project"
+            if name == "neon_keep_branches":
+                return True
+            if name == "neon_branch_expiry":
+                return 0
+            return default
+
+        def mock_getini(name):
+            if name == "neon_database":
+                return "neondb"
+            if name == "neon_role":
+                return "neondb_owner"
+            if name == "neon_env_var":
+                return "DATABASE_URL"
+            return None
+
+        mock_config.getoption.side_effect = mock_getoption
+        mock_config.getini.side_effect = mock_getini
+
+        with (
+            patch("pytest_neon.plugin.NeonAPI") as mock_neon_cls,
+            patch("pytest_neon.plugin._get_git_branch_name") as mock_git,
+        ):
+            # _get_git_branch_name returns sanitized value (slashes -> hyphens)
+            mock_git.return_value = "feature-my-branch"
+
+            mock_api = MagicMock()
+            mock_neon_cls.return_value = mock_api
+
+            captured_branch_name = None
+
+            def capture_branch_create(**kwargs):
+                nonlocal captured_branch_name
+                branch_config = kwargs.get("branch", {})
+                captured_branch_name = branch_config.get("name")
+
+                mock_result = MagicMock()
+                mock_result.branch.id = "test-branch-id"
+                mock_result.branch.parent_id = "parent-id"
+                mock_result.operations = [MagicMock(endpoint_id="ep-123")]
+                return mock_result
+
+            mock_api.branch_create.side_effect = capture_branch_create
+
+            mock_endpoint_response = MagicMock()
+            mock_endpoint_response.endpoint.current_state = EndpointState.active
+            mock_endpoint_response.endpoint.host = "test.neon.tech"
+            mock_api.endpoint.return_value = mock_endpoint_response
+
+            mock_password = MagicMock()
+            mock_password.role.password = "testpass"
+            mock_api.role_password_reset.return_value = mock_password
+
+            gen = _create_neon_branch(mock_request, branch_name_suffix="-migrated")
+            with contextlib.suppress(StopIteration):
+                next(gen)
+
+            assert captured_branch_name is not None
+            # Git branch "feature/my-branch" sanitized to "feature-my-branch"
+            assert captured_branch_name.startswith("pytest-feature-my-bran-")
+            assert captured_branch_name.endswith("-migrated")
+
+    def test_branch_name_truncates_long_git_branch(self):
+        """Git branch name is truncated to 15 characters."""
+        from pytest_neon.plugin import _create_neon_branch
+
+        mock_request = MagicMock()
+        mock_config = MagicMock()
+        mock_request.config = mock_config
+
+        def mock_getoption(name, default=None):
+            if name == "neon_api_key":
+                return "test-api-key"
+            if name == "neon_project_id":
+                return "test-project"
+            if name == "neon_keep_branches":
+                return True
+            if name == "neon_branch_expiry":
+                return 0
+            return default
+
+        def mock_getini(name):
+            if name == "neon_database":
+                return "neondb"
+            if name == "neon_role":
+                return "neondb_owner"
+            if name == "neon_env_var":
+                return "DATABASE_URL"
+            return None
+
+        mock_config.getoption.side_effect = mock_getoption
+        mock_config.getini.side_effect = mock_getini
+
+        with (
+            patch("pytest_neon.plugin.NeonAPI") as mock_neon_cls,
+            patch("pytest_neon.plugin._get_git_branch_name") as mock_git,
+        ):
+            # _get_git_branch_name returns sanitized value
+            mock_git.return_value = "feature-very-long-branch-name-truncated"
+
+            mock_api = MagicMock()
+            mock_neon_cls.return_value = mock_api
+
+            captured_branch_name = None
+
+            def capture_branch_create(**kwargs):
+                nonlocal captured_branch_name
+                branch_config = kwargs.get("branch", {})
+                captured_branch_name = branch_config.get("name")
+
+                mock_result = MagicMock()
+                mock_result.branch.id = "test-branch-id"
+                mock_result.branch.parent_id = "parent-id"
+                mock_result.operations = [MagicMock(endpoint_id="ep-123")]
+                return mock_result
+
+            mock_api.branch_create.side_effect = capture_branch_create
+
+            mock_endpoint_response = MagicMock()
+            mock_endpoint_response.endpoint.current_state = EndpointState.active
+            mock_endpoint_response.endpoint.host = "test.neon.tech"
+            mock_api.endpoint.return_value = mock_endpoint_response
+
+            mock_password = MagicMock()
+            mock_password.role.password = "testpass"
+            mock_api.role_password_reset.return_value = mock_password
+
+            gen = _create_neon_branch(mock_request, branch_name_suffix="-migrated")
+            with contextlib.suppress(StopIteration):
+                next(gen)
+
+            assert captured_branch_name is not None
+            # Long branch sanitized and truncated to first 15 chars
+            assert captured_branch_name.startswith("pytest-feature-very-lo-")
+            assert captured_branch_name.endswith("-migrated")
+
+    def test_branch_name_without_git(self):
+        """Branch name uses old format when not in a git repo."""
+        from pytest_neon.plugin import _create_neon_branch
+
+        mock_request = MagicMock()
+        mock_config = MagicMock()
+        mock_request.config = mock_config
+
+        def mock_getoption(name, default=None):
+            if name == "neon_api_key":
+                return "test-api-key"
+            if name == "neon_project_id":
+                return "test-project"
+            if name == "neon_keep_branches":
+                return True
+            if name == "neon_branch_expiry":
+                return 0
+            return default
+
+        def mock_getini(name):
+            if name == "neon_database":
+                return "neondb"
+            if name == "neon_role":
+                return "neondb_owner"
+            if name == "neon_env_var":
+                return "DATABASE_URL"
+            return None
+
+        mock_config.getoption.side_effect = mock_getoption
+        mock_config.getini.side_effect = mock_getini
+
+        with (
+            patch("pytest_neon.plugin.NeonAPI") as mock_neon_cls,
+            patch("pytest_neon.plugin._get_git_branch_name") as mock_git,
+        ):
+            mock_git.return_value = None  # Not in a git repo
+
+            mock_api = MagicMock()
+            mock_neon_cls.return_value = mock_api
+
+            captured_branch_name = None
+
+            def capture_branch_create(**kwargs):
+                nonlocal captured_branch_name
+                branch_config = kwargs.get("branch", {})
+                captured_branch_name = branch_config.get("name")
+
+                mock_result = MagicMock()
+                mock_result.branch.id = "test-branch-id"
+                mock_result.branch.parent_id = "parent-id"
+                mock_result.operations = [MagicMock(endpoint_id="ep-123")]
+                return mock_result
+
+            mock_api.branch_create.side_effect = capture_branch_create
+
+            mock_endpoint_response = MagicMock()
+            mock_endpoint_response.endpoint.current_state = EndpointState.active
+            mock_endpoint_response.endpoint.host = "test.neon.tech"
+            mock_api.endpoint.return_value = mock_endpoint_response
+
+            mock_password = MagicMock()
+            mock_password.role.password = "testpass"
+            mock_api.role_password_reset.return_value = mock_password
+
+            gen = _create_neon_branch(mock_request, branch_name_suffix="-migrated")
+            with contextlib.suppress(StopIteration):
+                next(gen)
+
+            assert captured_branch_name is not None
+            # Without git: pytest-[4 hex chars]-migrated
+            assert captured_branch_name.startswith("pytest-")
+            assert captured_branch_name.endswith("-migrated")
+            # Format: pytest-abcd-migrated (no git branch in the middle)
+            parts = captured_branch_name.split("-")
+            assert len(parts) == 3  # ['pytest', 'abcd', 'migrated']
+            assert len(parts[1]) == 4  # 2 bytes = 4 hex chars

pytest_neon-2.1.4/tests/test_default_branch_safety.py

@@ -0,0 +1,82 @@
+"""Tests for default branch safety check."""
+
+from unittest.mock import MagicMock
+
+from pytest_neon.plugin import _get_default_branch_id
+
+
+class TestGetDefaultBranchId:
+    """Test _get_default_branch_id helper function."""
+
+    def test_returns_default_branch_id(self):
+        """Test that default branch ID is returned when found."""
+        mock_neon = MagicMock()
+        mock_branch_default = MagicMock()
+        mock_branch_default.id = "br-default-123"
+        mock_branch_default.default = True
+        mock_branch_default.primary = False
+
+        mock_branch_other = MagicMock()
+        mock_branch_other.id = "br-other-456"
+        mock_branch_other.default = False
+        mock_branch_other.primary = False
+
+        mock_response = MagicMock()
+        mock_response.branches = [mock_branch_other, mock_branch_default]
+        mock_neon.branches.return_value = mock_response
+
+        result = _get_default_branch_id(mock_neon, "proj-123")
+        assert result == "br-default-123"
+
+    def test_returns_primary_branch_id_as_fallback(self):
+        """Test that primary branch ID is returned when default flag not set."""
+        mock_neon = MagicMock()
+        mock_branch_primary = MagicMock()
+        mock_branch_primary.id = "br-primary-123"
+        mock_branch_primary.default = False
+        mock_branch_primary.primary = True
+
+        mock_response = MagicMock()
+        mock_response.branches = [mock_branch_primary]
+        mock_neon.branches.return_value = mock_response
+
+        result = _get_default_branch_id(mock_neon, "proj-123")
+        assert result == "br-primary-123"
+
+    def test_returns_none_when_no_default_or_primary(self):
+        """Test that None is returned when no default/primary branch exists."""
+        mock_neon = MagicMock()
+        mock_branch = MagicMock()
+        mock_branch.id = "br-other-123"
+        mock_branch.default = False
+        mock_branch.primary = False
+
+        mock_response = MagicMock()
+        mock_response.branches = [mock_branch]
+        mock_neon.branches.return_value = mock_response
+
+        result = _get_default_branch_id(mock_neon, "proj-123")
+        assert result is None
+
+    def test_returns_none_on_api_error(self):
+        """Test that None is returned on API failure so tests can still run."""
+        mock_neon = MagicMock()
+        mock_neon.branches.side_effect = Exception("API error")
+
+        result = _get_default_branch_id(mock_neon, "proj-123")
+        assert result is None
+
+    def test_handles_missing_attributes_gracefully(self):
+        """Test graceful handling when branch object lacks expected attributes."""
+        mock_neon = MagicMock()
+        # Branch with no default/primary attributes at all
+        mock_branch = MagicMock(spec=["id"])
+        mock_branch.id = "br-123"
+
+        mock_response = MagicMock()
+        mock_response.branches = [mock_branch]
+        mock_neon.branches.return_value = mock_response
+
+        # Should not raise, getattr with default handles this
+        result = _get_default_branch_id(mock_neon, "proj-123")
+        assert result is None

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/tests/test_reset_behavior.py

@@ -162,6 +162,43 @@ class TestResetRetryBehavior:
         # Should have polled until finished
         assert get_call_count[0] == 3
 
+    def test_reset_raises_on_failed_operation(self, mocker):
+        """Verify reset raises RuntimeError when operation fails."""
+        branch = NeonBranch(
+            branch_id="br-test",
+            project_id="proj-test",
+            connection_string="postgresql://test",
+            host="test.neon.tech",
+            parent_id="br-parent",
+        )
+
+        # Mock POST response with pending operation
+        mock_post_response = mocker.Mock()
+        mock_post_response.raise_for_status = mocker.Mock()
+        mock_post_response.json.return_value = {
+            "operations": [{"id": "op-123", "status": "running"}]
+        }
+
+        # Mock GET response: operation failed
+        mock_get_response = mocker.Mock()
+        mock_get_response.raise_for_status = mocker.Mock()
+        mock_get_response.json.return_value = {
+            "operation": {
+                "id": "op-123",
+                "status": "failed",
+                "error": "Something went wrong",
+            }
+        }
+
+        mocker.patch(
+            "pytest_neon.plugin.requests.post", return_value=mock_post_response
+        )
+        mocker.patch("pytest_neon.plugin.requests.get", return_value=mock_get_response)
+        mocker.patch("pytest_neon.plugin.time.sleep")
+
+        with pytest.raises(RuntimeError, match="Operation op-123 failed"):
+            _reset_branch_to_parent(branch, "fake-api-key")
+
 
 class TestResetBehavior:
     """Test that branch reset happens between tests."""

{pytest_neon-2.1.2 → pytest_neon-2.1.4}/uv.lock

@@ -1200,7 +1200,7 @@ wheels = [
 
 [[package]]
 name = "pytest-neon"
-version = "2.1.0"
+version = "2.1.2"
 source = { editable = "." }
 dependencies = [
     { name = "neon-api" },