test: retain durable negotiation and lifecycle review coverage

crates/irtt-integration-tests/tests/managed_behavior.rs

@@ -162,9 +162,18 @@ async fn target_updates_preserve_identical_sessions_and_retire_removed_generatio
         handle.update_targets(vec![]).unwrap().await.unwrap();
         loop {
             if let ManagedEvent::TargetFinished { outcome } = events.recv().await.unwrap() {
+                let status = handle.status();
                 assert_eq!(outcome.target, first);
                 assert_eq!(outcome.end_reason, ManagedTargetEndReason::Removed);
                 assert_eq!(outcome.cleanup_failure, None);
+                assert_eq!(status.total_target_outcomes, 1);
+                assert_eq!(status.successful_target_outcomes, 1);
+                assert_eq!(
+                    status.recent_target_outcomes.as_ref(),
+                    &[(*outcome).clone()]
+                );
+                assert!(status.targets.iter().all(|target| target.target != first
+                    || target.lifecycle == ManagedTargetLifecycle::Terminal));
                 break;
             }
         }
@@ -191,6 +200,28 @@ async fn target_updates_preserve_identical_sessions_and_retire_removed_generatio
             }
         }
         let stop = handle.stop();
+        loop {
+            match events.recv().await.unwrap() {
+                ManagedEvent::TargetFinished { outcome } => {
+                    let status = handle.status();
+                    assert_eq!(outcome.target, second);
+                    assert_eq!(status.total_target_outcomes, 2);
+                    assert_eq!(
+                        status.recent_target_outcomes.as_ref(),
+                        &[(*outcome).clone()]
+                    );
+                    assert!(status.targets.iter().all(|target| target.target != second
+                        || target.lifecycle == ManagedTargetLifecycle::Terminal));
+                }
+                ManagedEvent::Completed { outcome } => {
+                    let status = handle.status();
+                    assert_eq!(status.lifecycle, ManagedLifecycle::Completed);
+                    assert_eq!(status.final_outcome.as_ref(), Some(&outcome));
+                    break;
+                }
+                _ => {}
+            }
+        }
         let outcome = run.await.unwrap();
         stop.await;
         assert_eq!(outcome.end_reason, ManagedEndReason::StopRequested);