Massive Improvements & MVP Patches

tests/conftest.py

@@ -16,6 +16,8 @@ def _env_defaults(monkeypatch: pytest.MonkeyPatch, tmp_path, request: pytest.Fix
     monkeypatch.setenv("GITEA_BOT_USERNAME", "codex-bot")
     monkeypatch.setenv("GITEA_WEBHOOK_SECRET", "secret")
     monkeypatch.setenv("OPENAI_API_KEY", "openai-key")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "api_key")
+    monkeypatch.delenv("CODEX_AUTH_JSON_PATH", raising=False)
     monkeypatch.setenv("ALLOWED_REPOS", "acme/repo")
     monkeypatch.setenv("COOLDOWN_SECONDS", "60")
     monkeypatch.setenv("WEBHOOK_MODE", "repo")

tests/test_config.py

@@ -1,6 +1,13 @@
 from gitea_codex_bot.config import get_settings
 
 
-def test_openai_api_key_required() -> None:
+def test_openai_api_key_from_env() -> None:
     settings = get_settings()
-    assert settings.openai_api_key.get_secret_value() == "openai-key"
+    assert settings.openai_api_key is not None
+    assert settings.openai_api_key.get_secret_value() == "openai-key"
+
+
+def test_codex_auth_defaults_to_api_key_mode() -> None:
+    settings = get_settings()
+    assert settings.codex_auth_mode == "api_key"
+    assert settings.codex_auth_json_path is None

tests/test_container_runner.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from gitea_codex_bot.config import get_settings
+from gitea_codex_bot.workers.container_runner import (
+    CONTAINER_CODEX_HOME,
+    _build_docker_command,
+    _build_install_and_run_command,
+    _load_codex_auth_json_b64,
+    _parse_codex_exec_stdout,
+    _resolve_codex_auth_json_path,
+    run_review_ephemeral,
+)
+
+
+def test_build_docker_command_api_key_mode_uses_openai_env() -> None:
+    settings = get_settings()
+
+    cmd = _build_docker_command(settings, container_name="codex-review-test", install_and_run="echo ok")
+
+    assert "OPENAI_API_KEY" in cmd
+    assert "OPENAI_ORG_ID" in cmd
+    assert "OPENAI_PROJECT_ID" in cmd
+    assert "--mount" not in cmd
+
+
+def test_build_docker_command_chatgpt_mode_mounts_auth_json(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    auth_file = tmp_path / "custom-auth.json"
+    auth_file.write_text('{"auth_mode":"chatgpt"}', encoding="utf-8")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(auth_file))
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    cmd = _build_docker_command(settings, container_name="codex-review-test", install_and_run="echo ok")
+
+    env_items = {value for index, value in enumerate(cmd) if index > 0 and cmd[index - 1] == "-e"}
+    assert "OPENAI_API_KEY" not in cmd
+    assert f"CODEX_HOME={CONTAINER_CODEX_HOME}" in env_items
+    assert "CODEX_AUTH_JSON_B64" in env_items
+
+
+def test_build_install_command_chatgpt_mode_copies_auth_json(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    auth_file = tmp_path / "auth.json"
+    auth_file.write_text("{}", encoding="utf-8")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(auth_file))
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    command = _build_install_and_run_command(settings)
+
+    assert 'printf "%s" "$CODEX_AUTH_JSON_B64" | base64 -d > /root/.codex/auth.json' in command
+    assert "codex exec --skip-git-repo-check --json -m gpt-5.3-codex" in command
+
+
+def test_chatgpt_mode_requires_existing_auth_json(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    missing = tmp_path / "missing-auth.json"
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(missing))
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    with pytest.raises(FileNotFoundError):
+        _resolve_codex_auth_json_path(settings)
+
+
+def test_load_codex_auth_json_b64_roundtrip(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    auth_file = tmp_path / "auth.json"
+    auth_file.write_text('{"auth_mode":"chatgpt","access_token":"abc"}', encoding="utf-8")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(auth_file))
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    encoded = _load_codex_auth_json_b64(settings)
+
+    assert encoded
+
+
+def test_run_review_ephemeral_chatgpt_does_not_fallback_to_api_key_path(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    auth_file = tmp_path / "auth.json"
+    auth_file.write_text('{"auth_mode":"chatgpt"}', encoding="utf-8")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(auth_file))
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    monkeypatch.setattr(
+        "gitea_codex_bot.workers.container_runner.prepare_review_prompt",
+        lambda *_args, **_kwargs: ("prompt", {"diff": ""}, object()),
+    )
+    monkeypatch.setattr("gitea_codex_bot.workers.container_runner.GiteaClient", lambda _settings: object())
+    monkeypatch.setattr(
+        "gitea_codex_bot.workers.container_runner.subprocess.run",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("docker unavailable")),
+    )
+
+    def _api_fallback_should_not_run(*_args, **_kwargs):
+        raise AssertionError("API-key fallback should not run in chatgpt mode")
+
+    monkeypatch.setattr("gitea_codex_bot.workers.container_runner.run_review_for_pr", _api_fallback_should_not_run)
+
+    from gitea_codex_bot.types import ParsedCommand
+
+    result = run_review_ephemeral(
+        settings,
+        repo="acme/repo",
+        pr_number=1,
+        command=ParsedCommand(name="review", raw="@codex review"),
+    )
+
+    assert result["verdict"] == "has_issues"
+    assert "ChatGPT auth runner failed" in result["summary"]
+
+
+def test_parse_codex_exec_stdout_from_stream_item_text_json() -> None:
+    stdout = '\n'.join(
+        [
+            '{"type":"thread.started","thread_id":"abc"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"{\\"verdict\\":\\"correct\\",\\"confidence\\":0.9,\\"summary\\":\\"ok\\",\\"findings\\":[]}"}}',
+        ]
+    )
+    parsed = _parse_codex_exec_stdout(stdout)
+    assert parsed["verdict"] == "correct"
+    assert parsed["summary"] == "ok"
+
+
+def test_parse_codex_exec_stdout_from_fenced_json_text() -> None:
+    stdout = '\n'.join(
+        [
+            '{"type":"thread.started","thread_id":"abc"}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"Here is the result:\\n```json\\n{\\"verdict\\":\\"has_issues\\",\\"confidence\\":0.8,\\"summary\\":\\"x\\",\\"findings\\":[]}\\n```"}}',
+        ]
+    )
+    parsed = _parse_codex_exec_stdout(stdout)
+    assert parsed["verdict"] == "has_issues"
+    assert parsed["summary"] == "x"

tests/test_dispatcher.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import httpx
+from sqlalchemy import select
+
+from gitea_codex_bot.config import get_settings
+from gitea_codex_bot.db import get_session_factory
+from gitea_codex_bot.models import ReviewJob
+from gitea_codex_bot.services.comments import get_persistent_review_comment_id, upsert_persistent_review_comment_id
+from gitea_codex_bot.services.jobs import enqueue_job
+from gitea_codex_bot.types import ParsedCommand
+from gitea_codex_bot.workers.dispatcher import process_one_job
+
+
+def test_process_one_job_recreates_persistent_comment_when_edit_returns_404(monkeypatch) -> None:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        job = enqueue_job(
+            session,
+            repo="acme/repo",
+            pr_number=9,
+            head_sha="deadbeef",
+            trigger_comment_id=111,
+            requested_by="alice",
+            command=ParsedCommand(name="review", raw="@codex review"),
+        )
+        upsert_persistent_review_comment_id(
+            session,
+            repo=job.repo,
+            pr_number=job.pr_number,
+            head_sha=job.head_sha,
+            comment_id=289,
+        )
+
+    monkeypatch.setattr(
+        "gitea_codex_bot.workers.dispatcher.run_review_ephemeral",
+        lambda *_args, **_kwargs: {
+            "verdict": "has_issues",
+            "confidence": 0.7,
+            "summary": "runner error",
+            "findings": [],
+        },
+    )
+
+    class _FakeGiteaClient:
+        def __init__(self, _settings) -> None:
+            self.posted_comment_id = 0
+
+        def get_pull_request(self, _repo: str, _pr_number: int):
+            return SimpleNamespace(is_fork=False)
+
+        def edit_issue_comment(self, _repo: str, _comment_id: int, _body: str) -> int:
+            request = httpx.Request("PATCH", "https://gitea.test/api/v1/repos/acme/repo/issues/comments/289")
+            response = httpx.Response(404, request=request, text='{"message":"not found"}')
+            raise httpx.HTTPStatusError("not found", request=request, response=response)
+
+        def post_issue_comment(self, _repo: str, _pr_number: int, _body: str) -> int:
+            self.posted_comment_id = 990
+            return self.posted_comment_id
+
+    monkeypatch.setattr("gitea_codex_bot.workers.dispatcher.GiteaClient", _FakeGiteaClient)
+
+    settings = get_settings()
+    processed = process_one_job(settings)
+    assert processed is True
+
+    with session_factory() as session:
+        persisted_comment_id = get_persistent_review_comment_id(session, "acme/repo", 9)
+        assert persisted_comment_id == 990
+        stored_job = session.execute(select(ReviewJob).where(ReviewJob.id == job.id)).scalar_one()
+        assert stored_job.status.value == "succeeded"

tests/test_main_env_validation.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import pytest
+
+from gitea_codex_bot.config import get_settings
+from gitea_codex_bot.main import _validate_required_env
+
+
+def test_validate_required_env_requires_api_key_in_api_key_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENAI_API_KEY", "")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "api_key")
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    with pytest.raises(RuntimeError, match="OPENAI_API_KEY is required"):
+        _validate_required_env(settings)
+
+
+def test_validate_required_env_allows_missing_key_in_chatgpt_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENAI_API_KEY", "")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    _validate_required_env(settings)

tests/test_main_logging.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+
+from gitea_codex_bot.config import get_settings
+from gitea_codex_bot.main import _log_startup_auth_json_status, _log_startup_identity
+
+
+def test_log_startup_identity_includes_bot_username(caplog) -> None:
+    settings = get_settings()
+    caplog.set_level(logging.INFO, logger="gitea_codex_bot.main")
+
+    _log_startup_identity(settings)
+
+    assert "Bot startup identity:" in caplog.text
+    assert "username=codex-bot" in caplog.text
+
+
+def test_log_startup_auth_json_valid_when_configured(monkeypatch, tmp_path, caplog) -> None:
+    auth_file = tmp_path / "auth.json"
+    auth_file.write_text('{"auth_mode":"chatgpt"}', encoding="utf-8")
+    monkeypatch.setenv("CODEX_AUTH_MODE", "chatgpt")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", str(auth_file))
+    get_settings.cache_clear()
+    settings = get_settings()
+    caplog.set_level(logging.INFO, logger="gitea_codex_bot.main")
+
+    _log_startup_auth_json_status(settings)
+
+    assert "mode=chatgpt auth.json valid" in caplog.text
+    assert str(auth_file) in caplog.text

tests/test_review_format.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from gitea_codex_bot.services.review_format import format_result_comment
+
+
+def test_format_result_comment_uses_markdown_comment_verbatim_with_marker() -> None:
+    body = format_result_comment(
+        "abc1234",
+        {
+            "verdict": "correct",
+            "confidence": 0.9,
+            "summary": "ignored when markdown_comment exists",
+            "findings": [],
+            "markdown_comment": "## Codex Review\n\nAll good.\n\nNo issues found.",
+        },
+    )
+    assert body.startswith("<!-- codex-review:head_sha=abc1234 -->\n## Codex Review")
+    assert "All good.\n\nNo issues found." in body
+
+
+def test_format_result_comment_replaces_existing_marker() -> None:
+    body = format_result_comment(
+        "def5678",
+        {
+            "markdown_comment": "<!-- codex-review:head_sha=old -->\n## Codex Review\n\nText.",
+        },
+    )
+    assert body.startswith("<!-- codex-review:head_sha=def5678 -->")
+    assert "old" not in body.splitlines()[0]
+

tests/test_webhook.py

@@ -79,3 +79,57 @@ def test_webhook_accepts_review_and_queues(monkeypatch) -> None:
     assert response.status_code == 200
     assert response.json()["status"] == "queued"
     assert posted_comments
+
+
+def test_webhook_logs_when_no_codex_review_command(monkeypatch) -> None:
+    messages: list[str] = []
+
+    def _log_info(message: str, *args, **_kwargs) -> None:
+        messages.append(message % args if args else message)
+
+    monkeypatch.setattr("gitea_codex_bot.main.logger.info", _log_info)
+    client = TestClient(app)
+    payload_obj = _payload("hello world", username="alice", comment_id=222)
+    raw = json.dumps(payload_obj).encode()
+
+    response = client.post(
+        "/webhook/gitea",
+        content=raw,
+        headers={
+            "X-Gitea-Event": "issue_comment",
+            "X-Gitea-Delivery": "d-3",
+            "X-Gitea-Signature": _sign(raw),
+            "Content-Type": "application/json",
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["reason"] == "no codex command"
+    assert any("Webhook ignored: no @codex review command" in item for item in messages)
+
+
+def test_webhook_logs_when_codex_command_is_not_review(monkeypatch) -> None:
+    messages: list[str] = []
+
+    def _log_info(message: str, *args, **_kwargs) -> None:
+        messages.append(message % args if args else message)
+
+    monkeypatch.setattr("gitea_codex_bot.main.logger.info", _log_info)
+    client = TestClient(app)
+    payload_obj = _payload("@codex explain", username="alice", comment_id=223)
+    raw = json.dumps(payload_obj).encode()
+
+    response = client.post(
+        "/webhook/gitea",
+        content=raw,
+        headers={
+            "X-Gitea-Event": "issue_comment",
+            "X-Gitea-Delivery": "d-4",
+            "X-Gitea-Signature": _sign(raw),
+            "Content-Type": "application/json",
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["status"] == "queued"
+    assert any("Webhook without @codex review command" in item for item in messages)