expand test coverage

Author: purificant

src/tests/unit/client/test_raw_client.py

@@ -1,4 +1,30 @@
+from collections.abc import AsyncGenerator
+
+import httpx
+import pytest
+import respx
+
+from bubble_data_api_client import configure
 from bubble_data_api_client.client import raw_client
+from bubble_data_api_client.pool import close_clients
+
+
+@pytest.fixture
+async def clean_client_pool() -> AsyncGenerator[None]:
+    """Ensure client pool is clean before and after each test."""
+    await close_clients()
+    yield
+    await close_clients()
+
+
+@pytest.fixture
+def configured_client(clean_client_pool: None) -> None:
+    """Configure the client for testing."""
+    configure(
+        data_api_root_url="https://test.example.com",
+        api_key="test-key",
+        retry=None,
+    )
 
 
 async def test_raw_client_init() -> None:
@@ -14,3 +40,159 @@ async def test_raw_client_init() -> None:
     # test creating with async context manager
     async with raw_client.RawClient() as client_instance:
         assert isinstance(client_instance, raw_client.RawClient)
+
+
+@respx.mock
+async def test_replace(configured_client: None) -> None:
+    """Test that replace uses PUT to fully replace a thing."""
+    route = respx.put("https://test.example.com/customer/123x456").mock(return_value=httpx.Response(204))
+
+    async with raw_client.RawClient() as client:
+        response = await client.replace(
+            typename="customer",
+            uid="123x456",
+            data={"name": "New Name", "email": "new@example.com"},
+        )
+
+    assert response.status_code == 204
+    assert route.call_count == 1
+
+
+@respx.mock
+async def test_bulk_create(configured_client: None) -> None:
+    """Test that bulk_create posts newline-delimited JSON."""
+    route = respx.post("https://test.example.com/customer/bulk").mock(
+        return_value=httpx.Response(200, json={"status": "success", "count": 2})
+    )
+
+    async with raw_client.RawClient() as client:
+        response = await client.bulk_create(
+            typename="customer",
+            data=[{"name": "Alice"}, {"name": "Bob"}],
+        )
+
+    assert response.status_code == 200
+    assert route.call_count == 1
+    # verify it sent newline-delimited JSON
+    request_content = route.calls[0].request.content.decode()
+    assert request_content == '{"name": "Alice"}\n{"name": "Bob"}'
+
+
+@respx.mock
+async def test_find_with_parameters(configured_client: None) -> None:
+    """Test that find passes optional parameters correctly."""
+    route = respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [], "count": 0, "remaining": 0}})
+    )
+
+    async with raw_client.RawClient() as client:
+        await client.find(
+            typename="customer",
+            cursor=10,
+            limit=50,
+            sort_field="name",
+            descending=True,
+            exclude_remaining=True,
+        )
+
+    assert route.call_count == 1
+    request = route.calls[0].request
+    assert "cursor=10" in str(request.url)
+    assert "limit=50" in str(request.url)
+    assert "sort_field=name" in str(request.url)
+    assert "descending=true" in str(request.url)
+    assert "exclude_remaining=true" in str(request.url)
+
+
+@respx.mock
+async def test_find_with_additional_sort_fields(configured_client: None) -> None:
+    """Test that find passes additional_sort_fields correctly."""
+    route = respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [], "count": 0, "remaining": 0}})
+    )
+
+    async with raw_client.RawClient() as client:
+        await client.find(
+            typename="customer",
+            additional_sort_fields=[{"sort_field": "age", "descending": False}],
+        )
+
+    assert route.call_count == 1
+    request = route.calls[0].request
+    assert "additional_sort_fields" in str(request.url)
+
+
+@respx.mock
+async def test_count(configured_client: None) -> None:
+    """Test that count returns total from count + remaining."""
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [], "count": 5, "remaining": 95}})
+    )
+
+    async with raw_client.RawClient() as client:
+        total = await client.count(typename="customer")
+
+    assert total == 100
+
+
+@respx.mock
+async def test_exists_by_uid_found(configured_client: None) -> None:
+    """Test exists returns True when record found by uid."""
+    respx.get("https://test.example.com/customer/123x456").mock(
+        return_value=httpx.Response(200, json={"response": {"_id": "123x456"}})
+    )
+
+    async with raw_client.RawClient() as client:
+        result = await client.exists(typename="customer", uid="123x456")
+
+    assert result is True
+
+
+@respx.mock
+async def test_exists_by_uid_not_found(configured_client: None) -> None:
+    """Test exists returns False when record not found by uid."""
+    respx.get("https://test.example.com/customer/123x456").mock(
+        return_value=httpx.Response(404, json={"status": "NOT_FOUND"})
+    )
+
+    async with raw_client.RawClient() as client:
+        result = await client.exists(typename="customer", uid="123x456")
+
+    assert result is False
+
+
+@respx.mock
+async def test_exists_by_uid_error_reraises(configured_client: None) -> None:
+    """Test exists re-raises non-404 HTTP errors."""
+    respx.get("https://test.example.com/customer/123x456").mock(
+        return_value=httpx.Response(500, json={"error": "server error"})
+    )
+
+    async with raw_client.RawClient() as client:
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            await client.exists(typename="customer", uid="123x456")
+
+    assert exc_info.value.response.status_code == 500
+
+
+@respx.mock
+async def test_exists_by_constraints(configured_client: None) -> None:
+    """Test exists with constraints uses find."""
+    respx.get("https://test.example.com/customer").mock(
+        return_value=httpx.Response(200, json={"response": {"results": [{"_id": "1x1"}], "count": 1, "remaining": 0}})
+    )
+
+    async with raw_client.RawClient() as client:
+        result = await client.exists(
+            typename="customer",
+            constraints=[{"key": "email", "constraint_type": "equals", "value": "test@example.com"}],
+        )
+
+    assert result is True
+
+
+async def test_exists_uid_and_constraints_raises(configured_client: None) -> None:
+    """Test exists raises when both uid and constraints provided."""
+    async with raw_client.RawClient() as client:
+        with pytest.raises(ValueError, match="Cannot specify both"):
+            await client.exists(typename="customer", uid="123x456", constraints=[{"key": "x"}])

src/tests/unit/test_config.py

@@ -0,0 +1,29 @@
+"""Tests for bubble_data_api_client.config module."""
+
+from bubble_data_api_client.config import (
+    NOT_SET,
+    configure,
+    get_config,
+    set_config_provider,
+)
+
+
+def test_not_set_repr():
+    """NOT_SET sentinel should have readable repr."""
+    assert repr(NOT_SET) == "NOT_SET"
+
+
+def test_set_config_provider():
+    """Config provider should override static config."""
+    # set static config first
+    configure(data_api_root_url="https://static.example.com", api_key="static-key")
+    assert get_config()["data_api_root_url"] == "https://static.example.com"
+
+    # set provider - should override static config
+    set_config_provider(lambda: {"data_api_root_url": "https://dynamic.example.com", "api_key": "dynamic-key"})
+    assert get_config()["data_api_root_url"] == "https://dynamic.example.com"
+    assert get_config()["api_key"] == "dynamic-key"
+
+    # calling configure should clear the provider
+    configure(data_api_root_url="https://new-static.example.com", api_key="new-static-key")
+    assert get_config()["data_api_root_url"] == "https://new-static.example.com"

src/tests/unit/test_pool.py

@@ -0,0 +1,67 @@
+"""Tests for bubble_data_api_client.pool module."""
+
+from collections.abc import AsyncGenerator
+
+import httpx
+import pytest
+
+from bubble_data_api_client import configure
+from bubble_data_api_client.exceptions import ConfigurationError
+from bubble_data_api_client.pool import client_scope, close_clients, get_client
+
+
+@pytest.fixture
+async def clean_client_pool() -> AsyncGenerator[None]:
+    """Ensure client pool is clean before and after each test."""
+    await close_clients()
+    yield
+    await close_clients()
+
+
+async def test_get_client_empty_url_raises(clean_client_pool: None) -> None:
+    """get_client should raise ConfigurationError when data_api_root_url is empty."""
+    configure(data_api_root_url="", api_key="valid-key")
+    with pytest.raises(ConfigurationError, match="data_api_root_url"):
+        get_client()
+
+
+async def test_get_client_empty_api_key_raises(clean_client_pool: None) -> None:
+    """get_client should raise ConfigurationError when api_key is empty."""
+    configure(data_api_root_url="https://example.com", api_key="")
+    with pytest.raises(ConfigurationError, match="api_key"):
+        get_client()
+
+
+async def test_client_scope_closes_clients(clean_client_pool: None) -> None:
+    """client_scope should close clients on exit."""
+    configure(data_api_root_url="https://example.com", api_key="valid-key", retry=None)
+
+    async with client_scope():
+        client = get_client()
+        assert not client.is_closed
+
+    # client should be closed after exiting scope
+    assert client.is_closed
+
+
+async def test_close_clients_skips_already_closed(clean_client_pool: None) -> None:
+    """close_clients should skip clients that are already closed."""
+    configure(data_api_root_url="https://example.com", api_key="valid-key", retry=None)
+
+    client = get_client()
+    # manually close the client first
+    await client.aclose()
+    assert client.is_closed
+
+    # close_clients should not raise when client is already closed
+    await close_clients()
+
+
+def test_get_client_outside_async_context() -> None:
+    """get_client should return uncached client when called outside async context."""
+    configure(data_api_root_url="https://example.com", api_key="valid-key", retry=None)
+
+    # called from sync context - no running event loop
+    client = get_client()
+    assert isinstance(client, httpx.AsyncClient)
+    assert not client.is_closed