Add tests

packages/apis/src/extract_substrs.rs

@@ -332,13 +332,42 @@ mod test {
         assert_eq!(idxes, vec![(12, 21)]);
     }
 
+    #[test]
+    fn test_email_domain_valid_different_emails() {
+        let input_str1 = "[email protected]";
+        let idxes1 = extract_email_domain_idxes(input_str1).unwrap();
+        assert_eq!(idxes1, vec![(12, 23)]);
+
+        let input_str2 = "[email protected]";
+        let idxes2 = extract_email_domain_idxes(input_str2).unwrap();
+        assert_eq!(idxes2, vec![(9, 20)]);
+
+        let input_str3 = "[email protected]";
+        let idxes3 = extract_email_domain_idxes(input_str3).unwrap();
+        assert_eq!(idxes3, vec![(14, 25)]);
+    }
+
+    #[test]
+    fn test_email_domain_empty() {
+        let input_str = "";
+        let result = extract_email_domain_idxes(input_str);
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_email_addr_in_subject_valid() {
         let input_str = "This is sent for [email protected]";
         let idxes = extract_email_addr_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(17, 38)]);
     }
 
+    #[test]
+    fn test_email_addr_in_subject_empty() {
+        let input_str = "";
+        let result = extract_email_addr_idxes(input_str);
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_email_addr_with_name_valid1() {
         let input_str = "from:[email protected] <[email protected]>";
@@ -354,20 +383,41 @@ mod test {
         assert_eq!(idxes, vec![(22, 43)]);
     }
 
+    #[test]
+    fn test_email_addr_with_name_empty() {
+        let input_str = "";
+        let result = extract_email_addr_with_name_idxes(input_str);
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_email_from_all_valid() {
         let input_str = "from:[email protected] <[email protected]>\r\n";
         let idxes = extract_from_all_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(5, 40)]);
     }
 
+    #[test]
+    fn test_email_from_all_empty() {
+        let input_str = "";
+        let result = extract_from_all_idxes(input_str);
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_email_from_addr_valid() {
         let input_str = "from:[email protected] <[email protected]>\r\n";
         let idxes = extract_from_addr_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(18, 39)]);
     }
 
+    #[test]
+    fn test_email_from_addr_empty() {
+        let input_str = "";
+        let result = extract_from_addr_idxes(input_str);
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_code_in_subject_valid() {
         let code_regex = DecomposedRegexConfig {
@@ -392,25 +442,84 @@ mod test {
         assert_eq!(idxes, vec![(28, 34)]);
     }
 
+    #[test]
+    fn test_code_in_subject_invalid() {
+        let code_regex = DecomposedRegexConfig {
+            parts: vec![
+                RegexPartConfig {
+                    is_public: false,
+                    regex_def: "CODE:0x".to_string(),
+                },
+                RegexPartConfig {
+                    is_public: true,
+                    regex_def: "(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)+".to_string(),
+                },
+            ],
+        };
+        let input_str = "subject:Email Wallet CODE:0xG123abc"; // Invalid hex code
+        let idxes = extract_substr_idxes(input_str, &code_regex);
+        assert!(idxes.is_err());
+    }
+
+    #[test]
+    fn test_code_in_subject_empty() {
+        let code_regex = DecomposedRegexConfig {
+            parts: vec![
+                RegexPartConfig {
+                    is_public: false,
+                    regex_def: "CODE:0x".to_string(),
+                },
+                RegexPartConfig {
+                    is_public: true,
+                    regex_def: "(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)+".to_string(),
+                },
+            ],
+        };
+        let input_str = "";
+        let idxes = extract_substr_idxes(input_str, &code_regex);
+        assert!(idxes.is_err());
+    }
+
     #[test]
     fn test_body_hash_valid() {
         let input_str = "dkim-signature:v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1694989812; x=1695594612; dara=google.com; h=to:subject:message-id:date:from:mime-version:from:to:cc:subject :date:message-id:reply-to; bh=BWETwQ9JDReS4GyR2v2TTR8Bpzj9ayumsWQJ3q7vehs=; b=";
         let idxes = extract_body_hash_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(219, 263)]);
     }
 
+    #[test]
+    fn test_body_hash_empty() {
+        let input_str = "";
+        let idxes = extract_body_hash_idxes(input_str);
+        assert!(idxes.is_err());
+    }
+
     #[test]
     fn test_timestamp_valid() {
         let input_str = "dkim-signature:v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1694989812; x=1695594612; dara=google.com; h=to:subject:message-id:date:from:mime-version:from:to:cc:subject :date:message-id:reply-to; bh=BWETwQ9JDReS4GyR2v2TTR8Bpzj9ayumsWQJ3q7vehs=; b=";
         let idxes = extract_timestamp_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(80, 90)]);
     }
 
+    #[test]
+    fn test_timestamp_empty() {
+        let input_str = "";
+        let idxes = extract_timestamp_idxes(input_str);
+        assert!(idxes.is_err());
+    }
+
     #[test]
     fn test_message_id_valid() {
         let input_str =
             "message-id:<CAJ7Y6jerCWt6t4HVqfXeeqRthJpj_1vYCpXzAVgowozVFKWbVQ@mail.gmail.com>\r\n";
         let idxes = extract_message_id_idxes(input_str).unwrap();
         assert_eq!(idxes, vec![(11, 79)]);
     }
+
+    #[test]
+    fn test_message_id_empty() {
+        let input_str = "";
+        let idxes = extract_message_id_idxes(input_str);
+        assert!(idxes.is_err());
+    }
 }

packages/apis/src/padding.rs

@@ -17,3 +17,36 @@ pub fn pad_string_node(mut cx: FunctionContext) -> JsResult<JsArray> {
     }
     Ok(padded_array)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pad_string_valid() {
+        let str = "Hello, World!";
+        let padded_bytes_size = 20;
+        let padded_bytes = pad_string(str, padded_bytes_size);
+        assert_eq!(padded_bytes.len(), padded_bytes_size);
+        assert_eq!(&padded_bytes[0..str.len()], str.as_bytes());
+        for byte in &padded_bytes[str.len()..] {
+            assert_eq!(*byte, 0);
+        }
+    }
+
+    #[test]
+    fn test_pad_string_empty_string() {
+        let str = "";
+        let padded_bytes_size = 10;
+        let padded_bytes = pad_string(str, padded_bytes_size);
+        assert_eq!(padded_bytes.len(), padded_bytes_size);
+    }
+
+    #[test]
+    fn test_pad_string_empty_string_no_padding() {
+        let str = "";
+        let padded_bytes_size = 0;
+        let padded_bytes = pad_string(str, padded_bytes_size);
+        assert_eq!(padded_bytes.len(), padded_bytes_size);
+    }
+}

packages/circom/tests/body_hash_regex.test.ts

@@ -46,6 +46,19 @@ describe("Bodyhash Regex", () => {
         }
     });
 
+    it("empty signature field test", async () => {
+        const signatureField = ``;
+        // const revealed = "1694989812";
+        const paddedStr = apis.padString(signatureField, 1024);
+        const circuitInputs = {
+            msg: paddedStr,
+        };
+        // const circuit = await wasm_tester(path.join(__dirname, "./circuits/test_bodyhash_regex.circom"), option);
+        const witness = await circuit.calculateWitness(circuitInputs);
+        await circuit.checkConstraints(witness);
+        expect(0n).toEqual(witness[1]);
+    });
+
     it("timestamp after new line", async () => {
         const signatureField = `\r\ndkim-signature:v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1694989812; x=1695594612; dara=google.com; h=to:subject:message-id:date:from:mime-version:from:to:cc:subject :date:message-id:reply-to; bh=BWETwQ9JDReS4GyR2v2TTR8Bpzj9ayumsWQJ3q7vehs=; b=`;
         // const revealed = "1694989812";

packages/circom/tests/email_addr.test.ts

@@ -44,6 +44,21 @@ describe("Email Address Regex", () => {
         }
     });
 
+    it("with an invalid email address", async () => {
+        const emailAddr = "suegamisora";
+        const paddedStr = apis.padString(emailAddr, 256);
+        const circuitInputs = {
+            msg: paddedStr,
+        };
+        // const circuit = await wasm_tester(path.join(__dirname, "./circuits/test_email_addr_regex.circom"), option);
+        const witness = await circuit.calculateWitness(circuitInputs);
+        await circuit.checkConstraints(witness);
+        expect(0n).toEqual(witness[1]);
+        for (let idx = 0; idx < 256; ++idx) {
+            expect(0n).toEqual(witness[2 + idx]);
+        }
+    });
+
     it("with a prefix", async () => {
         const prefix = "subject:";
         const emailAddr = "[email protected]";

packages/circom/tests/email_domain.test.ts

@@ -47,4 +47,17 @@ describe("Email Domain Regex", () => {
             }
         }
     });
+
+    it("test a regex of an empty email address", async () => {
+        const emailAddr = "";
+        const paddedStr = apis.padString(emailAddr, 256);
+        // const revealed = "";
+        const circuitInputs = {
+            msg: paddedStr,
+        };
+        // const circuit = await wasm_tester(path.join(__dirname, "./circuits/test_email_domain_regex.circom"), option);
+        const witness = await circuit.calculateWitness(circuitInputs);
+        await circuit.checkConstraints(witness);
+        expect(0n).toEqual(witness[1]);
+    });
 });