Add integration test for sync example

Adds asserts to the example project so it will fail if something isn't work between the client and server.  This also adds an integration test that builds and runs the sync example so the changes to the project can be validated e2e.

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

example/client.rs

@@ -15,12 +15,17 @@
 mod protocols;
 mod utils;
 
+use log::LevelFilter;
 use protocols::sync::{agent, agent_ttrpc, health, health_ttrpc};
 use std::thread;
 use ttrpc::context::{self, Context};
+use ttrpc::error::Error;
+use ttrpc::proto::Code;
 use ttrpc::Client;
 
 fn main() {
+    simple_logging::log_to_stderr(LevelFilter::Trace);
+
     let c = Client::connect(utils::SOCK_ADDR).unwrap();
     let hc = health_ttrpc::HealthClient::new(c.clone());
     let ac = agent_ttrpc::AgentServiceClient::new(c);
@@ -33,69 +38,97 @@ fn main() {
     let t = thread::spawn(move || {
         let req = health::CheckRequest::new();
         println!(
-            "OS Thread {:?} - {} started: {:?}",
+            "OS Thread {:?} - health.check() started: {:?}",
             std::thread::current().id(),
-            "health.check()",
             now.elapsed(),
         );
+
+        let rsp = thc.check(default_ctx(), &req);
+        match rsp.as_ref() {
+            Err(Error::RpcStatus(s)) => {
+                assert_eq!(Code::NOT_FOUND, s.code());
+                assert_eq!("Just for fun".to_string(), s.message())
+            }
+            Err(e) => {
+                panic!("not expecting an error from the example server: {:?}", e)
+            }
+            Ok(x) => {
+                panic!("not expecting a OK response from the example server: {:?}", x)
+            }
+        }
         println!(
-            "OS Thread {:?} - {} -> {:?} ended: {:?}",
+            "OS Thread {:?} - health.check() -> {:?} ended: {:?}",
             std::thread::current().id(),
-            "health.check()",
-            thc.check(default_ctx(), &req),
+            rsp,
             now.elapsed(),
         );
     });
 
     let t2 = thread::spawn(move || {
         println!(
-            "OS Thread {:?} - {} started: {:?}",
+            "OS Thread {:?} - agent.list_interfaces() started: {:?}",
             std::thread::current().id(),
-            "agent.list_interfaces()",
             now.elapsed(),
         );
 
         let show = match tac.list_interfaces(default_ctx(), &agent::ListInterfacesRequest::new()) {
-            Err(e) => format!("{:?}", e),
-            Ok(s) => format!("{:?}", s),
+            Err(e) => {
+                panic!("not expecting an error from the example server: {:?}", e)
+            }
+            Ok(s) => {
+                assert_eq!("first".to_string(), s.Interfaces[0].name);
+                assert_eq!("second".to_string(), s.Interfaces[1].name);
+                format!("{s:?}")
+            }
         };
 
         println!(
-            "OS Thread {:?} - {} -> {} ended: {:?}",
+            "OS Thread {:?} - agent.list_interfaces() -> {} ended: {:?}",
             std::thread::current().id(),
-            "agent.list_interfaces()",
             show,
             now.elapsed(),
         );
     });
 
     println!(
-        "Main OS Thread - {} started: {:?}",
-        "agent.online_cpu_mem()",
+        "Main OS Thread - agent.online_cpu_mem() started: {:?}",
         now.elapsed()
     );
     let show = match ac.online_cpu_mem(default_ctx(), &agent::OnlineCPUMemRequest::new()) {
-        Err(e) => format!("{:?}", e),
-        Ok(s) => format!("{:?}", s),
+        Err(Error::RpcStatus(s)) => {
+            assert_eq!(Code::NOT_FOUND, s.code());
+            assert_eq!(
+                "/grpc.AgentService/OnlineCPUMem is not supported".to_string(),
+                s.message()
+            );
+            format!("{s:?}")
+        }
+        Err(e) => {
+            panic!("not expecting an error from the example server: {:?}", e)
+        }
+        Ok(s) => {
+            panic!("not expecting a OK response from the example server: {:?}", s)
+        }
     };
     println!(
-        "Main OS Thread - {} -> {} ended: {:?}",
-        "agent.online_cpu_mem()",
+        "Main OS Thread - agent.online_cpu_mem() -> {} ended: {:?}",
         show,
         now.elapsed()
     );
 
     println!("\nsleep 2 seconds ...\n");
     thread::sleep(std::time::Duration::from_secs(2));
+
+    let version = hc.version(default_ctx(), &health::CheckRequest::new());
+    assert_eq!("mock.0.1", version.as_ref().unwrap().agent_version.as_str());
+    assert_eq!("0.0.1", version.as_ref().unwrap().grpc_version.as_str());
     println!(
-        "Main OS Thread - {} started: {:?}",
-        "health.version()",
+        "Main OS Thread - health.version() started: {:?}",
         now.elapsed()
     );
     println!(
-        "Main OS Thread - {} -> {:?} ended: {:?}",
-        "health.version()",
-        hc.version(default_ctx(), &health::CheckRequest::new()),
+        "Main OS Thread - health.version() -> {:?} ended: {:?}",
+        version,
         now.elapsed()
     );
 

tests/sync-test.rs

@@ -0,0 +1,61 @@
+use std::{
+    io::{BufRead, BufReader},
+    process::Command,
+    time::Duration,
+};
+
+#[test]
+fn run_sync_example() -> Result<(), Box<dyn std::error::Error>> {
+    // start the server and give it a moment to start.
+    let mut server = run_example("server").spawn().unwrap();
+    std::thread::sleep(Duration::from_secs(2));
+
+    let mut client = run_example("client").spawn().unwrap();
+    let mut client_succeeded = false;
+    let start = std::time::Instant::now();
+    let timeout = Duration::from_secs(600);
+    loop {
+        if start.elapsed() > timeout {
+            println!("Running the client timed out. output:");
+            client.kill().unwrap_or_else(|e| {
+                println!("This may occur on Windows if the process has exited: {e}");
+            });
+            let output = client.stdout.unwrap();
+            BufReader::new(output).lines().for_each(|line| {
+                println!("{}", line.unwrap());
+            });
+            break;
+        }
+
+        match client.try_wait() {
+            Ok(Some(status)) => {
+                client_succeeded = status.success();
+                break;
+            }
+            Ok(None) => {
+                // still running
+                continue;
+            }
+            Err(e) => {
+                println!("Error: {e}");
+                break;
+            }
+        }
+    }
+
+    // be sure to clean up the server, the client should have run to completion
+    server.kill()?;
+    assert!(client_succeeded);
+    Ok(())
+}
+
+fn run_example(example: &str) -> Command {
+    let mut cmd = Command::new("cargo");
+    cmd.arg("run")
+        .arg("--example")
+        .arg(example)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .current_dir("example");
+    cmd
+}