Merge pull request #1920 from mintlayer/trezor_tests_auto_confirmer

Auto-confirm dialogs during trezor_signer tests

Author: ImplOfAnImpl

Cargo.lock

@@ -215,7 +215,7 @@ serde = "1.0"
 serde_json = "1.0"
 serde_test = "1.0"
 serde_with = "3.6"
-serial_test = "3.0"
+serial_test = "3.2"
 sha-1 = "0.10"
 sha2 = "0.10"
 sha3 = "0.10"

Cargo.toml

@@ -15,7 +15,7 @@
 
 use std::{borrow::Cow, ffi::OsString};
 
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Debug, Clone, thiserror::Error, PartialEq, Eq)]
 pub enum GetFromEnvError {
     #[error("Env var {var_name}'s contents are not valid unicode: {data:?}")]
     NotUnicode { var_name: String, data: OsString },

logging/src/utils.rs

@@ -15,6 +15,7 @@ randomness = { path = "../randomness" }
 serialization = { path = "../serialization" }
 utils = { path = "../utils" }
 
+ctor.workspace = true
 hex.workspace = true
 itertools.workspace = true
 rand_chacha.workspace = true

test-utils/Cargo.toml

@@ -18,6 +18,7 @@ pub mod mock_time_getter;
 pub mod nft_utils;
 pub mod random;
 pub mod test_dir;
+pub mod threading;
 
 use std::collections::BTreeMap;
 

test-utils/src/lib.rs

@@ -0,0 +1,79 @@
+// Copyright (c) 2021-2025 RBB S.r.l
+// opensource@mintlayer.org
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::{
+    backtrace::{Backtrace, BacktraceStatus},
+    cell::Cell,
+    thread::{self, JoinHandle},
+};
+
+use logging::log;
+
+/// Spawn a new thread; if the thread panics, abort the process immediately.
+pub fn spawn_thread_aborting_on_panic<F, R>(func: F) -> JoinHandle<R>
+where
+    F: FnOnce() -> R + Send + std::panic::UnwindSafe + 'static,
+    R: Send + 'static,
+{
+    thread::spawn(move || {
+        match std::panic::catch_unwind(func) {
+            Ok(result) => result,
+            Err(err) => {
+                let backtrace =
+                    THREAD_LOCAL_BACKTRACE.with(|b| b.take()).expect("must be set by panic hook");
+
+                // Note: downcasting to `&str` is needed to catch panics like `panic!("foo")`.
+                // And downcasting to `String` is needed to catch those like `panic!("{}", "foo")`.
+                let msg = err
+                    .downcast_ref::<&str>()
+                    .copied()
+                    .or_else(|| err.downcast_ref::<String>().map(AsRef::as_ref))
+                    .unwrap_or("???");
+                let backtrace = match backtrace.status() {
+                    BacktraceStatus::Captured => backtrace.to_string(),
+                    BacktraceStatus::Disabled => {
+                        "  ** Backtrace disabled, set the RUST_BACKTRACE env var (e.g. to 'full') **"
+                            .to_owned()
+                    }
+                    BacktraceStatus::Unsupported => "  ** Backtrace unsupported **".to_owned(),
+                    _ => "  ** Unknown backtrace status **".to_owned(),
+                };
+                log::error!(
+                    "The thread panicked with message:\n  {msg}\nand backtrace:\n{backtrace}",
+                );
+                std::process::abort();
+            }
+        }
+    })
+}
+
+// A hack to be able to get the backtrace if the func passed to `spawn_thread_aborting_on_panic` panics.
+thread_local! {
+    static THREAD_LOCAL_BACKTRACE: Cell<Option<Backtrace>> = const { Cell::new(None) };
+}
+
+fn setup_panic_handling() {
+    let old_panic_hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let trace = Backtrace::capture();
+        THREAD_LOCAL_BACKTRACE.with(move |b| b.set(Some(trace)));
+        old_panic_hook(panic_info);
+    }));
+}
+
+#[ctor::ctor]
+fn init() {
+    setup_panic_handling();
+}

test-utils/src/threading.rs

@@ -0,0 +1,88 @@
+// Copyright (c) 2021-2025 RBB S.r.l
+// opensource@mintlayer.org
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub fn get_from_env(var_name: &str) -> Result<Option<String>, Error> {
+    Ok(logging::get_from_env(var_name)?)
+}
+
+pub fn bool_from_env(var_name: &str) -> Result<Option<bool>, Error> {
+    let Some(val) = get_from_env(var_name)? else {
+        return Ok(None);
+    };
+
+    let true_vals = ["1", "yes", "true"];
+    let false_vals = ["0", "no", "false"];
+
+    if true_vals.iter().any(|true_val| val.eq_ignore_ascii_case(true_val)) {
+        Ok(Some(true))
+    } else if false_vals.iter().any(|false_val| val.eq_ignore_ascii_case(false_val)) {
+        Ok(Some(false))
+    } else {
+        Err(Error::NonBoolValue {
+            var_name: var_name.to_owned(),
+            value: val,
+        })
+    }
+}
+
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
+pub enum Error {
+    #[error("Env var {var_name}'s value '{value}' cannot be interpreted as a bool")]
+    NonBoolValue { var_name: String, value: String },
+
+    #[error("Error obtaining env var value: {0}")]
+    GetFromEnvError(#[from] logging::GetFromEnvError),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bool_from_env() {
+        let var_name = "TEST_BOOL_FROM_ENV_TEST_VAR_NAME";
+
+        let result = bool_from_env(var_name);
+        assert_eq!(result, Ok(None));
+
+        let true_vals = ["1", "yes", "yEs", "true", "TruE"];
+        let false_vals = ["0", "no", "nO", "false", "fALSE"];
+        let bad_vals = ["2", "noo", "yess"];
+
+        for val in true_vals {
+            std::env::set_var(var_name, val);
+            let result = bool_from_env(var_name);
+            assert_eq!(result, Ok(Some(true)));
+        }
+
+        for val in false_vals {
+            std::env::set_var(var_name, val);
+            let result = bool_from_env(var_name);
+            assert_eq!(result, Ok(Some(false)));
+        }
+
+        for val in bad_vals {
+            std::env::set_var(var_name, val);
+            let result = bool_from_env(var_name);
+            assert_eq!(
+                result,
+                Err(Error::NonBoolValue {
+                    var_name: var_name.to_owned(),
+                    value: val.to_owned()
+                })
+            );
+        }
+    }
+}

utils/src/env_utils.rs

@@ -27,6 +27,7 @@ pub mod debug_panic;
 pub mod default_data_dir;
 pub mod displayable_option;
 pub mod ensure;
+pub mod env_utils;
 pub mod eventhandler;
 pub mod exp_rand;
 pub mod graph_traversals;

utils/src/lib.rs

@@ -40,9 +40,10 @@ zeroize.workspace = true
 chainstate-test-framework = { path = "../chainstate/test-framework" }
 test-utils = { path = "../test-utils" }
 
-serial_test = "3.2"
-
+ctor.workspace = true
 rstest.workspace = true
+serde_json.workspace = true
+serial_test.workspace = true
 tempfile.workspace = true
 
 [features]

wallet/Cargo.toml

@@ -14,7 +14,7 @@
 // limitations under the License.
 
 #[cfg(test)]
-mod signer_test_helpers;
+mod tests;
 
 use std::sync::Arc;