flaky-detector-cli 0.1.0__tar.gz

flaky_detector_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

flaky_detector_cli-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: flaky-detector-cli
+Version: 0.1.0
+Summary: Upload JUnit XML test reports to a flaky-detector project from the command line or CI.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://github.com/YOURNAME/flaky-detector
+Project-URL: Repository, https://github.com/YOURNAME/flaky-detector
+Keywords: testing,pytest,junit,ci,flaky-tests
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flaky-detector-cli
+
+A tiny, zero-dependency command-line tool that uploads a JUnit XML test
+report to a [flaky-detector](https://github.com/YOURNAME/flaky-detector)
+project — the same thing the project's GitHub Actions snippet does with
+`curl`, packaged as a real command.
+
+```bash
+pip install flaky-detector-cli
+```
+
+## Usage
+
+```bash
+pytest --junitxml=report.xml
+flaky-detector submit report.xml
+```
+
+By default it reads two environment variables — the same two names your
+flaky-detector project's CI snippet already uses:
+
+- `FLAKY_DETECTOR_URL` — your backend's base URL
+- `FLAKY_DETECTOR_TOKEN` — the project's upload token
+
+Everything else is auto-detected. In GitHub Actions, it reads `GITHUB_SHA`,
+`GITHUB_REF_NAME`, `GITHUB_RUN_ID`, and `GITHUB_RUN_ATTEMPT` automatically.
+Running locally, it falls back to your current `git` checkout for the
+commit and branch. You can override any of it explicitly:
+
+```bash
+flaky-detector submit report.xml \
+  --url https://your-backend.example.com \
+  --token YOUR_TOKEN \
+  --commit abc1234 \
+  --branch main \
+  --run-id 42 \
+  --run-attempt 1
+```
+
+## Why not `curl`?
+
+`curl` works fine and is what the project's own onboarding flow suggests
+first. This exists for people who'd rather not hand-build a multipart
+`curl` command in CI YAML, and for local use: run your suite, then
+`flaky-detector submit report.xml` to see the result on your dashboard
+without touching CI at all.
+
+## Exit codes
+
+- `0` — uploaded successfully
+- `1` — the server rejected the upload (bad token, malformed report, etc.);
+  stderr has the reason
+- `2` — a required argument is missing (no URL/token, and none could be
+  auto-detected)
+
+## Development
+
+```bash
+git clone https://github.com/YOURNAME/flaky-detector
+cd flaky-detector/cli
+pip install -e .
+```
+
+No dependencies to install for either running or developing this tool —
+only the Python standard library.

flaky_detector_cli-0.1.0/README.md

@@ -0,0 +1,65 @@
+# flaky-detector-cli
+
+A tiny, zero-dependency command-line tool that uploads a JUnit XML test
+report to a [flaky-detector](https://github.com/YOURNAME/flaky-detector)
+project — the same thing the project's GitHub Actions snippet does with
+`curl`, packaged as a real command.
+
+```bash
+pip install flaky-detector-cli
+```
+
+## Usage
+
+```bash
+pytest --junitxml=report.xml
+flaky-detector submit report.xml
+```
+
+By default it reads two environment variables — the same two names your
+flaky-detector project's CI snippet already uses:
+
+- `FLAKY_DETECTOR_URL` — your backend's base URL
+- `FLAKY_DETECTOR_TOKEN` — the project's upload token
+
+Everything else is auto-detected. In GitHub Actions, it reads `GITHUB_SHA`,
+`GITHUB_REF_NAME`, `GITHUB_RUN_ID`, and `GITHUB_RUN_ATTEMPT` automatically.
+Running locally, it falls back to your current `git` checkout for the
+commit and branch. You can override any of it explicitly:
+
+```bash
+flaky-detector submit report.xml \
+  --url https://your-backend.example.com \
+  --token YOUR_TOKEN \
+  --commit abc1234 \
+  --branch main \
+  --run-id 42 \
+  --run-attempt 1
+```
+
+## Why not `curl`?
+
+`curl` works fine and is what the project's own onboarding flow suggests
+first. This exists for people who'd rather not hand-build a multipart
+`curl` command in CI YAML, and for local use: run your suite, then
+`flaky-detector submit report.xml` to see the result on your dashboard
+without touching CI at all.
+
+## Exit codes
+
+- `0` — uploaded successfully
+- `1` — the server rejected the upload (bad token, malformed report, etc.);
+  stderr has the reason
+- `2` — a required argument is missing (no URL/token, and none could be
+  auto-detected)
+
+## Development
+
+```bash
+git clone https://github.com/YOURNAME/flaky-detector
+cd flaky-detector/cli
+pip install -e .
+```
+
+No dependencies to install for either running or developing this tool —
+only the Python standard library.

flaky_detector_cli-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flaky-detector-cli"
+version = "0.1.0"
+description = "Upload JUnit XML test reports to a flaky-detector project from the command line or CI."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Your Name" }]
+keywords = ["testing", "pytest", "junit", "ci", "flaky-tests"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Testing",
+]
+# Deliberately zero runtime dependencies: argparse, urllib, subprocess are
+# all standard library. Keeps `pip install` instant and avoids ever needing
+# a dependency-conflict fix for a tool this small.
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/YOURNAME/flaky-detector"
+Repository = "https://github.com/YOURNAME/flaky-detector"
+
+[project.scripts]
+flaky-detector = "flaky_detector_cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

flaky_detector_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flaky_detector_cli-0.1.0/src/flaky_detector_cli/__init__.py

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

flaky_detector_cli-0.1.0/src/flaky_detector_cli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flaky_detector_cli-0.1.0/src/flaky_detector_cli/cli.py

@@ -0,0 +1,201 @@
+"""
+flaky-detector-cli: a tiny, zero-dependency command that uploads a JUnit XML
+report to a flaky-detector project.
+
+    flaky-detector submit report.xml
+
+Reads FLAKY_DETECTOR_URL and FLAKY_DETECTOR_TOKEN from the environment by
+default (the same two names your GitHub Actions workflow secret/variable
+already use), or pass --url/--token explicitly. Everything else (commit sha,
+branch, run id/attempt) is auto-detected: from GitHub Actions' own env vars
+when running in CI, falling back to your local `git` checkout otherwise.
+
+No third-party dependencies: just the standard library.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import mimetypes
+import os
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+import uuid
+from pathlib import Path
+
+from . import __version__
+
+DEFAULT_TIMEOUT = 30
+
+
+def _git(*args: str) -> str | None:
+    try:
+        out = subprocess.run(
+            ["git", *args], capture_output=True, text=True, timeout=5, check=True
+        )
+        value = out.stdout.strip()
+        return value or None
+    except Exception:
+        return None
+
+
+def detect_commit_sha() -> str | None:
+    return os.environ.get("GITHUB_SHA") or _git("rev-parse", "HEAD")
+
+
+def detect_branch() -> str | None:
+    ref = os.environ.get("GITHUB_REF_NAME")
+    if ref:
+        return ref
+    branch = _git("rev-parse", "--abbrev-ref", "HEAD")
+    return None if branch == "HEAD" else branch  # "HEAD" means a detached checkout, not a real branch
+
+
+def detect_run_id() -> str:
+    return os.environ.get("GITHUB_RUN_ID") or f"local-{int(time.time())}"
+
+
+def detect_run_attempt() -> str:
+    return os.environ.get("GITHUB_RUN_ATTEMPT") or "1"
+
+
+def encode_multipart(fields: dict[str, str], file_field: str, file_path: Path) -> tuple[bytes, str]:
+    """Hand-rolled multipart/form-data body (stdlib only, no `requests`)."""
+    boundary = uuid.uuid4().hex
+    parts: list[bytes] = []
+
+    for name, value in fields.items():
+        parts.append(
+            f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"\r\n\r\n{value}\r\n'.encode()
+        )
+
+    content_type = mimetypes.guess_type(file_path.name)[0] or "application/xml"
+    parts.append(
+        (
+            f'--{boundary}\r\nContent-Disposition: form-data; name="{file_field}"; '
+            f'filename="{file_path.name}"\r\nContent-Type: {content_type}\r\n\r\n'
+        ).encode()
+        + file_path.read_bytes()
+        + b"\r\n"
+    )
+    parts.append(f"--{boundary}--\r\n".encode())
+
+    body = b"".join(parts)
+    return body, f"multipart/form-data; boundary={boundary}"
+
+
+class SubmitError(RuntimeError):
+    pass
+
+
+def submit_report(
+    *,
+    url: str,
+    token: str,
+    report_path: Path,
+    commit_sha: str,
+    branch: str,
+    run_id: str,
+    run_attempt: str,
+    job_name: str = "",
+) -> dict:
+    if not report_path.exists():
+        raise SubmitError(f"Report file not found: {report_path}")
+
+    fields = {
+        "run_id": run_id,
+        "run_attempt": run_attempt,
+        "job_name": job_name,
+        "commit_sha": commit_sha,
+        "branch": branch,
+    }
+    body, content_type = encode_multipart(fields, "report", report_path)
+
+    request = urllib.request.Request(
+        url.rstrip("/") + "/api/ingest/",
+        data=body,
+        method="POST",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": content_type,
+        },
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=DEFAULT_TIMEOUT) as resp:
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode(errors="replace")
+        raise SubmitError(f"Server rejected the upload ({exc.code}): {detail}") from exc
+    except urllib.error.URLError as exc:
+        raise SubmitError(f"Could not reach {url}: {exc.reason}") from exc
+    except OSError as exc:
+        raise SubmitError(f"Connection to {url} failed: {exc}") from exc
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="flaky-detector", description=__doc__.split("\n\n")[0])
+    parser.add_argument("--version", action="version", version=f"flaky-detector-cli {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    submit = sub.add_parser("submit", help="Upload a JUnit XML report")
+    submit.add_argument("report", type=Path, help="Path to the JUnit XML report, e.g. report.xml")
+    submit.add_argument("--url", default=os.environ.get("FLAKY_DETECTOR_URL"),
+                        help="Backend base URL (env: FLAKY_DETECTOR_URL)")
+    submit.add_argument("--token", default=os.environ.get("FLAKY_DETECTOR_TOKEN"),
+                        help="Project upload token (env: FLAKY_DETECTOR_TOKEN)")
+    submit.add_argument("--commit", default=None, help="Commit SHA (auto-detected if omitted)")
+    submit.add_argument("--branch", default=None, help="Branch name (auto-detected if omitted)")
+    submit.add_argument("--run-id", default=None, help="CI run id (auto-detected if omitted)")
+    submit.add_argument("--run-attempt", default=None, help="CI run attempt (auto-detected if omitted)")
+    submit.add_argument("--job-name", default="", help="Job name, for matrix builds")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    if args.command == "submit":
+        if not args.url:
+            print("error: no backend URL given (pass --url or set FLAKY_DETECTOR_URL)", file=sys.stderr)
+            return 2
+        if not args.token:
+            print("error: no token given (pass --token or set FLAKY_DETECTOR_TOKEN)", file=sys.stderr)
+            return 2
+
+        commit_sha = args.commit or detect_commit_sha()
+        branch = args.branch or detect_branch()
+        if not commit_sha:
+            print("error: could not determine commit SHA (pass --commit)", file=sys.stderr)
+            return 2
+        if not branch:
+            print("error: could not determine branch (pass --branch)", file=sys.stderr)
+            return 2
+
+        try:
+            result = submit_report(
+                url=args.url,
+                token=args.token,
+                report_path=args.report,
+                commit_sha=commit_sha,
+                branch=branch,
+                run_id=args.run_id or detect_run_id(),
+                run_attempt=args.run_attempt or detect_run_attempt(),
+                job_name=args.job_name,
+            )
+        except SubmitError as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+
+        verb = "Created" if result.get("created") else "Already recorded"
+        print(f"{verb} run {result.get('run')}: "
+              f"{result.get('tests_in_report', 0)} tests, {result.get('tests_scored', 0)} scored.")
+        return 0
+
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flaky_detector_cli-0.1.0/src/flaky_detector_cli.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: flaky-detector-cli
+Version: 0.1.0
+Summary: Upload JUnit XML test reports to a flaky-detector project from the command line or CI.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://github.com/YOURNAME/flaky-detector
+Project-URL: Repository, https://github.com/YOURNAME/flaky-detector
+Keywords: testing,pytest,junit,ci,flaky-tests
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flaky-detector-cli
+
+A tiny, zero-dependency command-line tool that uploads a JUnit XML test
+report to a [flaky-detector](https://github.com/YOURNAME/flaky-detector)
+project — the same thing the project's GitHub Actions snippet does with
+`curl`, packaged as a real command.
+
+```bash
+pip install flaky-detector-cli
+```
+
+## Usage
+
+```bash
+pytest --junitxml=report.xml
+flaky-detector submit report.xml
+```
+
+By default it reads two environment variables — the same two names your
+flaky-detector project's CI snippet already uses:
+
+- `FLAKY_DETECTOR_URL` — your backend's base URL
+- `FLAKY_DETECTOR_TOKEN` — the project's upload token
+
+Everything else is auto-detected. In GitHub Actions, it reads `GITHUB_SHA`,
+`GITHUB_REF_NAME`, `GITHUB_RUN_ID`, and `GITHUB_RUN_ATTEMPT` automatically.
+Running locally, it falls back to your current `git` checkout for the
+commit and branch. You can override any of it explicitly:
+
+```bash
+flaky-detector submit report.xml \
+  --url https://your-backend.example.com \
+  --token YOUR_TOKEN \
+  --commit abc1234 \
+  --branch main \
+  --run-id 42 \
+  --run-attempt 1
+```
+
+## Why not `curl`?
+
+`curl` works fine and is what the project's own onboarding flow suggests
+first. This exists for people who'd rather not hand-build a multipart
+`curl` command in CI YAML, and for local use: run your suite, then
+`flaky-detector submit report.xml` to see the result on your dashboard
+without touching CI at all.
+
+## Exit codes
+
+- `0` — uploaded successfully
+- `1` — the server rejected the upload (bad token, malformed report, etc.);
+  stderr has the reason
+- `2` — a required argument is missing (no URL/token, and none could be
+  auto-detected)
+
+## Development
+
+```bash
+git clone https://github.com/YOURNAME/flaky-detector
+cd flaky-detector/cli
+pip install -e .
+```
+
+No dependencies to install for either running or developing this tool —
+only the Python standard library.

flaky_detector_cli-0.1.0/src/flaky_detector_cli.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/flaky_detector_cli/__init__.py
+src/flaky_detector_cli/__main__.py
+src/flaky_detector_cli/cli.py
+src/flaky_detector_cli.egg-info/PKG-INFO
+src/flaky_detector_cli.egg-info/SOURCES.txt
+src/flaky_detector_cli.egg-info/dependency_links.txt
+src/flaky_detector_cli.egg-info/entry_points.txt
+src/flaky_detector_cli.egg-info/top_level.txt
+src/tests/test_cli.py

flaky_detector_cli-0.1.0/src/flaky_detector_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flaky_detector_cli-0.1.0/src/flaky_detector_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flaky-detector = flaky_detector_cli.cli:main

flaky_detector_cli-0.1.0/src/flaky_detector_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+flaky_detector_cli
+tests

flaky_detector_cli-0.1.0/src/tests/test_cli.py

@@ -0,0 +1,149 @@
+import io
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from flaky_detector_cli.cli import (
+    build_parser,
+    detect_branch,
+    detect_commit_sha,
+    detect_run_attempt,
+    detect_run_id,
+    encode_multipart,
+    main,
+    submit_report,
+)
+
+
+def test_encode_multipart_contains_all_fields_and_file_content(tmp_path=None):
+    tmp = Path(tempfile.mkdtemp())
+    report = tmp / "report.xml"
+    report.write_text("<testsuite></testsuite>")
+
+    body, content_type = encode_multipart(
+        {"run_id": "42", "branch": "main"}, "report", report
+    )
+    text = body.decode()
+
+    assert content_type.startswith("multipart/form-data; boundary=")
+    boundary = content_type.split("boundary=")[1]
+    assert text.count(f"--{boundary}") == 4  # 2 field parts + 1 file part + 1 closing boundary
+    assert text.strip().endswith(f"--{boundary}--")
+    assert 'name="run_id"' in text and "\r\n42\r\n" in text
+    assert 'name="branch"' in text and "\r\nmain\r\n" in text
+    assert 'name="report"; filename="report.xml"' in text
+    assert "<testsuite></testsuite>" in text
+
+
+def test_detect_commit_sha_prefers_github_env():
+    with patch.dict(os.environ, {"GITHUB_SHA": "deadbeef"}, clear=False):
+        assert detect_commit_sha() == "deadbeef"
+
+
+def test_detect_branch_prefers_github_env():
+    with patch.dict(os.environ, {"GITHUB_REF_NAME": "main"}, clear=False):
+        assert detect_branch() == "main"
+
+
+def test_detect_branch_falls_back_to_git_in_a_real_repo():
+    tmp = Path(tempfile.mkdtemp())
+    subprocess.run(["git", "init", "-q"], cwd=tmp, check=True)
+    subprocess.run(["git", "config", "user.email", "a@b.c"], cwd=tmp, check=True)
+    subprocess.run(["git", "config", "user.name", "a"], cwd=tmp, check=True)
+    (tmp / "f.txt").write_text("x")
+    subprocess.run(["git", "add", "."], cwd=tmp, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=tmp, check=True)
+
+    env = {k: v for k, v in os.environ.items() if k != "GITHUB_REF_NAME"}
+    cwd = os.getcwd()
+    try:
+        os.chdir(tmp)
+        with patch.dict(os.environ, env, clear=True):
+            branch = detect_branch()
+            sha = detect_commit_sha()
+    finally:
+        os.chdir(cwd)
+    assert branch in ("main", "master")  # depends on the machine's git default
+    assert sha is not None and len(sha) == 40
+
+
+def test_detect_run_id_falls_back_to_a_local_placeholder():
+    env = {k: v for k, v in os.environ.items() if k != "GITHUB_RUN_ID"}
+    with patch.dict(os.environ, env, clear=True):
+        assert detect_run_id().startswith("local-")
+
+
+def test_detect_run_attempt_defaults_to_one():
+    env = {k: v for k, v in os.environ.items() if k != "GITHUB_RUN_ATTEMPT"}
+    with patch.dict(os.environ, env, clear=True):
+        assert detect_run_attempt() == "1"
+
+
+def test_submit_report_raises_on_missing_file():
+    try:
+        submit_report(
+            url="https://x", token="t", report_path=Path("/no/such/file.xml"),
+            commit_sha="a", branch="main", run_id="1", run_attempt="1",
+        )
+        raise AssertionError("expected SubmitError")
+    except Exception as e:
+        assert "not found" in str(e)
+
+
+def test_build_parser_requires_a_subcommand():
+    parser = build_parser()
+    try:
+        parser.parse_args([])
+        raise AssertionError("expected SystemExit")
+    except SystemExit:
+        pass
+
+
+def test_main_errors_cleanly_with_no_token():
+    tmp = Path(tempfile.mkdtemp())
+    report = tmp / "r.xml"
+    report.write_text("<testsuite></testsuite>")
+    env = {k: v for k, v in os.environ.items() if k != "FLAKY_DETECTOR_TOKEN"}
+    err = io.StringIO()
+    with patch.dict(os.environ, env, clear=True), redirect_stderr(err):
+        code = main(["submit", str(report), "--url", "https://x"])
+    assert code == 2
+    assert "token" in err.getvalue()
+
+
+@patch("flaky_detector_cli.cli.urllib.request.urlopen")
+def test_main_success_path_prints_summary(mock_urlopen):
+    tmp = Path(tempfile.mkdtemp())
+    report = tmp / "r.xml"
+    report.write_text("<testsuite></testsuite>")
+
+    response = MagicMock()
+    response.read.return_value = json.dumps(
+        {"run": 7, "created": True, "tests_in_report": 3, "tests_scored": 3}
+    ).encode()
+    mock_urlopen.return_value.__enter__.return_value = response
+
+    out = io.StringIO()
+    with redirect_stdout(out):
+        code = main([
+            "submit", str(report),
+            "--url", "https://api.example.com",
+            "--token", "sekret",
+            "--commit", "a" * 40,
+            "--branch", "main",
+            "--run-id", "1",
+        ])
+    assert code == 0
+    assert "Created run 7" in out.getvalue()
+    assert "3 tests, 3 scored" in out.getvalue()
+
+    sent_request = mock_urlopen.call_args[0][0]
+    assert sent_request.full_url == "https://api.example.com/api/ingest/"
+    assert sent_request.get_header("Authorization") == "Bearer sekret"