Remove module level Session initialization in Rust unit tests

This was preventing the enterprise license checkout from dropping, also the initialization story is much better than it was when we added the rstest fixtures, we can get away with initialization in parallel more broadly.

Author: emesare

rust/tests/background_task.rs

@@ -1,15 +1,9 @@
 use binaryninja::background_task::*;
 use binaryninja::headless::Session;
-use rstest::*;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_background_task_registered(_session: &Session) {
+#[test]
+fn test_background_task_registered() {
+    let _session = Session::new().expect("Failed to initialize session");
     let task_progress = "test registered";
     let task = BackgroundTask::new(task_progress, false);
     BackgroundTask::running_tasks()
@@ -24,8 +18,9 @@ fn test_background_task_registered(_session: &Session) {
     assert!(!still_running, "Task still running");
 }
 
-#[rstest]
-fn test_background_task_cancellable(_session: &Session) {
+#[test]
+fn test_background_task_cancellable() {
+    let _session = Session::new().expect("Failed to initialize session");
     let task_progress = "test cancellable";
     let task = BackgroundTask::new(task_progress, false);
     BackgroundTask::running_tasks()
@@ -37,8 +32,9 @@ fn test_background_task_cancellable(_session: &Session) {
     task.finish();
 }
 
-#[rstest]
-fn test_background_task_progress(_session: &Session) {
+#[test]
+fn test_background_task_progress() {
+    let _session = Session::new().expect("Failed to initialize session");
     let task = BackgroundTask::new("test progress", false);
     let first_progress = task.progress_text().to_string();
     assert_eq!(first_progress, "test progress");

rust/tests/base_detection.rs

@@ -1,17 +1,11 @@
 use binaryninja::base_detection::{BaseAddressDetectionConfidence, BaseAddressDetectionSettings};
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::headless::Session;
-use rstest::{fixture, rstest};
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_base_detection(_session: &Session) {
+#[test]
+fn test_base_detection() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("raw_base_detection_aarch64"))
         .expect("Failed to create view");

rust/tests/binary_reader.rs

@@ -1,18 +1,12 @@
 use binaryninja::binary_reader::BinaryReader;
 use binaryninja::binary_view::{BinaryViewBase, BinaryViewExt};
 use binaryninja::headless::Session;
-use rstest::*;
 use std::io::{Read, Seek, SeekFrom};
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_binary_reader_seek(_session: &Session) {
+#[test]
+fn test_binary_reader_seek() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);
@@ -49,8 +43,9 @@ fn test_binary_reader_seek(_session: &Session) {
     );
 }
 
-#[rstest]
-fn test_binary_reader_read(_session: &Session) {
+#[test]
+fn test_binary_reader_read() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);

rust/tests/binary_view.rs

@@ -2,17 +2,11 @@ use binaryninja::binary_view::{AnalysisState, BinaryViewBase, BinaryViewExt};
 use binaryninja::headless::Session;
 use binaryninja::main_thread::execute_on_main_thread_and_wait;
 use binaryninja::symbol::{SymbolBuilder, SymbolType};
-use rstest::*;
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_binary_loading(_session: &Session) {
+#[test]
+fn test_binary_loading() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     assert!(view.has_initial_analysis(), "No initial analysis");
@@ -21,8 +15,9 @@ fn test_binary_loading(_session: &Session) {
     assert_eq!(view.file().is_database_backed(), false);
 }
 
-#[rstest]
-fn test_binary_saving(_session: &Session) {
+#[test]
+fn test_binary_saving() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     // Verify the contents before we modify.
@@ -48,8 +43,9 @@ fn test_binary_saving(_session: &Session) {
     );
 }
 
-#[rstest]
-fn test_binary_saving_database(_session: &Session) {
+#[test]
+fn test_binary_saving_database() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     // Update a symbol to verify modification

rust/tests/binary_writer.rs

@@ -2,18 +2,12 @@ use binaryninja::binary_reader::BinaryReader;
 use binaryninja::binary_view::{BinaryViewBase, BinaryViewExt};
 use binaryninja::binary_writer::BinaryWriter;
 use binaryninja::headless::Session;
-use rstest::*;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_binary_writer_seek(_session: &Session) {
+#[test]
+fn test_binary_writer_seek() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut writer = BinaryWriter::new(&view);
@@ -50,8 +44,9 @@ fn test_binary_writer_seek(_session: &Session) {
     );
 }
 
-#[rstest]
-fn test_binary_writer_write(_session: &Session) {
+#[test]
+fn test_binary_writer_write() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let mut reader = BinaryReader::new(&view);

rust/tests/collaboration.rs

@@ -1,22 +1,14 @@
 use binaryninja::binary_view::BinaryViewExt;
-use binaryninja::collaboration::{
-    has_collaboration_support, NoNameChangeset, Remote, RemoteFileType, RemoteProject,
-};
+use binaryninja::collaboration::{NoNameChangeset, Remote, RemoteFileType, RemoteProject};
 use binaryninja::headless::Session;
+use binaryninja::rc::Ref;
 use binaryninja::symbol::{SymbolBuilder, SymbolType};
 use rstest::*;
 use serial_test::serial;
+use std::env;
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-// TODO: This cannot run in CI, as headless does not have collaboration, we should gate this.
 // TODO: Why cant we create_project for the same project name? why does that fail.
-
 // TODO: Remote connection / disconnection is NOT thread safe, the core needs to lock on each.
 // TODO: Because of this we run these tests serially, this isnt _really_ an issue for real code, as
 // TODO: Real code shouldnt be trying to connect to the same remote on multiple threads.
@@ -28,6 +20,13 @@ fn temp_project_scope<T: Fn(&RemoteProject)>(remote: &Remote, project_name: &str
         // TODO: have connected by the time this errors out. Maybe?
         let _ = remote.connect();
     }
+
+    if let Ok(home_dir) = env::var("HOME").or_else(|_| env::var("USERPROFILE")) {
+        eprintln!("Current user directory: {}", home_dir);
+    } else {
+        eprintln!("Unable to determine the current user directory.");
+    }
+
     let project = remote
         .create_project(project_name, "Test project for test purposes")
         .expect("Failed to create project");
@@ -56,15 +55,26 @@ fn temp_project_scope<T: Fn(&RemoteProject)>(remote: &Remote, project_name: &str
         .expect("Failed to delete project");
 }
 
+/// Get the selected remote to test with.
+fn selected_remote() -> Option<Ref<Remote>> {
+    // If the user has initialized with a enterprise server we might already have an active remote.
+    match binaryninja::collaboration::active_remote() {
+        Some(remote) => Some(remote),
+        None => {
+            let remotes = binaryninja::collaboration::known_remotes();
+            remotes.iter().next().map(|r| r.clone())
+        }
+    }
+}
+
 #[rstest]
 #[serial]
-fn test_connection(_session: &Session) {
-    if !has_collaboration_support() {
-        eprintln!("No collaboration support, skipping test...");
+fn test_connection() {
+    let _session = Session::new().expect("Failed to initialize session");
+    let Some(remote) = selected_remote() else {
+        eprintln!("No known remotes, skipping test...");
         return;
-    }
-    let remotes = binaryninja::collaboration::known_remotes();
-    let remote = remotes.iter().next().expect("No known remotes!");
+    };
     assert!(remote.connect().is_ok(), "Failed to connect to remote");
     remote
         .disconnect()
@@ -74,13 +84,12 @@ fn test_connection(_session: &Session) {
 
 #[rstest]
 #[serial]
-fn test_project_creation(_session: &Session) {
-    if !has_collaboration_support() {
-        eprintln!("No collaboration support, skipping test...");
+fn test_project_creation() {
+    let _session = Session::new().expect("Failed to initialize session");
+    let Some(remote) = selected_remote() else {
+        eprintln!("No known remotes, skipping test...");
         return;
-    }
-    let remotes = binaryninja::collaboration::known_remotes();
-    let remote = remotes.iter().next().expect("No known remotes!");
+    };
     temp_project_scope(&remote, "test_creation", |project| {
         // Create the file than verify it by opening and checking contents.
         let created_file = project
@@ -155,13 +164,12 @@ fn test_project_creation(_session: &Session) {
 
 #[rstest]
 #[serial]
-fn test_project_sync(_session: &Session) {
-    if !has_collaboration_support() {
-        eprintln!("No collaboration support, skipping test...");
+fn test_project_sync() {
+    let _session = Session::new().expect("Failed to initialize session");
+    let Some(remote) = selected_remote() else {
+        eprintln!("No known remotes, skipping test...");
         return;
-    }
-    let remotes = binaryninja::collaboration::known_remotes();
-    let remote = remotes.iter().next().expect("No known remotes!");
+    };
     temp_project_scope(&remote, "test_sync", |project| {
         // Open a view so that we can upload it.
         let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();

rust/tests/component.rs

@@ -1,17 +1,11 @@
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::component::ComponentBuilder;
 use binaryninja::headless::Session;
-use rstest::*;
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_component_creation(_session: &Session) {
+#[test]
+fn test_component_creation() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let component = ComponentBuilder::new(view.clone()).name("test").finalize();

rust/tests/demangler.rs

@@ -6,16 +6,10 @@ use binaryninja::demangle::{
 use binaryninja::headless::Session;
 use binaryninja::rc::Ref;
 use binaryninja::types::{QualifiedName, Type};
-use rstest::*;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_demangler_simple(_session: &Session) {
+#[test]
+fn test_demangler_simple() {
+    let _session = Session::new().expect("Failed to initialize session");
     let placeholder_arch = CoreArchitecture::by_name("x86").expect("x86 exists");
     // Example LLVM-style mangled name
     let llvm_mangled = "_Z3fooi"; // "foo(int)" in LLVM mangling
@@ -45,8 +39,9 @@ fn test_demangler_simple(_session: &Session) {
     );
 }
 
-#[rstest]
-fn test_custom_demangler(_session: &Session) {
+#[test]
+fn test_custom_demangler() {
+    let _session = Session::new().expect("Failed to initialize session");
     struct TestDemangler;
 
     impl CustomDemangler for TestDemangler {

rust/tests/high_level_il.rs

@@ -1,17 +1,11 @@
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::headless::Session;
 use binaryninja::high_level_il::{HighLevelILInstructionKind, HighLevelInstructionIndex};
-use rstest::*;
 use std::path::PathBuf;
 
-#[fixture]
-#[once]
-fn session() -> Session {
-    Session::new().expect("Failed to initialize session")
-}
-
-#[rstest]
-fn test_hlil_info(_session: &Session) {
+#[test]
+fn test_hlil_info() {
+    let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let view = binaryninja::load(out_dir.join("atox.obj")).expect("Failed to create view");
     let image_base = view.original_image_base();

rust/tests/initialization.rs

@@ -5,12 +5,11 @@ use binaryninja::headless::{
     init, init_with_opts, shutdown, InitializationError, InitializationOptions,
 };
 use binaryninja::set_license;
-use rstest::rstest;
 
 // NOTE: Do not add any tests here, behavior will change (i.e. a failure might pass) if we initialize
 // NOTE: The core in another test. The only test here should be `test_license_validation`.
 
-#[rstest]
+#[test]
 fn test_license_validation() {
     // Release floating license if we already have one, otherwise the failure will succeed.
     release_license();