taskcluster-taskgraph 19.2.0__tar.gz → 20.0.0__tar.gz

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/.pre-commit-config.yaml

@@ -13,13 +13,13 @@ repos:
         exclude: template
       - id: check-added-large-files
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.14
+    rev: v0.15.4
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.9.28
+    rev: 0.10.7
     hooks:
       - id: uv-lock
   - repo: https://github.com/adrienverge/yamllint.git
@@ -37,7 +37,7 @@ repos:
                 test/test_util_path.py
             )$
   - repo: https://github.com/compilerla/conventional-pre-commit
-    rev: v4.3.0
+    rev: v4.4.0
     hooks:
       - id: conventional-pre-commit
         stages: [commit-msg]

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Change Log
 
+## [20.0.0] - 2026-03-17
+
+### Added
+
+- Support for generic-worker's `hide-cmd-window` feature
+- Ability to process kinds concurrently with threading
+
+### Fixed
+
+- BREAKING CHANGE: Binaries installed as part of `PIP_REQUIREMENTS` by `run-task` now end up in `~/.local/bin`
+- Exception when base revision is the null revision
+- Ability to use `optionally_keyed_by` with underlying dict using msgspec
+
+## [19.2.1] - 2026-02-19
+
+### Fixed
+
+- Loosen `optionally_keyed_by` constraints for msgspec compatibility
+
 ## [19.2.0] - 2026-02-18
 
 ### Fixed

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcluster-taskgraph
-Version: 19.2.0
+Version: 20.0.0
 Summary: Build taskcluster taskgraphs
 Project-URL: Repository, https://github.com/taskcluster/taskgraph
 Project-URL: Issues, https://github.com/taskcluster/taskgraph/issues

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/docs/reference/migrations.rst

@@ -3,6 +3,14 @@ Migration Guide
 
 This page can help when migrating Taskgraph across major versions.
 
+19.x -> 20.x
+------------
+
+* Binaries belonging to packages that get installed by `run-task` as part of
+  the `PIP_REQUIREMENTS` variable, are now installed to `~/.local/bin` instead
+  of `~/.local/lib/<python>/site-packages/bin`. Update any task commands that hardcode
+  the binary path accordingly.
+
 18.x -> 19.x
 ------------
 

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/pyproject.toml

@@ -1,7 +1,7 @@
 ### Project
 [project]
 name = "taskcluster-taskgraph"
-version = "19.2.0"
+version = "20.0.0"
 description = "Build taskcluster taskgraphs"
 readme = "README.rst"
 authors = [

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/src/taskgraph/generator.py

@@ -11,6 +11,7 @@ import platform
 from concurrent.futures import (
     FIRST_COMPLETED,
     ProcessPoolExecutor,
+    ThreadPoolExecutor,
     wait,
 )
 from dataclasses import dataclass
@@ -312,15 +313,13 @@ class TaskGraphGenerator:
 
         return all_tasks
 
-    def _load_tasks_parallel(self, kinds, kind_graph, parameters):
+    def _load_tasks_parallel(self, kinds, kind_graph, parameters, executor):
         all_tasks = {}
         futures_to_kind = {}
         futures = set()
         edges = set(kind_graph.edges)
 
-        with ProcessPoolExecutor(
-            mp_context=multiprocessing.get_context("fork")
-        ) as executor:
+        with executor:
 
             def submit_ready_kinds():
                 """Create the next batch of tasks for kinds without dependencies."""
@@ -434,29 +433,50 @@ class TaskGraphGenerator:
         yield "kind_graph", kind_graph
 
         logger.info("Generating full task set")
-        # The short version of the below is: we only support parallel kind
-        # processing on Linux.
+
+        # The next block deals with enabling parallel kind processing, which
+        # currently has different support on different platforms. In summary:
+        # * Parallel kind processing is supported and enabled by default on
+        #   Linux. We use multiple processes by default, but experimental
+        #   support for multiple threads can be enabled instead.
+        # * On other platforms, we have experimental support for parallel
+        #   kind processing with multiple threads.
         #
-        # Current parallel generation relies on multiprocessing, and more
-        # specifically: the "fork" multiprocessing method. This is not supported
-        # at all on Windows (it uses "spawn"). Forking is supported on macOS,
-        # but no longer works reliably in all cases, and our usage of it here
-        # causes crashes. See https://github.com/python/cpython/issues/77906
-        # and http://sealiesoftware.com/blog/archive/2017/6/5/Objective-C_and_fork_in_macOS_1013.html
-        # for more details on that.
-        # Other methods of multiprocessing (both "spawn" and "forkserver")
-        # do not work for our use case, because they cause global variables
-        # to be reinitialized, which are sometimes modified earlier in graph
-        # generation. These issues can theoretically be worked around by
-        # eliminating all reliance on globals as part of task generation, but
-        # is far from a small amount of work in users like Gecko/Firefox.
-        # In the long term, the better path forward is likely to be switching
-        # to threading with a free-threaded python to achieve similar parallel
-        # processing.
-        if platform.system() != "Linux" or os.environ.get("TASKGRAPH_SERIAL"):
-            all_tasks = self._load_tasks_serial(kinds, kind_graph, parameters)
-        else:
-            all_tasks = self._load_tasks_parallel(kinds, kind_graph, parameters)
+        # On all platforms serial kind processing can be enabled by setting
+        # TASKGRAPH_SERIAL in the environment.
+        #
+        # On all platforms, multiple threads can be enabled by setting
+        # TASKGRAPH_USE_THREADS in the environment. Taskgraph must be running
+        # from a free-threaded Python build to see any performance benefits.
+        #
+        # In the long term, the goal is turn enabled parallel kind processing for
+        # all platforms by default using threads, and remove support for multiple
+        # processes altogether.
+        def load_tasks():
+            if platform.system() == "Linux":
+                if os.environ.get("TASKGRAPH_SERIAL"):
+                    return self._load_tasks_serial(kinds, kind_graph, parameters)
+                elif os.environ.get("TASKGRAPH_USE_THREADS"):
+                    executor = ThreadPoolExecutor(max_workers=os.process_cpu_count())
+                else:
+                    executor = ProcessPoolExecutor(
+                        mp_context=multiprocessing.get_context("fork")
+                    )
+                return self._load_tasks_parallel(
+                    kinds, kind_graph, parameters, executor
+                )
+            else:
+                if os.environ.get("TASKGRAPH_SERIAL") or not os.environ.get(
+                    "TASKGRAPH_USE_THREADS"
+                ):
+                    return self._load_tasks_serial(kinds, kind_graph, parameters)
+                else:
+                    executor = ThreadPoolExecutor(max_workers=os.process_cpu_count())
+                return self._load_tasks_parallel(
+                    kinds, kind_graph, parameters, executor
+                )
+
+        all_tasks = load_tasks()
 
         full_task_set = TaskGraph(all_tasks, Graph(frozenset(all_tasks), frozenset()))
         yield self.verify("full_task_set", full_task_set, graph_config, parameters)

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/src/taskgraph/run-task/run-task

@@ -1044,8 +1044,8 @@ def install_pip_requirements(repositories):
 
     # TODO: Stop using system Python (#381)
     if shutil.which("uv"):
-        user_site_dir = subprocess.run(
-            [sys.executable, "-msite", "--user-site"], capture_output=True, text=True
+        user_base_dir = subprocess.run(
+            [sys.executable, "-msite", "--user-base"], capture_output=True, text=True
         ).stdout.strip()
         cmd = [
             "uv",
@@ -1053,8 +1053,8 @@ def install_pip_requirements(repositories):
             "install",
             "--python",
             sys.executable,
-            "--target",
-            user_site_dir,
+            "--prefix",
+            user_base_dir,
         ]
     else:
         cmd = [sys.executable, "-mpip", "install", "--user", "--break-system-packages"]

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/src/taskgraph/transforms/task.py

@@ -569,6 +569,7 @@ class GenericWorkerPayloadSchema(Schema, forbid_unknown_fields=False, kw_only=Tr
     # feature for task to run as current OS user
     run_task_as_current_user: Optional[bool] = None
     taskcluster_proxy: Optional[bool] = None
+    hide_cmd_window: Optional[bool] = None
     # Whether any artifacts are assigned to this worker
     skip_artifacts: Optional[bool] = None
 
@@ -681,6 +682,9 @@ def build_generic_worker_payload(config, task, task_def):
             "generic-worker:run-task-as-current-user:{}".format(task["worker-type"]),
         )
 
+    if worker.get("hide-cmd-window"):
+        features["hideCmdWindow"] = True
+
     if features:
         task_def["payload"]["features"] = features
 

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/src/taskgraph/util/schema.py

@@ -4,9 +4,9 @@
 
 import pprint
 import re
+import threading
 from collections.abc import Mapping
-from functools import reduce
-from typing import Literal, Optional, Union
+from typing import Annotated, Any, Literal, Optional, Union, get_args, get_origin
 
 import msgspec
 import voluptuous
@@ -14,6 +14,8 @@ import voluptuous
 import taskgraph
 from taskgraph.util.keyed_by import evaluate_keyed_by, iter_dot_path
 
+_schema_creation_lock = threading.RLock()
+
 # Common type definitions that are used across multiple schemas
 TaskPriority = Literal[
     "highest", "very-high", "high", "medium", "low", "very-low", "lowest"
@@ -67,11 +69,37 @@ def validate_schema(schema, obj, msg_prefix):
             raise Exception(f"{msg_prefix}\n{str(exc)}\n{pprint.pformat(obj)}")
 
 
-def UnionTypes(*types):
-    """Use `functools.reduce` to simulate `Union[*allowed_types]` on older
-    Python versions.
-    """
-    return reduce(lambda a, b: Union[a, b], types)
+class OptionallyKeyedBy:
+    """Metadata class for optionally_keyed_by fields in msgspec schemas."""
+
+    def __init__(self, *fields, wrapped_type):
+        self.fields = {f"by-{field}" for field in fields}
+        self.wrapped_type = wrapped_type
+
+    def uses_keyed_by(self, obj) -> bool:
+        if not isinstance(obj, dict) or len(obj) != 1:
+            return False
+
+        key = list(obj)[0]
+        if key not in self.fields:
+            return False
+
+        return True
+
+    def validate(self, obj) -> None:
+        if not self.uses_keyed_by(obj):
+            # Not using keyed by, validate directly against wrapped type
+            msgspec.convert(obj, self.wrapped_type)
+            return
+
+        # First validate the outer keyed-by dict
+        msgspec.convert(obj, dict[str, dict])
+
+        # Next validate each inner value. We call self.validate recursively to
+        # support nested `by-*` keys.
+        keyed_by_dict = list(obj.values())[0]
+        for value in keyed_by_dict.values():
+            self.validate(value)
 
 
 def optionally_keyed_by(*arguments, use_msgspec=False):
@@ -83,11 +111,15 @@ def optionally_keyed_by(*arguments, use_msgspec=False):
         use_msgspec: If True, return msgspec type hints; if False, return voluptuous validator
     """
     if use_msgspec:
-        # msgspec implementation - return type hints
+        # msgspec implementation - use Annotated[Any, OptionallyKeyedBy]
         _type = arguments[-1]
+        if _type is object:
+            return object
         fields = arguments[:-1]
-        bykeys = [Literal[f"by-{field}"] for field in fields]
-        return Union[_type, dict[UnionTypes(*bykeys), dict[str, _type]]]
+        wrapper = OptionallyKeyedBy(*fields, wrapped_type=_type)
+        # Annotating Any allows msgspec to accept any value without validation.
+        # The actual validation then happens in Schema.__post_init__
+        return Annotated[Any, wrapper]
     else:
         # voluptuous implementation - return validator function
         schema = arguments[-1]
@@ -251,28 +283,36 @@ class LegacySchema(voluptuous.Schema):
     """
     Operates identically to voluptuous.Schema, but applying some taskgraph-specific checks
     in the process.
+
+    voluptuous.Schema's `_compile` method is thread-unsafe. Any usage (whether direct or
+    indirect) of it must be protected by a lock.
     """
 
     def __init__(self, *args, check=True, **kwargs):
-        super().__init__(*args, **kwargs)
+        with _schema_creation_lock:
+            # this constructor may call `_compile`
+            super().__init__(*args, **kwargs)
 
-        self.check = check
-        if not taskgraph.fast and self.check:
-            check_schema(self)
+            self.check = check
+            if not taskgraph.fast and self.check:
+                check_schema(self)
 
     def extend(self, *args, **kwargs):
-        schema = super().extend(*args, **kwargs)
+        with _schema_creation_lock:
+            # `extend` may create a new Schema object, which may call `_compile`
+            schema = super().extend(*args, **kwargs)
 
-        if self.check:
-            check_schema(schema)
-        # We want twice extend schema to be checked too.
-        schema.__class__ = LegacySchema
-        return schema
+            if self.check:
+                check_schema(schema)
+            # We want twice extend schema to be checked too.
+            schema.__class__ = LegacySchema
+            return schema
 
     def _compile(self, schema):
-        if taskgraph.fast:
-            return
-        return super()._compile(schema)
+        with _schema_creation_lock:
+            if taskgraph.fast:
+                return
+            return super()._compile(schema)
 
     def __getitem__(self, item):
         return self.schema[item]  # type: ignore
@@ -305,6 +345,31 @@ class Schema(
             foo: str
     """
 
+    def __post_init__(self):
+        if taskgraph.fast:
+            return
+
+        # Validate fields that use optionally_keyed_by. We need to validate this
+        # manually because msgspec doesn't support union types with multiple
+        # dicts. Any fields that use `optionally_keyed_by("foo", dict)` would
+        # otherwise raise an exception.
+        for field_name, field_type in self.__class__.__annotations__.items():
+            origin = get_origin(field_type)
+            args = get_args(field_type)
+
+            if (
+                origin is not Annotated
+                or len(args) < 2
+                or not isinstance(args[1], OptionallyKeyedBy)
+            ):
+                # Not using `optionally_keyed_by`
+                continue
+
+            keyed_by = args[1]
+            obj = getattr(self, field_name)
+
+            keyed_by.validate(obj)
+
     @classmethod
     def validate(cls, data):
         """Validate data against this schema."""
@@ -312,7 +377,7 @@ class Schema(
             return data
 
         try:
-            return msgspec.convert(data, cls)
+            msgspec.convert(data, cls)
         except (msgspec.ValidationError, msgspec.DecodeError) as e:
             raise msgspec.ValidationError(str(e))
 

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/src/taskgraph/util/vcs.py

@@ -505,6 +505,11 @@ class GitRepository(Repository):
                 cmd.append("--cached")
             elif mode == "all":
                 cmd.append("HEAD")
+        elif base == self.NULL_REVISION:
+            # When base is NULL_REVISION (e.g new branches on Github), diff
+            # from the empty tree to show all files present at rev. Use Git's
+            # well-known empty tree hash.
+            cmd = ["diff", "4b825dc642cb6eb9a060e54bf8d69288fbee4904", rev]
         elif self.is_shallow:
             # In shallow clones, `git log` won't have the history necessary to
             # determine the files changed. Using `git diff` finds the

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/taskcluster/config.yml

@@ -7,6 +7,7 @@ treeherder:
         'check': 'Checks and lints'
         'doc': 'Documentation tasks'
         'unit': 'Unit test tasks'
+        'unit-multithread': 'Unit test tasks with multithreading enabled'
         'integration': 'Integration test tasks'
 
 index:

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/taskcluster/kinds/test/linux.yml

@@ -50,6 +50,26 @@ unit:
         command: >-
             uv run coverage run --data-file /builds/worker/artifacts/coverage --context=py{matrix[python]} -m pytest -vv
 
+unit-multithread:
+    description: "Run unit tests with py{matrix[python]} on Linux with multithreading enabled"
+    matrix:
+        set-name: "unit-multithread-py{matrix[python]}"
+        substitution-fields: [description, run.command, treeherder, worker, attributes]
+        python: ["314t"]
+    worker:
+        docker-image: {in-tree: python}
+        env:
+            TASKGRAPH_USE_THREADS: "1"
+        artifacts:
+            - type: file
+              path: "/builds/worker/artifacts/coverage"
+              name: "public/coverage.py{matrix[python]}"
+    treeherder:
+        symbol: unit-multithread(py{matrix[python]})
+    run:
+        command: >-
+            uv run coverage run --data-file /builds/worker/artifacts/coverage --context=py{matrix[python]} -m pytest -vv
+
 integration:
     description: "Run unit tests with py{matrix[python]} on Linux with resolution {matrix[resolution]}"
     attributes:

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/test/test_generator.py

@@ -3,6 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
+import os
 import platform
 from concurrent.futures import ProcessPoolExecutor
 
@@ -14,9 +15,13 @@ from taskgraph.generator import Kind, load_tasks_for_kind, load_tasks_for_kinds
 from taskgraph.loader.default import loader as default_loader
 
 linuxonly = pytest.mark.skipif(
-    platform.system() != "Linux",
+    platform.system() != "Linux" or os.environ.get("TASKGRAPH_USE_THREADS"),
     reason="requires Linux and 'fork' multiprocessing support",
 )
+threadsonly = pytest.mark.skipif(
+    not os.environ.get("TASKGRAPH_USE_THREADS"),
+    reason="requires multithreading to be enabled",
+)
 
 
 class FakePPE(ProcessPoolExecutor):
@@ -27,8 +32,16 @@ class FakePPE(ProcessPoolExecutor):
         return super().submit(kind_load_tasks, *args)
 
 
+class FakeTPE(ProcessPoolExecutor):
+    loaded_kinds = []
+
+    def submit(self, kind_load_tasks, *args):
+        self.loaded_kinds.append(kind_load_tasks.__self__.name)
+        return super().submit(kind_load_tasks, *args)
+
+
 @linuxonly
-def test_kind_ordering(mocker, maketgg):
+def test_kind_ordering_multiprocess(mocker, maketgg):
     "When task kinds depend on each other, they are loaded in postorder"
     mocked_ppe = mocker.patch.object(generator, "ProcessPoolExecutor", new=FakePPE)
     tgg = maketgg(
@@ -42,6 +55,21 @@ def test_kind_ordering(mocker, maketgg):
     assert mocked_ppe.loaded_kinds == ["_fake1", "_fake2", "_fake3"]
 
 
+@threadsonly
+def test_kind_ordering_multithread(mocker, maketgg):
+    "When task kinds depend on each other, they are loaded in postorder"
+    mocked_tpe = mocker.patch.object(generator, "ThreadPoolExecutor", new=FakeTPE)
+    tgg = maketgg(
+        kinds=[
+            ("_fake3", {"kind-dependencies": ["_fake2", "_fake1"]}),
+            ("_fake2", {"kind-dependencies": ["_fake1"]}),
+            ("_fake1", {"kind-dependencies": []}),
+        ]
+    )
+    tgg._run_until("full_task_set")
+    assert mocked_tpe.loaded_kinds == ["_fake1", "_fake2", "_fake3"]
+
+
 def test_full_task_set(maketgg):
     "The full_task_set property has all tasks"
     tgg = maketgg()

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/test/test_scripts_run_task.py

@@ -143,8 +143,8 @@ def test_install_pip_requirements_with_uv(
             "install",
             "--python",
             sys.executable,
-            "--target",
-            site.getusersitepackages(),
+            "--prefix",
+            site.getuserbase(),
             "--require-hashes",
             "-r",
             str(req),

{taskcluster_taskgraph-19.2.0 → taskcluster_taskgraph-20.0.0}/test/test_util_schema.py

@@ -284,32 +284,67 @@ class TestValidateSchemaDictHandler(unittest.TestCase):
 
 
 def test_optionally_keyed_by():
-    typ = optionally_keyed_by("foo", str, use_msgspec=True)
-    assert msgspec.convert("baz", typ) == "baz"
-    assert msgspec.convert({"by-foo": {"a": "b", "c": "d"}}, typ) == {
-        "by-foo": {"a": "b", "c": "d"}
-    }
+    class TestSchema(Schema):
+        field: optionally_keyed_by("foo", str, use_msgspec=True)  # type: ignore
+
+    TestSchema.validate({"field": "baz"})
+    TestSchema.validate({"field": {"by-foo": {"a": "b", "c": "d"}}})
+
+    with pytest.raises(msgspec.ValidationError):
+        TestSchema.validate({"field": 1})
+
+    with pytest.raises(msgspec.ValidationError):
+        TestSchema.validate({"field": {"by-bar": "a"}})
 
     with pytest.raises(msgspec.ValidationError):
-        msgspec.convert({"by-foo": {"a": 1, "c": "d"}}, typ)
+        TestSchema.validate({"field": {"by-bar": {1: "b"}}})
 
     with pytest.raises(msgspec.ValidationError):
-        msgspec.convert({"by-bar": {"a": "b"}}, typ)
+        TestSchema.validate({"field": {"by-bar": {"a": "b"}}})
+
+    with pytest.raises(msgspec.ValidationError):
+        TestSchema.validate({"field": {"by-foo": {"a": 1, "c": "d"}}})
+
+
+def test_optionally_keyed_by_multiple_keys():
+    class TestSchema(Schema):
+        field: optionally_keyed_by("foo", "bar", str, use_msgspec=True)  # type: ignore
+
+    TestSchema.validate({"field": {"by-foo": {"a": "b"}}})
+    TestSchema.validate({"field": {"by-bar": {"x": "y"}}})
+    TestSchema.validate({"field": {"by-foo": {"a": {"by-bar": {"x": "y"}}}}})
+
+    # Test invalid keyed-by field
+    with pytest.raises(msgspec.ValidationError):
+        TestSchema.validate({"field": {"by-unknown": {"a": "b"}}})
+
+    with pytest.raises(msgspec.ValidationError):
+        TestSchema.validate({"field": {"by-foo": {"a": {"by-bar": {"x": 1}}}}})
+
+
+def test_optionally_keyed_by_object_passthrough():
+    """When the type argument is `object`, optionally_keyed_by returns object directly."""
+    typ = optionally_keyed_by("foo", object, use_msgspec=True)
+    assert typ is object
+    # object accepts anything via msgspec.convert
+    assert msgspec.convert("hello", typ) == "hello"
+    assert msgspec.convert(42, typ) == 42
+    assert msgspec.convert({"by-foo": {"a": "b"}}, typ) == {"by-foo": {"a": "b"}}
+    assert msgspec.convert({"arbitrary": "dict"}, typ) == {"arbitrary": "dict"}
+
 
+def test_optionally_keyed_by_dict():
+    class TestSchema(Schema):
+        field: optionally_keyed_by("foo", dict[str, str], use_msgspec=True)  # type: ignore
 
-def test_optionally_keyed_by_mulitple_keys():
-    typ = optionally_keyed_by("foo", "bar", str, use_msgspec=True)
-    assert msgspec.convert("baz", typ) == "baz"
-    assert msgspec.convert({"by-foo": {"a": "b", "c": "d"}}, typ) == {
-        "by-foo": {"a": "b", "c": "d"}
-    }
-    assert msgspec.convert({"by-bar": {"x": "y"}}, typ) == {"by-bar": {"x": "y"}}
+    TestSchema.validate({"field": {"by-foo": {"a": {"x": "y"}}}})
+    TestSchema.validate({"field": {"a": "b"}})
 
     with pytest.raises(msgspec.ValidationError):
-        msgspec.convert({"by-foo": {"a": 123, "c": "d"}}, typ)
+        TestSchema.validate({"field": {"a": 1}})
 
     with pytest.raises(msgspec.ValidationError):
-        msgspec.convert({"by-bar": {"a": 1}}, typ)
+        TestSchema.validate({"field": {"by-foo": {"a": {"x": 1}}}})
 
     with pytest.raises(msgspec.ValidationError):
-        msgspec.convert({"by-unknown": {"a": "b"}}, typ)
+        TestSchema.validate({"field": {"by-foo": {"a": "b"}}})