fix: add gvar caching improved

Author: 1drturtle

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "avrae-ls"
-version = "0.8.4"
+version = "0.8.5"
 description = "Language server for Avrae draconic aliases"
 authors = [
   { name = "1drturtle" }

src/avrae_ls/__main__.py

@@ -12,14 +12,8 @@
 
 from lsprotocol import types
 
-from avrae_ls.testing.alias_tests import (
-    AliasTestError,
-    AliasTestResult,
-    diff_mismatched_parts,
-    discover_test_files,
-    parse_alias_tests,
-    run_alias_tests,
-)
+from avrae_ls.testing.alias_tests import AliasTestError, AliasTestResult, discover_test_files, parse_alias_tests, run_alias_tests
+from avrae_ls.testing._common import diff_mismatched_parts
 from avrae_ls.testing.gvar_tests import GVarTestError, GVarTestResult, parse_gvar_tests, run_gvar_tests
 from avrae_ls.config import AvraeLSConfig, CONFIG_FILENAME, load_config
 from avrae_ls.runtime.context import ContextBuilder
@@ -165,6 +159,7 @@ def _run_alias_tests(
 
     builder = ContextBuilder(config)
     executor = MockExecutor(config.service)
+    shared_gvar_cache = dict(builder.build_baseline().vars.gvars)
 
     test_files = discover_test_files(target, patterns=RUN_TEST_PATTERNS)
     alias_cases = []
@@ -186,8 +181,16 @@ def _run_alias_tests(
         print(f"No alias or gvar tests found under {target}")
         return 1 if parse_errors else 0
 
-    alias_results = asyncio.run(run_alias_tests(alias_cases, builder, executor)) if alias_cases else []
-    gvar_results = asyncio.run(run_gvar_tests(gvar_cases, builder, executor)) if gvar_cases else []
+    alias_results = (
+        asyncio.run(run_alias_tests(alias_cases, builder, executor, suite_gvar_cache=shared_gvar_cache))
+        if alias_cases
+        else []
+    )
+    gvar_results = (
+        asyncio.run(run_gvar_tests(gvar_cases, builder, executor, suite_gvar_cache=shared_gvar_cache))
+        if gvar_cases
+        else []
+    )
     results = [*alias_results, *gvar_results]
     _print_test_results(results, workspace_root)
 

src/avrae_ls/runtime/context.py

@@ -269,9 +269,7 @@ def _handle_gvar_response(self, key: str, resp: httpx.Response, *, blocking: boo
         return True
 
     def reset(self, gvars: Dict[str, Any] | None = None) -> None:
-        self._cache = {}
-        if gvars:
-            self._cache.update({str(k): v for k, v in gvars.items()})
+        self.load_snapshot(gvars)
 
     def seed(self, gvars: Dict[str, Any] | None = None) -> None:
         """Merge provided gvars into the cache without dropping fetched values."""
@@ -359,6 +357,11 @@ def ensure_blocking(self, key: str) -> bool:
     def snapshot(self) -> Dict[str, Any]:
         return dict(self._cache)
 
+    def load_snapshot(self, gvars: Dict[str, Any] | None = None) -> None:
+        self._cache = {}
+        if gvars:
+            self._cache.update({str(k): v for k, v in gvars.items()})
+
     async def refresh(self, seed: Dict[str, Any] | None = None, keys: Iterable[str] | None = None) -> Dict[str, Any]:
         self.reset(seed)
         if keys:

src/avrae_ls/testing/_common.py

@@ -111,6 +111,17 @@ def diff_mismatched_parts(expected: Any, actual: Any) -> tuple[Any, Any] | None:
     return expected, actual
 
 
+def merge_new_gvars_into_suite_cache(
+    suite_cache: dict[str, Any], active_cache: dict[str, Any], *, exclude_keys: set[str] | None = None
+) -> None:
+    excluded = {str(key) for key in (exclude_keys or set())}
+    for key, value in active_cache.items():
+        key_str = str(key)
+        if key_str in excluded or key_str in suite_cache:
+            continue
+        suite_cache[key_str] = value
+
+
 def compile_expected_pattern(text: str) -> re.Pattern[str] | None:
     """
     Interpret strings with /.../ segments (or re:prefix) as regex.

src/avrae_ls/testing/alias_tests.py

@@ -14,6 +14,7 @@
 from avrae_ls.testing._common import (
     deep_merge_dicts,
     dict_matches,
+    merge_new_gvars_into_suite_cache,
     parse_expected_value,
     parse_metadata_mapping,
     scalar_matches,
@@ -142,7 +143,11 @@ def parse_alias_tests(path: Path) -> list[AliasTestCase]:
 
 
 async def run_alias_tests(
-    cases: Iterable[AliasTestCase], builder: ContextBuilder, executor: MockExecutor
+    cases: Iterable[AliasTestCase],
+    builder: ContextBuilder,
+    executor: MockExecutor,
+    *,
+    suite_gvar_cache: dict[str, Any] | None = None,
 ) -> list[AliasTestResult]:
     case_list = list(cases)
     alias_sources: dict[Path, str] = {}
@@ -163,6 +168,7 @@ async def run_alias_tests(
         )
 
     baseline = builder.build_baseline()
+    shared_gvar_cache = suite_gvar_cache if suite_gvar_cache is not None else dict(baseline.vars.gvars)
     results: list[AliasTestResult] = []
     for case in case_list:
         error = alias_errors.get(case.alias_path)
@@ -176,6 +182,7 @@ async def run_alias_tests(
                 executor,
                 alias_source=alias_sources.get(case.alias_path),
                 base_context=baseline,
+                suite_gvar_cache=shared_gvar_cache,
             )
         )
     return results
@@ -188,6 +195,7 @@ async def run_alias_test(
     *,
     alias_source: str | None = None,
     base_context: ContextData | None = None,
+    suite_gvar_cache: dict[str, Any] | None = None,
 ) -> AliasTestResult:
     if alias_source is None:
         source_started = time.perf_counter()
@@ -212,9 +220,17 @@ async def run_alias_test(
         ctx_data.vars = ctx_data.vars.merge(VarSources.from_data(case.var_overrides))
     if case.character_overrides:
         ctx_data.character = deep_merge_dicts(ctx_data.character, case.character_overrides)
-    builder.gvar_resolver.reset(ctx_data.vars.gvars)
+    shared_gvar_cache = suite_gvar_cache if suite_gvar_cache is not None else dict(ctx_data.vars.gvars)
+    builder.gvar_resolver.load_snapshot(shared_gvar_cache)
+    builder.gvar_resolver.seed(ctx_data.vars.gvars)
+    local_only_gvars = set(ctx_data.vars.gvars.keys())
 
     rendered = await render_alias_command(alias_source, executor, ctx_data, builder.gvar_resolver, args=case.args)
+    merge_new_gvars_into_suite_cache(
+        shared_gvar_cache,
+        builder.gvar_resolver.snapshot(),
+        exclude_keys=local_only_gvars,
+    )
     if rendered.error:
         return AliasTestResult(
             case=case,

src/avrae_ls/testing/gvar_tests.py

@@ -10,7 +10,13 @@
 from avrae_ls.gvar_utils import sanitize_gvar_binding
 from avrae_ls.runtime.context import ContextBuilder, ContextData
 from avrae_ls.runtime.runtime import MockExecutor, ModuleExecutionError
-from avrae_ls.testing._common import deep_merge_dicts, parse_expected_value, parse_metadata_mapping, value_matches
+from avrae_ls.testing._common import (
+    deep_merge_dicts,
+    merge_new_gvars_into_suite_cache,
+    parse_expected_value,
+    parse_metadata_mapping,
+    value_matches,
+)
 
 log = logging.getLogger(__name__)
 
@@ -124,7 +130,11 @@ def parse_gvar_tests(path: Path) -> list[GVarTestCase]:
 
 
 async def run_gvar_tests(
-    cases: Iterable[GVarTestCase], builder: ContextBuilder, executor: MockExecutor
+    cases: Iterable[GVarTestCase],
+    builder: ContextBuilder,
+    executor: MockExecutor,
+    *,
+    suite_gvar_cache: dict[str, Any] | None = None,
 ) -> list[GVarTestResult]:
     case_list = list(cases)
     gvar_sources: dict[Path, str] = {}
@@ -141,6 +151,7 @@ async def run_gvar_tests(
         log.debug("Loaded %d gvar source file(s) for tests in %.2fms", len(gvar_sources), log_elapsed)
 
     baseline = builder.build_baseline()
+    shared_gvar_cache = suite_gvar_cache if suite_gvar_cache is not None else dict(baseline.vars.gvars)
     results: list[GVarTestResult] = []
     for case in case_list:
         error = gvar_errors.get(case.gvar_path)
@@ -154,6 +165,7 @@ async def run_gvar_tests(
                 executor,
                 gvar_source=gvar_sources.get(case.gvar_path),
                 base_context=baseline,
+                suite_gvar_cache=shared_gvar_cache,
             )
         )
     return results
@@ -166,6 +178,7 @@ async def run_gvar_test(
     *,
     gvar_source: str | None = None,
     base_context: ContextData | None = None,
+    suite_gvar_cache: dict[str, Any] | None = None,
 ) -> GVarTestResult:
     if gvar_source is None:
         source_started = time.perf_counter()
@@ -186,15 +199,24 @@ async def run_gvar_test(
         ctx_data.vars = ctx_data.vars.merge(VarSources.from_data(case.var_overrides))
     if case.character_overrides:
         ctx_data.character = deep_merge_dicts(ctx_data.character, case.character_overrides)
-    builder.gvar_resolver.reset(ctx_data.vars.gvars)
+    shared_gvar_cache = suite_gvar_cache if suite_gvar_cache is not None else dict(ctx_data.vars.gvars)
+    builder.gvar_resolver.load_snapshot(shared_gvar_cache)
+    builder.gvar_resolver.seed(ctx_data.vars.gvars)
+    local_only_gvars = set(ctx_data.vars.gvars.keys())
 
     collision = _reserved_name_collision(case.binding_name, executor, ctx_data)
     if collision is not None:
         return GVarTestResult(case=case, passed=False, actual=None, stdout="", error=collision)
 
     builder.gvar_resolver.seed({case.gvar_name: gvar_source})
+    local_only_gvars.add(case.gvar_name)
     wrapped_code = _wrap_test_body(case.binding_name, case.gvar_name, case.body)
     result = await executor.run(wrapped_code, ctx_data, builder.gvar_resolver)
+    merge_new_gvars_into_suite_cache(
+        shared_gvar_cache,
+        builder.gvar_resolver.snapshot(),
+        exclude_keys=local_only_gvars,
+    )
     if result.error:
         error_line, error_col = _map_error_position(result.error, wrapper_lines=1)
         return GVarTestResult(

tests/test_alias_tests.py

@@ -355,3 +355,50 @@ async def test_alias_tests_allow_metadata_vars_override(tmp_path):
     case = parse_alias_tests(test_path)[0]
     result = (await run_alias_tests([case], builder, executor))[0]
     assert result.passed
+
+
+@pytest.mark.asyncio
+async def test_alias_tests_reuse_nested_gvar_fetches_across_cases(monkeypatch, tmp_path):
+    alias_path = tmp_path / "outer.alias"
+    alias_path.write_text('!alias outer echo <drac2>using(mod="remote")\nreturn mod.answer</drac2>')
+    test_path = tmp_path / "outer.alias-test"
+    test_path.write_text('!outer\n---\n"42"\n\n!outer\n---\n"42"\n')
+
+    config = AvraeLSConfig.default(tmp_path)
+    config.enable_gvar_fetch = True
+    config.service.token = "token"
+    builder = ContextBuilder(config)
+    executor = MockExecutor(config.service)
+
+    calls: list[str] = []
+
+    class DummyResponse:
+        status_code = 200
+
+        def __init__(self, key: str):
+            self.key = key
+
+        def json(self):
+            return {"value": "answer = 42\n"}
+
+    class DummyClient:
+        def __init__(self, **kwargs):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return False
+
+        async def get(self, url, headers=None):
+            calls.append(url.rsplit("/", 1)[-1])
+            return DummyResponse(calls[-1])
+
+    monkeypatch.setattr("avrae_ls.runtime.context.httpx.AsyncClient", DummyClient)
+
+    cases = parse_alias_tests(test_path)
+    results = await run_alias_tests(cases, builder, executor)
+
+    assert all(result.passed for result in results)
+    assert calls == ["remote"]