ci(api): codecarbon test ci pushes emissions to api (#1123)

* ci(api): codecarbon test ci pushes emissions to api

* trigger it

* fix: secrets access

* fix: cli uses hierarchical config as emissions tracker

* tests: add cli tests

Author: inimaz

.github/workflows/test-package.yml

@@ -9,12 +9,16 @@ on:
       - "tests/**"
       - "pyproject.toml"
       - "uv.lock"
+      - ".github/workflows/test-package.yml"
   push:
     branches: [master]
 
 jobs:
   python-test:
     runs-on: ubuntu-24.04
+    env:
+      CODECARBON_API_KEY: ${{ secrets.CODECARBON_API_TOKEN }}
+      CODECARBON_EXPERIMENT_ID: ${{ secrets.CODECARBON_EXPERIMENT_ID_TEST_PACKAGE }}
     strategy:
         matrix:
           python-version: ["3.12", "3.13", "3.14"]
@@ -29,7 +33,7 @@ jobs:
     - name: Install dependencies
       run: uv sync --python ${{ matrix.python-version }}
     - name: Test package
-      run: uv run --python ${{ matrix.python-version }} task test-coverage
+      run: uv run --python ${{ matrix.python-version }} codecarbon monitor -- uv run --python ${{ matrix.python-version }} task test-coverage
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5
       with:

codecarbon/cli/cli_utils.py

@@ -5,6 +5,8 @@
 import typer
 from rich.prompt import Confirm
 
+from codecarbon.core.config import get_hierarchical_config
+
 
 def get_config(path: Optional[Path] = None):
     p = path or Path.cwd().resolve() / ".codecarbon.config"
@@ -37,22 +39,16 @@ def get_api_endpoint(path: Optional[Path] = None):
     return "https://api.codecarbon.io"
 
 
-def get_existing_local_exp_id(path: Optional[Path] = None):
-    p = path or Path.cwd().resolve() / ".codecarbon.config"
-    if p.exists():
-        existing_path = p
-    else:
-        existing_path = Path("~/.codecarbon.config").expanduser()
-    return _get_local_exp_id(existing_path)
-
-
-def _get_local_exp_id(p: Optional[Path] = None):
-    config = configparser.ConfigParser()
-    config.read(str(p))
-    if "codecarbon" in config.sections():
-        d = dict(config["codecarbon"])
-        if "experiment_id" in d:
-            return d["experiment_id"]
+def get_existing_exp_id() -> Optional[str]:
+    """
+    Return experiment_id resolved from the same hierarchical config strategy
+    used by EmissionsTracker (global file, local file, then CODECARBON_* env).
+    """
+    try:
+        conf = get_hierarchical_config()
+    except KeyError:
+        return None
+    return conf.get("experiment_id")
 
 
 def write_local_exp_id(exp_id, path: Optional[Path] = None):

codecarbon/cli/main.py

@@ -18,7 +18,7 @@
     create_new_config_file,
     get_api_endpoint,
     get_config,
-    get_existing_local_exp_id,
+    get_existing_exp_id,
     overwrite_local_config,
 )
 from codecarbon.cli.monitor import run_and_monitor
@@ -356,10 +356,10 @@ def monitor(
             "region": region,
         }
     else:
-        experiment_id = get_existing_local_exp_id()
+        experiment_id = get_existing_exp_id()
         if api and experiment_id is None:
             print(
-                "ERROR: No experiment id, call 'codecarbon config' first. Or run in offline mode with `--offline --country-iso-code FRA` flag if you don't want to connect to the API.",
+                "ERROR: No experiment id. Set CODECARBON_EXPERIMENT_ID, call 'codecarbon config' first, or run in offline mode with `--offline --country-iso-code FRA`.",
                 file=sys.stderr,
             )
             raise typer.Exit(1)

tests/cli/test_cli_main.py

@@ -1,5 +1,8 @@
 """Tests for the CodeCarbon CLI main function."""
 
+from types import SimpleNamespace
+
+import pytest
 from typer.testing import CliRunner
 
 from codecarbon.cli import main as cli_main
@@ -112,3 +115,183 @@ def fake_get_access_token():
     captured = capsys.readouterr()
     assert "Could not validate remote configuration details" in captured.out
     assert "Not able to retrieve the access token" in captured.out
+
+
+def test_main_exits_with_error_when_command_raises(monkeypatch, capsys):
+    def fake_cli():
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(cli_main, "codecarbon", fake_cli)
+
+    with pytest.raises(SystemExit) as exc_info:
+        cli_main.main()
+
+    captured = capsys.readouterr()
+    assert exc_info.value.code == 1
+    assert "Error:" in captured.out
+    assert "boom" in captured.out
+
+
+def test_login_calls_authorize_and_auth_check(monkeypatch):
+    calls = {"authorize": 0, "set_token": None, "check_auth": 0}
+
+    class FakeApiClient:
+        def __init__(self, endpoint_url=None):
+            self.endpoint_url = endpoint_url
+
+        def set_access_token(self, token):
+            calls["set_token"] = token
+
+        def check_auth(self):
+            calls["check_auth"] += 1
+
+    monkeypatch.setattr(cli_main, "ApiClient", FakeApiClient)
+    monkeypatch.setattr(
+        cli_main,
+        "authorize",
+        lambda: calls.__setitem__("authorize", calls["authorize"] + 1),
+    )
+    monkeypatch.setattr(cli_main, "get_access_token", lambda: "login-token")
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main.codecarbon, ["login"])
+    assert result.exit_code == 0
+    assert calls["authorize"] == 1
+    assert calls["set_token"] == "login-token"
+    assert calls["check_auth"] == 1
+
+
+def test_get_api_key_uses_bearer_token(monkeypatch):
+    captured = {}
+
+    class FakeResponse:
+        def json(self):
+            return {"token": "project-api-token"}
+
+    def fake_post(url, json, headers):
+        captured["url"] = url
+        captured["json"] = json
+        captured["headers"] = headers
+        return FakeResponse()
+
+    monkeypatch.setattr(cli_main, "get_access_token", lambda: "access-token")
+    monkeypatch.setattr(cli_main.requests, "post", fake_post)
+
+    token = cli_main.get_api_key("proj-123")
+    assert token == "project-api-token"
+    assert captured["url"].endswith("/projects/proj-123/api-tokens")
+    assert captured["json"]["project_id"] == "proj-123"
+    assert captured["headers"]["Authorization"] == "Bearer access-token"
+
+
+def test_get_token_command_prints_token(monkeypatch):
+    monkeypatch.setattr(cli_main, "get_api_key", lambda project_id: "abc123")
+    runner = CliRunner()
+    result = runner.invoke(cli_main.codecarbon, ["get-token", "proj-id"])
+    assert result.exit_code == 0
+    assert "Your token: abc123" in result.output
+
+
+def test_show_config_prints_missing_project_and_experiment(
+    monkeypatch, tmp_path, capsys
+):
+    class FakeApiClient:
+        def __init__(self, endpoint_url=None):
+            self.endpoint_url = endpoint_url
+
+        def set_access_token(self, token):
+            self.token = token
+
+        def get_organization(self, organization_id):
+            return {"id": organization_id}
+
+        def get_project(self, project_id):
+            return {"id": project_id}
+
+        def get_experiment(self, experiment_id):
+            return {"id": experiment_id}
+
+    monkeypatch.setattr(cli_main, "ApiClient", FakeApiClient)
+    monkeypatch.setattr(cli_main, "get_access_token", lambda: "fake-token")
+    monkeypatch.setattr(
+        cli_main, "get_api_endpoint", lambda path: "https://api.codecarbon.io"
+    )
+
+    monkeypatch.setattr(
+        cli_main,
+        "get_config",
+        lambda path: {
+            "api_endpoint": "https://api.codecarbon.io",
+            "organization_id": "org-id",
+        },
+    )
+    cli_main.show_config(tmp_path / ".codecarbon.config")
+    captured = capsys.readouterr()
+    assert "No project_id in config" in captured.out
+
+    monkeypatch.setattr(
+        cli_main,
+        "get_config",
+        lambda path: {
+            "api_endpoint": "https://api.codecarbon.io",
+            "organization_id": "org-id",
+            "project_id": "project-id",
+        },
+    )
+    cli_main.show_config(tmp_path / ".codecarbon.config")
+    captured = capsys.readouterr()
+    assert "No experiment_id in config" in captured.out
+
+
+def test_monitor_online_requires_experiment_id(monkeypatch):
+    monkeypatch.setattr(cli_main, "get_existing_exp_id", lambda: None)
+    runner = CliRunner()
+    result = runner.invoke(cli_main.codecarbon, ["monitor"])
+    assert result.exit_code == 1
+    assert "No experiment id" in result.output
+
+
+def test_monitor_offline_initializes_offline_tracker(monkeypatch):
+    calls = {"kwargs": None, "started": 0}
+
+    class FakeOfflineTracker:
+        def __init__(self, **kwargs):
+            calls["kwargs"] = kwargs
+            self._another_instance_already_running = True
+
+        def start(self):
+            calls["started"] += 1
+
+        def stop(self):
+            return None
+
+    monkeypatch.setattr(cli_main, "OfflineEmissionsTracker", FakeOfflineTracker)
+    monkeypatch.setattr(cli_main.signal, "signal", lambda *args, **kwargs: None)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main.codecarbon,
+        ["monitor", "--offline", "--country-iso-code", "FRA", "--region", "IDF"],
+    )
+    assert result.exit_code == 0
+    assert calls["started"] == 1
+    assert calls["kwargs"]["country_iso_code"] == "FRA"
+    assert calls["kwargs"]["region"] == "IDF"
+
+
+def test_monitor_delegates_to_run_and_monitor_with_extra_args(monkeypatch):
+    captured = {}
+
+    def fake_run_and_monitor(ctx, **kwargs):
+        captured["args"] = list(ctx.args)
+        captured["kwargs"] = kwargs
+        return "ok"
+
+    monkeypatch.setattr(cli_main, "run_and_monitor", fake_run_and_monitor)
+    monkeypatch.setattr(cli_main, "get_existing_exp_id", lambda: "exp-1")
+
+    ctx = SimpleNamespace(args=["python", "train.py"])
+    result = cli_main.monitor(ctx=ctx, api=False)
+    assert result == "ok"
+    assert captured["args"] == ["python", "train.py"]
+    assert captured["kwargs"]["save_to_api"] is False

tests/test_config.py

@@ -17,6 +17,23 @@
 
 
 class TestConfig(unittest.TestCase):
+    def setUp(self):
+        self._original_environ = os.environ.copy()
+        for key in [
+            "CODECARBON_API_KEY",
+            "CODECARBON_EXPERIMENT_ID",
+            "CODECARBON_API_ENDPOINT",
+            "codecarbon_api_key",
+            "codecarbon_experiment_id",
+            "codecarbon_api_endpoint",
+        ]:
+            os.environ.pop(key, None)
+        os.environ.setdefault("CODECARBON_ALLOW_MULTIPLE_RUNS", "True")
+
+    def tearDown(self):
+        os.environ.clear()
+        os.environ.update(self._original_environ)
+
     def test_clean_env_key(self):
         for key in [1, None, 0.2, [], set()]:
             with self.assertRaises(AssertionError):