keyfork/keyfork-seed/src/tests.rs

use crate::client::Client;
use hex_literal::hex;
use keyfork_derive_util::{request::*, DerivationPath};
use std::{os::unix::net::UnixStream, str::FromStr};
use tempdir::TempDir;
use tokio::runtime::Builder;
use std::sync::mpsc::channel;

#[test]
fn it_works() {
    // Test literals taken from keyfork-derive-util.
    // Setup
    let entropy = &hex!("000102030405060708090a0b0c0d0e0f")[..];
    let mnemonic = keyforkd::Mnemonic::from_entropy(entropy, Default::default()).unwrap();
    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
    let tempdir = TempDir::new("keyfork-seed").unwrap();
    let socket_path = tempdir.path().join("keyforkd.sock");
    let (tx, rx) = channel();

    let handle = rt.spawn({
        let socket_path = socket_path.clone();
        async move {
            let mut server = keyforkd::UnixServer::bind(&socket_path).unwrap();
            // Connections can be pending for a few seconds, so signal to the main
            // test we're ready to start accepting.
            tx.send(()).unwrap();
            let service = keyforkd::ServiceBuilder::new()
                .layer(keyforkd::middleware::BincodeLayer::new())
                .service(keyforkd::Keyforkd::new(mnemonic));
            server.run(service).await.unwrap();
        }
    });

    rx.recv().unwrap();
    let socket = UnixStream::connect(&socket_path).unwrap();
    let mut client = Client::new(socket);
    let req = DerivationRequest::new(
        DerivationAlgorithm::Ed25519,
        DerivationPath::from_str("m/0'/1'/2'/2'/1000000000'").unwrap(),
    );
    let response = client.request(&req).unwrap();
    assert_eq!(
        response.data,
        hex!("8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793")
    );
    handle.abort();
}