Rust test targets now create a test launcher allow for setting env vars

rust/private/BUILD

@@ -1,5 +1,7 @@
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
 
+exports_files(["test_runner_template.rs"])
+
 bzl_library(
     name = "rules",
     srcs = glob(

rust/private/rust.bzl

@@ -15,7 +15,7 @@
 # buildifier: disable=module-docstring
 load("//rust/private:common.bzl", "rust_common")
 load("//rust/private:rustc.bzl", "rustc_compile_action")
-load("//rust/private:utils.bzl", "determine_output_hash", "find_toolchain")
+load("//rust/private:utils.bzl", "determine_output_hash", "expand_locations", "find_toolchain")
 
 # TODO(marco): Separate each rule into its own file.
 
@@ -219,6 +219,100 @@ def _rust_binary_impl(ctx):
         ),
     )
 
+def _create_test_launcher(ctx, toolchain, output, providers):
+    """Create a process wrapper to ensure runtime environment variables are defined for the test binary
+
+    Args:
+        ctx (ctx): The rule's context object
+        toolchain (rust_toolchain): The current rust toolchain
+        output (File): The output File that will be produced, depends on crate type.
+        providers (list): Providers from a rust compile action. See `rustc_compile_action`
+
+    Returns:
+        list: A list of providers similar to `rustc_compile_action` but with modified default info
+    """
+
+    args = ctx.actions.args()
+
+    # Because returned executables must be created from the same rule, the 
+    # launcher target is simply copied and exposed. 
+
+    # TODO: Find a better way to detect the configuration this executable
+    # was built in. Here we detect whether or not the executable is built 
+    # for windows based on it's extension.
+    if ctx.executable._launcher.basename.endswith(".exe"):
+        launcher = ctx.actions.declare_file(name_to_crate_name(ctx.label.name + ".launcher.exe"))
+        # Because the windows target
+        args.add_all([
+            ctx.executable._launcher.path.replace("/", "\\"),
+            launcher.path.replace("/", "\\"),
+        ])
+    else:
+        launcher = ctx.actions.declare_file(name_to_crate_name(ctx.label.name + ".launcher"))
+        args.add_all([
+            ctx.executable._launcher,
+            launcher,
+        ])
+
+    ctx.actions.run(
+        outputs = [launcher],
+        tools = [ctx.executable._launcher],
+        mnemonic = "GeneratingLauncher",
+        executable = ctx.executable._launcher_installer,
+        arguments = [args],
+    )
+
+    # Get data attribute
+    data = getattr(ctx.attr, "data", [])
+
+    # Expand the environment variables and write them to a file
+    environ_file = ctx.actions.declare_file(launcher.basename + ".launchfiles/env")
+    environ = expand_locations(
+        ctx,
+        getattr(ctx.attr, "env", {}),
+        data,
+    )
+
+    # Convert the environment variables into a list to be written into a file.
+    environ_list = []
+    for key, value in environ.items():
+        environ_list.extend([key, value])
+
+    ctx.actions.write(
+        output = environ_file,
+        content = "\n".join(environ_list)
+    )
+
+    launcher_files = [environ_file]
+
+    # Replace the `DefaultInfo` provider in the returned list
+    default_info = None
+    for i in range(len(providers)):
+        if type(providers[i]) == "DefaultInfo":
+            default_info = providers[i]
+            providers.pop(i)
+            break
+
+    if not default_info:
+        fail("No DefaultInfo provider returned from `rustc_compile_action`")
+
+    providers.extend([
+        DefaultInfo(
+            files = default_info.files,
+            runfiles = default_info.default_runfiles.merge(
+                # The output is now also considered a runfile
+                ctx.runfiles(files = launcher_files + [output]),
+            ),
+            executable = launcher,
+        ),
+        OutputGroupInfo(
+            launcher_files = depset(launcher_files),
+            output = depset([output]),
+        ),
+    ])
+
+    return providers
+
 def _rust_test_common(ctx, toolchain, output):
     """Builds a Rust test binary.
 
@@ -267,15 +361,16 @@ def _rust_test_common(ctx, toolchain, output):
             is_test = True,
         )
 
-    return rustc_compile_action(
+    providers = rustc_compile_action(
         ctx = ctx,
         toolchain = toolchain,
         crate_type = crate_type,
         crate_info = target,
         rust_flags = ["--test"],
-        environ = ctx.attr.env,
     )
 
+    return _create_test_launcher(ctx, toolchain, output, providers)
+
 def _rust_test_impl(ctx):
     """The implementation of the `rust_test` rule
 
@@ -511,6 +606,23 @@ _rust_test_attrs = {
             ["Make variable"](https://docs.bazel.build/versions/master/be/make-variables.html) substitution.
         """),
     ),
+    "_launcher": attr.label(
+        executable = True,
+        default = Label("//util/launcher:launcher"),
+        cfg = "exec",
+        doc = _tidy("""
+            A launcher executable for loading environment and argument files passed in via the `env` attribute
+            and ensuring the variables are set for the underlying test executable.
+        """),
+    ),
+    "_launcher_installer": attr.label(
+        executable = True,
+        default = Label("//util/launcher:installer"),
+        cfg = "exec",
+        doc = _tidy("""
+            A helper script for creating an installer within the test rule.
+        """),
+    ),
 }
 
 rust_library = rule(

rust/private/rustc.bzl

@@ -586,13 +586,6 @@ def rustc_compile_action(
         build_flags_files,
     )
 
-    # Make the user defined enviroment variables available to the action
-    expanded_env = dict()
-    data = getattr(ctx.attr, "data", [])
-    for key in environ:
-        expanded_env[key] = ctx.expand_location(environ[key], data)
-    env.update(expanded_env)
-
     if hasattr(ctx.attr, "version") and ctx.attr.version != "0.0.0":
         formatted_version = " v{}".format(ctx.attr.version)
     else:

test/test_env/tests/run.rs

@@ -4,7 +4,7 @@ fn run() {
     let output = std::process::Command::new(path).output().expect("Failed to run process");
     assert_eq!(&b"Hello world\n"[..], output.stdout.as_slice());
 
-    // Test the `env` attribute of `rust_test`
-    assert_eq!(env!("FERRIS_SAYS"), "Hello fellow Rustaceans!");
-    assert_eq!(env!("HELLO_WORLD_BIN"), "test/test_env/hello-world");
+    // Test the `env` attribute of `rust_test` at run time
+    assert_eq!(std::env::var("FERRIS_SAYS").unwrap(), "Hello fellow Rustaceans!");
+    assert_eq!(std::env::var("HELLO_WORLD_BIN").unwrap(), "test/test_env/hello-world");
 }

tools/runfiles/runfiles.rs

@@ -37,6 +37,17 @@ use std::io;
 use std::path::Path;
 use std::path::PathBuf;
 
+
+/// The common name of Bazel runfiles directory suffix
+const RUNFILES_SUFFIX: &'static str = ".runfiles";
+
+/// Tests are wrapped in a `.runner` executable so we need to 
+/// also know to look for this directory as well
+#[cfg(target_family = "unix")]
+const TEST_RUNFILES_SUFFIX: &'static str = ".runner.runfiles";
+#[cfg(target_family = "windows")]
+const TEST_RUNFILES_SUFFIX: &'static str = ".runner.exe.runfiles";
+
 pub struct Runfiles {
     runfiles_dir: PathBuf,
 }
@@ -70,14 +81,33 @@ fn find_runfiles_dir() -> io::Result<PathBuf> {
     let exec_path = std::env::args().nth(0).expect("arg 0 was not set");
 
     let mut binary_path = PathBuf::from(&exec_path);
+    if !binary_path.is_absolute() {
+        binary_path = std::env::current_dir()
+            .expect("Failed to get current directory")
+            .join(binary_path);
+    }
     loop {
         // Check for our neighboring $binary.runfiles directory.
-        let mut runfiles_name = binary_path.file_name().unwrap().to_owned();
-        runfiles_name.push(".runfiles");
+        {
+            let mut runfiles_name = binary_path.file_name().unwrap().to_owned();
+            runfiles_name.push(RUNFILES_SUFFIX);
 
-        let runfiles_path = binary_path.with_file_name(&runfiles_name);
-        if runfiles_path.is_dir() {
-            return Ok(runfiles_path);
+            let runfiles_path = binary_path.with_file_name(&runfiles_name);
+            if runfiles_path.is_dir() {
+                return Ok(runfiles_path);
+            }
+        }
+
+        // Test binaries are executed by a $binary.runner, so check for 
+        // $binary.runner.runfiles
+        {
+            let mut runfiles_name = binary_path.file_name().unwrap().to_owned();
+            runfiles_name.push(TEST_RUNFILES_SUFFIX);
+
+            let runfiles_path = binary_path.with_file_name(&runfiles_name);
+            if runfiles_path.is_dir() {
+                return Ok(runfiles_path);
+            }
         }
 
         // Check if we're already under a *.runfiles directory.
@@ -87,7 +117,10 @@ fn find_runfiles_dir() -> io::Result<PathBuf> {
             while let Some(ancestor) = next {
                 if ancestor
                     .file_name()
-                    .map_or(false, |f| f.to_string_lossy().ends_with(".runfiles"))
+                    .map_or(false, |f| {
+                        let f_str = f.to_string_lossy();
+                        f_str.ends_with(RUNFILES_SUFFIX) || f_str.ends_with(TEST_RUNFILES_SUFFIX)
+                    })
                 {
                     return Ok(ancestor.to_path_buf());
                 }

util/launcher/BUILD.bazel

@@ -0,0 +1,24 @@
+load("//rust:rust.bzl", "rust_binary", "rust_test")
+load(":installer.bzl", "installer")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_binary(
+    name = "launcher",
+    edition = "2018",
+    srcs = ["launcher_main.rs"]
+)
+
+rust_test(
+    name = "launcher_test",
+    edition = "2018",
+    crate = ":launcher",
+)
+
+installer(
+    name = "installer",
+    src = select({
+        "//rust/platform:windows": "launcher_installer.bat",
+        "//conditions:default": "launcher_installer.sh",
+    }),
+)

util/launcher/installer.bzl

@@ -0,0 +1,36 @@
+"""A module defining the installer rule for the rules_rust test launcher"""
+
+def _installer_impl(ctx):
+    """The `installer` rule's implementation
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        list: A list a DefaultInfo provider
+    """
+
+    installer = ctx.actions.declare_file(ctx.file.src.basename)
+
+    ctx.actions.expand_template(
+        template = ctx.file.src,
+        output = installer,
+        substitutions = {},
+        is_executable = True,
+    )
+
+    return [DefaultInfo(
+        files = depset([installer]),
+        executable = installer,
+    )]
+
+installer = rule(
+    doc = "A rule which makes a native executable script avaialble to other rules",
+    implementation = _installer_impl,
+    attrs = {
+        "src": attr.label(
+            allow_single_file = [".sh", ".bat"],
+        ),
+    },
+    executable = True,
+)

util/launcher/launcher_installer.bat

@@ -0,0 +1,5 @@
+@ECHO OFF
+@REM A native windows script for creating a `run` action output of the
+@REM the rules_rust launcher binary
+
+copy /v /y /b "%1" "%2"

util/launcher/launcher_installer.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# A simple script for creating a `run` action output of the
+# the rules_rust launcher binary
+
+cp "$1" "$2"