truss 0.10.0rc1__py3-none-any.whl → 0.60.0__py3-none-any.whl

truss/tests/{server → templates/control}/control/test_server.py

@@ -1,18 +1,38 @@
 import os
+import sys
 from contextlib import contextmanager
+from pathlib import Path
 from typing import Dict, List
+from unittest.mock import AsyncMock, patch
 
+import httpx
 import pytest
-from httpx import AsyncClient
-from truss.server.control.application import create_app
-from truss.server.control.patch.types import (
+from tenacity import RetryError
+from truss.truss_handle.patch.custom_types import PatchRequest
+
+# Needed to simulate the set up on the model docker container
+sys.path.append(
+    str(
+        Path(__file__).parent.parent.parent.parent.parent
+        / "templates"
+        / "control"
+        / "control"
+    )
+)
+
+sys.path.append(str(Path(__file__).parent.parent.parent.parent.parent / "templates"))
+sys.path.append(
+    str(Path(__file__).parent.parent.parent.parent.parent / "templates" / "shared")
+)
+
+from truss.templates.control.control.application import create_app  # noqa
+from truss.templates.control.control.helpers.custom_types import (  # noqa
     Action,
     ModelCodePatch,
     Patch,
     PatchType,
     PythonRequirementPatch,
 )
-from truss.types import PatchRequest
 
 
 @pytest.fixture
@@ -21,17 +41,13 @@ def truss_original_hash():
 
 
 @pytest.fixture
-def app(tmp_truss_dir, truss_original_hash):
+def app(truss_container_fs, truss_original_hash):
     with _env_var({"HASH_TRUSS": truss_original_hash}):
-        inf_serv_home = tmp_truss_dir
+        inf_serv_home = truss_container_fs / "app"
         control_app = create_app(
             {
                 "inference_server_home": inf_serv_home,
-                "inference_server_process_args": [
-                    "python",
-                    "-m",
-                    "truss.server.inference_server",
-                ],
+                "inference_server_process_args": ["python", "main.py"],
                 "control_server_host": "*",
                 "control_server_port": 8081,
                 "inference_server_port": 8082,
@@ -59,7 +75,10 @@ def anyio_backend(request):
 
 @pytest.fixture()
 async def client(app):
-    async with AsyncClient(app=app, base_url="http://localhost:8080") as async_client:
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(
+        transport=transport, base_url="http://localhost:8080"
+    ) as async_client:
         yield async_client
 
 
@@ -87,9 +106,7 @@ class Model:
     patch = Patch(
         type=PatchType.MODEL_CODE,
         body=ModelCodePatch(
-            action=Action.UPDATE,
-            path="model.py",
-            content=mock_model_file_content,
+            action=Action.UPDATE, path="model.py", content=mock_model_file_content
         ),
     )
     await _verify_apply_patch_success(client, patch)
@@ -112,9 +129,7 @@ class Model:
     patch = Patch(
         type=PatchType.MODEL_CODE,
         body=ModelCodePatch(
-            action=Action.UPDATE,
-            path="model.py",
-            content=mock_model_file_content,
+            action=Action.UPDATE, path="model.py", content=mock_model_file_content
         ),
     )
     await _verify_apply_patch_success(client, patch)
@@ -129,9 +144,7 @@ async def test_patch_model_code_create_new(app, client):
     patch = Patch(
         type=PatchType.MODEL_CODE,
         body=ModelCodePatch(
-            action=Action.UPDATE,
-            path="touched",
-            content=empty_content,
+            action=Action.UPDATE, path="touched", content=empty_content
         ),
     )
     await _verify_apply_patch_success(client, patch)
@@ -144,9 +157,7 @@ async def test_patch_model_code_create_in_new_dir(app, client):
     patch = Patch(
         type=PatchType.MODEL_CODE,
         body=ModelCodePatch(
-            action=Action.UPDATE,
-            path="new_directory/touched",
-            content=empty_content,
+            action=Action.UPDATE, path="new_directory/touched", content=empty_content
         ),
     )
     await _verify_apply_patch_success(client, patch)
@@ -203,6 +214,50 @@ async def test_patch_failed_unrecoverable(client):
     assert resp.json()["error"]["type"] == "patch_failed_unrecoverable"
 
 
+@pytest.mark.anyio
+async def test_health_check(client):
+    resp = await client.get("/v1/models/model")
+    assert resp.status_code == 200
+    assert resp.json() == {}
+
+
+@pytest.mark.anyio
+async def test_health_check_retries(client, app):
+    async def mock_send(*args, **kwargs):
+        return httpx.Response(
+            status_code=503, json={"error": "Model with name model is not ready."}
+        )
+
+    app.state.proxy_client.send = AsyncMock(side_effect=mock_send)
+
+    with pytest.raises(RetryError):
+        await client.get("/v1/models/model")
+
+    # Health check was retried 10 times
+    assert app.state.proxy_client.send.call_count == 10
+
+
+@pytest.mark.anyio
+async def test_retries(client, app):
+    app.state.proxy_client.send = AsyncMock(
+        side_effect=[
+            httpx.ConnectTimeout("Connect timeout"),
+            httpx.ReadTimeout("Read timeout"),
+            httpx.ReadError("Read error"),
+            httpx.ConnectError("Connect error"),
+            httpx.RemoteProtocolError("Remote protocol error"),
+        ]
+    )
+
+    with patch("endpoints.INFERENCE_SERVER_START_WAIT_SECS", new=4), pytest.raises(
+        RetryError
+    ):
+        await client.get("/v1/models/model")
+
+    # We should have made 5 attempts
+    assert app.state.proxy_client.send.call_count == 5
+
+
 async def _verify_apply_patch_success(client, patch: Patch):
     resp = await client.get("/control/truss_hash")
     original_hash = resp.json()["result"]

truss/tests/{server → templates/control}/control/test_server_integration.py

@@ -15,7 +15,6 @@ from typing import Callable
 import psutil
 import pytest
 import requests
-from truss.server.control.server import ControlServer
 
 PATCH_PING_MAX_DELAY_SECS = 3
 
@@ -28,8 +27,8 @@ class ControlServerDetails:
 
 
 @pytest.fixture
-def control_server(tmp_truss_control_dir):
-    with _configured_control_server(tmp_truss_control_dir) as server:
+def control_server(truss_control_container_fs):
+    with _configured_control_server(truss_control_container_fs) as server:
         yield server
 
 
@@ -63,10 +62,7 @@ class Model:
 
     def predict(inp):
         time.sleep(random.uniform(0, 0.5))
-        resp = requests.post(
-            f"{ctrl_url}/v1/models/model:predict",
-            json=inp,
-        )
+        resp = requests.post(f"{ctrl_url}/v1/models/model:predict", json=inp)
         return resp.json()
 
     with ThreadPool(10) as p:
@@ -96,11 +92,18 @@ class Model:
 
 
 @pytest.mark.integration
-def test_truss_control_server_patch_ping_delays(tmp_truss_control_dir: Path):
+def test_truss_control_server_health_check(control_server: ControlServerDetails):
+    ctrl_url = f"http://localhost:{control_server.control_server_port}"
+    resp = requests.get(f"{ctrl_url}/v1/models/model")
+    assert resp.status_code == 200
+    assert resp.json() == {}
+
+
+@pytest.mark.integration
+def test_truss_control_server_patch_ping_delays(truss_control_container_fs: Path):
     for _ in range(10):
         with _configured_control_server(
-            tmp_truss_control_dir,
-            with_patch_ping_flow=True,
+            truss_control_container_fs, with_patch_ping_flow=True
         ) as control_server:
             # Account for patch ping delays
             time.sleep(PATCH_PING_MAX_DELAY_SECS)
@@ -172,8 +175,7 @@ def _process_tree_is_dead(pid: int):
 
 @contextmanager
 def _configured_control_server(
-    truss_control_container_fs: Path,
-    with_patch_ping_flow: bool = False,
+    truss_control_container_fs: Path, with_patch_ping_flow: bool = False
 ):
     # Pick random ports to reduce reuse, port release may take time
     # which can interfere with tests
@@ -183,14 +185,20 @@ def _configured_control_server(
 
     def start_truss_server(stdout_capture_file_path):
         if with_patch_ping_flow:
-            os.environ[
-                "PATCH_PING_URL_TRUSS"
-            ] = f"http://localhost:{patch_ping_server_port}"
+            os.environ["PATCH_PING_URL_TRUSS"] = (
+                f"http://localhost:{patch_ping_server_port}"
+            )
         sys.stdout = open(stdout_capture_file_path, "w")
+        app_path = truss_control_container_fs / "app"
+        sys.path.append(str(app_path))
+        control_path = truss_control_container_fs / "control" / "control"
+        sys.path.append(str(control_path))
+
+        from server import ControlServer
 
         control_server = ControlServer(
             python_executable_path=sys.executable,
-            inf_serv_home=str(truss_control_container_fs),
+            inf_serv_home=str(app_path),
             control_server_port=ctrl_port,
             inference_server_port=inf_port,
         )

truss/tests/templates/core/server/test_dynamic_config_resolver.py

@@ -0,0 +1,108 @@
+import json
+
+import aiofiles
+import pytest
+from truss.templates.shared import dynamic_config_resolver
+
+from truss_chains import definitions
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "RandInt": {
+                "predict_url": "https://model-id.api.baseten.co/deployment/deployment-id/predict"
+            }
+        },
+        {},
+        "",
+    ],
+)
+def test_get_dynamic_chainlet_config_value_sync(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    with (tmp_path / definitions.DYNAMIC_CHAINLET_CONFIG_KEY).open("w") as f:
+        f.write(json.dumps(config))
+    chainlet_service_config = dynamic_config_resolver.get_dynamic_config_value_sync(
+        definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+    )
+    assert json.loads(chainlet_service_config) == config
+
+
+@pytest.mark.parametrize(
+    "config", [{"environment_name": "production", "foo": "bar"}, {}, "", None]
+)
+def test_get_dynamic_config_environment_value_sync(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    with (tmp_path / dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY).open(
+        "w"
+    ) as f:
+        f.write(json.dumps(config))
+    environment_str = dynamic_config_resolver.get_dynamic_config_value_sync(
+        dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+    )
+    assert json.loads(environment_str) == config
+
+
+def test_get_missing_config_value_sync(dynamic_config_mount_dir):
+    chainlet_service_config = dynamic_config_resolver.get_dynamic_config_value_sync(
+        definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+    )
+    assert not chainlet_service_config
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "RandInt": {
+                "predict_url": "https://model-id.api.baseten.co/deployment/deployment-id/predict"
+            }
+        },
+        {},
+        "",
+    ],
+)
+async def test_get_dynamic_chainlet_config_value_async(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    async with aiofiles.open(
+        tmp_path / definitions.DYNAMIC_CHAINLET_CONFIG_KEY, "w"
+    ) as f:
+        await f.write(json.dumps(config))
+    chainlet_service_config = (
+        await dynamic_config_resolver.get_dynamic_config_value_async(
+            definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+        )
+    )
+    assert json.loads(chainlet_service_config) == config
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "config", [{"environment_name": "production", "foo": "bar"}, {}, "", None]
+)
+async def test_get_dynamic_config_environment_value_async(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    async with aiofiles.open(
+        tmp_path / dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY, "w"
+    ) as f:
+        await f.write(json.dumps(config))
+    environment_str = await dynamic_config_resolver.get_dynamic_config_value_async(
+        dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+    )
+    assert json.loads(environment_str) == config
+
+
+@pytest.mark.asyncio
+async def test_get_missing_config_value_async(dynamic_config_mount_dir):
+    chainlet_service_config = (
+        await dynamic_config_resolver.get_dynamic_config_value_async(
+            definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+        )
+    )
+    assert not chainlet_service_config

truss/tests/templates/core/server/test_lazy_data_resolver.py

@@ -0,0 +1,329 @@
+import datetime
+import json
+import os
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Callable
+from unittest.mock import patch
+
+import pytest
+import requests_mock
+from truss.templates.shared.lazy_data_resolver import (
+    BASETEN_FS_ENABLED_ENV_VAR,
+    LAZY_DATA_RESOLVER_PATH,
+    LazyDataResolver,
+)
+
+
+@pytest.fixture
+def baseten_pointer_manifest_mock() -> Callable:
+    def _baseten_pointer_manifest_mock(
+        foo_expiry_timestamp: int, bar_expiry_timestamp: int
+    ):
+        return f"""
+pointers:
+- uid: foo
+  file_name: foo-name
+  hashtype: hash-type
+  hash: foo-hash
+  size: 100
+  resolution:
+    url: https://foo-rl
+    expiration_timestamp: {foo_expiry_timestamp}
+- uid: bar
+  file_name: bar-name
+  hashtype: hash-type
+  hash: bar-hash
+  size: 1000
+  resolution:
+    url: https://bar-rl
+    expiration_timestamp: {bar_expiry_timestamp}
+"""
+
+    return _baseten_pointer_manifest_mock
+
+
+def test_lazy_data_resolution_not_found():
+    ldr = LazyDataResolver(Path("foo"))
+    assert not LAZY_DATA_RESOLVER_PATH.exists()
+    assert ldr._bptr_resolution == {}
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry,expectation",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            nullcontext(),
+        ),
+        (
+            int(
+                datetime.datetime(2020, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(2020, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            pytest.raises(RuntimeError),
+        ),
+    ],
+)
+def test_lazy_data_resolution(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, expectation, tmp_path
+):
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ):
+        with expectation:
+            ldr = LazyDataResolver(Path("foo"))
+            assert ldr._bptr_resolution == {
+                "foo-name": ("https://foo-rl", "foo-hash", 100),
+                "bar-name": ("https://bar-rl", "bar-hash", 1000),
+            }
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+        )
+    ],
+)
+def test_lazy_data_fetch(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, tmp_path
+):
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ):
+        data_dir = Path(tmp_path)
+        ldr = LazyDataResolver(data_dir)
+        with requests_mock.Mocker() as m:
+            for file_name, (url, _, _) in ldr._bptr_resolution.items():
+                resp = {"file_name": file_name, "url": url}
+                m.get(url, json=resp)
+            ldr.fetch()
+            for file_name, (url, _, _) in ldr._bptr_resolution.items():
+                assert (ldr._data_dir / file_name).read_text() == json.dumps(
+                    {"file_name": file_name, "url": url}
+                )
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+        )
+    ],
+)
+def test_lazy_data_fetch_to_cache_non_200_status(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, tmp_path, monkeypatch
+):
+    monkeypatch.setenv(BASETEN_FS_ENABLED_ENV_VAR, "True")
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    cache_dir = tmp_path / "cache" / "org" / "artifacts"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir.touch()
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ) as _, patch(
+        "truss.templates.shared.lazy_data_resolver.CACHE_DIR", cache_dir
+    ) as _:
+        data_dir = Path(tmp_path)
+        ldr = LazyDataResolver(data_dir)
+        assert ldr._uses_b10_cache
+        with requests_mock.Mocker() as m:
+            for _, (url, _, _) in ldr._bptr_resolution.items():
+                m.get(url, status_code=500)
+            with pytest.raises(RuntimeError):
+                ldr.fetch()
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+        )
+    ],
+)
+def test_lazy_data_fetch_to_cache(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, tmp_path, monkeypatch
+):
+    monkeypatch.setenv(BASETEN_FS_ENABLED_ENV_VAR, "True")
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    cache_dir = tmp_path / "cache" / "org" / "artifacts"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir.touch()
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ) as _, patch(
+        "truss.templates.shared.lazy_data_resolver.CACHE_DIR", cache_dir
+    ) as CACHE_DIR:
+        data_dir = Path(tmp_path)
+        ldr = LazyDataResolver(data_dir)
+        assert ldr._uses_b10_cache
+        with requests_mock.Mocker() as m:
+            for file_name, (url, hash, _) in ldr._bptr_resolution.items():
+                resp = {"file_name": file_name, "url": url}
+                m.get(url, json=resp)
+            ldr.fetch()
+            for file_name, (url, hash, _) in ldr._bptr_resolution.items():
+                assert (CACHE_DIR / hash).read_text() == json.dumps(
+                    {"file_name": file_name, "url": url}
+                )
+                assert os.path.islink(ldr._data_dir / file_name)
+                assert os.readlink(ldr._data_dir / file_name) == str(CACHE_DIR / hash)
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+        )
+    ],
+)
+def test_lazy_data_fetch_to_cache_fallback_if_no_space(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, tmp_path, monkeypatch
+):
+    monkeypatch.setenv(BASETEN_FS_ENABLED_ENV_VAR, "True")
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    cache_dir = tmp_path / "cache" / "org" / "artifacts"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir.touch()
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ) as _, patch(
+        "truss.templates.shared.lazy_data_resolver.CACHE_DIR", cache_dir
+    ) as _, patch(
+        "truss.templates.shared.lazy_data_resolver.shutil.disk_usage"
+    ) as mock_disk_usage:
+        data_dir = Path(tmp_path)
+        ldr = LazyDataResolver(data_dir)
+        assert ldr._uses_b10_cache
+
+        mock_disk_usage.return_value.free = 1
+        with requests_mock.Mocker() as m:
+            for file_name, (url, _, _) in ldr._bptr_resolution.items():
+                resp = {"file_name": file_name, "url": url}
+                m.get(url, json=resp)
+            ldr.fetch()
+
+            for file_name, (url, _, _) in ldr._bptr_resolution.items():
+                assert (ldr._data_dir / file_name).read_text() == json.dumps(
+                    {"file_name": file_name, "url": url}
+                )
+
+
+@pytest.mark.parametrize(
+    "foo_expiry,bar_expiry",
+    [
+        (
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+            int(
+                datetime.datetime(3000, 1, 1, tzinfo=datetime.timezone.utc).timestamp()
+            ),
+        )
+    ],
+)
+def test_lazy_data_fetch_cached(
+    baseten_pointer_manifest_mock, foo_expiry, bar_expiry, tmp_path, monkeypatch
+):
+    monkeypatch.setenv(BASETEN_FS_ENABLED_ENV_VAR, "True")
+    baseten_pointer_manifest_mock = baseten_pointer_manifest_mock(
+        foo_expiry, bar_expiry
+    )
+    manifest_path = tmp_path / "bptr" / "bptr-manifest"
+    manifest_path.parent.mkdir()
+    manifest_path.touch()
+    manifest_path.write_text(baseten_pointer_manifest_mock)
+    cache_dir = tmp_path / "cache" / "org" / "artifacts"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir.touch()
+    with patch(
+        "truss.templates.shared.lazy_data_resolver.LAZY_DATA_RESOLVER_PATH",
+        manifest_path,
+    ) as _, patch(
+        "truss.templates.shared.lazy_data_resolver.CACHE_DIR", cache_dir
+    ) as CACHE_DIR:
+        data_dir = Path(tmp_path)
+        ldr = LazyDataResolver(data_dir)
+        assert ldr._uses_b10_cache
+        with requests_mock.Mocker() as m:
+            for file_name, (url, hash, _) in ldr._bptr_resolution.items():
+                resp = {"file_name": file_name, "url": url}
+                (CACHE_DIR / hash).write_text(json.dumps(resp))
+                m.get(url, json=resp)
+            ldr.fetch()
+            for file_name, (url, hash, _) in ldr._bptr_resolution.items():
+                assert (CACHE_DIR / hash).read_text() == json.dumps(
+                    {"file_name": file_name, "url": url}
+                )
+                assert not m.called
+                assert os.path.islink(ldr._data_dir / file_name)
+                assert os.readlink(ldr._data_dir / file_name) == str(CACHE_DIR / hash)