"""Mirrors tests/search.rs. Spawns the real binary plus a local gn3 stub (HTTP server serving the recorded fixture), so gn3 needs no external network. /search now requires a bearer token (AuthToken), so the token-gated scenarios also need a live gn-auth and a token (see docs/gn-auth.md) and skip with a message rather than failing when either is missing, same as the other gated endpoint tests. auth_token() tries this server's own POST /get-test-token first (EXTRA_ENV below makes that possible), falling back to GN4_TEST_AUTH_TOKEN. """ import http.client import http.server import json import os import threading import unittest import urllib.parse from auth_helpers import TOKEN_ENV, auth_server_reachable, auth_token from server_test_case import HOST, PORT, ServerTestCase, wait_for_port FIXTURE = os.path.join( os.path.dirname(__file__), "..", "data", "search_alcohol_phenotype.json" ) class Gn3StubHandler(http.server.BaseHTTPRequestHandler): """Stands in for gn3's /api/search during tests.""" def do_GET(self): query = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query) if "boom" in query.get("query", [""])[0]: body = b'{"error": "gn3 exploded"}' self.send_response(http.client.INTERNAL_SERVER_ERROR) elif "&&" in query.get("query", [""])[0]: # Mirrors production gn3's shape: diagnostic under # "error", Python repr under "error_type". body = json.dumps( { "error": "Syntax: AND ", "error_type": "b'QueryParserError'", } ).encode() self.send_response(http.client.BAD_REQUEST) else: with open(FIXTURE, "rb") as fixture: body = fixture.read() self.send_response(http.client.OK) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def log_message(self, *args): pass class SearchTest(ServerTestCase): # Lets this test's own server answer POST /get-test-token so # auth_token() can self-issue one (see auth_helpers.TOKEN_ENV). EXTRA_ENV = TOKEN_ENV # The bearer token, fetched once by require_auth() and reused by # every token-gated request (one round trip, not one per call). token = None @classmethod def setUpClass(cls): cls.stub = http.server.ThreadingHTTPServer( (HOST, 0), Gn3StubHandler ) stub_port = cls.stub.server_address[1] threading.Thread(target=cls.stub.serve_forever, daemon=True).start() os.environ["GN3_URL"] = f"http://127.0.0.1:{stub_port}/api/" super().setUpClass() @classmethod def tearDownClass(cls): super().tearDownClass() cls.stub.shutdown() def require_auth(self): token = auth_token() if not token: self.skipTest("no token (see docs/gn-auth.md)") if not auth_server_reachable(): self.skipTest("no gn-auth reachable") # Stash it so get() reuses this one fetch instead of fetching # again (a failed second fetch would send "Bearer None"). type(self).token = token def get(self, uri, with_token=True): conn = http.client.HTTPConnection(HOST, int(PORT), timeout=10) try: headers = {"Authorization": f"Bearer {self.token}"} if with_token else {} conn.request("GET", uri, headers=headers) response = conn.getresponse() return response.status, json.loads(response.read()) finally: conn.close() def test_search_without_a_token_returns_401(self): # No gn-auth call happens for a missing header, so this needs # neither a token nor a live server. status, body = self.get("/search?q=alcohol", with_token=False) self.assertEqual(status, http.client.UNAUTHORIZED) self.assertEqual(body["code"], "invalid_token") def test_search_wraps_gn3_hits_in_envelope(self): self.require_auth() status, body = self.get("/search?q=alcohol&type=phenotype&limit=5") self.assertEqual(status, http.client.OK) hits = body["data"] self.assertEqual(len(hits), 5) self.assertEqual(hits[0]["name"], "10199") self.assertEqual(hits[0]["dataset"], "C57BL-6JxC57BL-6NJF2Publish") self.assertEqual(body["next"], []) def test_search_validates_parameters(self): self.require_auth() status, body = self.get("/search?q=%20%20") self.assertEqual(status, http.client.BAD_REQUEST) self.assertEqual(body["code"], "invalid_parameter") status, body = self.get("/search?q=alcohol&type=genotype") self.assertEqual(status, http.client.BAD_REQUEST) self.assertIn("phenotype", body["detail"]) def test_search_forwards_gn3_parse_errors(self): self.require_auth() status, body = self.get("/search?q=a%26%26b") self.assertEqual(status, http.client.UNPROCESSABLE_ENTITY) self.assertEqual(body["code"], "invalid_query") self.assertIn("Syntax: AND ", body["detail"]) def test_search_caps_limit(self): self.require_auth() status, _ = self.get("/search?q=alcohol&limit=9999") self.assertEqual(status, http.client.OK) def test_search_maps_gn3_failures_to_502(self): self.require_auth() status, body = self.get("/search?q=boom") self.assertEqual(status, http.client.BAD_GATEWAY) self.assertEqual(body["code"], "backend_error") if __name__ == "__main__": unittest.main()