Fix encode/decode todo's (#13683)

Mistakes have been made. I forgot about a bunch of `todo`s in the helper
functions. So, this PR replaces them with proper errors. It also adds
tests for parse-time evaluation, because one `todo` I missed was in a
`run_const` function.

crates/nu-command/src/strings/base/hex.rs

@@ -53,7 +53,7 @@ impl Command for DecodeHex {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        todo!()
+        super::decode(data_encoding::HEXLOWER_PERMISSIVE, call.span(), input)
     }
 }
 

crates/nu-command/src/strings/base/mod.rs

@@ -54,14 +54,17 @@ fn get_string(input: PipelineData, call_span: Span) -> Result<(String, Span), Sh
             match val {
                 Value::String { val, .. } => Ok((val, span)),
 
-                _ => {
+                value => Err(ShellError::TypeMismatch {
-                    todo!("Invalid type")
+                    err_message: "binary or string".to_owned(),
-                }
+                    span: call_span,
+                }),
             }
         }
-        PipelineData::ListStream(..) => {
+        PipelineData::ListStream(list, ..) => Err(ShellError::PipelineMismatch {
-            todo!()
+            exp_input_type: "binary or string".to_owned(),
-        }
+            dst_span: call_span,
+            src_span: list.span(),
+        }),
         PipelineData::ByteStream(stream, ..) => {
             let span = stream.span();
             Ok((stream.into_string()?, span))
@@ -80,20 +83,23 @@ fn get_binary(input: PipelineData, call_span: Span) -> Result<(Vec<u8>, Span), S
                 Value::Binary { val, .. } => Ok((val, span)),
                 Value::String { val, .. } => Ok((val.into_bytes(), span)),
 
-                _ => {
+                value => Err(ShellError::TypeMismatch {
-                    todo!("Invalid type")
+                    err_message: "binary or string".to_owned(),
-                }
+                    span: call_span,
+                }),
             }
         }
-        PipelineData::ListStream(..) => {
+        PipelineData::ListStream(list, ..) => Err(ShellError::PipelineMismatch {
-            todo!()
+            exp_input_type: "binary or string".to_owned(),
-        }
+            dst_span: call_span,
+            src_span: list.span(),
+        }),
         PipelineData::ByteStream(stream, ..) => {
             let span = stream.span();
             Ok((stream.into_bytes()?, span))
         }
-        PipelineData::Empty => {
+        PipelineData::Empty => Err(ShellError::PipelineEmpty {
-            todo!("Can't have empty data");
+            dst_span: call_span,
-        }
+        }),
     }
 }

crates/nu-command/tests/commands/base/base32.rs

@@ -2,16 +2,14 @@ use nu_test_support::nu;
 
 #[test]
 fn canonical() {
-    for value in super::random_bytes() {
+    super::test_canonical("base32");
-        let outcome = nu!("{} | encode base32 | decode base32 | to nuon", value);
+    super::test_canonical("base32 --nopad");
-        assert_eq!(outcome.out, value);
+}
 
-        let outcome = nu!(
+#[test]
-            "{} | encode base32 --nopad | decode base32 --nopad | to nuon",
+fn const_() {
-            value
+    super::test_const("base32");
-        );
+    super::test_const("base32 --nopad");
-        assert_eq!(outcome.out, value);
-    }
 }
 
 #[test]

crates/nu-command/tests/commands/base/base32hex.rs

@@ -2,16 +2,14 @@ use nu_test_support::nu;
 
 #[test]
 fn canonical() {
-    for value in super::random_bytes() {
+    super::test_canonical("base32hex");
-        let outcome = nu!("{} | encode base32hex | decode base32hex | to nuon", value);
+    super::test_canonical("base32hex --nopad");
-        assert_eq!(outcome.out, value);
+}
 
-        let outcome = nu!(
+#[test]
-            "{} | encode base32hex --nopad | decode base32hex --nopad | to nuon",
+fn const_() {
-            value
+    super::test_const("base32hex");
-        );
+    super::test_const("base32hex --nopad");
-        assert_eq!(outcome.out, value);
-    }
 }
 
 #[test]

crates/nu-command/tests/commands/base/base64.rs

@@ -2,31 +2,18 @@ use nu_test_support::nu;
 
 #[test]
 fn canonical() {
-    for value in super::random_bytes() {
+    super::test_canonical("new-base64");
-        let outcome = nu!(
+    super::test_canonical("new-base64 --url");
-            "{} | encode new-base64 | decode new-base64 | to nuon",
+    super::test_canonical("new-base64 --nopad");
-            value
+    super::test_canonical("new-base64 --url --nopad");
-        );
+}
-        assert_eq!(outcome.out, value);
 
-        let outcome = nu!(
+#[test]
-            "{} | encode new-base64 --url | decode new-base64 --url | to nuon",
+fn const_() {
-            value
+    super::test_const("new-base64");
-        );
+    super::test_const("new-base64 --url");
-        assert_eq!(outcome.out, value);
+    super::test_const("new-base64 --nopad");
-
+    super::test_const("new-base64 --url --nopad");
-        let outcome = nu!(
-            "{} | encode new-base64 --nopad | decode new-base64 --nopad | to nuon",
-            value
-        );
-        assert_eq!(outcome.out, value);
-
-        let outcome = nu!(
-            "{} | encode new-base64 --url --nopad | decode new-base64 --url --nopad | to nuon",
-            value
-        );
-        assert_eq!(outcome.out, value);
-    }
 }
 
 #[test]

crates/nu-command/tests/commands/base/hex.rs

@@ -2,10 +2,12 @@ use nu_test_support::nu;
 
 #[test]
 fn canonical() {
-    for value in super::random_bytes() {
+    super::test_canonical("hex");
-        let outcome = nu!("{} | encode hex | decode hex | to nuon", value);
+}
-        assert_eq!(outcome.out, value);
+
-    }
+#[test]
+fn const_() {
+    super::test_const("hex");
 }
 
 #[test]

crates/nu-command/tests/commands/base/mod.rs

@@ -2,13 +2,15 @@ use data_encoding::HEXUPPER;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 
+use nu_test_support::nu;
+
 mod base32;
 mod base32hex;
 mod base64;
 mod hex;
 
 /// Generate a few random binaries.
-pub fn random_bytes() -> Vec<String> {
+fn random_bytes() -> Vec<String> {
     const NUM: usize = 32;
     let mut rng = ChaCha8Rng::seed_from_u64(4);
 
@@ -17,8 +19,26 @@ pub fn random_bytes() -> Vec<String> {
             let length = rng.gen_range(0..512);
             let mut bytes = vec![0u8; length];
             rng.fill_bytes(&mut bytes);
-            let hex_bytes = HEXUPPER.encode(&bytes);
+            HEXUPPER.encode(&bytes)
-            format!("0x[{}]", hex_bytes)
         })
         .collect()
 }
+
+pub fn test_canonical(cmd: &str) {
+    for value in random_bytes() {
+        let outcome = nu!("0x[{}] | encode {1} | decode {1} | to nuon", value, cmd);
+        let nuon_value = format!("0x[{value}]");
+        assert_eq!(outcome.out, nuon_value);
+    }
+}
+
+pub fn test_const(cmd: &str) {
+    for value in random_bytes() {
+        let outcome = nu!(
+            r#"const out = (0x[{}] | encode {1} | decode {1} | encode hex); $out"#,
+            value,
+            cmd
+        );
+        assert_eq!(outcome.out, value);
+    }
+}