Add unit tests and update lint config

26 tests covering inventory parsing, query validation, and
response conversion across all three DataFrame backends and
sample Parquet files. Removes placeholder test. Adds ANN401
ignore (Any returns are intentional) and ANN ignore for tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: deeenes

pyproject.toml

@@ -139,7 +139,9 @@ ignore = [
     "E303",  # Name: too-many-blank-lines
     "E501",  # Name: line too long
     "E731",  # Name: lambda-assignment
-    "E741"  # allow I, O, l as variable names -> I is the identity matrix
+    "E741",  # allow I, O, l as variable names -> I is the identity matrix
+    # flake8-annotations (ANN)
+    "ANN401",  # Any is needed for multi-backend DataFrame returns
 ]
 select = [
     "B",  # flake8-bugbear
@@ -185,7 +187,7 @@ section-order = [
 "*/__init__.py" = ["D104", "F401"]
 "docs/*" = ["I"]
 "docs/src/conf.py" = ["D100"]
-"tests/*" = ["D"]
+"tests/*" = ["D", "ANN"]
 "tests/conftest.py" = ["D101", "D102", "D103", "E402"]
 
 [tool.ruff.lint.pydocstyle]

tests/conftest.py

@@ -0,0 +1,37 @@
+"""
+Shared test fixtures for omnipath-client tests.
+"""
+
+from pathlib import Path
+
+import pytest
+
+
+SAMPLES_DIR = Path(__file__).parent.parent / 'parquet-samples'
+
+
+@pytest.fixture
+def entities_parquet():
+    """
+    Path to the sample entities Parquet file.
+    """
+
+    return SAMPLES_DIR / 'search_entities.parquet'
+
+
+@pytest.fixture
+def interactions_parquet():
+    """
+    Path to the sample interactions Parquet file.
+    """
+
+    return SAMPLES_DIR / 'search_interactions.parquet'
+
+
+@pytest.fixture
+def associations_parquet():
+    """
+    Path to the sample associations Parquet file.
+    """
+
+    return SAMPLES_DIR / 'search_associations.parquet'

tests/test_inventory.py

@@ -0,0 +1,161 @@
+"""
+Tests for API inventory loading and parsing.
+"""
+
+import json
+from pathlib import Path
+
+from omnipath_client._endpoints import ParamDef, EndpointDef
+from omnipath_client._inventory import (
+    Inventory,
+    parse_openapi,
+    _build_static_fallback,
+)
+
+
+OPENAPI_PATH = Path(__file__).parent.parent / 'planning' / 'openapi.json'
+
+
+class TestStaticFallback:
+    """
+    Tests for the static fallback inventory.
+    """
+
+    def test_builds_endpoints(self):
+
+        endpoints = _build_static_fallback()
+
+        assert len(endpoints) > 0
+        assert 'exports/entities/parquet' in endpoints
+        assert 'exports/interactions/parquet' in endpoints
+        assert 'exports/associations/parquet' in endpoints
+
+    def test_entity_filters(self):
+
+        endpoints = _build_static_fallback()
+        ep = endpoints['exports/entities/parquet']
+
+        assert isinstance(ep, EndpointDef)
+        assert ep.method == 'POST'
+        assert ep.response_format == 'parquet'
+        assert 'taxonomy_ids' in ep.params
+        assert 'entity_types' in ep.params
+
+    def test_interaction_filters(self):
+
+        endpoints = _build_static_fallback()
+        ep = endpoints['exports/interactions/parquet']
+
+        assert 'direction' in ep.params
+        pdef = ep.params['direction']
+        assert pdef.allowed_values == [
+            'any',
+            'directed',
+            'undirected',
+        ]
+
+
+class TestParseOpenapi:
+    """
+    Tests for OpenAPI spec parsing.
+    """
+
+    def test_parse_local_spec(self):
+
+        if not OPENAPI_PATH.exists():
+            return
+
+        with open(OPENAPI_PATH) as f:
+            spec = json.load(f)
+
+        endpoints = parse_openapi(spec)
+
+        assert len(endpoints) > 0
+        assert 'exports/entities/parquet' in endpoints
+        assert 'exports/interactions/parquet' in endpoints
+        assert 'exports/associations/parquet' in endpoints
+
+    def test_export_endpoints_have_filters(self):
+
+        if not OPENAPI_PATH.exists():
+            return
+
+        with open(OPENAPI_PATH) as f:
+            spec = json.load(f)
+
+        endpoints = parse_openapi(spec)
+        ep = endpoints['exports/interactions/parquet']
+
+        assert ep.method == 'POST'
+        assert ep.response_format == 'parquet'
+        assert 'entity_ids' in ep.params
+        assert 'direction' in ep.params
+
+        direction = ep.params['direction']
+        assert direction.allowed_values == [
+            'any',
+            'directed',
+            'undirected',
+        ]
+
+    def test_ontology_endpoints(self):
+
+        if not OPENAPI_PATH.exists():
+            return
+
+        with open(OPENAPI_PATH) as f:
+            spec = json.load(f)
+
+        endpoints = parse_openapi(spec)
+
+        assert 'terms' in endpoints
+        assert 'tree' in endpoints
+        assert 'ontologies' in endpoints
+
+
+class TestInventory:
+    """
+    Tests for the Inventory class.
+    """
+
+    def test_fallback_on_bad_url(self):
+
+        inv = Inventory(base_url='http://localhost:99999')
+        inv.load()
+
+        assert len(inv.endpoints) > 0
+        assert 'exports/entities/parquet' in inv.endpoints
+
+    def test_params_method(self):
+
+        inv = Inventory(base_url='http://localhost:99999')
+        inv.load()
+
+        params = inv.params('exports/interactions/parquet')
+
+        assert 'entity_ids' in params
+        assert isinstance(params['entity_ids'], ParamDef)
+
+    def test_allowed_values_method(self):
+
+        inv = Inventory(base_url='http://localhost:99999')
+        inv.load()
+
+        values = inv.allowed_values(
+            'exports/interactions/parquet',
+            'direction',
+        )
+
+        assert values == ['any', 'directed', 'undirected']
+
+    def test_allowed_values_unconstrained(self):
+
+        inv = Inventory(base_url='http://localhost:99999')
+        inv.load()
+
+        values = inv.allowed_values(
+            'exports/entities/parquet',
+            'taxonomy_ids',
+        )
+
+        assert values is None

tests/test_placeholder.py

@@ -0,0 +1,117 @@
+"""
+Tests for query building and validation.
+"""
+
+import pytest
+
+from omnipath_client._query import QueryBuilder
+from omnipath_client._errors import (
+    UnknownEndpointError,
+    UnknownParameterError,
+    InvalidParameterValueError,
+)
+from omnipath_client._inventory import Inventory
+
+
+@pytest.fixture
+def query_builder():
+    """
+    A QueryBuilder with static fallback inventory.
+    """
+
+    inv = Inventory(base_url='http://localhost:99999')
+    inv.load()
+    return QueryBuilder(inv)
+
+
+class TestQueryBuilder:
+    """
+    Tests for QueryBuilder.build().
+    """
+
+    def test_valid_entity_query(self, query_builder):
+
+        query = query_builder.build(
+            'exports/entities/parquet',
+            taxonomy_ids=['9606'],
+        )
+
+        assert query.endpoint.path == '/exports/entities/parquet'
+        assert query.params == {'taxonomy_ids': ['9606']}
+
+    def test_valid_interaction_query(self, query_builder):
+
+        query = query_builder.build(
+            'exports/interactions/parquet',
+            entity_ids=['Q9Y6K9'],
+            direction='directed',
+        )
+
+        assert query.params['entity_ids'] == ['Q9Y6K9']
+        assert query.params['direction'] == 'directed'
+
+    def test_unknown_endpoint(self, query_builder):
+
+        with pytest.raises(UnknownEndpointError):
+            query_builder.build('nonexistent/endpoint')
+
+    def test_unknown_parameter(self, query_builder):
+
+        with pytest.raises(UnknownParameterError):
+            query_builder.build(
+                'exports/entities/parquet',
+                bogus_param='value',
+            )
+
+    def test_invalid_enum_value(self, query_builder):
+
+        with pytest.raises(InvalidParameterValueError):
+            query_builder.build(
+                'exports/interactions/parquet',
+                direction='sideways',
+            )
+
+    def test_valid_enum_value(self, query_builder):
+
+        query = query_builder.build(
+            'exports/interactions/parquet',
+            sign='positive',
+        )
+
+        assert query.params['sign'] == 'positive'
+
+    def test_none_values_skipped(self, query_builder):
+
+        query = query_builder.build(
+            'exports/entities/parquet',
+            taxonomy_ids=['9606'],
+            entity_types=None,
+        )
+
+        assert 'entity_types' not in query.params
+
+
+class TestQueryJsonBody:
+    """
+    Tests for Query.json_body construction.
+    """
+
+    def test_filters_nested(self, query_builder):
+
+        query = query_builder.build(
+            'exports/entities/parquet',
+            taxonomy_ids=['9606'],
+            entity_types=['protein'],
+        )
+
+        body = query.json_body
+
+        assert 'filters' in body
+        assert body['filters']['taxonomy_ids'] == ['9606']
+        assert body['filters']['entity_types'] == ['protein']
+
+    def test_get_endpoint_no_body(self, query_builder):
+
+        query = query_builder.build('health')
+
+        assert query.json_body is None