Move storage status subcommand into status command

In an attempt to rework the structure of the storage command to better
accommodate future requirements for allowing to change the read-write
state of the unencrypted volume (as well as potentially the encrypted
one), this change removes the storage status subcommand and merges its
output into the storage command.

4 files changed, 89 insertions, 76 deletions

diff --git a/nitrocli/src/args.rs b/nitrocli/src/args.rs
index 10a097e..0b0429a 100644
--- a/nitrocli/src/args.rs
+++ b/nitrocli/src/args.rs
@@ -250,7 +250,6 @@ Enum! {StorageCommand, [
   Close => ("close", storage_close),
   Hidden => ("hidden", storage_hidden),
   Open => ("open", storage_open),
-  Status => ("status", storage_status),
 ]}
 
 /// Execute a storage subcommand.
@@ -295,15 +294,6 @@ fn storage_close(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   commands::storage_close(ctx)
 }
 
-/// Print the status of the nitrokey's storage.
-fn storage_status(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-  let mut parser = argparse::ArgumentParser::new();
-  parser.set_description("Prints the status of the Nitrokey's storage");
-  parse(ctx, parser, args)?;
-
-  commands::storage_status(ctx)
-}
-
 Enum! {HiddenCommand, [
   Close => ("close", storage_hidden_close),
   Create => ("create", storage_hidden_create),
diff --git a/nitrocli/src/commands.rs b/nitrocli/src/commands.rs
index 7bb314c..d1ded11 100644
--- a/nitrocli/src/commands.rs
+++ b/nitrocli/src/commands.rs
@@ -258,6 +258,39 @@ where
   })
 }
 
+/// Pretty print the status of a Nitrokey Storage.
+fn print_storage_status(
+  ctx: &mut args::ExecCtx<'_>,
+  status: &nitrokey::StorageStatus,
+) -> Result<()> {
+  println!(
+    ctx,
+    r#"  Storage:
+    SD card ID:        {id:#x}
+    firmware:          {fw}
+    storage keys:      {sk}
+    volumes:
+      unencrypted:     {vu}
+      encrypted:       {ve}
+      hidden:          {vh}"#,
+    id = status.serial_number_sd_card,
+    fw = if status.firmware_locked {
+      "locked"
+    } else {
+      "unlocked"
+    },
+    sk = if status.stick_initialized {
+      "created"
+    } else {
+      "not created"
+    },
+    vu = get_volume_status(&status.unencrypted_volume),
+    ve = get_volume_status(&status.encrypted_volume),
+    vh = get_volume_status(&status.hidden_volume),
+  )?;
+  Ok(())
+}
+
 /// Query and pretty print the status that is common to all Nitrokey devices.
 fn print_status(
   ctx: &mut args::ExecCtx<'_>,
@@ -267,6 +300,7 @@ fn print_status(
   let serial_number = device
     .get_serial_number()
     .map_err(|err| get_error("Could not query the serial number", err))?;
+
   println!(
     ctx,
     r#"Status:
@@ -282,7 +316,16 @@ fn print_status(
     urc = device.get_user_retry_count(),
     arc = device.get_admin_retry_count(),
   )?;
-  Ok(())
+
+  if let nitrokey::DeviceWrapper::Storage(device) = device {
+    let status = device
+      .get_status()
+      .map_err(|err| get_error("Getting Storage status failed", err))?;
+
+    print_storage_status(ctx, &status)
+  } else {
+    Ok(())
+  }
 }
 
 /// Inquire the status of the nitrokey.
@@ -399,49 +442,6 @@ pub fn storage_hidden_close(ctx: &mut args::ExecCtx<'_>) -> Result<()> {
     .map_err(|err| get_error("Closing hidden volume failed", err))
 }
 
-/// Pretty print the status of a Nitrokey Storage.
-fn print_storage_status(
-  ctx: &mut args::ExecCtx<'_>,
-  status: &nitrokey::StorageStatus,
-) -> Result<()> {
-  println!(
-    ctx,
-    r#"Status:
-  SD card ID:        {id:#x}
-  firmware:          {fw}
-  storage keys:      {sk}
-  volumes:
-    unencrypted:     {vu}
-    encrypted:       {ve}
-    hidden:          {vh}"#,
-    id = status.serial_number_sd_card,
-    fw = if status.firmware_locked {
-      "locked"
-    } else {
-      "unlocked"
-    },
-    sk = if status.stick_initialized {
-      "created"
-    } else {
-      "not created"
-    },
-    vu = get_volume_status(&status.unencrypted_volume),
-    ve = get_volume_status(&status.encrypted_volume),
-    vh = get_volume_status(&status.hidden_volume),
-  )?;
-  Ok(())
-}
-
-/// Connect to and pretty print the status of a Nitrokey Storage.
-pub fn storage_status(ctx: &mut args::ExecCtx<'_>) -> Result<()> {
-  let device = get_storage_device(ctx)?;
-  let status = device
-    .get_status()
-    .map_err(|err| get_error("Getting Storage status failed", err))?;
-
-  print_storage_status(ctx, &status)
-}
-
 /// Return a String representation of the given Option.
 fn format_option<T: fmt::Display>(option: Option<T>) -> String {
   match option {
diff --git a/nitrocli/src/tests/status.rs b/nitrocli/src/tests/status.rs
index 83ce61f..7aac5ad 100644
--- a/nitrocli/src/tests/status.rs
+++ b/nitrocli/src/tests/status.rs
@@ -37,10 +37,10 @@ fn not_found() {
 }
 
 #[test_device]
-fn output(device: nitrokey::DeviceWrapper) -> crate::Result<()> {
+fn output_pro(device: nitrokey::Pro) -> crate::Result<()> {
   let re = regex::Regex::new(
     r#"^Status:
-  model:             (Pro|Storage)
+  model:             Pro
   serial number:     0x[[:xdigit:]]{8}
   firmware version:  \d+\.\d+
   user retry count:  [0-3]
@@ -53,3 +53,29 @@ $"#,
   assert!(re.is_match(&out), out);
   Ok(())
 }
+
+#[test_device]
+fn output_storage(device: nitrokey::Storage) -> crate::Result<()> {
+  let re = regex::Regex::new(
+    r#"^Status:
+  model:             Storage
+  serial number:     0x[[:xdigit:]]{8}
+  firmware version:  \d+\.\d+
+  user retry count:  [0-3]
+  admin retry count: [0-3]
+  Storage:
+    SD card ID:        0x[[:xdigit:]]{8}
+    firmware:          (un)?locked
+    storage keys:      (not )?created
+    volumes:
+      unencrypted:     (read-only|active|inactive)
+      encrypted:       (read-only|active|inactive)
+      hidden:          (read-only|active|inactive)
+$"#,
+  )
+  .unwrap();
+
+  let out = Nitrocli::with_dev(device).handle(&["status"])?;
+  assert!(re.is_match(&out), out);
+  Ok(())
+}
diff --git a/nitrocli/src/tests/storage.rs b/nitrocli/src/tests/storage.rs
index be933ca..5b45bdc 100644
--- a/nitrocli/src/tests/storage.rs
+++ b/nitrocli/src/tests/storage.rs
@@ -20,15 +20,6 @@
 use super::*;
 
 #[test_device]
-fn status_on_pro(device: nitrokey::Pro) {
-  let res = Nitrocli::with_dev(device).handle(&["storage", "status"]);
-  assert_eq!(
-    res.unwrap_str_err(),
-    "This command is only available on the Nitrokey Storage",
-  );
-}
-
-#[test_device]
 fn status_open_close(device: nitrokey::Storage) -> crate::Result<()> {
   fn make_re(open: Option<bool>) -> regex::Regex {
     let encrypted = match open {
@@ -42,14 +33,11 @@ fn status_open_close(device: nitrokey::Storage) -> crate::Result<()> {
       None => "(read-only|active|inactive)",
     };
     let re = format!(
-      r#"^Status:
-  SD card ID:        0x[[:xdigit:]]{{8}}
-  firmware:          (un)?locked
-  storage keys:      (not )?created
-  volumes:
-    unencrypted:     (read-only|active|inactive)
-    encrypted:       {}
-    hidden:          (read-only|active|inactive)
+      r#"
+    volumes:
+      unencrypted:     (read-only|active|inactive)
+      encrypted:       {}
+      hidden:          (read-only|active|inactive)
 $"#,
       encrypted
     );
@@ -57,21 +45,30 @@ $"#,
   }
 
   let mut ncli = Nitrocli::with_dev(device);
-  let out = ncli.handle(&["storage", "status"])?;
+  let out = ncli.handle(&["status"])?;
   assert!(make_re(None).is_match(&out), out);
 
   let _ = ncli.handle(&["storage", "open"])?;
-  let out = ncli.handle(&["storage", "status"])?;
+  let out = ncli.handle(&["status"])?;
   assert!(make_re(Some(true)).is_match(&out), out);
 
   let _ = ncli.handle(&["storage", "close"])?;
-  let out = ncli.handle(&["storage", "status"])?;
+  let out = ncli.handle(&["status"])?;
   assert!(make_re(Some(false)).is_match(&out), out);
 
   Ok(())
 }
 
 #[test_device]
+fn encrypted_open_on_pro(device: nitrokey::Pro) {
+  let res = Nitrocli::with_dev(device).handle(&["storage", "open"]);
+  assert_eq!(
+    res.unwrap_str_err(),
+    "This command is only available on the Nitrokey Storage",
+  );
+}
+
+#[test_device]
 fn encrypted_open_close(device: nitrokey::Storage) -> crate::Result<()> {
   let mut ncli = Nitrocli::with_dev(device);
   let out = ncli.handle(&["storage", "open"])?;