# -*- coding: utf-8 -*- """Test for web.""" import json import unittest from typing import ClassVar, Dict, List import rdflib import rdflib.plugins.parsers.notation3 import yaml from fastapi import FastAPI from starlette.testclient import TestClient from bioregistry import Resource from bioregistry.app.api import MappingResponse, URIResponse from bioregistry.app.impl import get_app class TestWeb(unittest.TestCase): """Tests for the web application.""" fastapi: ClassVar[FastAPI] client: ClassVar[TestClient] @classmethod def setUpClass(cls) -> None: """Set up the test case with an app.""" cls.fastapi = get_app() cls.client = TestClient(cls.fastapi) def test_api_registry(self): """Test the registry endpoint.""" fail_endpoint = "/api/registry?format=FAIL" with self.subTest(endpoint=fail_endpoint): res = self.client.get(fail_endpoint) self.assertEqual(400, res.status_code) for endpoint, parse_func in [ ("/api/registry", self._parse_registry_json), ("/api/registry?format=json", self._parse_registry_json), ("/api/registry?format=yaml", self._parse_registry_yaml), # ("/api/registry?format=turtle", partial(self._parse_registry_rdf, format="turtle")), ]: with self.subTest(endpoint=endpoint): self._test_registry(endpoint, parse_func) def _test_registry(self, endpoint, parse_func): res = self.client.get(endpoint) self.assertEqual(200, res.status_code) self.assertIsInstance(res.text, str) registry = parse_func(res) self.assertIn("chebi", registry) self.assertEqual("CHEBI", registry["chebi"].get_preferred_prefix()) @staticmethod def _parse_registry_json(res) -> Dict[str, Resource]: data = res.json().items() return {key: Resource.parse_obj(resource) for key, resource in data} def _parse_registry_rdf(self, res, fmt: str) -> Dict[str, Resource]: graph = rdflib.Graph() try: graph.parse(data=res.text, format=fmt) except rdflib.plugins.parsers.notation3.BadSyntax: self.fail(f"Bad syntax for format {fmt}:\n\n{res.text}") sparql = """\ SELECT ?prefix ?description ?homepage ?uri_format ?example WHERE { ?resource a bioregistry.schema:0000001 ; dcterms:description ?description ; foaf:homepage ?homepage ; bioregistry.schema:0000029 ?prefix ; bioregistry.schema:0000006 ?uri_format ; bioregistry.schema:0000005 ?example ; } """ rv = {} for record in graph.query(sparql): prefix = record["prefix"]["value"] rv[prefix] = Resource( prefix=prefix, description=record["description"]["value"], homepage=record["homepage"]["value"], uri_format=record["uri_format"]["value"], example=record["example"]["value"], ) return rv @staticmethod def _parse_registry_yaml(res) -> Dict[str, Resource]: data = yaml.safe_load(res.text).items() return {key: Resource.parse_obj(resource) for key, resource in data} def test_api_resource(self): """Test the resource endpoint.""" res = self.client.get("/api/registry/3dmet?format=nope") self.assertEqual(400, res.status_code) self.assert_endpoint( "/api/registry/3dmet", ["yaml", "json"], ) # test something that's wrong gives a proper error with self.subTest(fmt=None): res = self.client.get("/api/registry/nope") self.assertEqual(404, res.status_code) def test_ui_resource_rdf(self): """Test the UI resource with content negotiation.""" prefix = "3dmet" for accept, fmt in [ ("text/turtle", "turtle"), ("text/n3", "n3"), ("application/ld+json", "jsonld"), ]: with self.subTest(format=fmt): res = self.client.get(f"/registry/{prefix}", headers={"Accept": accept}) self.assertEqual( 200, res.status_code, msg=f"Failed on {prefix} to accept {accept} ({fmt})" ) self.assertEqual(accept, res.request.headers.get("Accept", [])) if fmt == "jsonld": continue with self.assertRaises(ValueError, msg="result was return as JSON"): json.loads(res.text) g = rdflib.Graph() g.parse(data=res.text, format=fmt) # Check for single prefix results = list( g.query("SELECT ?s WHERE { ?s a }") ) self.assertEqual(1, len(results)) self.assertEqual(f"https://bioregistry.io/registry/{prefix}", str(results[0][0])) def test_api_metaregistry(self): """Test the metaregistry endpoint.""" self.assert_endpoint( "/api/metaregistry", ["json", "yaml"], ) def test_api_metaresource(self): """Test the metaresource endpoint.""" self.assert_endpoint( "/api/metaregistry/miriam", ["json", "yaml", "turtle", "jsonld"], ) def test_api_reference(self): """Test the reference endpoint.""" for value in [ "/api/reference/chebi:24867", "/api/reference/ctri:CTRI/2023/04/052053", # check paths are accepted ]: self.assert_endpoint( value, ["json", "yaml"], ) def test_api_collections(self): """Test the collections endpoint.""" self.assert_endpoint( "/api/collection", ["json", "yaml"], ) def test_api_collection(self): """Test the collection endpoint.""" self.assert_endpoint( "/api/collection/0000001", ["json", "yaml", "turtle", "jsonld"], ) res = self.client.get("/api/collection/0000001?format=context").json() self.assertIn("@context", res) self.assertIn("biostudies", res["@context"]) def test_api_contexts(self): """Test the contexts endpoint.""" self.assert_endpoint( "/api/context", ["json", "yaml"], ) def test_api_context(self): """Test the context endpoint.""" self.assert_endpoint( "/api/context/obo", ["json", "yaml"], ) def test_api_contributors(self): """Test the contributors endpoint.""" self.assert_endpoint( "/api/contributors", ["json", "yaml"], ) def test_api_contributor(self): """Test the contributor endpoint.""" self.assert_endpoint( "/api/contributor/0000-0003-4423-4370", ["json", "yaml"], ) def assert_endpoint(self, endpoint: str, formats: List[str]) -> None: """Test downloading the full registry as JSON.""" self.assertTrue(endpoint.startswith("/")) with self.subTest(fmt=None): res = self.client.get(endpoint) self.assertEqual(200, res.status_code) for fmt in formats: url = f"{endpoint}?format={fmt}" with self.subTest(fmt=fmt, endpoint=url): res = self.client.get(url) self.assertEqual(200, res.status_code, msg=f"\n\n{res.text}") def test_search(self): """Test search.""" res = self.client.get("/api/search?q=che") self.assertEqual(200, res.status_code, msg=f"\n\n{res.text}") def test_autocomplete(self): """Test search.""" for q in ["che", "chebi", "xxxxx", "chebi:123", "chebi:dd"]: with self.subTest(query=q): res = self.client.get(f"/api/autocomplete?q={q}") self.assertEqual(200, res.status_code) def test_external_registry_mappings(self): """Test external registry mappings.""" url = "/api/metaregistry/obofoundry/mapping/bioportal" res = self.client.get(url) res_parsed = MappingResponse.parse_obj(res.json()) self.assertEqual("obofoundry", res_parsed.meta.source) self.assertEqual("bioportal", res_parsed.meta.target) self.assertIn("gaz", res_parsed.mappings) self.assertEqual("GAZ", res_parsed.mappings["gaz"]) # This is an obsolete OBO Foundry ontology so it won't get uploaded to BioPortal self.assertIn("loggerhead", res_parsed.meta.source_only) # This is a non-ontology so it won't get in OBO Foundry self.assertIn("DCTERMS", res_parsed.meta.target_only) def test_iri_mapping(self): """Test IRI mappings. .. seealso:: https://github.com/biopragmatics/bioregistry/issues/1065 """ uri = "http://id.nlm.nih.gov/mesh/C063233" res = self.client.post("/api/uri/parse/", json={"uri": uri}) self.assertEqual(200, res.status_code) data = URIResponse.parse_obj(res.json()) self.assertEqual(uri, data.uri) self.assertIn("https://meshb.nlm.nih.gov/record/ui?ui=C063233", data.providers.values()) # Bad URI uri = "xxxx" res = self.client.post("/api/uri/parse/", json={"uri": uri}) self.assertEqual(404, res.status_code)