chore(test): properly run Rust host

Signed-off-by: Brooks Townsend <brooks@cosmonic.com>

try

actually care about port

wasmcloud 0.78

sotp

Author: brooksmtownsend

tests/event_consumer_integration.rs

@@ -89,9 +89,13 @@ async fn test_event_stream() -> Result<()> {
     let mut stream = get_event_consumer(config.nats_url()).await;
 
     // NOTE: the first heartbeat doesn't come for 30s so we are ignoring it for now
+    let ctl_port = config
+        .nats_port
+        .unwrap_or(crate::helpers::DEFAULT_NATS_PORT)
+        .to_string();
 
     // Start an actor
-    helpers::run_wash_command(["start", "actor", ECHO_REFERENCE]).await;
+    helpers::run_wash_command(["start", "actor", ECHO_REFERENCE, "--ctl-port", &ctl_port]).await;
 
     let mut evt = wait_for_event(&mut stream, DEFAULT_TIMEOUT_DURATION).await;
     if let Event::ActorStarted(actor) = evt.as_ref() {
@@ -106,7 +110,14 @@ async fn test_event_stream() -> Result<()> {
     evt.ack().await.expect("Should be able to ack event");
 
     // Start a provider
-    helpers::run_wash_command(["start", "provider", HTTP_SERVER_REFERENCE]).await;
+    helpers::run_wash_command([
+        "start",
+        "provider",
+        HTTP_SERVER_REFERENCE,
+        "--ctl-port",
+        &ctl_port,
+    ])
+    .await;
 
     let mut evt = wait_for_event(&mut stream, DEFAULT_TIMEOUT_DURATION).await;
     if let Event::ProviderStarted(provider) = evt.as_ref() {
@@ -128,6 +139,8 @@ async fn test_event_stream() -> Result<()> {
         ECHO_ACTOR_ID,
         HTTP_SERVER_PROVIDER_ID,
         CONTRACT_ID,
+        "--ctl-port",
+        &ctl_port,
     ])
     .await;
 
@@ -153,7 +166,15 @@ async fn test_event_stream() -> Result<()> {
     evt.ack().await.expect("Should be able to ack event");
 
     // Delete link
-    helpers::run_wash_command(["link", "del", ECHO_ACTOR_ID, CONTRACT_ID]).await;
+    helpers::run_wash_command([
+        "link",
+        "del",
+        ECHO_ACTOR_ID,
+        CONTRACT_ID,
+        "--ctl-port",
+        &ctl_port,
+    ])
+    .await;
 
     let mut evt = wait_for_event(&mut stream, LINK_OPERATION_TIMEOUT_DURATION).await;
     if let Event::LinkdefDeleted(link) = evt.as_ref() {
@@ -174,7 +195,7 @@ async fn test_event_stream() -> Result<()> {
 
     // Stop provider
     let host_id = serde_json::from_slice::<HostResponse>(
-        &helpers::run_wash_command(["get", "hosts", "-o", "json"]).await,
+        &helpers::run_wash_command(["get", "hosts", "-o", "json", "--ctl-port", &ctl_port]).await,
     )
     .unwrap()
     .hosts[0]
@@ -190,6 +211,8 @@ async fn test_event_stream() -> Result<()> {
         HTTP_SERVER_PROVIDER_ID,
         LINK_NAME,
         CONTRACT_ID,
+        "--ctl-port",
+        &ctl_port,
     ])
     .await;
 
@@ -206,7 +229,15 @@ async fn test_event_stream() -> Result<()> {
     evt.ack().await.expect("Should be able to ack event");
 
     // Stop an actor
-    helpers::run_wash_command(["stop", "actor", &host_id, ECHO_ACTOR_ID]).await;
+    helpers::run_wash_command([
+        "stop",
+        "actor",
+        &host_id,
+        ECHO_ACTOR_ID,
+        "--ctl-port",
+        &ctl_port,
+    ])
+    .await;
 
     let mut evt = wait_for_event(&mut stream, DEFAULT_TIMEOUT_DURATION).await;
     if let Event::ActorStopped(actor) = evt.as_ref() {
@@ -221,7 +252,7 @@ async fn test_event_stream() -> Result<()> {
     evt.ack().await.expect("Should be able to ack event");
 
     // Stop the host
-    helpers::run_wash_command(["stop", "host", &host_id]).await;
+    helpers::run_wash_command(["stop", "host", &host_id, "--ctl-port", &ctl_port]).await;
 
     let mut evt = wait_for_event(&mut stream, DEFAULT_TIMEOUT_DURATION).await;
     if let Event::HostStopped(host) = evt.as_ref() {
@@ -250,8 +281,12 @@ async fn test_nack_and_rereceive() -> Result<()> {
 
     let mut stream = get_event_consumer(config.nats_url()).await;
 
+    let ctl_port = config
+        .nats_port
+        .unwrap_or(crate::helpers::DEFAULT_NATS_PORT)
+        .to_string();
     // Start an actor
-    helpers::run_wash_command(["start", "actor", ECHO_REFERENCE]).await;
+    helpers::run_wash_command(["start", "actor", ECHO_REFERENCE, "--ctl-port", &ctl_port]).await;
 
     // Get the event and then nack it
     let mut evt = wait_for_event(&mut stream, DEFAULT_TIMEOUT_DURATION).await;

tests/helpers.rs

@@ -16,8 +16,7 @@ use tokio::process::Command;
 use anyhow::Result;
 use wadm::consumers::{CommandConsumer, ScopedMessage};
 
-const DEFAULT_WASMCLOUD_PORT: u16 = 4000;
-const DEFAULT_NATS_PORT: u16 = 4222;
+pub const DEFAULT_NATS_PORT: u16 = 4222;
 pub const ECHO_ACTOR_ID: &str = "MBCFOPM6JW2APJLXJD3Z5O4CN7CPYJ2B4FTKLJUR5YR5MITIU7HD3WD5";
 pub const HTTP_SERVER_PROVIDER_ID: &str =
     "VAG3QITQQ2ODAOWB5TTQSDJ53XK3SHBEIFNK4AYJ5RKAX2UNSCAPHA5M";
@@ -63,32 +62,19 @@ pub struct TestWashConfig {
 
     /// Only connect to pre-existing NATS instance
     pub nats_connect_only: bool,
-
-    /// Port on which to run wasmCloud (via `wash up`)
-    pub wasmcloud_port: Option<u16>,
 }
 
 impl TestWashConfig {
     /// Build a test wash configuration with randomized ports
     pub async fn random() -> Result<TestWashConfig> {
         let nats_port = Some(get_random_tcp_port());
-        let wasmcloud_port = Some(get_random_tcp_port());
 
         Ok(TestWashConfig {
             nats_port,
-            wasmcloud_port,
             ..TestWashConfig::default()
         })
     }
 
-    /// Get the washboard URL for this config
-    pub fn washboard_url(&self) -> String {
-        format!(
-            "localhost:{}",
-            self.wasmcloud_port.unwrap_or(DEFAULT_WASMCLOUD_PORT)
-        )
-    }
-
     /// Get the NATS URL for this config
     pub fn nats_url(&self) -> String {
         format!("127.0.0.1:{}", self.nats_port.unwrap_or(DEFAULT_NATS_PORT))
@@ -98,22 +84,29 @@ impl TestWashConfig {
 /// Start a local wash instance
 async fn start_wash_instance(cfg: &TestWashConfig) -> Result<CleanupGuard> {
     let nats_port = cfg.nats_port.unwrap_or(DEFAULT_NATS_PORT).to_string();
-    let wasmcloud_port = cfg
-        .wasmcloud_port
-        .unwrap_or(DEFAULT_WASMCLOUD_PORT)
-        .to_string();
+    let wash_host_key = nkeys::KeyPair::new_server();
+
+    let seed = wash_host_key.seed().expect("seed to exist").to_string();
 
     // Build args
-    let mut args: Vec<&str> = Vec::from(["up", "-d", "--disable-wadm", "--nats-port", &nats_port]);
+    let mut args: Vec<&str> = Vec::from([
+        "up",
+        "-d",
+        "--disable-wadm",
+        "--nats-port",
+        &nats_port,
+        "--host-seed",
+        &seed,
+        "--wasmcloud-version",
+        "v0.78.0-rc3",
+    ]);
     if cfg.nats_connect_only {
         args.push("--nats-connect-only");
     }
 
     // Build the command
     let mut cmd = Command::new("wash");
     cmd.args(&args)
-        .env("WASMCLOUD_PORT", &wasmcloud_port)
-        .env("WASMCLOUD_DASHBOARD_PORT", &wasmcloud_port)
         .stderr(std::process::Stdio::null())
         .stdout(std::process::Stdio::null());
 
@@ -124,32 +117,45 @@ async fn start_wash_instance(cfg: &TestWashConfig) -> Result<CleanupGuard> {
     };
 
     let output = cmd.status().await.expect("Unable to run detached wash up");
-
     assert!(output.success(), "Error trying to start host",);
 
-    // Give the host just a bit more time to get totally ready
-    tokio::time::sleep(std::time::Duration::from_secs(10)).await;
+    // Run wash get inventory keypair.public_key() --nats-port {nats_port}
+    // and retry 5 times, sleeping for a second between tries, to ensure
+    // the host launched
+    let mut retries = 5;
+    while retries > 0 {
+        let output = Command::new("wash")
+            .args([
+                "get",
+                "inventory",
+                &wash_host_key.public_key(),
+                "--ctl-port",
+                &nats_port,
+            ])
+            .output()
+            .await
+            .expect("Unable to run wash command");
+        if output.status.success() {
+            break;
+        }
+        retries -= 1;
+        if retries == 0 {
+            panic!("Failed to launch host");
+        }
+        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+    }
 
     Ok(guard)
 }
 
 /// Set up and run a wash instance that can be used for a test
 pub async fn setup_test_wash(cfg: &TestWashConfig) -> CleanupGuard {
-    match tokio::net::TcpStream::connect(cfg.washboard_url()).await {
-        // NOTE: DO NOT use unwrap_or here. Otherwise we allocate a cleanup guard that then gets
-        // dropped, which runs `wash down`
-        #[allow(clippy::unnecessary_lazy_evaluations)]
-        Err(_) => start_wash_instance(cfg)
-            .await
-            .unwrap_or_else(|_| CleanupGuard {
-                child: None,
-                already_running: false,
-            }),
-        Ok(_) => CleanupGuard {
+    start_wash_instance(cfg)
+        .await
+        .unwrap_or_else(|_| CleanupGuard {
             child: None,
-            already_running: true,
-        },
-    }
+            already_running: false,
+        })
 }
 
 pub async fn wait_for_server(url: &str) {