Download tests from releases

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

Cargo.lock

@@ -10,8 +10,11 @@ rust-version.workspace = true
 
 [dependencies]
 anyhow = "1.0"
+flate2 = "1.0"
 json5 = "0.4.1"
+reqwest = { version = "0.12", features = ["blocking"] }
 serde = "1.0"
+tar = "0.4.40"
 testing-framework = { path = "../testing-framework" }
 
 [lints]

tests/conformance-tests/Cargo.toml

@@ -1,32 +1,33 @@
-use std::collections::HashMap;
-
 use anyhow::Context as _;
 
 fn main() {
-    let dir = std::fs::read_dir("/Users/rylev/Code/fermyon/conformance-test/tests").unwrap();
-    for entry in dir {
+    let tests_dir = download_tests();
+
+    for entry in std::fs::read_dir(tests_dir).unwrap() {
         let entry = entry.unwrap();
+        if !entry.path().is_dir() {
+            continue;
+        }
         let spin_binary = "/Users/rylev/.local/bin/spin".into();
         let test_config = std::fs::read_to_string(entry.path().join("test.json5")).unwrap();
         let test_config: TestConfig = json5::from_str(&test_config).unwrap();
-        let config = testing_framework::TestEnvironmentConfig::spin(
+        let env_config = testing_framework::TestEnvironmentConfig::spin(
             spin_binary,
-            ["-f".into(), entry.path().to_str().unwrap().into()],
+            [],
             move |e| {
+                e.copy_into(entry.path().join("target"), "target")
+                    .context("failed to copy target directory")?;
                 e.copy_into(entry.path().join("spin.toml"), "spin.toml")
                     .context("failed to copy spin.toml")?;
-                let mut cmd = std::process::Command::new("spin");
-                cmd.env("CARGO_TARGET_DIR", entry.path().join("target"));
-                cmd.args(["build", "-f", entry.path().to_str().unwrap()]);
-                e.run_in(&mut cmd)?;
                 Ok(())
             },
             testing_framework::ServicesConfig::none(),
             testing_framework::runtimes::SpinAppType::Http,
         );
-        let mut env = testing_framework::TestEnvironment::up(config, |_| Ok(())).unwrap();
+        let mut env = testing_framework::TestEnvironment::up(env_config, |_| Ok(())).unwrap();
         let spin = env.runtime_mut();
         for invocation in test_config.invocations {
+            let Invocation::Http(invocation) = invocation;
             let headers = invocation
                 .request
                 .headers
@@ -53,7 +54,7 @@ fn main() {
                 .headers()
                 .iter()
                 .map(|(k, v)| (k.to_lowercase(), v.to_lowercase()))
-                .collect::<HashMap<_, _>>();
+                .collect::<std::collections::HashMap<_, _>>();
             for expected_header in invocation.response.headers {
                 let expected_name = expected_header.name.to_lowercase();
                 let expected_value = expected_header.value.map(|v| v.to_lowercase());
@@ -83,13 +84,45 @@ fn main() {
     }
 }
 
+/// Download the conformance tests and return the path to the directory where they are written to
+fn download_tests() -> std::path::PathBuf {
+    let response = reqwest::blocking::get(
+        "https://github.com/fermyon/conformance-tests/releases/download/canary/tests.tar.gz",
+    )
+    .unwrap()
+    .error_for_status()
+    .unwrap();
+    let response = flate2::read::GzDecoder::new(response);
+    let dir = std::env::temp_dir().join("conformance-tests");
+    for entry in tar::Archive::new(response).entries().unwrap() {
+        let mut entry = entry.unwrap();
+        if entry.header().entry_type() != tar::EntryType::Regular {
+            continue;
+        }
+        let path = dir.join(entry.path().unwrap());
+        let parent_dir = path.parent().unwrap();
+        std::fs::create_dir_all(&parent_dir).unwrap();
+        let mut file = std::fs::File::create(&path).unwrap();
+        std::io::copy(&mut entry, &mut file).unwrap();
+    }
+    dir
+}
+
+/// The configuration of a conformance test
 #[derive(Debug, serde::Deserialize)]
 struct TestConfig {
     invocations: Vec<Invocation>,
 }
 
 #[derive(Debug, serde::Deserialize)]
-struct Invocation {
+#[serde(untagged)]
+enum Invocation {
+    Http(HttpInvocation),
+}
+
+/// An invocation of the runtime
+#[derive(Debug, serde::Deserialize)]
+struct HttpInvocation {
     request: Request,
     response: Response,
 }