Enable more tests on Windows (#3348)

Author: UebelAndre

.bazelci/presubmit.yml

@@ -72,19 +72,6 @@ default_windows_targets: &default_windows_targets
 default_windows_no_runfiles_targets: &default_windows_no_runfiles_targets
   - "--" # Allows negative patterns; hack for https://github.com/bazelbuild/continuous-integration/pull/245
   - "//..."
-  # TODO: https://github.com/bazelbuild/rules_rust/issues/1156
-  - "-//crate_universe/..."
-  - "-//test/chained_direct_deps:mod3_doc_test"
-  - "-//test/out_dir_in_tests:demo_lib_doc_test"
-  - "-//test/rustc_env_files:output_test"
-  - "-//test/test_env_launcher:test"
-  - "-//test/test_env:test_manifest_dir"
-  - "-//test/test_env:test_run"
-  - "-//test/unit/rustdoc/..."
-  - "-//rust/runfiles/..."
-  # Runfiles used by the test only.
-  - "-//test/empty_suite:deps_test"
-  - "-//cargo/cargo_toml_variable_extractor/testdata/..."
 crate_universe_vendor_example_targets: &crate_universe_vendor_example_targets
   - "//vendor_external:crates_vendor"
   - "//vendor_local_manifests:crates_vendor"

cargo/cargo_toml_variable_extractor/testdata/BUILD.bazel

@@ -1,12 +1,22 @@
-load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
 load("//cargo:defs.bzl", "cargo_toml_env_vars")
-load("//rust:defs.bzl", "rust_binary")
+load("//rust:defs.bzl", "rust_binary", "rust_test")
+
+# TODO: This target currently fails on windows.
+NOT_WINDOWS = select({
+    "@platforms//os:windows": ["@platforms//:incompatible"],
+    "//conditions:default": [],
+})
 
 genrule(
     name = "gen_empty_cargo_output",
-    srcs = glob(["empty/**"]),
+    srcs = glob([
+        "empty/**/*.toml",
+        "empty/**/*.rs",
+    ]),
     outs = ["empty_cargo_output"],
-    cmd = "RUSTC=$(location //tools/upstream_wrapper:rustc) $(location //tools/upstream_wrapper:cargo) run --manifest-path=cargo/cargo_toml_variable_extractor/testdata/empty/Cargo.toml > $@",
+    cmd = "RUSTC=$(execpath //tools/upstream_wrapper:rustc) $(execpath //tools/upstream_wrapper:cargo) run --manifest-path=cargo/cargo_toml_variable_extractor/testdata/empty/Cargo.toml > $@",
+    cmd_bat = "set RUSTC=$(execpath //tools/upstream_wrapper:rustc) && $(execpath //tools/upstream_wrapper:cargo) run --manifest-path=cargo\\cargo_toml_variable_extractor\\testdata\\empty\\Cargo.toml > $@",
+    target_compatible_with = NOT_WINDOWS,
     tools = [
         "//tools/upstream_wrapper:cargo",
         "//tools/upstream_wrapper:rustc",
@@ -28,21 +38,38 @@ rust_binary(
 genrule(
     name = "gen_empty_bazel_output",
     outs = ["empty_bazel_output"],
-    cmd = "$(location :empty_bin) > $@",
+    cmd = "$(execpath :empty_bin) > $@",
+    cmd_bat = "$(execpath :empty_bin) > $@",
     tools = [":empty_bin"],
 )
 
-diff_test(
+rust_test(
     name = "empty_diff_test",
-    file1 = ":empty_cargo_output",
-    file2 = ":empty_bazel_output",
+    srcs = ["diff_test.rs"],
+    data = [
+        ":empty_bazel_output",
+        ":empty_cargo_output",
+    ],
+    edition = "2021",
+    env = {
+        "FILE_1": "$(rlocationpath :empty_cargo_output)",
+        "FILE_2": "$(rlocationpath :empty_bazel_output)",
+    },
+    deps = [
+        "//rust/runfiles",
+    ],
 )
 
 genrule(
     name = "gen_standalone_cargo_output",
-    srcs = glob(["standalone/**"]),
+    srcs = glob([
+        "standalone/**/*.toml",
+        "standalone/**/*.rs",
+    ]),
     outs = ["standalone_cargo_output"],
-    cmd = "RUSTC=$(location //tools/upstream_wrapper:rustc) $(location //tools/upstream_wrapper:cargo) run --manifest-path=cargo/cargo_toml_variable_extractor/testdata/standalone/Cargo.toml > $@",
+    cmd = "RUSTC=$(execpath //tools/upstream_wrapper:rustc) $(execpath //tools/upstream_wrapper:cargo) run --manifest-path=cargo/cargo_toml_variable_extractor/testdata/standalone/Cargo.toml > $@",
+    cmd_bat = "set RUSTC=$(execpath //tools/upstream_wrapper:rustc) && $(execpath //tools/upstream_wrapper:cargo) run --manifest-path=cargo\\cargo_toml_variable_extractor\\testdata\\standalone\\Cargo.toml > $@",
+    target_compatible_with = NOT_WINDOWS,
     tools = [
         "//rust/toolchain:current_rust_stdlib_files",
         "//tools/upstream_wrapper:cargo",
@@ -65,24 +92,42 @@ rust_binary(
 genrule(
     name = "gen_standalone_bazel_output",
     outs = ["standalone_bazel_output"],
-    cmd = "$(location :standalone_bin) > $@",
+    cmd = "$(execpath :standalone_bin) > $@",
+    cmd_bat = "$(execpath :standalone_bin) > $@",
     tools = [":standalone_bin"],
 )
 
-diff_test(
+rust_test(
     name = "standalone_diff_test",
-    file1 = ":standalone_cargo_output",
-    file2 = ":standalone_bazel_output",
+    srcs = ["diff_test.rs"],
+    data = [
+        ":standalone_bazel_output",
+        ":standalone_cargo_output",
+    ],
+    edition = "2021",
+    env = {
+        "FILE_1": "$(rlocationpath :standalone_cargo_output)",
+        "FILE_2": "$(rlocationpath :standalone_bazel_output)",
+    },
+    deps = [
+        "//rust/runfiles",
+    ],
 )
 
 genrule(
     name = "gen_workspace_subcrate_cargo_output",
     srcs = glob(
-        ["workspace/**"],
+        include = [
+            "workspace/**/*.toml",
+            "workspace/**/*.rs",
+            "workspace/**/.gitignore",
+        ],
         exclude = ["workspace/target/**"],
     ),
     outs = ["workspace_subcrate_cargo_output"],
-    cmd = "RUSTC=$(location //tools/upstream_wrapper:rustc) $(location //tools/upstream_wrapper:cargo) run --quiet --manifest-path=cargo/cargo_toml_variable_extractor/testdata/workspace/subcrate/Cargo.toml > $@",
+    cmd = "RUSTC=$(execpath //tools/upstream_wrapper:rustc) $(execpath //tools/upstream_wrapper:cargo) run --quiet --manifest-path=cargo/cargo_toml_variable_extractor/testdata/workspace/subcrate/Cargo.toml > $@",
+    cmd_bat = "set RUSTC=$(execpath //tools/upstream_wrapper:rustc) && $(execpath //tools/upstream_wrapper:cargo) run --quiet --manifest-path=cargo\\cargo_toml_variable_extractor\\testdata\\workspace\\subcrate\\Cargo.toml > $@",
+    target_compatible_with = NOT_WINDOWS,
     tools = [
         "//rust/toolchain:current_rust_stdlib_files",
         "//tools/upstream_wrapper:cargo",
@@ -106,12 +151,24 @@ rust_binary(
 genrule(
     name = "gen_workspace_subcrate_bazel_output",
     outs = ["workspace_subcrate_bazel_output"],
-    cmd = "$(location :workspace_subcrate_bin) > $@",
+    cmd = "$(execpath :workspace_subcrate_bin) > $@",
+    cmd_bat = "$(execpath :workspace_subcrate_bin) > $@",
     tools = [":workspace_subcrate_bin"],
 )
 
-diff_test(
+rust_test(
     name = "workspace_subcrate_diff_test",
-    file1 = ":workspace_subcrate_cargo_output",
-    file2 = ":workspace_subcrate_bazel_output",
+    srcs = ["diff_test.rs"],
+    data = [
+        ":workspace_subcrate_bazel_output",
+        ":workspace_subcrate_cargo_output",
+    ],
+    edition = "2021",
+    env = {
+        "FILE_1": "$(rlocationpath :workspace_subcrate_cargo_output)",
+        "FILE_2": "$(rlocationpath :workspace_subcrate_bazel_output)",
+    },
+    deps = [
+        "//rust/runfiles",
+    ],
 )

cargo/cargo_toml_variable_extractor/testdata/diff_test.rs

@@ -0,0 +1,24 @@
+#[test]
+fn diff_test() {
+    let runfiles = runfiles::Runfiles::create().unwrap();
+
+    let file_1_env = std::env::var("FILE_1").unwrap();
+    let file_2_env = std::env::var("FILE_2").unwrap();
+
+    let file_1 = runfiles::rlocation!(runfiles, &file_1_env).unwrap();
+    let file_2 = runfiles::rlocation!(runfiles, &file_2_env).unwrap();
+
+    let file_1_content = std::fs::read_to_string(&file_1).unwrap();
+    let file_2_content = std::fs::read_to_string(&file_2).unwrap();
+
+    let file_1_lines = file_1_content.split_whitespace().collect::<Vec<&str>>();
+    let file_2_lines = file_2_content.split_whitespace().collect::<Vec<&str>>();
+
+    assert_eq!(
+        file_1_lines,
+        file_2_lines,
+        "Files `{}` and `{}` differ.",
+        file_1.display(),
+        file_2.display()
+    );
+}

crate_universe/BUILD.bazel

@@ -109,6 +109,12 @@ rust_test(
         "CARGO": "$(rootpath @rules_rust//rust/toolchain:current_cargo_files)",
         "RUSTC": "$(rootpath @rules_rust//rust/toolchain:current_rustc_files)",
     },
+    # TODO: `crate_universe` currently does not work on Windows.
+    # https://github.com/bazelbuild/rules_rust/issues/1156
+    target_compatible_with = select({
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
     deps = [
         "@rules_rust//rust/runfiles",
     ] + all_crate_deps(
@@ -136,6 +142,12 @@ rust_test(
         proc_macro_dev = True,
     ),
     tags = ["requires-network"],
+    # TODO: `crate_universe` currently does not work on Windows.
+    # https://github.com/bazelbuild/rules_rust/issues/1156
+    target_compatible_with = select({
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
     deps = [
         ":cargo_bazel",
         "@rules_rust//rust/runfiles",
@@ -153,9 +165,10 @@ rust_test(
     ],
     edition = "2021",
     rustc_env = {
-        "CARGO_TOML": "$(rootpath :Cargo.toml)",
-        "VERSION_BZL": "$(rootpath :version.bzl)",
+        "CARGO_TOML": "$(rlocationpath :Cargo.toml)",
+        "VERSION_BZL": "$(rlocationpath :version.bzl)",
     },
+    deps = ["//rust/runfiles"],
 )
 
 rust_doc(
@@ -172,4 +185,10 @@ rust_doc(
 rust_doc_test(
     name = "rustdoc_test",
     crate = ":cargo_bazel",
+    # TODO: `rust_doc_test` currently does not work on Windows.
+    # https://github.com/bazelbuild/rules_rust/issues/1156
+    target_compatible_with = select({
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
 )

crate_universe/tests/version_test.rs

@@ -4,11 +4,21 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
+fn cargo_toml_path() -> PathBuf {
+    let r = runfiles::Runfiles::create().unwrap();
+    runfiles::rlocation!(r, env!("CARGO_TOML")).unwrap()
+}
+
+fn version_bzl_path() -> PathBuf {
+    let r = runfiles::Runfiles::create().unwrap();
+    runfiles::rlocation!(r, env!("VERSION_BZL")).unwrap()
+}
+
 #[test]
 fn test_cargo_and_bazel_versions() {
     // Parse the version field from the `cargo-bazel` Cargo.toml file
     let cargo_version = {
-        let cargo_path = PathBuf::from(env!("CARGO_TOML"));
+        let cargo_path = cargo_toml_path();
         let file = File::open(cargo_path).expect("Failed to load Cargo.toml file");
         BufReader::new(file)
             .lines()
@@ -25,7 +35,7 @@ fn test_cargo_and_bazel_versions() {
 
     // Parse the version global from the Bazel module
     let bazel_version = {
-        let bazel_path = PathBuf::from(env!("VERSION_BZL"));
+        let bazel_path = version_bzl_path();
         let file = File::open(bazel_path).expect("Failed to load versions.bzl file");
         BufReader::new(file)
             .lines()

rust/runfiles/runfiles.rs

@@ -407,13 +407,55 @@ mod test {
         assert_eq!(original_name, std::env::var("TEST_WORKSPACE").unwrap());
     }
 
+    /// Create a temp directory to act as a runfiles directory for testing
+    /// [super::Mode::DirectoryBased] style runfiles.
+    fn make_runfiles_like_dir(name: &str) -> String {
+        with_mock_env([("FAKE", None::<&str>)], || {
+            let r = Runfiles::create().unwrap();
+
+            let path = "rules_rust/rust/runfiles/data/sample.txt";
+            let f = rlocation!(r, path).unwrap();
+
+            let temp_dir = PathBuf::from(std::env::var("TEST_TMPDIR").unwrap());
+            let runfiles_dir = temp_dir.join(name);
+            let test_path = runfiles_dir.join(path);
+            if let Some(parent) = test_path.parent() {
+                std::fs::create_dir_all(parent).expect("Failed to create test path parents.");
+            }
+
+            std::fs::copy(f, test_path).expect("Failed to copy test file");
+
+            runfiles_dir.to_str().unwrap().to_string()
+        })
+    }
+
+    /// Test the general behavior of runfiles. The behavior of runfiles will change
+    /// depending on the system but each mode is explicitly covered in other tests.
+    #[test]
+    fn test_standard_lookup() {
+        let r = Runfiles::create().unwrap();
+
+        let f = rlocation!(r, "rules_rust/rust/runfiles/data/sample.txt").unwrap();
+
+        let mut f = File::open(&f)
+            .unwrap_or_else(|e| panic!("Failed to open file: {}\n{:?}", f.display(), e));
+
+        let mut buffer = String::new();
+        f.read_to_string(&mut buffer).unwrap();
+
+        assert_eq!("Example Text!", buffer);
+    }
+
     /// Only `RUNFILES_DIR` is set.
     #[test]
     fn test_env_only_runfiles_dir() {
+        let runfiles_dir = make_runfiles_like_dir("test_env_only_runfiles_dir");
+
         with_mock_env(
             [
-                (TEST_SRCDIR_ENV_VAR, None::<&str>),
                 (MANIFEST_FILE_ENV_VAR, None::<&str>),
+                (RUNFILES_DIR_ENV_VAR, Some(runfiles_dir.as_str())),
+                (TEST_SRCDIR_ENV_VAR, None::<&str>),
             ],
             || {
                 let r = Runfiles::create().unwrap();
@@ -422,7 +464,8 @@ mod test {
                 let f = rlocation!(r, "rules_rust/rust/runfiles/data/sample.txt").unwrap();
                 assert_eq!(d.join("rust/runfiles/data/sample.txt"), f);
 
-                let mut f = File::open(f).unwrap();
+                let mut f = File::open(&f)
+                    .unwrap_or_else(|e| panic!("Failed to open file: {}\n{:?}", f.display(), e));
 
                 let mut buffer = String::new();
                 f.read_to_string(&mut buffer).unwrap();
@@ -435,17 +478,21 @@ mod test {
     /// Only `TEST_SRCDIR` is set.
     #[test]
     fn test_env_only_test_srcdir() {
+        let runfiles_dir = make_runfiles_like_dir("test_env_only_test_srcdir");
+
         with_mock_env(
             [
-                (RUNFILES_DIR_ENV_VAR, None::<&str>),
                 (MANIFEST_FILE_ENV_VAR, None::<&str>),
+                (RUNFILES_DIR_ENV_VAR, None::<&str>),
+                (TEST_SRCDIR_ENV_VAR, Some(runfiles_dir.as_str())),
             ],
             || {
                 let r = Runfiles::create().unwrap();
 
-                let mut f =
-                    File::open(rlocation!(r, "rules_rust/rust/runfiles/data/sample.txt").unwrap())
-                        .unwrap();
+                let runfile = rlocation!(r, "rules_rust/rust/runfiles/data/sample.txt").unwrap();
+
+                let mut f = File::open(&runfile)
+                    .unwrap_or_else(|e| panic!("Failed to open: {}\n{:?}", runfile.display(), e));
 
                 let mut buffer = String::new();
                 f.read_to_string(&mut buffer).unwrap();
@@ -455,7 +502,12 @@ mod test {
         );
     }
 
-    /// Neither `RUNFILES_DIR` or `TEST_SRCDIR` are set
+    /// `RUNFILES_DIR`, `TEST_SRCDIR`, and `MANIFEST_FILE_ENV_VAR` are not set. This
+    /// will test the `.runfiles` directory lookup.
+    ///
+    /// This test is skipped on windows as these directories are not guaranteed
+    /// to have been created.
+    #[cfg(not(target_family = "windows"))]
     #[test]
     fn test_env_nothing_set() {
         with_mock_env(