Webdriver based UI testing of Tauri + Sycamore

[humb1t]

Hello there, I would like to ask if someone has succeed in configuring UI automated tests using Sycamore (as part of tauri app) and webdriver? As Tauri guide and examples focuses on npm based frontends, it is a little bit non-trivial and I am looking for existing examples without success at the moment(

[humb1t]

Just a simple example of what #55 (comment) discussed here linked to sycamore repo and docs may be enough.

[arctic-hen7]

I may be horribly out of date, but Perseus (now-mostly-outdated fullstack framework for Sycamore) had a lot of end-to-end testing built with fantoccini...some of that code might be helpful? Quite manual and a bit verbose, but it worked. You could have a look through the codebase there, every example had E2E tests and the harness was pretty minimal (from memory just a macro that did a little bit of framework-specific work).

[humb1t]

Thanks, they have nice examples, I will read them https://github.com/framesurge/perseus/blob/383a96a26d2da75d9c54814422c4b1347f268516/docs/0.3.4/en-US/reference/testing/manual.md?plain=1#L3

[humb1t]

const DRIVER_URL: &str = "http://127.0.0.1:4444";

// Singleton tauri-driver process, started once for all tests.
static DRIVER: LazyLock<Option<Child>> = LazyLock::new(|| {
    println!("running driver...");
    let bin = which::which("tauri-driver").ok()?;
    let mut child = std::process::Command::new(&bin).args(["--port", "4444"]).spawn().ok()?;
    println!("spawned driver {bin:?}...");
    // Give tauri-driver + WebKitWebDriver time to boot
    std::thread::sleep(Duration::from_secs(5));
    println!("waiting for driver...");
    // Check if tauri-driver is still alive (exits immediately if WebKitWebDriver is missing)
    match child.try_wait() {
        Ok(Some(status)) => {
            eprintln!("tauri-driver exited with {status}");
            None
        },
        Ok(None) => Some(child),
        Err(error) => {
            eprintln!("error occured during driver run: {error}");
            None
        },
    }
});

pub async fn with_client() -> Client {
    if DRIVER.is_none() {
        std::thread::sleep(Duration::from_secs(5));
        panic!("tauri-driver not running (see stderr for details)");
    } else {
        println!("running dizola app");
        let app_bin = std::env::var("DIZOLA_APP_BIN").unwrap_or_else(|_| "target/debug/dizola-app".to_string());
        let mut caps = Map::<String, Value>::new();
        let mut tauri_opts = Map::<String, Value>::new();
        tauri_opts.insert("application".to_string(), json!(app_bin));
        caps.insert("tauri:options".to_string(), Value::Object(tauri_opts));
        println!("building client for our app");
        let client = ClientBuilder::native()
            .capabilities(caps)
            .connect(DRIVER_URL)
            .await
            .expect("failed to connect");
        client
            .goto("tauri://localhost")
            .await
            .expect("failed to navigate to initial host");
        client
            .wait()
            .for_element(Locator::Css(".app"))
            .await
            .expect("Sycamore .app div not found - app didn't mount");
        std::thread::sleep(Duration::from_millis(500));
        client
    }
}

a little bit of WIP monster that I made.

Currently it's succesfully running the infrastructure, but I still have issues on how to connect tauri and fantoccini. Will keep this thread updated until I solve it

[humb1t]

I think current problem is that I don't understand sycamore + tauri app good enough.

When I do cargo tauri build --debug --no-bundle and than run ./target/debug/dizola-app manually, I see "Could not connect to localhost: Connection refused" error.

[humb1t]

So - very dirty, but working setup:

// Singleton tauri-driver process, started once for all tests.
static DRIVER: LazyLock<Option<DriverGuard>> = LazyLock::new(|| {
    // Ensure panic hook is registered before spawning any processes
    *_PANIC_GUARD;

    println!("running driver...");
    let bin = which::which("tauri-driver").ok()?;
    let mut cmd = std::process::Command::new(&bin);
    let mut child = cmd.args(["--port", "4444"]).process_group(0).spawn().ok()?;
    DRIVER_PGROUP.store(child.id(), Ordering::Relaxed);
    println!("spawned driver {bin:?}...");
    // Give tauri-driver + WebKitWebDriver time to boot
    std::thread::sleep(Duration::from_secs(5));
    println!("waiting for driver...");
    // Check if tauri-driver is still alive (exits immediately if WebKitWebDriver is missing)
    match child.try_wait() {
        Ok(Some(status)) => {
            eprintln!("tauri-driver exited with {status}");
            DRIVER_PGROUP.store(0, Ordering::Relaxed);
            None
        },
        Ok(None) => Some(DriverGuard { child }),
        Err(error) => {
            eprintln!("error occured during driver run: {error}");
            DRIVER_PGROUP.store(0, Ordering::Relaxed);
            None
        },
    }
});

pub async fn with_client() -> Client {
    // Force driver initialization so its Drop runs on test exit.
    // This also ensures the panic hook is registered before we proceed.
    let _ = *DRIVER;

    if DRIVER.is_none() {
        panic!("tauri-driver not running (see stderr for details)");
    } else {
        println!("running dizola app");
        let app_bin = std::env::var("DIZOLA_APP_BIN").unwrap_or_else(|_| {
            let test_exe = std::env::current_exe().unwrap();
            // Test binaries are in target/{profile}/deps/, app binary in target/{profile}/
            let target_dir = test_exe
                .parent()
                .and_then(|p| p.parent())
                .expect("can't find target directory from test exe");
            let mut app_bin = target_dir.join("dizola-app");
            if !app_bin.exists() {
                // Fallback: try parent's debug/release dirs
                if let Some(parent) = target_dir.parent() {
                    for profile in &["debug", "release"] {
                        let candidate = parent.join(profile).join("dizola-app");
                        if candidate.exists() {
                            app_bin = candidate;
                            break;
                        }
                    }
                }
            }
            app_bin.display().to_string()
        });
        let mut caps = Map::<String, Value>::new();
        let mut tauri_opts = Map::<String, Value>::new();
        tauri_opts.insert("application".to_string(), json!(app_bin));
        caps.insert("tauri:options".to_string(), Value::Object(tauri_opts));
        println!("building client for our app");
        let client = ClientBuilder::native()
            .capabilities(caps)
            .connect(DRIVER_URL)
            .await
            .expect("failed to connect");
        client
            .goto("tauri://localhost")
            .await
            .expect("failed to navigate to initial host");
        client
            .wait()
            .for_element(Locator::Css(".app"))
            .await
            .expect("Sycamore .app div not found - app didn't mount");
        std::thread::sleep(Duration::from_millis(500));
        client
    }
}