chore(tvix/build): migrate from test_case to rstest

Change-Id: I75d8d61f836c76e8765e0e3b49022c056de84850
Reviewed-on: https://cl.tvl.fyi/c/depot/+/11466
Reviewed-by: Connor Brewster <cbrewster@hey.com>
Autosubmit: flokli <flokli@flokli.de>
Tested-by: BuildkiteCI

tvix/Cargo.lock

@@ -4318,7 +4318,7 @@ dependencies = [
  "itertools 0.12.0",
  "prost 0.12.3",
  "prost-build",
- "test-case",
+ "rstest",
  "thiserror",
  "tokio",
  "tokio-listener",

tvix/Cargo.nix

@@ -13730,8 +13730,8 @@ rec {
         ];
         devDependencies = [
           {
-            name = "test-case";
+            name = "rstest";
-            packageId = "test-case";
+            packageId = "rstest";
           }
         ];
         features = {

tvix/build/Cargo.toml

@@ -30,4 +30,4 @@ default = []
 tonic-reflection = ["dep:tonic-reflection"]
 
 [dev-dependencies]
-test-case = "3.3.1"
+rstest = "0.19.0"

tvix/build/src/buildservice/from_addr.rs

@@ -50,38 +50,41 @@ mod tests {
     use std::sync::Arc;
 
     use super::from_addr;
-    use test_case::test_case;
+    use rstest::rstest;
     use tvix_castore::{
         blobservice::{BlobService, MemoryBlobService},
         directoryservice::{DirectoryService, MemoryDirectoryService},
     };
 
+    #[rstest]
     /// This uses an unsupported scheme.
-    #[test_case("http://foo.example/test", false; "unsupported scheme")]
+    #[case::unsupported_scheme("http://foo.example/test", false)]
     /// This configures dummy
-    #[test_case("dummy://", true; "valid dummy")]
+    #[case::valid_dummy("dummy://", true)]
     /// Correct scheme to connect to a unix socket.
-    #[test_case("grpc+unix:///path/to/somewhere", true; "grpc valid unix socket")]
+    #[case::grpc_valid_unix_socket("grpc+unix:///path/to/somewhere", true)]
     /// Correct scheme for unix socket, but setting a host too, which is invalid.
-    #[test_case("grpc+unix://host.example/path/to/somewhere", false; "grpc invalid unix socket and host")]
+    #[case::grpc_invalid_unix_socket_and_host("grpc+unix://host.example/path/to/somewhere", false)]
     /// Correct scheme to connect to localhost, with port 12345
-    #[test_case("grpc+http://[::1]:12345", true; "grpc valid IPv6 localhost port 12345")]
+    #[case::grpc_valid_ipv6_localhost_port_12345("grpc+http://[::1]:12345", true)]
     /// Correct scheme to connect to localhost over http, without specifying a port.
-    #[test_case("grpc+http://localhost", true; "grpc valid http host without port")]
+    #[case::grpc_valid_http_host_without_port("grpc+http://localhost", true)]
     /// Correct scheme to connect to localhost over http, without specifying a port.
-    #[test_case("grpc+https://localhost", true; "grpc valid https host without port")]
+    #[case::grpc_valid_https_host_without_port("grpc+https://localhost", true)]
     /// Correct scheme to connect to localhost over http, but with additional path, which is invalid.
-    #[test_case("grpc+http://localhost/some-path", false; "grpc valid invalid host and path")]
+    #[case::grpc_invalid_host_and_path("grpc+http://localhost/some-path", false)]
     #[tokio::test]
-    async fn test_from_addr(uri_str: &str, is_ok: bool) {
+    async fn test_from_addr(#[case] uri_str: &str, #[case] exp_succeed: bool) {
         let blob_service: Arc<dyn BlobService> = Arc::from(MemoryBlobService::default());
         let directory_service: Arc<dyn DirectoryService> =
             Arc::from(MemoryDirectoryService::default());
-        assert_eq!(
+
-            from_addr(uri_str, blob_service, directory_service)
+        let resp = from_addr(uri_str, blob_service, directory_service).await;
-                .await
+
-                .is_ok(),
+        if exp_succeed {
-            is_ok
+            resp.expect("should succeed");
-        )
+        } else {
+            assert!(resp.is_err(), "should fail");
+        }
     }
 }

tvix/build/src/proto/mod.rs

@@ -236,28 +236,27 @@ impl build_request::BuildConstraints {
 
 #[cfg(test)]
 mod tests {
-    use test_case::test_case;
+    use super::{is_clean_path, is_clean_relative_path};
+    use rstest::rstest;
 
-    use crate::proto::is_clean_relative_path;
+    #[rstest]
-
+    #[case::fail_trailing_slash("foo/bar/", false)]
-    use super::is_clean_path;
+    #[case::fail_dotdot("foo/../bar", false)]
-
+    #[case::fail_singledot("foo/./bar", false)]
-    #[test_case("foo/bar/", false; "fail trailing slash")]
+    #[case::fail_unnecessary_slashes("foo//bar", false)]
-    #[test_case("foo/../bar", false; "fail dotdot")]
+    #[case::fail_absolute_unnecessary_slashes("//foo/bar", false)]
-    #[test_case("foo/./bar", false; "fail singledot")]
+    #[case::ok_empty("", true)]
-    #[test_case("foo//bar", false; "fail unnecessary slashes")]
+    #[case::ok_relative("foo/bar", true)]
-    #[test_case("//foo/bar", false; "fail absolute unnecessary slashes")]
+    #[case::ok_absolute("/", true)]
-    #[test_case("", true; "ok empty")]
+    #[case::ok_absolute2("/foo/bar", true)]
-    #[test_case("foo/bar", true; "ok relative")]
+    fn test_is_clean_path(#[case] s: &str, #[case] expected: bool) {
-    #[test_case("/", true; "ok absolute")]
-    #[test_case("/foo/bar", true; "ok absolute2")]
-    fn test_is_clean_path(s: &str, expected: bool) {
         assert_eq!(is_clean_path(s), expected);
     }
 
-    #[test_case("/", false; "fail absolute")]
+    #[rstest]
-    #[test_case("foo/bar", true; "ok relative")]
+    #[case::fail_absolute("/", false)]
-    fn test_is_clean_relative_path(s: &str, expected: bool) {
+    #[case::ok_relative("foo/bar", true)]
+    fn test_is_clean_relative_path(#[case] s: &str, #[case] expected: bool) {
         assert_eq!(is_clean_relative_path(s), expected);
     }