test(audit,heal): assert three more smoke tests (#6248)

`audit_runtime_facade_stops_empty_replay_workers` called the stop path and checked nothing, the same shape as the notify facade test in the previous commit. It now asserts the worker manager is empty afterwards and that a second call — which shutdown paths make — stays harmless.

The two heal timestamp tests bound their fields to `_`. Both timestamps come from `SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default()`, so a pre-epoch clock yields 0; binding to `_` could not tell that apart from a real reading, which is precisely what the tests said they were guarding. They now require the value to be past 2020-01-01, and `last_update` not to predate `start_time`.

`test_config_parsing_with_multiple_instances` is left as it was — see the issue comment. Asserting on it turned up something bigger than a missing assertion.

Refs backlog#1836

crates/audit/tests/pipeline_layer_test.rs

@@ -236,12 +236,19 @@ async fn audit_pipeline_reports_empty_runtime_snapshots() {
 }
 
 #[tokio::test]
-async fn audit_runtime_facade_stops_empty_replay_workers() {
+async fn stopping_audit_replay_workers_is_a_no_op_when_there_are_none() {
     let registry = Arc::new(Mutex::new(AuditRegistry::new()));
     let replay_workers = Arc::new(RwLock::new(rustfs_targets::ReplayWorkerManager::new()));
-    let facade = AuditRuntimeFacade::new(registry, replay_workers);
+    let facade = AuditRuntimeFacade::new(registry, Arc::clone(&replay_workers));
 
     facade.stop_replay_workers().await;
+
+    // The stop path takes the manager's workers and hands them to the adapter,
+    // so an empty facade must leave it empty rather than wedge it, and a second
+    // call — which shutdown paths make — must stay harmless (rustfs/backlog#1836).
+    assert!(replay_workers.read().await.is_empty());
+    facade.stop_replay_workers().await;
+    assert!(replay_workers.read().await.is_empty());
 }
 
 #[tokio::test]

crates/heal/tests/heal_bug_fixes_test.rs

@@ -117,13 +117,16 @@ fn test_format_set_disk_id_from_i32_valid() {
     assert_eq!(result.unwrap(), "pool_0_set_1");
 }
 
+/// A wall-clock lower bound for "the timestamp was actually read from the
+/// clock": 2020-01-01. `unwrap_or_default()` on a pre-epoch clock yields 0, and
+/// the old versions of these tests bound the fields to `_` and so could not tell
+/// that apart from a real reading (rustfs/backlog#1836).
+const SANE_EPOCH_SECS: u64 = 1_577_836_800;
+
 #[test]
 fn test_resume_state_timestamp_handling() {
     use rustfs_heal::heal::resume::ResumeState;
 
-    // Test that ResumeState creation doesn't panic even if system time is before epoch
-    // This is a theoretical test - in practice, system time should never be before epoch
-    // But we want to ensure unwrap_or_default handles edge cases
     let state = ResumeState::new(
         "test-task".to_string(),
         "test-type".to_string(),
@@ -131,22 +134,30 @@ fn test_resume_state_timestamp_handling() {
         vec!["bucket1".to_string()],
     );
 
-    // Verify fields are initialized (u64 is always >= 0)
-    // The important thing is that unwrap_or_default prevents panic
-    let _ = state.start_time;
-    let _ = state.last_update;
+    assert!(
+        state.start_time > SANE_EPOCH_SECS,
+        "start_time fell back to the default instead of reading the clock: {}",
+        state.start_time
+    );
+    assert!(
+        state.last_update >= state.start_time,
+        "last_update {} must not predate start_time {}",
+        state.last_update,
+        state.start_time
+    );
 }
 
 #[test]
 fn test_resume_checkpoint_timestamp_handling() {
     use rustfs_heal::heal::resume::ResumeCheckpoint;
 
-    // Test that ResumeCheckpoint creation doesn't panic
     let checkpoint = ResumeCheckpoint::new("test-task".to_string());
 
-    // Verify field is initialized (u64 is always >= 0)
-    // The important thing is that unwrap_or_default prevents panic
-    let _ = checkpoint.checkpoint_time;
+    assert!(
+        checkpoint.checkpoint_time > SANE_EPOCH_SECS,
+        "checkpoint_time fell back to the default instead of reading the clock: {}",
+        checkpoint.checkpoint_time
+    );
 }
 
 #[test]