Fix config log matching

Cargo.lock

@@ -5779,6 +5779,7 @@ dependencies = [
  "humantime",
  "indexmap 2.0.1",
  "insta",
+ "itertools 0.11.0",
  "lazy_static",
  "once_cell",
  "owo-colors",

zebra-test/Cargo.toml

@@ -19,6 +19,7 @@ hex = "0.4.3"
 indexmap = "2.0.1"
 lazy_static = "1.4.0"
 insta = "1.33.0"
+itertools = "0.11.0"
 proptest = "1.3.1"
 once_cell = "1.18.0"
 rand = "0.8.5"

zebra-test/src/command.rs

@@ -21,10 +21,11 @@ use tracing::instrument;
 
 #[macro_use]
 mod arguments;
+
 pub mod to_regex;
 
 pub use self::arguments::Arguments;
-use self::to_regex::{CollectRegexSet, ToRegex, ToRegexSet};
+use self::to_regex::{CollectRegexSet, ToRegexSet};
 
 /// A super-trait for [`Iterator`] + [`Debug`].
 pub trait IteratorDebug: Iterator + Debug {}
@@ -791,7 +792,7 @@ impl<T> TestChild<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn expect_stdout_line_matches<R>(&mut self, success_regex: R) -> Result<String>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
         self.apply_failure_regexes_to_outputs();
 
@@ -823,7 +824,7 @@ impl<T> TestChild<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn expect_stderr_line_matches<R>(&mut self, success_regex: R) -> Result<String>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
         self.apply_failure_regexes_to_outputs();
 
@@ -855,7 +856,7 @@ impl<T> TestChild<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn expect_stdout_line_matches_silent<R>(&mut self, success_regex: R) -> Result<String>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
         self.apply_failure_regexes_to_outputs();
 
@@ -887,7 +888,7 @@ impl<T> TestChild<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn expect_stderr_line_matches_silent<R>(&mut self, success_regex: R) -> Result<String>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
         self.apply_failure_regexes_to_outputs();
 
@@ -1246,9 +1247,9 @@ impl<T> TestOutput<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn stdout_matches<R>(&self, regex: R) -> Result<&Self>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
-        let re = regex.to_regex().expect("regex must be valid");
+        let re = regex.to_regex_set().expect("regex must be valid");
 
         self.output_check(
             |stdout| re.is_match(stdout),
@@ -1270,9 +1271,9 @@ impl<T> TestOutput<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn stdout_line_matches<R>(&self, regex: R) -> Result<&Self>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
-        let re = regex.to_regex().expect("regex must be valid");
+        let re = regex.to_regex_set().expect("regex must be valid");
 
         self.any_output_line(
             |line| re.is_match(line),
@@ -1300,9 +1301,9 @@ impl<T> TestOutput<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn stderr_matches<R>(&self, regex: R) -> Result<&Self>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
-        let re = regex.to_regex().expect("regex must be valid");
+        let re = regex.to_regex_set().expect("regex must be valid");
 
         self.output_check(
             |stderr| re.is_match(stderr),
@@ -1324,9 +1325,9 @@ impl<T> TestOutput<T> {
     #[allow(clippy::unwrap_in_result)]
     pub fn stderr_line_matches<R>(&self, regex: R) -> Result<&Self>
     where
-        R: ToRegex + Debug,
+        R: ToRegexSet + Debug,
     {
-        let re = regex.to_regex().expect("regex must be valid");
+        let re = regex.to_regex_set().expect("regex must be valid");
 
         self.any_output_line(
             |line| re.is_match(line),

zebra-test/src/command/to_regex.rs

@@ -2,6 +2,7 @@
 
 use std::iter;
 
+use itertools::Itertools;
 use regex::{Error, Regex, RegexBuilder, RegexSet, RegexSetBuilder};
 
 /// A trait for converting a value to a [`Regex`].
@@ -135,15 +136,20 @@ pub trait CollectRegexSet {
 impl<I> CollectRegexSet for I
 where
     I: IntoIterator,
-    I::Item: ToRegex,
+    I::Item: ToRegexSet,
 {
     fn collect_regex_set(self) -> Result<RegexSet, Error> {
-        let regexes: Result<Vec<Regex>, Error> =
-            self.into_iter().map(|item| item.to_regex()).collect();
+        let regexes: Result<Vec<RegexSet>, Error> = self
+            .into_iter()
+            .map(|item| item.to_regex_set())
+            .try_collect();
         let regexes = regexes?;
 
         // This conversion discards flags and limits from Regex and RegexBuilder.
-        let regexes = regexes.iter().map(|regex| regex.as_str());
+        let regexes = regexes
+            .iter()
+            .map(|regex_set| regex_set.patterns())
+            .flatten();
 
         RegexSet::new(regexes)
     }

zebrad/tests/acceptance.rs

@@ -161,7 +161,12 @@ use zebra_network::constants::PORT_IN_USE_ERROR;
 use zebra_node_services::rpc_client::RpcRequestClient;
 use zebra_state::{constants::LOCK_FILE_ERROR, database_format_version_in_code};
 
-use zebra_test::{args, command::ContextFrom, net::random_known_port, prelude::*};
+use zebra_test::{
+    args,
+    command::{to_regex::CollectRegexSet, ContextFrom},
+    net::random_known_port,
+    prelude::*,
+};
 
 mod common;
 
@@ -925,17 +930,27 @@ fn stored_configs_work() -> Result<()> {
         let mut child =
             run_dir.spawn_child(args!["-c", stored_config_path.to_str().unwrap(), "start"])?;
 
+        let success_regexes = [
+            // When logs are sent to the terminal, we see the config loading message and path.
+            format!(
+                "loaded zebra config.*config_path.*=.*{}",
+                regex::escape(
+                    stored_config_path
+                        .file_name()
+                        .expect("config path must have a file name")
+                        .to_str()
+                        .expect("config paths are valid unicode")
+                )
+            ),
+            // If they are sent to a file, we just see a log file message.
+            "Sending logs to".to_string(),
+        ]
+        .iter()
+        .collect_regex_set()
+        .expect("regexes are valid");
+
         // Zebra was able to start with the stored config.
-        // When logs are sent to the terminal, we see the config loading message and path.
-        // If they are sent to a file, we just see a log file message.
-        child.expect_stdout_line_matches(format!(
-            "(loaded zebra config.*config_path.*=.*{})|(Sending logs to)",
-            regex::escape(
-                stored_config_path
-                    .to_str()
-                    .expect("config paths are valid unicode")
-            )
-        ))?;
+        child.expect_stdout_line_matches(success_regexes)?;
 
         // finish
         child.kill(false)?;