feat: end to end tests (#487)

Autoparallel · web-flow · commit c6942c77ea8a · 2025-02-27T14:56:02.000-07:00
* WIP: e2e tests

* feat: working end-to-end TEE

* chore: cleanup wasm testing

Now has mode for tee and origo

* fix: should run different modes now

* cleanup

* fix: use stdout for notary startup

* Update test_client_native_tee.yaml

* fix: use cached builds if available

* fix

* fixes

* try to fix ci

* LET'S TRY AGAIN SHALL WE
diff --git a/.github/workflows/test_client_native_tee.yaml b/.github/workflows/test_client_native_tee.yaml
@@ -36,8 +36,4 @@ jobs:
       - run: chmod +x target/release/client
 
       - run: |
-          export RUST_LOG=DEBUG
-          ./target/release/notary --config ./fixture/notary-config.toml &
-          sleep 10
-
-          ./target/release/client --config ./fixture/client.tee_tcp_local.json
+          cargo test -p web-prover-tests
diff --git a/.github/workflows/test_client_wasm_origo.yaml b/.github/workflows/test_client_wasm_origo.yaml
@@ -62,4 +62,4 @@ jobs:
           (cd client_wasm/demo/static && rm -rf build && ln -s ../../../proofs/web_proof_circuits build)
 
           cd client_wasm/demo
-          npm test
+          npm test origo
diff --git a/.github/workflows/test_client_wasm_tee.yaml b/.github/workflows/test_client_wasm_tee.yaml
@@ -61,9 +61,5 @@ jobs:
           # symlink proofs/web_proof_circuits
           (cd client_wasm/demo/static && rm -rf build && ln -s ../../../proofs/web_proof_circuits build)
 
-          # TODO quick workaround to use TEE fixture instead of Origo fixture in
-          #      client_wasm/demo/js/index.js proverConfig
-          cp fixture/client.tee_tcp_local.json fixture/client.origo_tcp_local.json
-
           cd client_wasm/demo
-          npm test
+          npm test tee
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,9 +3,7 @@ name   ="webprover"
 edition="2021"
 
 [workspace]
-members=["client", "client_ios", "client_wasm", "notary", "proofs", "web-prover-core"]
-# members =["client", "client_wasm", "proofs"] # config for wasm32 rust analyzer
-# members =["client", "client_ios"] # config for ios rust analyzer
+members =["client", "client_ios", "client_wasm", "notary", "proofs", "web-prover-core", "tests"]
 resolver="2"
 
 [workspace.metadata]
@@ -16,6 +14,7 @@ web_prover_circuits_version="0.10.0"
 # Local re-exporting
 client         ={ path="client" }
 proofs         ={ path="proofs" }
+notary         ={ path="notary" }
 web-prover-core={ path="web-prover-core" }
 # Serde
 serde     ={ version="1.0.204", features=["derive"] }
@@ -66,6 +65,8 @@ ff         ={ version="0.13", default-features=false, features=["derive"] }
 tiny-keccak={ version="2.0.2", features=["keccak"] }
 url        ="2.5.4"
 
+tracing-test="0.2"
+
 [profile.dev]
 opt-level      =1
 split-debuginfo="unpacked"
diff --git a/client_wasm/demo/js/index.js b/client_wasm/demo/js/index.js
@@ -1,6 +1,8 @@
 import init, { setup_tracing, initThreadPool } from "../pkg/client_wasm.js";
-import { witness } from "./witness";
 import { WEB_PROVER_CIRCUITS_VERSION } from "./config";
+import teeConfig from "../../../fixture/client.tee_tcp_local.json";
+import origoConfig from "../../../fixture/client.origo_tcp_local.json";
+import { DEFAULT_MODE } from "../scripts/test.js";
 
 const numConcurrency = navigator.hardwareConcurrency;
 
@@ -65,7 +67,10 @@ const getByteParams = async function (setupFile) {
 
 start();
 
-import proverConfig from "../../../fixture/client.origo_tcp_local.json";
+const mode = window.MODE || DEFAULT_MODE; // Get the mode from window object
+const proverConfig = mode === 'origo' ? origoConfig : teeConfig;
+
+console.log(`Using ${mode} mode`);
 
 const proofWorker = new Worker(new URL("./proof.js", import.meta.url), {
   type: "module",
diff --git a/client_wasm/demo/package.json b/client_wasm/demo/package.json
@@ -5,7 +5,7 @@
   "scripts": {
     "prestart": "node scripts/generate-config.js",
     "start": "webpack-dev-server --port 8090",
-    "test": "node scripts/generate-config.js && playwright test --browser=chromium"
+    "test": "node scripts/generate-config.js && node scripts/test.js"
   },
   "devDependencies": {
     "@wasm-tool/wasm-pack-plugin": "^1.7.0",
diff --git a/client_wasm/demo/scripts/test.js b/client_wasm/demo/scripts/test.js
@@ -0,0 +1,12 @@
+const { spawn } = require('child_process');
+
+const DEFAULT_MODE = "tee"
+
+const mode = process.argv[2] || DEFAULT_MODE; // Default to tee if no argument provided
+process.env.MODE = mode;
+
+// Run the playwright test
+spawn('npx', ['playwright', 'test', '--browser=chromium'], {
+    stdio: 'inherit',
+    env: process.env
+});
diff --git a/client_wasm/demo/tests/proof.spec.js b/client_wasm/demo/tests/proof.spec.js
@@ -1,6 +1,9 @@
 const { test, expect } = require('@playwright/test')
 
 test('should generate proof', async ({ page }) => {
+  // Set the mode on window before loading the page
+  await page.addInitScript(`window.MODE = '${process.env.MODE || 'tee'}'`);
+
   test.setTimeout(600000) // 10 min
 
   // Add page error handler
diff --git a/proofs/Cargo.toml b/proofs/Cargo.toml
@@ -40,8 +40,8 @@ wasm-bindgen-futures="0.4.37"
 circom_witnesscalc={ git="https://github.com/pluto/circom-witnesscalc" } # Fork is needed apparently??
 
 [dev-dependencies]
-tracing-test="0.2.5"
-tempdir     ="0.3.7"
+tracing-test.workspace=true
+tempdir               ="0.3.7"
 
 [build-dependencies]
 cargo_metadata="0.19.1"
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name   ="web-prover-tests"
+version="0.1.0"
+edition="2021"
+
+[dependencies]
+tokio     ={ workspace=true }
+tracing   ={ workspace=true }
+serde_json={ workspace=true }
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
@@ -0,0 +1,207 @@
+use std::{
+  io::{BufRead, BufReader},
+  path::PathBuf,
+  process::{Child, Command, Stdio},
+  sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+  },
+  thread,
+  time::Duration,
+};
+
+use tokio::time::{sleep, timeout};
+
+struct TestSetup {
+  notary: Child,
+  client: Child,
+}
+
+impl TestSetup {
+  async fn new() -> Self {
+    // Find the workspace root directory
+    let workspace_root = {
+      let output =
+        Command::new("cargo").args(["metadata", "--format-version", "1"]).output().unwrap();
+
+      if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!("cargo metadata failed: {}", stderr);
+      }
+
+      let metadata: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+
+      PathBuf::from(metadata["workspace_root"].as_str().unwrap())
+    };
+
+    println!("Workspace root: {:?}", workspace_root);
+
+    // Check for pre-built binaries in target/release
+    let notary_bin = workspace_root.join("target/release/notary");
+    let client_bin = workspace_root.join("target/release/client");
+
+    let use_prebuilt = notary_bin.exists() && client_bin.exists();
+    println!("Using pre-built binaries: {}", use_prebuilt);
+
+    // Print the config file content for debugging
+    let notary_config_path = workspace_root.join("fixture/notary-config.toml");
+    if notary_config_path.exists() {
+      match std::fs::read_to_string(&notary_config_path) {
+        Ok(content) => println!("Notary config content:\n{}", content),
+        Err(e) => println!("Error reading notary config: {}", e),
+      }
+    } else {
+      println!("Notary config file not found at {:?}", notary_config_path);
+    }
+
+    // This matches exactly what worked in your shell script
+    let mut notary = if use_prebuilt {
+      // Change directory to workspace root first
+      std::env::set_current_dir(&workspace_root).unwrap();
+      println!("Current directory: {:?}", std::env::current_dir().unwrap());
+
+      let cmd = Command::new("./target/release/notary")
+        .arg("--config")
+        .arg("./fixture/notary-config.toml")
+        .env("RUST_LOG", "DEBUG")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+      println!("Started notary with PID: {}", cmd.id());
+      cmd
+    } else {
+      Command::new("cargo")
+        .args(["run", "-p", "notary", "--release", "--"])
+        .arg("--config")
+        .arg(notary_config_path)
+        .env("RUST_LOG", "DEBUG")
+        .current_dir(&workspace_root)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap()
+    };
+
+    // Create a flag to indicate when the notary is ready
+    let ready_flag = Arc::new(AtomicBool::new(false));
+    let ready_flag_clone = ready_flag.clone();
+
+    let notary_stdout = notary.stdout.take().unwrap();
+    let notary_stderr = notary.stderr.take().unwrap();
+
+    // Spawn a thread to monitor notary output
+    thread::spawn(move || {
+      let stdout_reader = BufReader::new(notary_stdout);
+      let stderr_reader = BufReader::new(notary_stderr);
+
+      // Check both stdout and stderr for the ready message
+      for line in stdout_reader.lines().chain(stderr_reader.lines()) {
+        if let Ok(line) = line {
+          println!("Notary: {}", line);
+          if line.contains("Listening on https://0.0.0.0:7443") {
+            ready_flag_clone.store(true, Ordering::SeqCst);
+            break;
+          }
+        }
+      }
+    });
+
+    // Wait for notary to be ready with a timeout, or sleep 10 seconds like the original workflow
+    match timeout(Duration::from_secs(60), async {
+      while !ready_flag.load(Ordering::SeqCst) {
+        sleep(Duration::from_millis(100)).await;
+      }
+
+      // Add extra delay to match original workflow
+      sleep(Duration::from_secs(5)).await;
+    })
+    .await
+    {
+      Ok(_) => println!("Notary is ready!"),
+      Err(_) => {
+        println!("Timeout waiting for notary ready message - sleeping 10 seconds anyway");
+        sleep(Duration::from_secs(10)).await;
+      },
+    }
+
+    // Start client with exact same pattern as the working workflow
+    let client = if use_prebuilt {
+      // We're already in workspace_root directory
+      println!("Current directory before client: {:?}", std::env::current_dir().unwrap());
+
+      let cmd = Command::new("./target/release/client")
+        .arg("--config")
+        .arg("./fixture/client.tee_tcp_local.json")
+        .env("RUST_LOG", "DEBUG")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+      println!("Started client with PID: {}", cmd.id());
+      cmd
+    } else {
+      Command::new("cargo")
+        .args(["run", "-p", "client", "--"])
+        .arg("--config")
+        .arg(workspace_root.join("fixture/client.tee_tcp_local.json"))
+        .env("RUST_LOG", "DEBUG")
+        .current_dir(&workspace_root)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap()
+    };
+
+    Self { notary, client }
+  }
+}
+
+impl Drop for TestSetup {
+  fn drop(&mut self) {
+    let _ = self.notary.kill();
+    let _ = self.client.kill();
+  }
+}
+
+#[tokio::test]
+async fn test_proving_successful() {
+  let mut setup = TestSetup::new().await;
+
+  let stdout = BufReader::new(setup.client.stdout.take().unwrap());
+  let stderr = BufReader::new(setup.client.stderr.take().unwrap());
+
+  // Wait for proving successful with timeout
+  let result = timeout(Duration::from_secs(60), async {
+    let mut stdout_lines = stdout.lines();
+    let mut stderr_lines = stderr.lines();
+    loop {
+      // Check stdout
+      if let Some(Ok(line)) = stdout_lines.next() {
+        println!("Client stdout: {}", line);
+        if line.contains("Proving Successful") {
+          return true;
+        }
+      }
+
+      // Check stderr
+      if let Some(Ok(line)) = stderr_lines.next() {
+        println!("Client stderr: {}", line);
+        if line.contains("Proving Successful") {
+          return true;
+        }
+      }
+
+      // Small sleep to avoid busy waiting
+      sleep(Duration::from_millis(10)).await;
+    }
+  })
+  .await;
+
+  match result {
+    Ok(found) => assert!(found, "Did not find 'Proving Successful' in output"),
+    Err(_) => panic!("Timed out waiting for 'Proving Successful' after 60 seconds"),
+  }
+}
