chore(candid-utils): Factor out Candid pretty printing function

rs/nervous_system/candid_utils/BUILD.bazel

@@ -11,7 +11,9 @@ DEPENDENCIES = [
 
 MACRO_DEPENDENCIES = []
 
-DEV_DEPENDENCIES = []
+DEV_DEPENDENCIES = [
+    "@crate_index//:pretty_assertions",
+]
 
 MACRO_DEV_DEPENDENCIES = []
 

rs/nervous_system/candid_utils/Cargo.toml

@@ -12,3 +12,6 @@ path = "src/lib.rs"
 [dependencies]
 candid = { workspace = true }
 candid_parser = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }

rs/nervous_system/candid_utils/src/lib.rs

@@ -1 +1,2 @@
+pub mod printing;
 pub mod validation;

rs/nervous_system/candid_utils/src/printing.rs

@@ -0,0 +1,10 @@
+use candid::{CandidType, IDLValue};
+
+pub fn pretty<T: CandidType>(value: T) -> Result<String, String> {
+    let value = IDLValue::try_from_candid_type(&value).map_err(|err| err.to_string())?;
+
+    Ok(value.to_string())
+}
+
+#[cfg(test)]
+mod tests;

rs/nervous_system/candid_utils/src/printing/tests.rs

@@ -0,0 +1,78 @@
+use super::*;
+
+#[derive(candid::CandidType, Clone, PartialEq)]
+struct DummyCandidStruct {
+    pub status: Option<i32>,
+    pub module_hash: Vec<u8>,
+    pub controllers: String,
+    pub memory_size: Option<u64>,
+    pub cycles: Option<u64>,
+}
+
+#[derive(candid::CandidType, Clone, PartialEq)]
+enum DummyCandidVariant {
+    Foo(String),
+    Bar { abc: String, xyz: String },
+}
+
+#[derive(candid::CandidType, Clone, PartialEq)]
+struct DummyCandidContainer {
+    foo: DummyCandidVariant,
+    bar: Result<DummyCandidVariant, String>,
+}
+
+#[track_caller]
+fn run_test<T: CandidType>(value: T, expected_result: Result<String, String>) {
+    let observed_result = pretty(value);
+
+    match (observed_result, expected_result) {
+        (Ok(observed), Ok(expected)) => {
+            pretty_assertions::assert_str_eq!(observed, expected);
+        }
+        (observed, expected) => {
+            pretty_assertions::assert_eq!(observed, expected);
+        }
+    }
+}
+
+#[test]
+fn test_candid_value_pretty_printing() {
+    // Scenario A: Simple structure whose fields are various built-in types.
+
+    run_test(
+        DummyCandidStruct {
+            status: Some(42),
+            module_hash: vec![1, 2, 3, 4],
+            controllers: "foo".to_string(),
+            memory_size: Some(100),
+            cycles: Some(123),
+        },
+        Ok(r#"record {
+  status = opt (42 : int32);
+  controllers = "foo";
+  memory_size = opt (100 : nat64);
+  cycles = opt (123 : nat64);
+  module_hash = blob "\01\02\03\04";
+}"#
+        .to_string()),
+    );
+
+    // Scenario B: Complex structure.
+
+    let expected_result = r#"record {
+  bar = variant { Ok = variant { Bar = record { abc = "abc"; xyz = "xyz" } } };
+  foo = variant { Foo = "hello" };
+}"#
+    .to_string();
+
+    run_test(
+        DummyCandidContainer {
+            foo: DummyCandidVariant::Foo("hello".to_string()),
+            bar: Ok(DummyCandidVariant::Bar {
+                abc: "abc".to_string(),
+                xyz: "xyz".to_string(),
+            }),
+        },
+        Ok(expected_result),
+    );
+}

rs/sns/cli/BUILD.bazel

@@ -7,6 +7,7 @@ DEPENDENCIES = [
     # Keep sorted.
     "//rs/crypto/sha2",
     "//rs/nervous_system/agent",
+    "//rs/nervous_system/candid_utils",
     "//rs/nervous_system/common",
     "//rs/nervous_system/common/test_keys",
     "//rs/nervous_system/humanize",

rs/sns/cli/Cargo.toml

@@ -17,6 +17,7 @@ path = "src/lib.rs"
 anyhow = { workspace = true }
 base64 = { workspace = true }
 candid = { workspace = true }
+candid-utils = { path = "../../nervous_system/candid_utils" }
 clap = { workspace = true }
 futures = { workspace = true }
 hex = { workspace = true }

rs/sns/cli/src/neuron_id_to_candid_subaccount.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use anyhow::{anyhow, Result};
-use candid::IDLValue;
+use candid_utils::printing;
 use clap::Parser;
 use ic_sns_governance::pb::v1::NeuronId;
 
@@ -37,9 +37,7 @@ pub fn neuron_id_to_subaccount(args: NeuronIdToCandidSubaccountArgs) -> Result<S
         .to_vec();
 
     // We'll convert it to a candid string.
-    let idl = IDLValue::try_from_candid_type(&subaccount)
-        .unwrap()
-        .to_string();
+    let idl = printing::pretty(&subaccount).unwrap();
 
     if args.escaped {
         Ok(idl.replace('\\', "\\\\").replace('\"', "\\\""))