Let the kernel pick the client port (for parallel test runs)

Author: michaelklishin

crates/edp_node/tests/gen_event_tests.rs

@@ -20,6 +20,10 @@ use std::pin::Pin;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 struct LoggerHandler {
     id: OwnedTerm,
     events: Arc<Mutex<Vec<OwnedTerm>>>,
@@ -122,8 +126,8 @@ impl GenEventHandler for RemovingHandler {
 
 #[tokio::test]
 async fn test_gen_event_notify() {
-    let mut node = Node::new("test_genevent@localhost", "secret");
-    node.start(5580).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genevent"), "secret");
+    node.start(0).await.unwrap();
 
     let events = Arc::new(Mutex::new(Vec::new()));
     let handler = LoggerHandler::new(OwnedTerm::Atom(Atom::new("logger")), events.clone());
@@ -151,8 +155,8 @@ async fn test_gen_event_notify() {
 
 #[tokio::test]
 async fn test_gen_event_multiple_handlers() {
-    let mut node = Node::new("test_genevent_multi@localhost", "secret");
-    node.start(5581).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genevent_multi"), "secret");
+    node.start(0).await.unwrap();
 
     let events1 = Arc::new(Mutex::new(Vec::new()));
     let events2 = Arc::new(Mutex::new(Vec::new()));
@@ -195,8 +199,8 @@ async fn test_gen_event_multiple_handlers() {
 
 #[tokio::test]
 async fn test_gen_event_handler_removal() {
-    let mut node = Node::new("test_genevent_remove@localhost", "secret");
-    node.start(5582).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genevent_remove"), "secret");
+    node.start(0).await.unwrap();
 
     let handler = RemovingHandler::new(OwnedTerm::Atom(Atom::new("removing")), "stop".to_string());
 
@@ -230,8 +234,8 @@ async fn test_gen_event_handler_removal() {
 
 #[tokio::test]
 async fn test_gen_event_which_handlers() {
-    let mut node = Node::new("test_genevent_which@localhost", "secret");
-    node.start(5583).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genevent_which"), "secret");
+    node.start(0).await.unwrap();
 
     let events1 = Arc::new(Mutex::new(Vec::new()));
     let events2 = Arc::new(Mutex::new(Vec::new()));
@@ -256,8 +260,8 @@ async fn test_gen_event_which_handlers() {
 
 #[tokio::test]
 async fn test_gen_event_delete_handler() {
-    let mut node = Node::new("test_genevent_delete@localhost", "secret");
-    node.start(5584).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genevent_delete"), "secret");
+    node.start(0).await.unwrap();
 
     let events = Arc::new(Mutex::new(Vec::new()));
     let handler = LoggerHandler::new(OwnedTerm::Atom(Atom::new("logger")), events.clone());

crates/edp_node/tests/gen_server_tests.rs

@@ -18,6 +18,10 @@ use erltf::types::{Atom, ExternalPid};
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 struct CounterServer {
     count: i64,
     casts_received: Arc<Mutex<Vec<OwnedTerm>>>,
@@ -69,8 +73,8 @@ impl GenServer for CounterServer {
 
 #[tokio::test]
 async fn test_genserver_call() {
-    let mut node = Node::new("test_genserver@localhost", "secret");
-    node.start(5558).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genserver"), "secret");
+    node.start(0).await.unwrap();
 
     let casts = Arc::new(Mutex::new(Vec::new()));
     let server = CounterServer::new(casts.clone());
@@ -86,8 +90,8 @@ async fn test_genserver_call() {
 
 #[tokio::test]
 async fn test_genserver_cast() {
-    let mut node = Node::new("test_genserver_cast@localhost", "secret");
-    node.start(5559).await.unwrap();
+    let mut node = Node::new(test_node_name("test_genserver_cast"), "secret");
+    node.start(0).await.unwrap();
 
     let casts = Arc::new(Mutex::new(Vec::new()));
     let server = CounterServer::new(casts.clone());

crates/edp_node/tests/link_monitor_tests.rs

@@ -18,6 +18,10 @@ use erltf::types::{ExternalPid, ExternalReference};
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 #[derive(Clone)]
 struct LinkTestProcess {
     exit_received: Arc<Mutex<Vec<(ExternalPid, OwnedTerm)>>>,
@@ -65,8 +69,8 @@ impl Process for LinkTestProcess {
 
 #[tokio::test]
 async fn test_link_tracking() {
-    let mut node = Node::new("test_link@localhost", "secret");
-    node.start(5560).await.unwrap();
+    let mut node = Node::new(test_node_name("test_link"), "secret");
+    node.start(0).await.unwrap();
 
     let exits = Arc::new(Mutex::new(Vec::new()));
     let monitor_exits = Arc::new(Mutex::new(Vec::new()));
@@ -84,8 +88,8 @@ async fn test_link_tracking() {
 
 #[tokio::test]
 async fn test_unlink() {
-    let mut node = Node::new("test_unlink@localhost", "secret");
-    node.start(5561).await.unwrap();
+    let mut node = Node::new(test_node_name("test_unlink"), "secret");
+    node.start(0).await.unwrap();
 
     let exits = Arc::new(Mutex::new(Vec::new()));
     let monitor_exits = Arc::new(Mutex::new(Vec::new()));
@@ -108,8 +112,8 @@ async fn test_unlink() {
 
 #[tokio::test]
 async fn test_monitor_tracking() {
-    let mut node = Node::new("test_monitor@localhost", "secret");
-    node.start(5562).await.unwrap();
+    let mut node = Node::new(test_node_name("test_monitor"), "secret");
+    node.start(0).await.unwrap();
 
     let exits = Arc::new(Mutex::new(Vec::new()));
     let monitor_exits = Arc::new(Mutex::new(Vec::new()));
@@ -129,8 +133,8 @@ async fn test_monitor_tracking() {
 
 #[tokio::test]
 async fn test_demonitor() {
-    let mut node = Node::new("test_demonitor@localhost", "secret");
-    node.start(5563).await.unwrap();
+    let mut node = Node::new(test_node_name("test_demonitor"), "secret");
+    node.start(0).await.unwrap();
 
     let exits = Arc::new(Mutex::new(Vec::new()));
     let monitor_exits = Arc::new(Mutex::new(Vec::new()));

crates/edp_node/tests/message_passing_tests.rs

@@ -18,6 +18,10 @@ use erltf::types::Atom;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 struct CollectorProcess {
     messages: Arc<Mutex<Vec<OwnedTerm>>>,
 }
@@ -39,8 +43,8 @@ impl Process for CollectorProcess {
 
 #[tokio::test]
 async fn test_local_message_passing() {
-    let mut node = Node::new("test@localhost", "secret");
-    node.start(5555).await.unwrap();
+    let mut node = Node::new(test_node_name("test"), "secret");
+    node.start(0).await.unwrap();
 
     let messages = Arc::new(Mutex::new(Vec::new()));
     let collector = CollectorProcess::new(messages.clone());
@@ -62,8 +66,8 @@ async fn test_local_message_passing() {
 
 #[tokio::test]
 async fn test_registered_name_message_passing() {
-    let mut node = Node::new("test2@localhost", "secret");
-    node.start(5556).await.unwrap();
+    let mut node = Node::new(test_node_name("test2"), "secret");
+    node.start(0).await.unwrap();
 
     let messages = Arc::new(Mutex::new(Vec::new()));
     let collector = CollectorProcess::new(messages.clone());
@@ -84,12 +88,13 @@ async fn test_registered_name_message_passing() {
 
 #[tokio::test]
 async fn test_message_to_nonexistent_process() {
-    let mut node = Node::new("test3@localhost", "secret");
-    node.start(5557).await.unwrap();
+    let name = test_node_name("test3");
+    let mut node = Node::new(&name, "secret");
+    node.start(0).await.unwrap();
 
     let result = node
         .send(
-            &erltf::types::ExternalPid::new(Atom::new("test3@localhost"), 99999, 0, 1),
+            &erltf::types::ExternalPid::new(Atom::new(&name), 99999, 0, 1),
             OwnedTerm::Atom(Atom::new("test")),
         )
         .await;

crates/edp_node/tests/node_tests.rs

@@ -16,6 +16,10 @@ use edp_node::{Message, Node, Process};
 use erltf::OwnedTerm;
 use erltf::types::Atom;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 struct TestProcess {
     received: Vec<OwnedTerm>,
 }
@@ -43,8 +47,8 @@ impl Process for TestProcess {
 
 #[tokio::test]
 async fn test_spawn_and_register_process() {
-    let mut node = Node::new("test@localhost", "secret");
-    node.start(5570).await.unwrap();
+    let mut node = Node::new(test_node_name("test"), "secret");
+    node.start(0).await.unwrap();
 
     let process = TestProcess::new();
     let pid = node.spawn(process).await.unwrap();
@@ -59,8 +63,8 @@ async fn test_spawn_and_register_process() {
 
 #[tokio::test]
 async fn test_unregister_process() {
-    let mut node = Node::new("test2@localhost", "secret");
-    node.start(5571).await.unwrap();
+    let mut node = Node::new(test_node_name("test2"), "secret");
+    node.start(0).await.unwrap();
 
     let process = TestProcess::new();
     let pid = node.spawn(process).await.unwrap();
@@ -75,8 +79,8 @@ async fn test_unregister_process() {
 
 #[tokio::test]
 async fn test_duplicate_registration_fails() {
-    let mut node = Node::new("test3@localhost", "secret");
-    node.start(5572).await.unwrap();
+    let mut node = Node::new(test_node_name("test3"), "secret");
+    node.start(0).await.unwrap();
 
     let process1 = TestProcess::new();
     let pid1 = node.spawn(process1).await.unwrap();
@@ -90,8 +94,8 @@ async fn test_duplicate_registration_fails() {
 
 #[tokio::test]
 async fn test_list_registered_names() {
-    let mut node = Node::new("test4@localhost", "secret");
-    node.start(5573).await.unwrap();
+    let mut node = Node::new(test_node_name("test4"), "secret");
+    node.start(0).await.unwrap();
 
     let process1 = TestProcess::new();
     let pid1 = node.spawn(process1).await.unwrap();
@@ -113,8 +117,8 @@ async fn test_list_registered_names() {
 
 #[tokio::test]
 async fn test_process_count() {
-    let mut node = Node::new("test5@localhost", "secret");
-    node.start(5574).await.unwrap();
+    let mut node = Node::new(test_node_name("test5"), "secret");
+    node.start(0).await.unwrap();
 
     assert_eq!(node.process_count().await, 0);
 

crates/edp_node/tests/rpc_tests.rs

@@ -14,27 +14,32 @@
 
 use edp_node::Node;
 
+fn test_node_name(base: &str) -> String {
+    format!("{}_{}@localhost", base, std::process::id())
+}
+
 //
 // Reference Creation Tests
 //
 
 #[tokio::test]
 async fn test_rpc_reference_creation() {
-    let mut node = Node::new("rpc_test1@localhost", "secret");
-    node.start(5580).await.unwrap();
+    let name = test_node_name("rpc_test1");
+    let mut node = Node::new(&name, "secret");
+    node.start(0).await.unwrap();
 
     let ref1 = node.make_reference();
     let ref2 = node.make_reference();
 
     assert_ne!(ref1, ref2);
-    assert_eq!(ref1.node.as_str(), "rpc_test1@localhost");
-    assert_eq!(ref2.node.as_str(), "rpc_test1@localhost");
+    assert_eq!(ref1.node.as_str(), name);
+    assert_eq!(ref2.node.as_str(), name);
 }
 
 #[tokio::test]
 async fn test_rpc_reference_uniqueness() {
-    let mut node = Node::new("rpc_test1b@localhost", "secret");
-    node.start(5580).await.unwrap();
+    let mut node = Node::new(test_node_name("rpc_test1b"), "secret");
+    node.start(0).await.unwrap();
 
     let mut refs = Vec::new();
     for _ in 0..100 {
@@ -58,8 +63,8 @@ async fn test_rpc_reference_uniqueness() {
 
 #[tokio::test]
 async fn test_rpc_to_nonexistent_node() {
-    let mut node = Node::new("rpc_test2@localhost", "secret");
-    node.start(5581).await.unwrap();
+    let mut node = Node::new(test_node_name("rpc_test2"), "secret");
+    node.start(0).await.unwrap();
 
     let result = node
         .rpc_call("nonexistent@localhost", "erlang", "node", vec![])
@@ -70,8 +75,8 @@ async fn test_rpc_to_nonexistent_node() {
 
 #[tokio::test]
 async fn test_rpc_requires_connection() {
-    let mut node = Node::new("rpc_test3@localhost", "secret");
-    node.start(5582).await.unwrap();
+    let mut node = Node::new(test_node_name("rpc_test3"), "secret");
+    node.start(0).await.unwrap();
 
     let result = node
         .rpc_call("not_connected@localhost", "erlang", "node", vec![])
@@ -86,16 +91,17 @@ async fn test_rpc_requires_connection() {
 
 #[tokio::test]
 async fn test_rpc_node_name_and_cookie_accessors() {
-    let node = Node::new("rpc_test4@localhost", "secret_cookie");
+    let name = test_node_name("rpc_test4");
+    let node = Node::new(&name, "secret_cookie");
 
-    assert_eq!(node.name().as_str(), "rpc_test4@localhost");
+    assert_eq!(node.name().as_str(), name);
     assert_eq!(node.cookie(), "secret_cookie");
 }
 
 #[tokio::test]
 async fn test_rpc_creation_increments() {
-    let mut node = Node::new("rpc_test5@localhost", "secret");
-    node.start(5583).await.unwrap();
+    let mut node = Node::new(test_node_name("rpc_test5"), "secret");
+    node.start(0).await.unwrap();
 
     let initial_creation = node.creation();
     assert!(initial_creation > 0);