add a test for non-root modules

Author: aignas

python/uv/private/toolchains_hub.bzl

@@ -19,7 +19,7 @@ load(":toolchain_types.bzl", "UV_TOOLCHAIN_TYPE")
 def toolchains_hub(
         *,
         name = None,
-        names,
+        toolchains,
         implementations,
         target_compatible_with,
         target_settings):
@@ -29,40 +29,38 @@ def toolchains_hub(
     TODO @aignas 2025-03-09: see if this can be reused in the python toolchains.
 
     Args:
-        name: Unused.
-        names: The names for toolchain targets. The later occurring items take
-            precedence over the previous items if they match the target platform.
+        name: The prefix to all of the targets, which goes after a numeric prefix.
+        toolchains: The toolchain names for the targets defined by this macro.
+            The earlier occurring items take precedence over the later items if
+            they match the target platform and target settings.
         implementations: The name to label mapping.
         target_compatible_with: The name to target_compatible_with list mapping.
         target_settings: The name to target_settings list mapping.
     """
-    if len(names) != len(implementations):
+    if len(toolchains) != len(implementations):
         fail("Each name must have an implementation")
 
-    # We are setting the order of the toolchains so that the later coming
-    # toolchains override the previous definitions using the toolchain
-    # resolution properties:
+    # We are defining the toolchains so that the order of toolchain matching is
+    # the same as the order of the toolchains, because:
     # * the toolchains are matched by target settings and target_compatible_with
     # * the first toolchain satisfying the above wins
     #
     # this means we need to register the toolchains prefixed with a number of
     # format 00xy, where x and y are some digits and the leading zeros to
     # ensure lexicographical sorting.
-    prefix_len = len(str(len(names)))
+    #
+    # Add 1 so that there is always a leading zero
+    prefix_len = len(str(len(toolchains))) + 1
     prefix = "0" * (prefix_len - 1)
 
-    # reverse the names list so that the later items override earlier toolchain
-    # registrations.
-    names = [n for _, n in sorted(enumerate(names), key = lambda x: -x[0])]
-
-    for i, name in enumerate(names):
+    for i, toolchain in enumerate(toolchains):
         # prefix with a prefix and then truncate the string.
         number_prefix = "{}{}".format(prefix, i)[-prefix_len:]
 
         native.toolchain(
-            name = "{}_{}".format(number_prefix, name),
-            target_compatible_with = target_compatible_with.get(name, []),
-            target_settings = target_settings.get(name, []),
-            toolchain = implementations[name],
+            name = "{}_{}_{}".format(number_prefix, name, toolchain),
+            target_compatible_with = target_compatible_with.get(toolchain, []),
+            target_settings = target_settings.get(toolchain, []),
+            toolchain = implementations[toolchain],
             toolchain_type = UV_TOOLCHAIN_TYPE,
         )

python/uv/private/uv_toolchains_repo.bzl

@@ -29,7 +29,8 @@ def _toolchains_repo_impl(repository_ctx):
     contents = _TEMPLATE.format(
         render.call(
             "toolchains_hub",
-            names = render.list(repository_ctx.attr.toolchain_names),
+            name = repr("uv_toolchain"),
+            toolchains = render.list(repository_ctx.attr.toolchain_names),
             implementations = render.dict(
                 repository_ctx.attr.toolchain_implementations,
             ),

tests/uv/uv/uv_tests.bzl

@@ -436,6 +436,57 @@ def _test_complex_configuring(env):
 
 _tests.append(_test_complex_configuring)
 
+def _test_non_rules_python_non_root_is_ignored(env):
+    calls = []
+    uv = _process_modules(
+        env,
+        module_ctx = _mock_mctx(
+            _mod(
+                default = [
+                    _default(
+                        base_url = "https://example.org",
+                        manifest_filename = "manifest.json",
+                        version = "1.0.0",
+                        platform = "osx",
+                        compatible_with = ["@platforms//os:os"],
+                    ),
+                ],
+                configure = [
+                    _configure(),  # use defaults
+                ],
+            ),
+            _mod(
+                name = "something",
+                configure = [
+                    _configure(version = "6.6.6"),  # use defaults whatever they are
+                ],
+            ),
+        ),
+        uv_repository = lambda **kwargs: calls.append(kwargs),
+    )
+
+    uv.names().contains_exactly([
+        "1_0_0_osx",
+    ])
+    uv.implementations().contains_exactly({
+        "1_0_0_osx": "@uv_1_0_0_osx//:uv_toolchain",
+    })
+    uv.compatible_with().contains_exactly({
+        "1_0_0_osx": ["@platforms//os:os"],
+    })
+    uv.target_settings().contains_exactly({})
+    env.expect.that_collection(calls).contains_exactly([
+        {
+            "name": "uv_1_0_0_osx",
+            "platform": "osx",
+            "sha256": "deadb00f",
+            "urls": ["https://example.org/1.0.0/osx"],
+            "version": "1.0.0",
+        },
+    ])
+
+_tests.append(_test_non_rules_python_non_root_is_ignored)
+
 _analysis_tests = []
 
 def _test_toolchain_precedence(name):

tests/uv/uv_toolchains/BUILD.bazel

@@ -1,15 +1,11 @@
 load("//python/uv/private:toolchains_hub.bzl", "toolchains_hub")  # buildifier: disable=bzl-visibility
 
 toolchains_hub(
+    name = "uv_unit_test",
     implementations = {
         "bar": "//tests/uv/uv:fake_bar",
         "foo": "//tests/uv/uv:fake_foof",
     },
-    # We expect foo to take precedence over bar
-    names = [
-        "bar",
-        "foo",
-    ],
     target_compatible_with = {
         "bar": [
             "@platforms//os:linux",
@@ -21,4 +17,9 @@ toolchains_hub(
         ],
     },
     target_settings = {},
+    # We expect foo to take precedence over bar
+    toolchains = [
+        "foo",
+        "bar",
+    ],
 )