Improve tests

Author: Qard

.github/workflows/CI.yml

@@ -59,7 +59,7 @@ jobs:
       - uses: actions/setup-node@v4
         if: ${{ !matrix.settings.docker }}
         with:
-          node-version: 20
+          node-version: 24
       - name: Install
         uses: dtolnay/rust-toolchain@stable
         if: ${{ !matrix.settings.docker }}
@@ -161,18 +161,31 @@ jobs:
           if-no-files-found: error
 
   test-macOS-windows-binding:
-    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
+    name: Test ${{ matrix.settings.target }} - node@${{ matrix.node }} + python@${{ matrix.python }}
     needs:
       - build
     strategy:
       fail-fast: false
       matrix:
         settings:
-          - host: macos-latest
+          - host: macos-13
             target: x86_64-apple-darwin
+            architecture: x64
+          - host: macos-latest
+            target: aarch64-apple-darwin
+            architecture: arm64
         node:
           - '18'
           - '20'
+          - '22'
+          - '24'
+        python:
+          - '3.8'
+          - '3.9'
+          - '3.10'
+          - '3.11'
+          - '3.12'
+          - '3.13'
     runs-on: ${{ matrix.settings.host }}
     steps:
       - uses: actions/checkout@v4
@@ -187,8 +200,12 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
+          architecture: ${{ matrix.settings.architecture }}
           cache: pnpm
-          architecture: x64
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+          architecture: ${{ matrix.settings.architecture }}
       - run: pnpm install
       - uses: actions/download-artifact@v4
         with:
@@ -209,7 +226,7 @@ jobs:
       - run: pnpm test
 
   test-linux-binding:
-    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
+    name: Test ${{ matrix.settings.target }} - node@${{ matrix.node }} + python@${{ matrix.python }}
     needs:
       - build
     strategy:
@@ -218,6 +235,7 @@ jobs:
         settings:
           - host: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
+            architecture: x64
           # Not supported yet.
           # - host: ubuntu-22.04
           #   target: x86_64-unknown-linux-musl
@@ -229,6 +247,15 @@ jobs:
         node:
           - '18'
           - '20'
+          - '22'
+          - '24'
+        python:
+          - '3.8'
+          - '3.9'
+          - '3.10'
+          - '3.11'
+          - '3.12'
+          - '3.13'
     runs-on: ${{ matrix.settings.host }}
     steps:
       - uses: actions/checkout@v4
@@ -239,7 +266,12 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
+          architecture: ${{ matrix.settings.architecture }}
           cache: pnpm
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+          architecture: ${{ matrix.settings.architecture }}
       - name: Install dependencies
         run: pnpm install
       - name: Fix soname

Cargo.lock

@@ -35,6 +35,7 @@ pyo3 = { version = "0.25.1", features = ["experimental-async"] }
 pyo3-async-runtimes = { version = "0.25.0", features = ["tokio-runtime"] }
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = ["full"] }
+libc = "0.2"
 
 [build-dependencies]
 napi-build = { version = "2", optional = true }

Cargo.toml

@@ -160,4 +160,168 @@ mod tests {
       assert_eq!(message, LifespanSendMessage::LifespanStartupComplete);
     });
   }
+
+  #[test]
+  fn test_lifespan_send_message_from_pyobject_error_cases() {
+    Python::with_gil(|py| {
+      // Test missing 'type' key
+      let dict = PyDict::new(py);
+      let result: Result<LifespanSendMessage, _> = dict.extract();
+      assert!(result.is_err());
+      assert!(
+        result
+          .unwrap_err()
+          .to_string()
+          .contains("Missing 'type' key")
+      );
+
+      // Test unknown message type
+      let dict = PyDict::new(py);
+      dict.set_item("type", "unknown.message.type").unwrap();
+      let result: Result<LifespanSendMessage, _> = dict.extract();
+      assert!(result.is_err());
+      assert!(
+        result
+          .unwrap_err()
+          .to_string()
+          .contains("Unknown Lifespan send message type")
+      );
+
+      // Test non-dict object
+      let list = py.eval(c"[]", None, None).unwrap();
+      let result: Result<LifespanSendMessage, _> = list.extract();
+      assert!(result.is_err());
+
+      // Test invalid type value (not string)
+      let dict = PyDict::new(py);
+      dict.set_item("type", 123).unwrap();
+      let result: Result<LifespanSendMessage, _> = dict.extract();
+      assert!(result.is_err());
+    });
+  }
+
+  #[test]
+  fn test_lifespan_send_message_traits() {
+    // Test Debug trait
+    let msg1 = LifespanSendMessage::LifespanStartupComplete;
+    let msg2 = LifespanSendMessage::LifespanShutdownComplete;
+
+    let debug1 = format!("{:?}", msg1);
+    let debug2 = format!("{:?}", msg2);
+    assert!(debug1.contains("LifespanStartupComplete"));
+    assert!(debug2.contains("LifespanShutdownComplete"));
+
+    // Test Clone
+    let cloned1 = msg1.clone();
+    let cloned2 = msg2.clone();
+
+    // Test PartialEq and Eq
+    assert_eq!(msg1, cloned1);
+    assert_eq!(msg2, cloned2);
+    assert_ne!(msg1, msg2);
+
+    // Test Hash
+    use std::collections::HashSet;
+    let mut set = HashSet::new();
+    set.insert(msg1);
+    set.insert(cloned1); // Should not increase size due to equality
+    set.insert(msg2);
+    assert_eq!(set.len(), 2); // Only unique messages
+  }
+
+  #[test]
+  fn test_lifespan_receive_message_traits() {
+    // Test all the derive traits for LifespanReceiveMessage
+    let msg1 = LifespanReceiveMessage::LifespanStartup;
+    let msg2 = LifespanReceiveMessage::LifespanShutdown;
+
+    // Test Debug
+    let debug1 = format!("{:?}", msg1);
+    let debug2 = format!("{:?}", msg2);
+    assert!(debug1.contains("LifespanStartup"));
+    assert!(debug2.contains("LifespanShutdown"));
+
+    // Test Clone and Copy
+    let cloned1 = msg1.clone();
+    let copied1 = msg1;
+
+    // Test PartialEq and Eq
+    assert_eq!(msg1, cloned1);
+    assert_eq!(msg1, copied1);
+    assert_ne!(msg1, msg2);
+
+    // Test Hash
+    use std::collections::HashSet;
+    let mut set = HashSet::new();
+    set.insert(msg1);
+    set.insert(copied1); // Should not increase size due to equality
+    set.insert(msg2);
+    assert_eq!(set.len(), 2); // Only unique messages
+  }
+
+  #[test]
+  fn test_lifespan_scope_with_populated_state() {
+    Python::with_gil(|py| {
+      // Create a state dictionary with some data
+      let state_dict = PyDict::new(py);
+      state_dict.set_item("initialized", true).unwrap();
+      state_dict.set_item("counter", 42).unwrap();
+
+      let lifespan_scope = LifespanScope {
+        state: Some(state_dict.unbind()),
+      };
+
+      let py_obj = lifespan_scope.into_pyobject(py).unwrap();
+
+      // Verify the scope structure
+      assert_eq!(
+        dict_extract!(py_obj, "type", String),
+        "lifespan".to_string()
+      );
+
+      // Verify ASGI info is present
+      let asgi_info = dict_get!(py_obj, "asgi");
+      let asgi_dict = asgi_info.downcast::<PyDict>().unwrap();
+      assert_eq!(
+        asgi_dict
+          .get_item("version")
+          .unwrap()
+          .unwrap()
+          .extract::<String>()
+          .unwrap(),
+        "3.0"
+      );
+      assert_eq!(
+        asgi_dict
+          .get_item("spec_version")
+          .unwrap()
+          .unwrap()
+          .extract::<String>()
+          .unwrap(),
+        "2.0"
+      );
+
+      // Verify state is preserved
+      let state_obj = dict_get!(py_obj, "state");
+      let state_dict = state_obj.downcast::<PyDict>().unwrap();
+      assert_eq!(
+        state_dict
+          .get_item("initialized")
+          .unwrap()
+          .unwrap()
+          .extract::<bool>()
+          .unwrap(),
+        true
+      );
+      assert_eq!(
+        state_dict
+          .get_item("counter")
+          .unwrap()
+          .unwrap()
+          .extract::<i32>()
+          .unwrap(),
+        42
+      );
+    });
+  }
 }

src/asgi/lifespan.rs

@@ -7,12 +7,7 @@ use std::{
 };
 
 #[cfg(target_os = "linux")]
-use std::os::raw::c_void;
-
-#[cfg(target_os = "linux")]
-unsafe extern "C" {
-  fn dlopen(filename: *const i8, flag: i32) -> *mut c_void;
-}
+use std::{ffi::CStr, mem};
 
 use bytes::BytesMut;
 use http_handler::{Handler, Request, RequestExt, Response, extensions::DocumentRoot};
@@ -288,54 +283,38 @@ impl Handler for Asgi {
   }
 }
 
-/// Load Python library with RTLD_GLOBAL on Linux to make symbols available
+/// Load Python library with RTLD_GLOBAL on Linux to expose interpreter symbols
 #[cfg(target_os = "linux")]
 fn ensure_python_symbols_global() {
-  unsafe {
-    // Try to find the system Python library dynamically
-    use std::process::Command;
-
-    // First try to find the Python library using find command
-    if let Ok(output) = Command::new("find")
-      .args(&[
-        "/usr/lib",
-        "/usr/lib64",
-        "/usr/local/lib",
-        "-name",
-        "libpython3*.so.*",
-        "-type",
-        "f",
-      ])
-      .output()
+  // Only perform the promotion once per process
+  static GLOBALIZE_ONCE: OnceLock<()> = OnceLock::new();
+
+  GLOBALIZE_ONCE.get_or_init(|| unsafe {
+    let mut info: libc::Dl_info = mem::zeroed();
+    if libc::dladdr(pyo3::ffi::Py_Initialize as *const _, &mut info) == 0
+      || info.dli_fname.is_null()
     {
-      let output_str = String::from_utf8_lossy(&output.stdout);
-      for lib_path in output_str.lines() {
-        if let Ok(lib_cstring) = CString::new(lib_path) {
-          let handle = dlopen(lib_cstring.as_ptr(), RTLD_NOW | RTLD_GLOBAL);
-          if !handle.is_null() {
-            // Successfully loaded Python library with RTLD_GLOBAL
-            return;
-          }
-        }
-      }
+      eprintln!("unable to locate libpython for RTLD_GLOBAL promotion");
+      return;
     }
 
-    const RTLD_GLOBAL: i32 = 0x100;
-    const RTLD_NOW: i32 = 0x2;
-
-    // Fallback to trying common library names if find command fails
-    // Try a range of Python versions (3.9 to 3.100 should cover future versions)
-    for minor in 9..=100 {
-      let lib_name = format!("libpython3.{}.so.1.0\0", minor);
-      let handle = dlopen(lib_name.as_ptr() as *const i8, RTLD_NOW | RTLD_GLOBAL);
-      if !handle.is_null() {
-        // Successfully loaded Python library with RTLD_GLOBAL
-        return;
+    let path_cstr = CStr::from_ptr(info.dli_fname);
+    let path_str = path_cstr.to_string_lossy();
+
+    // Clear any prior dlerror state before attempting to reopen
+    libc::dlerror();
+
+    let handle = libc::dlopen(info.dli_fname, libc::RTLD_NOW | libc::RTLD_GLOBAL);
+    if handle.is_null() {
+      let error = libc::dlerror();
+      if !error.is_null() {
+        let msg = CStr::from_ptr(error).to_string_lossy();
+        eprintln!("dlopen({path_str}) failed with RTLD_GLOBAL: {msg}",);
+      } else {
+        eprintln!("dlopen({path_str}) returned null without dlerror",);
       }
     }
-
-    eprintln!("Failed to locate system Python library");
-  }
+  });
 }
 
 /// Find all Python site-packages directories in a virtual environment