add tests that run executables, particularly for --openapi (#21), fix #22

Author: davepacheco

Cargo.lock

@@ -21,6 +21,9 @@ uuid = { version = "0.8", features = [ "serde", "v4" ] }
 
 [dev-dependencies]
 libc = "0.2.71"
+openapiv3 = "0.3.0"
+subprocess = "0.2.4"
+newline-converter = "0.1.0"
 
 [dependencies.slog]
 version = "2.5"

Cargo.toml

@@ -16,7 +16,6 @@ Work queue (see also: existing GitHub issues):
 * decide on a code name for the whole control plane and rename the repo
 ** oxide controller -> Oxc?  Or something using the new code name?
 * general maintenance and cleanup
-** add a test that runs --openapi (to make sure it works)
 ** scope out switching to sync
 ** create separate exports for internal vs. external models
 ** proper config + logging for sled agent

TODO.adoc

@@ -16,18 +16,19 @@
 use clap::{App, Arg};
 use oxide_api_prototype::controller_run_openapi_external;
 use oxide_api_prototype::controller_run_server;
+use oxide_api_prototype::fatal;
+use oxide_api_prototype::CmdError;
 use oxide_api_prototype::ConfigController;
 use std::path::Path;
-use std::process::exit;
 
 #[tokio::main]
 async fn main() {
-    if let Err(message) = do_run().await {
-        fatal(message);
+    if let Err(cmd_error) = do_run().await {
+        fatal(cmd_error);
     }
 }
 
-async fn do_run() -> Result<(), String> {
+async fn do_run() -> Result<(), CmdError> {
     let matches = App::new("oxide-api-prototype")
         .after_help("See README.adoc for more information")
         .arg(
@@ -39,23 +40,21 @@ async fn do_run() -> Result<(), String> {
         .arg(Arg::with_name("CONFIG_FILE_PATH").required(true).index(1))
         .get_matches_safe()
         .map_err(|clap_error| {
-            format!("parsing arguments: {}", clap_error.message)
+            CmdError::Usage(format!(
+                "parsing arguments: {}",
+                clap_error.message
+            ))
         })?;
 
     let config_file = matches.value_of("CONFIG_FILE_PATH").unwrap();
     let config_file_path = Path::new(config_file);
     let config = ConfigController::from_file(config_file_path)
-        .map_err(|e| e.to_string())?;
+        .map_err(|e| CmdError::Failure(e.to_string()))?;
 
     if matches.is_present("openapi") {
         controller_run_openapi_external();
         Ok(())
     } else {
-        controller_run_server(&config).await
+        controller_run_server(&config).await.map_err(CmdError::Failure)
     }
 }
-
-fn fatal(message: String) -> ! {
-    eprintln!("{}: {}", std::env::args().next().unwrap(), message);
-    exit(1);
-}

src/bin/oxide_controller.rs

@@ -6,13 +6,13 @@
  * TODO see the TODO for oxide-controller.
  */
 
-use std::process::exit;
-
 use clap::{App, Arg};
 use dropshot::ConfigDropshot;
 use dropshot::ConfigLogging;
 use dropshot::ConfigLoggingLevel;
+use oxide_api_prototype::fatal;
 use oxide_api_prototype::sa_run_server;
+use oxide_api_prototype::CmdError;
 use oxide_api_prototype::ConfigSledAgent;
 use oxide_api_prototype::SimMode;
 use std::net::SocketAddr;
@@ -25,7 +25,7 @@ async fn main() {
     }
 }
 
-async fn do_run() -> Result<(), String> {
+async fn do_run() -> Result<(), CmdError> {
     let matches = App::new("sled_agent")
         .after_help("See README.adoc for more information")
         .arg(
@@ -42,27 +42,30 @@ async fn do_run() -> Result<(), String> {
         .arg(Arg::with_name("CONTROLLER_IP:PORT").required(true).index(3))
         .get_matches_safe()
         .map_err(|clap_error| {
-            format!("parsing arguments: {}", clap_error.message)
+            CmdError::Usage(format!(
+                "parsing arguments: {}",
+                clap_error.message
+            ))
         })?;
 
     let sa_id = {
         let value_str = matches.value_of("SA_UUID").unwrap();
         Uuid::parse_str(value_str)
-            .map_err(|e| format!("parsing SA_UUID: {}", e))?
+            .map_err(|e| CmdError::Usage(format!("parsing SA_UUID: {}", e)))?
     };
 
     let sa_addr = {
         let value_str = matches.value_of("SA_IP:PORT").unwrap();
-        value_str
-            .parse::<SocketAddr>()
-            .map_err(|e| format!("parsing SA_IP:PORT: {}", e))?
+        value_str.parse::<SocketAddr>().map_err(|e| {
+            CmdError::Usage(format!("parsing SA_IP:PORT: {}", e))
+        })?
     };
 
     let controller_addr = {
         let value_str = matches.value_of("CONTROLLER_IP:PORT").unwrap();
-        value_str
-            .parse::<SocketAddr>()
-            .map_err(|e| format!("parsing CONTROLLER_IP:PORT: {}", e))?
+        value_str.parse::<SocketAddr>().map_err(|e| {
+            CmdError::Usage(format!("parsing CONTROLLER_IP:PORT: {}", e))
+        })?
     };
 
     let sim_mode = match matches.value_of("sim-mode").unwrap() {
@@ -85,10 +88,5 @@ async fn do_run() -> Result<(), String> {
         },
     };
 
-    sa_run_server(&config).await
-}
-
-fn fatal(message: String) -> ! {
-    eprintln!("{}: {}", std::env::args().next().unwrap(), message);
-    exit(1);
+    sa_run_server(&config).await.map_err(CmdError::Failure)
 }

src/bin/sled_agent.rs

@@ -0,0 +1,32 @@
+/*!
+ * Facilities used by the command-line tools
+ */
+
+use std::env::current_exe;
+use std::process::exit;
+
+/** represents a fatal error in a command-line program */
+pub enum CmdError {
+    /** incorrect command-line arguments */
+    Usage(String),
+    /** all other errors */
+    Failure(String),
+}
+
+/**
+ * Exits the current process on a fatal error.
+ */
+pub fn fatal(cmd_error: CmdError) -> ! {
+    let arg0_result = current_exe().ok();
+    let arg0 = arg0_result
+        .as_deref()
+        .and_then(|pathbuf| pathbuf.file_stem())
+        .and_then(|file_name| file_name.to_str())
+        .unwrap_or("command");
+    let (exit_code, message) = match cmd_error {
+        CmdError::Usage(m) => (2, m),
+        CmdError::Failure(m) => (1, m),
+    };
+    eprintln!("{}: {}", arg0, message);
+    exit(exit_code);
+}

src/cmd.rs

@@ -54,6 +54,7 @@
 
 mod api_error;
 pub mod api_model;
+mod cmd;
 mod datastore;
 mod http_client;
 mod oxide_controller;
@@ -76,5 +77,8 @@ pub use sled_agent::SledAgentClient;
 pub use sled_agent::SledAgentServer;
 pub use sled_agent::SledAgentTestInterfaces;
 
+pub use cmd::fatal;
+pub use cmd::CmdError;
+
 #[macro_use]
 extern crate slog;

src/lib.rs

@@ -58,10 +58,10 @@ impl fmt::Display for LoadError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.kind {
             LoadErrorKind::Io(e) => {
-                write!(f, "read \"{}\": {:?}", self.path.display(), e)
+                write!(f, "read \"{}\": {}", self.path.display(), e)
             }
             LoadErrorKind::Parse(e) => {
-                write!(f, "parse \"{}\": {:?}", self.path.display(), e)
+                write!(f, "parse \"{}\": {}", self.path.display(), e)
             }
         }
     }