Bind payjoin-test-utils

[spacebear21]

And use the test utils in bdk_integration_test instead of a live server.

[DanGould]

related alternative #11

[benalleng]

So I have run into a problem on the python side of getting the async TestServices working, namely getting the initialize up as a runtime that can be accessed from follow-up methods.

Digging a little deeper with this library as a possible solution https://github.com/PyO3/pyo3-async-runtimes?tab=readme-ov-file

[DanGould]

May you explain your problem of the lack of a runtime in more detail? If it's "Tokio runtime missing" on the rust side you might be able to initialize a static runtime when you initialize TestServices that each of the async methods can use. But you might also need python support

[benalleng]

getting a no reactor running error.

thread '<unnamed>' panicked at /home/user/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.44.2/src/net/tcp/listener.rs:304:22:
there is no reactor running, must be called from the context of a Tokio 1.x runtime

I have been able to modify the initialize method to work with a tokio::Runtime::new() within that method but perhaps that is not the best way to go about it.
I will try to make a static runtime for the methods to use

[DanGould]

Yep I think you can use something like this and then may be able to avoid using PyO3

use std::sync::{Arc, Mutex, Once};

use tokio::runtime::Runtime;

static INIT: Once = Once::new();
static mut RUNTIME: Option<Arc<Mutex<Runtime>>> = None;

pub fn get_runtime() -> Arc<Mutex<Runtime>> {
    unsafe {
        INIT.call_once(|| {
            let rt = Runtime::new().expect("Failed to create Tokio runtime");
            RUNTIME = Some(Arc::new(Mutex::new(rt)));
        });
        RUNTIME.clone().unwrap()
    }
}

pub fn block_on<F: std::future::Future>(future: F) -> F::Output {
    let rt = get_runtime();
    let rt = rt.lock().unwrap();
    rt.block_on(future)
}

Or, I think we might have lazy_static in the tree and we can make this safe:

use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime;

/// Provides a lazily-initialized, globally accessible Tokio runtime.
/// This is safe and free of data races.
lazy_static::lazy_static! {
    static ref RUNTIME: Arc<Mutex<Runtime>> = {
        let rt = Runtime::new().expect("Failed to create Tokio runtime");
        Arc::new(Mutex::new(rt))
    };
}

/// Returns a reference-counted, mutex-protected handle to the global Tokio runtime.
pub fn get_runtime() -> Arc<Mutex<Runtime>> {
    RUNTIME.clone()
}

/// Runs the provided future to completion on the global Tokio runtime.
pub fn block_on<F: std::future::Future>(future: F) -> F::Output {
    let rt = get_runtime();
    let rt = rt.lock().unwrap();
    rt.block_on(future)
}

[benalleng]

I went about it a pretty similar way I ended up using this approach. sorry to keep taking your attention away for help with this.

lazy_static! {
    static ref RUNTIME: Arc<std::sync::Mutex<Runtime>> =
        Arc::new(std::sync::Mutex::new(Runtime::new().expect("Failed to create Tokio runtime")));
}


#[cfg_attr(feature = "uniffi", uniffi::export)]
impl TestServices {
    #[cfg_attr(feature = "uniffi", uniffi::constructor)]
    pub fn initialize() -> Result<Self, BoxSendSyncError> {
        let runtime = RUNTIME.lock().unwrap();
        let service = runtime.block_on(async {
            payjoin_test_utils::TestServices::initialize().await.map_err(|e| {
                eprintln!("Initialization failed: {e}");
                BoxSendSyncError::from(e)
            })
        })?;
        Ok(TestServices(Mutex::new(service)))
    }

    pub fn cert(&self) -> Vec<u8> {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async { self.0.lock().await.cert() })
    }

    pub fn directory_url(&self) -> Url {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async { self.0.lock().await.directory_url().into() })
    }

    pub fn take_directory_handle(&self) -> JoinHandle {
        let runtime = RUNTIME.lock().unwrap();
        runtime
            .block_on(async { JoinHandle(Arc::new(self.0.lock().await.take_directory_handle())) })
    }

    pub fn ohttp_relay_url(&self) -> Url {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async { self.0.lock().await.ohttp_relay_url().into() })
    }

    pub fn ohttp_gateway_url(&self) -> Url {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async { self.0.lock().await.ohttp_gateway_url().into() })
    }

    pub fn take_ohttp_relay_handle(&self) -> JoinHandle {
        let runtime = RUNTIME.lock().unwrap();
        runtime
            .block_on(async { JoinHandle(Arc::new(self.0.lock().await.take_ohttp_relay_handle())) })
    }

    pub fn wait_for_services_ready(&self) -> Result<(), BoxSendSyncError> {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async {
            self.0
                .lock()
                .await
                .wait_for_services_ready()
                .await
                .map_err(|e| payjoin_test_utils::BoxSendSyncError::from(e).into())
        })
    }

    pub fn fetch_ohttp_keys(&self) -> Result<crate::OhttpKeys, crate::io::IoError> {
        let runtime = RUNTIME.lock().unwrap();
        runtime.block_on(async {
            self.0.lock().await.fetch_ohttp_keys().await.map_err(Into::into).map(Into::into)
        })
    }
}

[DanGould]

implemented by #82, but not yet replaced in python until #85

[spacebear21]

Closed by #85