libFenrir/src/tests.rs

use crate::*;

#[::tokio::test]
async fn test_connection_dirsync() {
    return;
    use enc::asym::{KeyID, PrivKey, PubKey};
    let rand = enc::Random::new();
    let (priv_exchange_key, pub_exchange_key) =
        match enc::asym::KeyExchangeKind::X25519DiffieHellman.new_keypair(&rand)
        {
            Ok((privkey, pubkey)) => {
                (PrivKey::Exchange(privkey), PubKey::Exchange(pubkey))
            }
            Err(_) => {
                assert!(false, "Can't generate random keypair");
                return;
            }
        };
    let dnssec_record = Record {
        public_keys: [(KeyID(42), pub_exchange_key)].to_vec(),
        addresses: [record::Address {
            ip: ::std::net::IpAddr::V4(::std::net::Ipv4Addr::new(127, 0, 0, 1)),
            port: Some(::core::num::NonZeroU16::new(31337).unwrap()),
            priority: record::AddressPriority::P1,
            weight: record::AddressWeight::W1,
            handshake_ids: [HandshakeID::DirectorySynchronized].to_vec(),
            public_key_idx: [record::PubKeyIdx(0)].to_vec(),
        }]
        .to_vec(),
        key_exchanges: [enc::asym::KeyExchangeKind::X25519DiffieHellman]
            .to_vec(),
        hkdfs: [enc::hkdf::HkdfKind::Sha3].to_vec(),
        ciphers: [enc::sym::CipherKind::XChaCha20Poly1305].to_vec(),
    };
    let cfg_client = {
        let mut cfg = config::Config::default();
        cfg.threads = Some(::core::num::NonZeroUsize::new(1).unwrap());
        cfg
    };
    let cfg_server = {
        let mut cfg = cfg_client.clone();
        cfg.keys = [(KeyID(42), priv_exchange_key, pub_exchange_key)].to_vec();
        cfg
    };

    let mut server = Fenrir::new(&cfg_server).unwrap();
    let _ = server.setup_no_workers().await;
    let srv_worker = server.start_single_worker().await;

    ::tokio::task::spawn_local(async move { srv_worker });
    let mut client = Fenrir::new(&cfg_client).unwrap();
    let _ = client.setup_no_workers().await;
    let cli_worker = server.start_single_worker().await;
    ::tokio::task::spawn_local(async move { cli_worker });

    use crate::{
        connection::handshake::HandshakeID,
        dnssec::{record, Record},
    };

    let _ = client
        .connect_resolved(
            dnssec_record,
            &Domain("example.com".to_owned()),
            auth::SERVICEID_AUTH,
        )
        .await;

    /*
    let thread_id = ThreadTracker { total: 1, id: 0 };

    let (stop_sender, _) = ::tokio::sync::broadcast::channel::<bool>(1);

    use ::std::net;
    let cli_socket_addr = [net::SocketAddr::new(
        net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)),
        0,
    )]
    .to_vec();
    let srv_socket_addr = [net::SocketAddr::new(
        net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)),
        0,
    )]
    .to_vec();

    let srv_sock = Arc::new(connection::socket::bind_udp(srv_socket_addr[0])
        .await
        .unwrap());
    let cli_sock = Arc::new(connection::socket::bind_udp(cli_socket_addr[0])
        .await
        .unwrap());

    use crate::inner::worker::Work;
    let (srv_work_send, srv_work_recv) = ::async_channel::unbounded::<Work>();
    let (cli_work_send, cli_work_recv) = ::async_channel::unbounded::<Work>();

    let srv_queue = Arc::new([srv_work_recv.clone()].to_vec());
    let cli_queue = Arc::new([cli_work_recv.clone()].to_vec());

    let listen_work_srv =


    ::tokio::spawn(Fenrir::listen_udp(
            stop_sender.subscribe(),


    let _server = crate::inner::worker::Worker::new(
        cfg.clone(),
        thread_id,
        stop_sender.subscribe(),
        None,
        srv_socket_addr,
        srv_work_recv,
    );
    let _client = crate::inner::worker::Worker::new(
        cfg,
        thread_id,
        stop_sender.subscribe(),
        None,
        cli_socket_addr,
        cli_work_recv,
    );

    todo!()
    */
}