From 649ff6395bdca06530ceabd3e216c66851dc60d6 Mon Sep 17 00:00:00 2001 From: Pjotr Prins Date: Mon, 5 Oct 2026 07:34:26 +0000 Subject: Rename /dev/token to /get-test-token; require a token everywhere Rename: POST /dev/token -> POST /get-test-token (src/routes/dev.rs, TestToken replacing DevToken), matching tests/get_test_token.rs and test/python/test_get_test_token.py (renamed from tests/dev_token.rs/test_dev_token.py). Config::dev_token_enabled() and the GN_AUTH_DEV_* config keys keep their names -- they're about the dev-token feature generically, not tied to this one route's path. Every endpoint now requires a valid token, not just the dataset_probeset*/traits* family: species(_by_name/_datasets), groups(_by_name/_strains/_traits*/_datasets) and dataset_by_name all gain an AuthToken parameter. /, /version, /openapi.json and /get-test-token itself are the only exceptions -- a health check, a version check, the spec describing all this, and the endpoint that hands out a token in the first place (which would be circular if it needed one). Rather than repeating security(("bearer_token" = [])) on every #[utoipa::path], ApiDoc now declares it once as the document's default security(...), and the three exceptions besides /get-test-token (/, /version) override it with their own empty security() -- standard OpenAPI semantics (an operation's own security, even empty, overrides the document default; an absent one inherits it). error::Unauthorized, a new #[derive(utoipa::IntoResponses)] type wrapping ApiError, is the shared 401 every gated handler now references bare in its own responses(...) list instead of writing out the same (status = 401, description = "...", body = ApiError) tuple by hand. Verified the resolved security per operation in a live /openapi.json. tests/common::auth_token() (Rust) and the new test/python/auth_helpers.auth_token() (Python, deduplicating what four files previously each defined locally) now try this server's own POST /get-test-token first, falling back to GN4_TEST_AUTH_TOKEN -- every previously-ungated test file gains a token check and switches to get_with_token; the whole suite, both languages, now runs with zero manually-provisioned tokens given GENENETWORK4_DEV_MODE=true GENENETWORK4_BIND=127.0.0.1 for the test run. ServerTestCase gains EXTRA_ENV so each Python test class can start its own server with dev mode on. Verified both configured (auto-fetch) and unconfigured (GN4_TEST_AUTH_TOKEN fallback, and full skip when neither is set, e.g. the Guix build sandbox) paths. README.md, docs/gn-auth.md and RELEASE_NOTES.md updated throughout for the rename and the new blanket token requirement. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01XDDpXvZBQat9uSgDeEMJ8d --- test/python/test_get_test_token.py | 105 +++++++++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 test/python/test_get_test_token.py (limited to 'test/python/test_get_test_token.py') diff --git a/test/python/test_get_test_token.py b/test/python/test_get_test_token.py new file mode 100644 index 0000000..2426ebd --- /dev/null +++ b/test/python/test_get_test_token.py @@ -0,0 +1,105 @@ +"""Mirrors tests/get_test_token.rs. POST /get-test-token only exists +when GENENETWORK4_DEV_MODE is on and GENENETWORK4_BIND resolves to +loopback (see Config::dev_token_enabled, src/routes/dev.rs). Each test +class below spawns its own server subprocess with its own environment +(ServerTestCase.EXTRA_ENV), so -- unlike the Rust test, which has to +keep its env mutations in one sequential test function -- these can be +separate test classes safely. +""" + +import http.client +import json +import os +import unittest +from urllib.parse import urlparse + +from server_test_case import HOST, PORT, ServerTestCase + +AUTH_SERVER_URL = os.environ.get("AUTH_SERVER_URL", "http://127.0.0.1:8081/") + + +def auth_server_reachable(): + url = urlparse(AUTH_SERVER_URL) + conn = http.client.HTTPConnection(url.hostname, url.port or 80, timeout=2) + try: + conn.request("GET", url.path.rstrip("/") + "/auth/public-jwks") + return conn.getresponse().status == 200 + except OSError: + return False + finally: + conn.close() + + +def post_test_token(): + conn = http.client.HTTPConnection(HOST, int(PORT), timeout=10) + try: + conn.request("POST", "/get-test-token") + response = conn.getresponse() + return response, response.read() + finally: + conn.close() + + +class GetTestTokenDisabledByDefaultTest(ServerTestCase): + """No EXTRA_ENV -- the out-of-the-box default (dev_mode off).""" + + def test_get_test_token_returns_404_by_default(self): + response, _body = post_test_token() + self.assertEqual(response.status, 404) + + def test_get_test_token_not_in_openapi_json_by_default(self): + # /openapi.json itself is one of the few endpoints that stays + # ungated (see lib.rs) -- no token needed here. + conn = http.client.HTTPConnection(HOST, int(PORT), timeout=10) + try: + conn.request("GET", "/openapi.json") + body = conn.getresponse().read() + finally: + conn.close() + spec = json.loads(body) + self.assertNotIn("/get-test-token", spec["paths"]) + + +class GetTestTokenDevModeButWrongBindTest(ServerTestCase): + """dev_mode on, but not bound to loopback: still disabled.""" + + EXTRA_ENV = {"GENENETWORK4_DEV_MODE": "true", "GENENETWORK4_BIND": "0.0.0.0"} + + def test_get_test_token_returns_404(self): + response, _body = post_test_token() + self.assertEqual(response.status, 404) + + +class GetTestTokenEnabledTest(ServerTestCase): + """Both set: this is the only configuration where it works.""" + + EXTRA_ENV = {"GENENETWORK4_DEV_MODE": "true", "GENENETWORK4_BIND": "127.0.0.1"} + + def test_get_test_token_returns_a_usable_token(self): + if not auth_server_reachable(): + self.skipTest(f"no gn-auth reachable at {AUTH_SERVER_URL}") + + response, body = post_test_token() + self.assertEqual(response.status, 200) + + token = json.loads(body) + self.assertTrue(token["access_token"]) + self.assertEqual(token["token_type"], "Bearer") + + # Exercise the issued token against a real gated endpoint -- it + # should be genuinely usable, not just a well-formed response. + conn = http.client.HTTPConnection(HOST, int(PORT), timeout=10) + try: + conn.request( + "GET", + "/traits/BXD/10001", + headers={"Authorization": f"Bearer {token['access_token']}"}, + ) + response = conn.getresponse() + finally: + conn.close() + self.assertEqual(response.status, 200) + + +if __name__ == "__main__": + unittest.main() -- cgit 1.4.1