git-analyser 0.2.1__tar.gz → 0.2.2__tar.gz

{git_analyser-0.2.1 → git_analyser-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-analyser
-Version: 0.2.1
+Version: 0.2.2
 Summary: Git repository analyser — commit history, churn, contributor patterns, dispatches to analyser family
 Author-email: Michael Borck <michael.borck@curtin.edu.au>
 License: MIT

{git_analyser-0.2.1 → git_analyser-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "git-analyser"
-version = "0.2.1"
+version = "0.2.2"
 description = "Git repository analyser — commit history, churn, contributor patterns, dispatches to analyser family"
 authors = [{name = "Michael Borck", email = "michael.borck@curtin.edu.au"}]
 readme = "README.md"
@@ -41,3 +41,7 @@ packages = ["src/git_analyser"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]
+addopts = "-m 'not slow'"
+markers = [
+    "slow: tests that load real models or make network calls — opt-in with `pytest -m slow`",
+]

git_analyser-0.2.2/src/git_analyser/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version as _v
+__version__ = _v("git-analyser")
+del _v

{git_analyser-0.2.1 → git_analyser-0.2.2}/src/git_analyser/api.py

@@ -14,7 +14,7 @@ class AnalyseRequest(BaseModel):
 
 @app.get("/health")
 def health():
-    return {"status": "ok"}
+    return {"status": "ok", "version": version("git-analyser")}
 
 
 @app.post("/analyse", response_model=GitAnalysisResult)

{git_analyser-0.2.1 → git_analyser-0.2.2}/tests/test_api.py

@@ -1,3 +1,5 @@
+from importlib.metadata import version
+
 import pytest
 from fastapi.testclient import TestClient
 
@@ -9,7 +11,7 @@ client = TestClient(app)
 def test_health():
     response = client.get("/health")
     assert response.status_code == 200
-    assert response.json() == {"status": "ok"}
+    assert response.json() == {"status": "ok", "version": version("git-analyser")}
 
 
 def test_analyse_valid_repo(temp_repo):
@@ -27,8 +29,12 @@ def test_analyse_zip_path_returns_400():
 
 
 def test_analyse_nonexistent_path_returns_400():
-    response = client.post("/analyse", json={"repo": "/nonexistent/path/repo"})
+    response = client.post(
+        "/analyse", json={"repo": "/nonexistent/path/that/cannot/exist"}
+    )
     assert response.status_code == 400
+    detail = response.json()["detail"].lower()
+    assert "exist" in detail or "not found" in detail or "git" in detail
 
 
 def test_analyse_missing_body_returns_422():
@@ -39,9 +45,10 @@ def test_analyse_missing_body_returns_422():
 def test_analyse_returns_learning_signals(temp_repo):
     response = client.post("/analyse", json={"repo": str(temp_repo)})
     assert response.status_code == 200
-    data = response.json()
-    sig = data["learning_signals"]
-    assert "commit_count" in sig
-    assert "total_additions" in sig
-    assert "add_delete_ratio" in sig
-    assert "commit_regularity_cv" in sig
+    sig = response.json()["learning_signals"]
+    assert sig["commit_count"] == 2
+    # Only the second commit's 1 addition counts (root commit has no parent).
+    assert sig["total_additions"] == 1
+    assert sig["total_deletions"] == 0
+    assert sig["add_delete_ratio"] == 0.0
+    assert sig["generic_message_ratio"] == 0.0

git_analyser-0.2.2/tests/test_core.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+
+import pytest
+
+from git_analyser.core import analyse_repo
+from git_analyser.models import GitAnalysisResult
+
+
+def test_valid_repo_returns_result(temp_repo):
+    result = analyse_repo(temp_repo)
+    assert isinstance(result, GitAnalysisResult)
+    assert result.error is None
+    assert result.commit_count >= 2
+
+
+def test_valid_repo_has_authors(temp_repo):
+    result = analyse_repo(temp_repo)
+    assert len(result.authors) >= 1
+    assert "Test" in result.authors
+
+
+def test_valid_repo_has_timeline(temp_repo):
+    result = analyse_repo(temp_repo)
+    assert len(result.timeline) >= 2
+    # First commit subject
+    subjects = [c.subject for c in result.timeline]
+    assert "add index.html" in subjects
+
+
+def test_zip_path_returns_bundle_analyser_error():
+    result = analyse_repo("/some/path/repo.zip")
+    assert result.error is not None
+    assert "bundle-analyser" in result.error
+
+
+def test_nonexistent_path_returns_error():
+    result = analyse_repo("/nonexistent/path/to/repo")
+    assert result.error is not None
+    assert result.commit_count == 0
+
+
+def test_path_without_git_returns_error(tmp_path):
+    result = analyse_repo(tmp_path)
+    assert result.error is not None
+    assert ".git" in result.error or "not a git" in result.error
+
+
+def test_learning_signals_values_are_deterministic(temp_repo):
+    """The 2-commit fixture has known signal values; pin them.
+
+    Note: the first (root) commit has no parent so diff-tree --numstat
+    reports nothing for it, hence only the second commit's 1 addition is
+    counted. This matches the current implementation's behaviour.
+    """
+    result = analyse_repo(temp_repo)
+    sig = result.learning_signals
+    assert sig.commit_count == 2
+    assert sig.total_additions == 1  # only the second commit's line is counted
+    assert sig.total_deletions == 0
+    assert sig.add_delete_ratio == 0.0
+    assert sig.generic_message_ratio == 0.0  # both messages are descriptive
+    # avg_message_length: "add index.html" (14) + "add stylesheet" (14) / 2 = 14
+    assert sig.avg_message_length == 14.0
+
+
+def test_string_path_accepted(temp_repo):
+    result = analyse_repo(str(temp_repo))
+    assert result.error is None
+    assert result.commit_count >= 2
+
+
+def test_remote_url_invokes_git_clone(monkeypatch):
+    """Remote URLs trigger git clone with the right argv (no network)."""
+    import subprocess as _subprocess
+    from pathlib import Path as _Path
+    from unittest.mock import MagicMock
+
+    from git_analyser import core as _core
+
+    captured_calls: list[list[str]] = []
+    real_run = _subprocess.run
+
+    def fake_run(cmd, *args, **kwargs):
+        captured_calls.append(list(cmd))
+        if isinstance(cmd, list) and len(cmd) >= 2 and cmd[0] == "git" and cmd[1] == "clone":
+            target = cmd[-1]
+            target_path = _Path(target)
+            target_path.mkdir(parents=True, exist_ok=True)
+            (target_path / ".git").mkdir(exist_ok=True)
+            mock = MagicMock()
+            mock.returncode = 0
+            mock.stdout = ""
+            mock.stderr = ""
+            return mock
+        # All other git invocations (log, diff-tree...) — return empty output
+        mock = MagicMock()
+        mock.returncode = 0
+        mock.stdout = ""
+        mock.stderr = ""
+        return mock
+
+    # Patch the symbol used inside core.py
+    monkeypatch.setattr(_core.subprocess, "run", fake_run)
+
+    result = analyse_repo("https://github.com/example/repo.git")
+
+    clone_calls = [
+        c for c in captured_calls
+        if len(c) >= 2 and c[0] == "git" and c[1] == "clone"
+    ]
+    assert len(clone_calls) == 1
+    assert "https://github.com/example/repo.git" in clone_calls[0]
+    # Sanity: result is a GitAnalysisResult, no clone error surfaced
+    assert isinstance(result, GitAnalysisResult)
+    assert result.error is None or "clone" not in result.error.lower()

git_analyser-0.2.2/tests/test_invariants.py

@@ -0,0 +1,46 @@
+"""Invariant tests — fast, run by default."""
+
+from importlib.metadata import version
+
+import pytest
+
+
+def test_package_imports_cleanly() -> None:
+    """Smoke alarm — package must import without errors."""
+    import git_analyser  # noqa: F401
+    from git_analyser.cli import main  # noqa: F401
+    from git_analyser.api import app  # noqa: F401
+
+
+def test_health_version_matches_installed_package() -> None:
+    """/health must report the actual installed package version."""
+    from fastapi.testclient import TestClient
+
+    from git_analyser.api import app
+
+    client = TestClient(app)
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["version"] == version("git-analyser")
+
+
+def test_app_title_matches_installed_package() -> None:
+    """FastAPI app.version must match the installed package."""
+    from git_analyser.api import app
+
+    assert app.version == version("git-analyser")
+
+
+def test_non_git_directory_returns_loud_error(tmp_path) -> None:
+    """A directory without .git must error explicitly, not silently zero-fill.
+
+    Family pattern: failures are loud, not silent.
+    """
+    from git_analyser.core import analyse_repo
+
+    result = analyse_repo(tmp_path)
+    assert result.error is not None
+    # Must NOT have populated signals — silent zero-fill is a real risk
+    assert result.commit_count == 0
+    assert result.suspicious_flags == []
+    assert result.learning_signals.commit_count == 0

git_analyser-0.2.2/tests/test_suspicious_patterns.py

@@ -0,0 +1,189 @@
+"""POS/NEG matrix for the four suspicious-pattern rules in core.py.
+
+Each of the four rules (bulk upload, single-session 24h dump, massive
+commit, multi-author) gets one positive and one negative test using
+deterministic fixtures with forged commit dates and author emails.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+from git_analyser.core import analyse_repo
+
+
+def _git_init(repo: Path) -> None:
+    subprocess.run(["git", "init", str(repo)], check=True, capture_output=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@test.com"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+    )
+
+
+def _commit(
+    repo: Path,
+    message: str,
+    when: datetime,
+    author_name: str = "Test",
+    author_email: str = "test@test.com",
+) -> None:
+    """Create a commit with forged author/committer dates and identity."""
+    iso = when.isoformat()
+    env = {
+        **os.environ,
+        "GIT_AUTHOR_DATE": iso,
+        "GIT_COMMITTER_DATE": iso,
+        "GIT_AUTHOR_NAME": author_name,
+        "GIT_AUTHOR_EMAIL": author_email,
+        "GIT_COMMITTER_NAME": author_name,
+        "GIT_COMMITTER_EMAIL": author_email,
+    }
+    subprocess.run(
+        ["git", "add", "."], cwd=repo, check=True, capture_output=True, env=env
+    )
+    subprocess.run(
+        ["git", "commit", "-m", message],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        env=env,
+    )
+
+
+def _make_repo(tmp_path: Path, num_commits: int, span_hours: float) -> Path:
+    """Init repo, make N commits spread evenly over span_hours."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git_init(repo)
+
+    start = datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+    step = timedelta(hours=span_hours / max(num_commits - 1, 1))
+
+    for i in range(num_commits):
+        (repo / f"file_{i}.txt").write_text(f"content {i}\n")
+        when = start + step * i
+        _commit(repo, f"add file_{i}", when)
+
+    return repo
+
+
+def _make_repo_with_huge_commit(tmp_path: Path, lines: int) -> Path:
+    """Init repo, make a baseline commit, then a huge commit with N lines added."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git_init(repo)
+
+    start = datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    # Baseline commit (the root commit's diff doesn't show in numstat)
+    (repo / "seed.txt").write_text("seed\n")
+    _commit(repo, "seed file", start)
+
+    # Huge commit on top
+    huge = "\n".join(f"line {i}" for i in range(lines)) + "\n"
+    (repo / "huge.txt").write_text(huge)
+    _commit(repo, "add huge file", start + timedelta(hours=1))
+
+    return repo
+
+
+def _make_repo_with_multiple_authors(tmp_path: Path, num_authors: int) -> Path:
+    """Init repo with one commit per author (distinct emails)."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git_init(repo)
+
+    start = datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    for i in range(num_authors):
+        (repo / f"file_{i}.txt").write_text(f"content {i}\n")
+        when = start + timedelta(hours=i * 10)
+        _commit(
+            repo,
+            f"add file_{i}",
+            when,
+            author_name=f"Author{i}",
+            author_email=f"author{i}@example.com",
+        )
+
+    return repo
+
+
+# ---- bulk-upload rule (`<= 2 commits`) -------------------------------------
+
+
+def test_no_bulk_upload_flag_for_more_than_two_commits(tmp_path):
+    """3+ commits should NOT trigger the bulk-upload flag."""
+    repo = _make_repo(tmp_path, num_commits=4, span_hours=72)
+    result = analyse_repo(repo)
+    assert not any("bulk upload" in flag.lower() for flag in result.suspicious_flags)
+
+
+# ---- 24-hour-dump rule -----------------------------------------------------
+
+
+def test_no_24h_dump_flag_when_span_exceeds_day(tmp_path):
+    """Commits spanning >24h should NOT trigger the single-session-dump flag."""
+    repo = _make_repo(tmp_path, num_commits=4, span_hours=72)
+    result = analyse_repo(repo)
+    assert not any(
+        "single session" in flag.lower() for flag in result.suspicious_flags
+    )
+
+
+# ---- massive-commit rule (>500 additions) ----------------------------------
+
+
+def test_massive_commit_flagged(tmp_path):
+    """A commit with >500 additions triggers the very-large-commit flag."""
+    repo = _make_repo_with_huge_commit(tmp_path, lines=600)
+    result = analyse_repo(repo)
+    assert any(
+        "addition" in flag.lower() or "large" in flag.lower()
+        for flag in result.suspicious_flags
+    )
+
+
+def test_no_massive_commit_flag_for_small_commits(tmp_path):
+    """Small commits don't trigger the very-large-commit flag."""
+    repo = _make_repo(tmp_path, num_commits=3, span_hours=48)
+    result = analyse_repo(repo)
+    assert not any(
+        "addition" in flag.lower() and "large" in flag.lower()
+        for flag in result.suspicious_flags
+    )
+
+
+# ---- multi-author rule (`> 2` distinct emails) -----------------------------
+
+
+def test_multi_author_flagged(tmp_path):
+    """3+ distinct author emails triggers the multi-author flag."""
+    repo = _make_repo_with_multiple_authors(tmp_path, num_authors=3)
+    result = analyse_repo(repo)
+    assert any(
+        "author" in flag.lower() and "multiple" in flag.lower()
+        for flag in result.suspicious_flags
+    )
+
+
+def test_no_multi_author_flag_for_single_author(tmp_path):
+    """Single author should NOT trigger the multi-author flag."""
+    repo = _make_repo(tmp_path, num_commits=4, span_hours=48)
+    result = analyse_repo(repo)
+    assert not any(
+        "author" in flag.lower() and "multiple" in flag.lower()
+        for flag in result.suspicious_flags
+    )

git_analyser-0.2.1/src/git_analyser/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"

git_analyser-0.2.1/tests/test_core.py

@@ -1,73 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from git_analyser.core import analyse_repo
-from git_analyser.models import GitAnalysisResult
-
-
-def test_valid_repo_returns_result(temp_repo):
-    result = analyse_repo(temp_repo)
-    assert isinstance(result, GitAnalysisResult)
-    assert result.error is None
-    assert result.commit_count >= 2
-
-
-def test_valid_repo_has_authors(temp_repo):
-    result = analyse_repo(temp_repo)
-    assert len(result.authors) >= 1
-    assert "Test" in result.authors
-
-
-def test_valid_repo_has_timeline(temp_repo):
-    result = analyse_repo(temp_repo)
-    assert len(result.timeline) >= 2
-    # First commit subject
-    subjects = [c.subject for c in result.timeline]
-    assert "add index.html" in subjects
-
-
-def test_zip_path_returns_bundle_analyser_error():
-    result = analyse_repo("/some/path/repo.zip")
-    assert result.error is not None
-    assert "bundle-analyser" in result.error
-
-
-def test_nonexistent_path_returns_error():
-    result = analyse_repo("/nonexistent/path/to/repo")
-    assert result.error is not None
-    assert result.commit_count == 0
-
-
-def test_path_without_git_returns_error(tmp_path):
-    result = analyse_repo(tmp_path)
-    assert result.error is not None
-    assert ".git" in result.error or "not a git" in result.error
-
-
-def test_learning_signals_has_expected_fields(temp_repo):
-    result = analyse_repo(temp_repo)
-    sig = result.learning_signals
-    assert hasattr(sig, "commit_count")
-    assert hasattr(sig, "total_additions")
-    assert hasattr(sig, "total_deletions")
-    assert hasattr(sig, "add_delete_ratio")
-    assert hasattr(sig, "avg_message_length")
-    assert hasattr(sig, "generic_message_ratio")
-    assert hasattr(sig, "time_span_hours")
-    assert hasattr(sig, "max_gap_hours")
-    assert hasattr(sig, "commit_regularity_cv")
-
-
-def test_learning_signals_values(temp_repo):
-    result = analyse_repo(temp_repo)
-    sig = result.learning_signals
-    assert sig.commit_count >= 2
-    assert sig.total_additions >= 0
-    assert sig.avg_message_length > 0
-
-
-def test_string_path_accepted(temp_repo):
-    result = analyse_repo(str(temp_repo))
-    assert result.error is None
-    assert result.commit_count >= 2