#[tokio::test(max_threads = 1)]
async fn multiple_consecutive_ephemeral_listening_addresses() {
let node = ipfs::Node::new("test_node").await;
let target = libp2p::build_multiaddr!(Ip4([127, 0, 0, 1]), Tcp(0u16));
let first = node.add_listening_address(target.clone()).await.unwrap();
assert_ne!(target, first);
let second = node.add_listening_address(target.clone()).await.unwrap();
assert_ne!(target, second);
assert_ne!(first, second);
}
#[tokio::test(max_threads = 1)]
async fn multiple_concurrent_ephemeral_listening_addresses_on_same_ip() {
let node = ipfs::Node::new("test_node").await;
let target = libp2p::build_multiaddr!(Ip4([127, 0, 0, 1]), Tcp(0u16));
let first = node.add_listening_address(target.clone());
let second = node.add_listening_address(target);
let (first, second) = futures::future::join(first, second).await;
assert!(
first.is_ok() || second.is_ok(),
"first: {:?}, second: {:?}",
first,
second
);
}
#[tokio::test(max_threads = 1)]
#[cfg(not(target_os = "macos"))]
async fn multiple_concurrent_ephemeral_listening_addresses_on_different_ip() {
let node = ipfs::Node::new("test_node").await;
let first =
node.add_listening_address(libp2p::build_multiaddr!(Ip4([127, 0, 0, 1]), Tcp(0u16)));
let second =
node.add_listening_address(libp2p::build_multiaddr!(Ip4([127, 0, 0, 2]), Tcp(0u16)));
let (first, second) = futures::future::join(first, second).await;
first.unwrap();
second.unwrap();
}
#[tokio::test(max_threads = 1)]
async fn adding_unspecified_addr_resolves_with_first() {
let node = ipfs::Node::new("test_node").await;
node.add_listening_address(libp2p::build_multiaddr!(Ip4([0, 0, 0, 0]), Tcp(0u16)))
.await
.unwrap();
}
#[tokio::test(max_threads = 1)]
async fn listening_for_multiple_unspecified_addresses() {
let node = ipfs::Node::new("test_node").await;
let target = libp2p::build_multiaddr!(Ip4([0, 0, 0, 0]), Tcp(0u16));
let first = node.add_listening_address(target.clone());
let second = node.add_listening_address(target);
let (first, second) = futures::future::join(first, second).await;
assert!(
first.is_ok() || second.is_ok(),
"first: {:?}, second: {:?}",
first,
second
);
}
#[tokio::test(max_threads = 1)]
async fn remove_listening_address() {
let node = ipfs::Node::new("test_node").await;
let unbound = libp2p::build_multiaddr!(Ip4([127, 0, 0, 1]), Tcp(0u16));
let first = node.add_listening_address(unbound.clone()).await.unwrap();
node.remove_listening_address(unbound.clone())
.await
.unwrap_err();
node.remove_listening_address(first).await.unwrap();
}
#[test]
#[ignore]
fn remove_listening_address_before_completing() {
}
#[tokio::test(max_threads = 1)]
async fn pre_configured_listening_addrs() {
use ipfs::{IpfsOptions, MultiaddrWithPeerId, MultiaddrWithoutPeerId, Node};
use libp2p::Multiaddr;
use std::convert::TryFrom;
let mut opts = IpfsOptions::inmemory_with_generated_keys();
let addr: Multiaddr = "/ip4/127.0.0.1/tcp/4001".parse().unwrap();
opts.listening_addrs.push(addr.clone());
let ipfs = Node::with_options(opts).await;
let (_id, addrs) = ipfs.identity().await.unwrap();
let addrs: Vec<MultiaddrWithoutPeerId> = addrs
.into_iter()
.map(|addr| MultiaddrWithPeerId::try_from(addr).unwrap().multiaddr)
.collect();
let addr = MultiaddrWithoutPeerId::try_from(addr).unwrap();
assert!(
addrs.contains(&addr),
"pre-configured listening addr not found; listening addrs: {:?}",
addrs
);
}