State management not working, please help

[39george]

I want to test my command handler. If I register state within setup method, I get panic:

    fn create_app(
        builder: tauri::Builder<MockRuntime>,
    ) -> tauri::App<MockRuntime> {
        builder
            .plugin(tauri_plugin_opener::init())
            .plugin(tauri_plugin_store::Builder::default().build())
            .setup(|app| {
                // let store: super::Store = app.store("store.json")?;
                // app.manage(store);
                app.manage(String::new());
                Ok(())
            })
            .invoke_handler(tauri::generate_handler![
                super::auth::set_app_password,
                super::auth::example
            ])
            // remove the string argument to use your app's config file
            .build(tauri::generate_context!())
            .expect("failed to build app")

#[tauri::command]
pub fn example(
    store: tauri::State<'_, String>,
    password: String,
) -> Result<(), String> {
    println!("Password: {password}");
    Ok(())
}

running 1 test

thread 'tests::test_tauri' panicked at rustwallet/src-tauri/src/lib.rs:57:18:
called `Result::unwrap()` on an `Err` value: String("state not managed for field `store` on command `example`. You must call `.manage()` before using this command")
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test tests::test_tauri ... FAILED

failures:

failures:
    tests::test_tauri

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.01s

error: test failed, to rerun pass `--lib`

It will work only if I call manage method directly on builder. But actually I want to use tauri_plugin_store::Store, and it requires to be built within setup method, it wants app to be available. Tauri docs says I can use setup to manage state:

use tauri::{Builder, Manager};

struct AppData {
  welcome_message: &'static str,
}

fn main() {
  Builder::default()
    .setup(|app| {
      app.manage(AppData {
        welcome_message: "Welcome to Tauri!",
      });
      Ok(())
    })
    .run(tauri::generate_context!())
    .unwrap();
}

Please help, what I'm doing wrong?

[FabianLars]

Can you maybe share tests::test_tauri as well? (Your actual test that uses the code you showed)

Also for completeness sake the output of the tauri info command would be appreciated:)

[39george]

Here it is:

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use serde::de::DeserializeOwned;
    use serde_json::json;
    use tauri::{
        Manager, WebviewWindow,
        test::{MockRuntime, mock_builder},
    };
    use tauri_plugin_store::StoreExt;

    #[test]
    fn test_tauri() {
        let app = create_app(mock_builder());
        let webview =
            tauri::WebviewWindowBuilder::new(&app, "main", Default::default())
                .build()
                .unwrap();

        let _res: () =
            make_call(&webview, "example", json!({"password": "goodpassword"}))
                .unwrap();
    }

    fn create_app(
        builder: tauri::Builder<MockRuntime>,
    ) -> tauri::App<MockRuntime> {
        builder
            .plugin(tauri_plugin_opener::init())
            .plugin(tauri_plugin_store::Builder::default().build())
            .setup(|app| {
                // let store: super::Store = app.store("store.json")?;
                // app.manage(store);
                app.manage(String::new());
                Ok(())
            })
            .invoke_handler(tauri::generate_handler![
                super::auth::set_app_password,
                super::auth::example
            ])
            // remove the string argument to use your app's config file
            .build(tauri::generate_context!())
            .expect("failed to build app")
    }

    fn make_call<T>(
        webview: &WebviewWindow<MockRuntime>,
        method: &str,
        params: serde_json::Value,
    ) -> Result<T, serde_json::Value>
    where
        T: DeserializeOwned,
    {
        tauri::test::get_ipc_response(
            webview,
            tauri::webview::InvokeRequest {
                cmd: method.into(),
                callback: tauri::ipc::CallbackFn(0),
                error: tauri::ipc::CallbackFn(1),
                // alternatively use "tauri://localhost"
                url: "http://tauri.localhost".parse().unwrap(),
                body: tauri::ipc::InvokeBody::Json(params),
                headers: Default::default(),
                invoke_key: tauri::test::INVOKE_KEY.to_string(),
            },
        )
        .map(|b| b.deserialize::<T>().unwrap())
    }
}

[39george]

I figured out that setup hook never called with MockRuntime

[39george]

I added run call to app, and it moved further:

    #[test]
    fn test_tauri() {
        let app = create_app(mock_builder());
        let webview =
            tauri::WebviewWindowBuilder::new(&app, "main", Default::default())
                .build()
                .unwrap();
        app.run(|_app_handle, event| match event {
            tauri::RunEvent::ExitRequested { api, .. } => {
                api.prevent_exit();
            }
            _ => {}
        });

        let _res: () =
            make_call(&webview, "example", json!({"password": "goodpassword"}))
                .unwrap();
    }

But now it fails with

Failed to setup app: a webview with label `main` already exists
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test tests::test_tauri ... FAILED

I tried to replace webview creation with that code:

        // let webview =
        //     tauri::WebviewWindowBuilder::new(&app, "main", Default::default())
        //         .build()
        //         .unwrap();
        let webview = app.get_webview_window("main").unwrap();

But got:

called `Option::unwrap()` on a `None` value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test tests::test_tauri ... FAILED

[39george]

Finally worked code:

    #[test]
    fn test_tauri() {
        let app = create_app(mock_builder());
        let webview =
            tauri::WebviewWindowBuilder::new(&app, "test", Default::default())
                .build()
                .unwrap();

        std::thread::spawn(move || {
            app.run(|_app_handle, event| match event {
                tauri::RunEvent::ExitRequested { api, .. } => {
                    api.prevent_exit();
                }
                _ => {}
            });
        });
        // Without this, the state is still not managed - the setup callback doesn't get called
        std::thread::sleep(std::time::Duration::from_secs(1));

        let _res: () =
            make_call(&webview, "example", json!({"password": "goodpassword"}))
                .unwrap();
    }

Could you help me understand why I can't create windows with the 'main' label during testing, and if my test setup approach is appropriate?

[FabianLars]

Could you help me understand why I can't create windows with the 'main' label during testing

Do you have windows configured in tauri.conf.json? That may still be read in tests, not sure. If not then it looks like a bug.

and if my test setup approach is appropriate?

hmm, guess so. it's a bit unfortunate that setup doesn't run though. i think it's supposed to work so maybe a bug as well.