feat(wasm-utxo): refactor fixtures handling and tree rendering

Simplified the fixture handling code and tree rendering utilities. Moved
non-test-related code behind #[cfg(test)] attributes to reduce binary size.
Removed unused color schemes and unnecessary public exports.

Issue: BTC-2652

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

packages/wasm-utxo/cli/src/format/fixtures.rs

@@ -1,117 +1,75 @@
+#[cfg(test)]
 use super::tree::{node_to_string_with_scheme, ColorScheme};
+#[cfg(test)]
 use crate::node::Node;
+#[cfg(test)]
 use std::env;
+#[cfg(test)]
 use std::fs;
+#[cfg(test)]
 use std::io::{self, Write};
-use std::path::PathBuf;
 
-/// Generate a tree representation of a Node without colors
-pub fn generate_tree_text(node: &Node) -> Result<String, io::Error> {
-    // Use the no-color scheme for consistent fixture output
+/// Ensure the generated tree output matches the fixture file
+/// If the fixture doesn't exist, it will be created
+#[cfg(test)]
+pub fn assert_tree_matches_fixture(node: &Node, name: &str) -> Result<(), io::Error> {
     let no_color_scheme = ColorScheme::no_color();
-    node_to_string_with_scheme(node, &no_color_scheme)
-}
-
-/// Generate a tree representation of a Node with a specific color scheme
-pub fn generate_tree_text_with_scheme(
-    node: &Node,
-    color_scheme: &ColorScheme,
-) -> Result<String, io::Error> {
-    node_to_string_with_scheme(node, color_scheme)
-}
+    let generated = node_to_string_with_scheme(node, &no_color_scheme)?;
 
-/// Returns the path to the fixture directory
-pub fn fixtures_directory() -> PathBuf {
     let project_dir = env::current_dir().expect("Failed to get current directory");
-    project_dir.join("test").join("fixtures")
-}
-
-/// Write tree output to a fixture file
-pub fn write_fixture(name: &str, content: &str) -> Result<(), io::Error> {
-    let fixtures_dir = fixtures_directory();
-    fs::create_dir_all(&fixtures_dir)?;
-
+    let fixtures_dir = project_dir.join("test").join("fixtures");
     let fixture_path = fixtures_dir.join(format!("{}.txt", name));
 
-    // Write the content to the file
-    let mut file = fs::File::create(&fixture_path)?;
-    file.write_all(content.as_bytes())?;
+    if fixture_path.exists() {
+        let fixture_content = fs::read_to_string(&fixture_path)?;
+        // Compare the generated output to the fixture
+        assert_eq!(
+            generated, fixture_content,
+            "Generated tree output doesn't match fixture file: {}",
+            name
+        );
+    } else {
+        // Create the fixture if it doesn't exist
+        fs::create_dir_all(&fixtures_dir)?;
+        let mut file = fs::File::create(&fixture_path)?;
+        file.write_all(generated.as_bytes())?;
+        println!("Created new fixture: {}.txt", name);
+    }
 
     Ok(())
 }
 
-/// Read the content of a fixture file if it exists
-pub fn read_fixture(name: &str) -> Result<Option<String>, io::Error> {
-    let fixture_path = fixtures_directory().join(format!("{}.txt", name));
+/// Assert tree matches fixture, updating if needed or requested
+#[cfg(test)]
+pub fn assert_or_update_fixture(node: &Node, name: &str) -> Result<(), io::Error> {
+    let no_color_scheme = ColorScheme::no_color();
+    let generated = node_to_string_with_scheme(node, &no_color_scheme)?;
 
-    if fixture_path.exists() {
-        let content = fs::read_to_string(&fixture_path)?;
-        Ok(Some(content))
-    } else {
-        Ok(None)
-    }
-}
+    let project_dir = env::current_dir().expect("Failed to get current directory");
+    let fixtures_dir = project_dir.join("test").join("fixtures");
+    let fixture_path = fixtures_dir.join(format!("{}.txt", name));
 
-/// Ensure the generated tree output matches the fixture file
-/// If the fixture doesn't exist, it will be created
-pub fn assert_tree_matches_fixture(node: &Node, name: &str) -> Result<(), io::Error> {
-    let generated = generate_tree_text(node)?;
+    let update_fixtures = env::var("UPDATE_FIXTURES").is_ok();
 
-    match read_fixture(name)? {
-        Some(fixture_content) => {
-            // Compare the generated output to the fixture
+    if fixture_path.exists() {
+        let fixture_content = fs::read_to_string(&fixture_path)?;
+        if update_fixtures || generated != fixture_content {
+            let mut file = fs::File::create(&fixture_path)?;
+            file.write_all(generated.as_bytes())?;
+            println!("Updated fixture: {}.txt", name);
+        } else {
             assert_eq!(
                 generated, fixture_content,
                 "Generated tree output doesn't match fixture file: {}",
                 name
             );
         }
-        None => {
-            // Create the fixture if it doesn't exist
-            write_fixture(name, &generated)?;
-            println!("Created new fixture: {}.txt", name);
-        }
-    }
-
-    Ok(())
-}
-
-/// Force update of a fixture file with new content
-pub fn update_fixture(node: &Node, name: &str) -> Result<(), io::Error> {
-    let generated = generate_tree_text(node)?;
-    write_fixture(name, &generated)
-}
-
-// Environment variable to force fixture updates
-const UPDATE_FIXTURES_ENV: &str = "UPDATE_FIXTURES";
-
-/// Check if fixtures should be updated
-pub fn should_update_fixtures() -> bool {
-    env::var(UPDATE_FIXTURES_ENV).is_ok()
-}
-
-/// Assert tree matches fixture, updating if needed or requested
-pub fn assert_or_update_fixture(node: &Node, name: &str) -> Result<(), io::Error> {
-    let generated = generate_tree_text(node)?;
-
-    match read_fixture(name)? {
-        Some(fixture_content) => {
-            if should_update_fixtures() || generated != fixture_content {
-                write_fixture(name, &generated)?;
-                println!("Updated fixture: {}.txt", name);
-            } else {
-                assert_eq!(
-                    generated, fixture_content,
-                    "Generated tree output doesn't match fixture file: {}",
-                    name
-                );
-            }
-        }
-        None => {
-            // Create the fixture if it doesn't exist
-            write_fixture(name, &generated)?;
-            println!("Created new fixture: {}.txt", name);
-        }
+    } else {
+        // Create the fixture if it doesn't exist
+        fs::create_dir_all(&fixtures_dir)?;
+        let mut file = fs::File::create(&fixture_path)?;
+        file.write_all(generated.as_bytes())?;
+        println!("Created new fixture: {}.txt", name);
     }
 
     Ok(())

packages/wasm-utxo/cli/src/format/mod.rs

@@ -3,7 +3,4 @@ pub mod fixtures;
 mod tests;
 mod tree;
 
-pub use tree::{
-    add_node_to_tree, add_node_to_tree_with_scheme, format_primitive_for_tree, node_to_string,
-    node_to_string_with_scheme, render_tree, render_tree_with_scheme, ColorScheme,
-};
+pub use tree::{render_tree_with_scheme, ColorScheme};

packages/wasm-utxo/cli/src/format/tree.rs

@@ -1,6 +1,8 @@
 use crate::node::{Node, Primitive};
 use colored::*;
-use ptree::{print_tree, TreeBuilder};
+use ptree::print_tree;
+#[cfg(test)]
+use ptree::TreeBuilder;
 use std::borrow::Cow;
 use std::io;
 
@@ -46,30 +48,6 @@ impl ColorScheme {
         }
     }
 
-    /// High contrast color scheme for better visibility
-    pub fn high_contrast() -> Self {
-        Self {
-            label_style: |s| s.bold().bright_white().to_string(),
-            value_style: |s| s.to_string(),
-            buffer_style: |s| s.bright_cyan().to_string(),
-            numeric_style: |s| s.bright_yellow().to_string(),
-            string_style: |s| s.bright_green().to_string(),
-            boolean_style: |s| s.bright_magenta().to_string(),
-        }
-    }
-
-    /// Minimal color scheme with subtle styling
-    pub fn minimal() -> Self {
-        Self {
-            label_style: |s| s.dimmed().to_string(),
-            value_style: |s| s.to_string(),
-            buffer_style: |s| s.blue().to_string(),
-            numeric_style: |s| s.to_string(),
-            string_style: |s| s.to_string(),
-            boolean_style: |s| s.to_string(),
-        }
-    }
-
     /// Apply appropriate styling to a primitive value based on its type
     pub fn style_primitive(&self, primitive: &Primitive, formatted_value: &str) -> String {
         match primitive {
@@ -149,7 +127,8 @@ pub fn format_primitive_for_tree(primitive: &Primitive) -> String {
 }
 
 /// Render a Node tree to a string with the specified color scheme
-pub fn node_to_string_with_scheme(
+#[cfg(test)]
+pub(super) fn node_to_string_with_scheme(
     node: &Node,
     color_scheme: &ColorScheme,
 ) -> Result<String, io::Error> {
@@ -173,17 +152,9 @@ pub fn node_to_string_with_scheme(
     Ok(String::from_utf8_lossy(&output).to_string())
 }
 
-/// Render a Node tree to a string (using default color scheme for backward compatibility)
-pub fn node_to_string(node: &Node) -> Result<String, io::Error> {
-    node_to_string_with_scheme(node, &ColorScheme::default())
-}
-
 /// Helper function to add a node and its children to a tree with color scheme
-pub fn add_node_to_tree_with_scheme(
-    tree: &mut TreeBuilder,
-    node: &Node,
-    color_scheme: &ColorScheme,
-) {
+#[cfg(test)]
+fn add_node_to_tree_with_scheme(tree: &mut TreeBuilder, node: &Node, color_scheme: &ColorScheme) {
     let styled_label = (color_scheme.label_style)(&node.label);
     let value_str = format_primitive_for_tree(&node.value);
     let styled_value = color_scheme.style_primitive(&node.value, &value_str);
@@ -197,18 +168,8 @@ pub fn add_node_to_tree_with_scheme(
     tree.end_child();
 }
 
-/// Helper function to add a node and its children to a tree (using default color scheme for backward compatibility)
-pub fn add_node_to_tree(tree: &mut TreeBuilder, node: &Node) {
-    add_node_to_tree_with_scheme(tree, node, &ColorScheme::default());
-}
-
 /// Render a Node tree to the terminal with the specified color scheme
 pub fn render_tree_with_scheme(node: &Node, color_scheme: &ColorScheme) -> Result<(), io::Error> {
     let tree_item = NodeTreeItem { node, color_scheme };
     print_tree(&tree_item)
 }
-
-/// Render a Node tree to the terminal (using default color scheme for backward compatibility)
-pub fn render_tree(node: &Node) -> Result<(), io::Error> {
-    render_tree_with_scheme(node, &ColorScheme::default())
-}

packages/wasm-utxo/cli/src/node.rs

@@ -82,6 +82,7 @@ impl Node {
         }
     }
 
+    #[cfg(test)]
     pub fn with_children(label: impl Into<String>, value: Primitive, children: Vec<Node>) -> Self {
         Self {
             label: label.into(),
@@ -94,15 +95,11 @@ impl Node {
         self.children.push(child);
     }
 
-    pub fn with_child(mut self, child: Node) -> Self {
-        self.children.push(child);
-        self
-    }
-
     pub fn extend(&mut self, nodes: impl IntoIterator<Item = Node>) {
         self.children.extend(nodes);
     }
 
+    #[cfg(test)]
     pub fn child_count(&self) -> usize {
         self.children.len()
     }

packages/wasm-utxo/cli/src/psbt/mod.rs

@@ -27,4 +27,3 @@ pub fn handle_command(command: PsbtCommand) -> Result<()> {
         } => parse::handle_parse_command(path, no_color, raw),
     }
 }
-

packages/wasm-utxo/cli/src/psbt/parse.rs

@@ -30,4 +30,3 @@ pub fn handle_parse_command(path: PathBuf, no_color: bool, raw: bool) -> Result<
 
     Ok(())
 }
-

packages/wasm-utxo/cli/src/tx/mod.rs

@@ -20,4 +20,3 @@ pub fn handle_command(command: TxCommand) -> Result<()> {
         TxCommand::Parse { path, no_color } => parse::handle_parse_command(path, no_color),
     }
 }
-