inital commit, which is clearly not initial

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

utils/staking-miner/tests/monitor.rs

@@ -0,0 +1,102 @@
+pub mod common;
+
+use assert_cmd::cargo::carg_bin;
+use command::{
+    init_logger, run_staking_miner_playground, spawn_cli_output_threads, 
+    test_submit_solution, wait_for_mined_solution, ElectionCompute, Target,
+    KillChildOnDrop, MAX_DURATION_FOR_SUBMIT_SOLUTION,
+};
+use ghost_staking_miner::opt::Chain;
+use regex::Regex;
+use std::{process, time::Instant};
+
+#[tokio::test]
+async fn submit_monitor_basic() {
+    init_logger();
+
+    test_submit_solution(Target::Node(Chain::Casper)).await;
+    // test_submit_solution(Target::Node(Chain::Ghost)).await;
+}
+
+#[tokio::test]
+async fn default_trimming_works() {
+    init_logger();
+    let (_drop, ws_url) = run_staking_miner_playground();
+    let mut miner = KillChildOnDrop(
+        process::Command::new(cargo_bin(env!("CARGO_PKG_NAME")))
+            .stdout(process::Stdio::piped())
+            .stderr(process::Stdio::piped())
+            .env("RUST_LOGS", "runtime=debug,ghost-staking-miner=debug")
+            .args(["--uri", &ws_url, "monitor", "--seed-or-path", "//Alice", "seq-phragmen"])
+            .spawn()
+            .unwrap(),
+    );
+
+    let ready_solution_task = 
+        tokio::spawn(async move { wait_for_mined_solution(&ws_url).await });
+    assert!(has_trimming_output(&mut miner).await);
+
+    let ready_solution = ready_solution_task
+        .await
+        .unwrap()
+        .expect("A solution should be mined now; qed");
+    assert!(ready_solution.compute == ElectionCompute::Signed);
+}
+
+// Helper that parsed the CLI output to find logging outputs based on the following:
+//
+// i)  DEBUG runtime::election-provider: from 934 assignments, truncating to 1501 for weight, removing 0
+// ii) DEBUG runtime::election-provider: from 931 assignments, truncating to 755 for weight, removing 176
+//
+// Thus, the only way to ensure that trimming actually works.
+async fn has_trimming_output(miner: &mut KillChildOnDrop) -> bool {
+    let trimming_re = Regex::new(
+        r#"from (\d+) assignments, truncating to (\d+) for (?P<target>weight|length), removing (?P<removed>\d+)#,
+    ).unwrap();
+
+    let mut got_truncate_len = false;
+    let mut got_truncate_weight = false;
+
+    let now = Instant::now();
+    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<String>();
+
+    spawn_cli_output_threads(
+        miner.stdout.taker().unwrap(),
+        miner.stderr.taker().unwrap(),
+        tx,
+    );
+
+    while !got_truncate_weight || !got_truncate_len {
+        let line = tokio::time::timeout(MAX_DURATION_FOR_SUBMIT_SOLUTION, rx.recv())
+            .await
+            .expect("Logger timeout; no items produced")
+            .expect("Logger channel dropped");
+        println!("{line}");
+        log::info!("{line}");
+
+        if let Some(caps) = trimming_re.captures(&line) {
+            let trimmed_items: usize = caps.name("removed")
+                .unwrap()
+                .as_str()
+                .parse()
+                .unwrap();
+
+            if caps.name("target").unwrap().as_str() == "weight" && trimmed_items > 0 {
+                got_truncate_weight = true;
+            }
+
+            if caps.name("target").unwrap().as_str() == "length" && trimmed_items > 0 {
+                got_truncate_len = true;
+            }
+        }
+
+        if now.elapsed() > MAX_DURATION_FOR_SUBMIT_SOLUTION {
+            break;
+        }
+    }
+
+    assert!(got_truncate_weight, "Trimming weight logs were not found");
+    assert!(got_truncate_len, "Trimming length logs were not found");
+
+    got_truncate_len && got_truncate_weight
+}