1011. 1011
1012. 1012 // The queued items landed in the child's queues.
1013. 1013 assert!(!cancel.is_cancelled());
1014. 1014 assert!(reg.stop("child-1"));
1015. 1015 assert!(cancel.is_cancelled());
1016. 1016
1017. 1017 reg.unregister("child-1");
1018. 1018 assert!(reg.active().is_empty());
1019. 1019 assert!(!reg.steer("child-1", "gone"));
1020. 1020 }
1021. 1021
1022. 1022 #[test]
1023. 1023 fn scope_checks_route_children_to_their_own_parent() {
1024. 1024 let reg = WorkerRegistry::new();
1025. 1025 for (id, parent) in [("c1", "pA"), ("c2", "pB")] {
1026. 1026 reg.register(
1027. 1027 id.into(),
1028. 1028 WorkerHandle {
1029. 1029 label: id.into(),
1030. 1030 agent_id: None,
1031. 1031 agent_revision: None,
1032. 1032 started_at: std::time::Instant::now(),
1033. 1033 steering: Arc::new(SteeringQueues::new()),
1034. 1034 cancel: CancellationToken::new(),
1035. 1035 parent_session_id: parent.into(),
1036. 1036 },
1037. 1037 );
1038. 1038 }
1039. 1039 assert_eq!(
1040. 1040 reg.parent_of("c1").as_deref(),
1041. 1041 Some("pA"),
1042. 1042 "ownership is recorded"
1043. 1043 );
1044. 1044 assert_eq!(reg.parent_of("missing"), None);
1045. 1045 let a = reg.active_for("pA");
1046. 1046 assert_eq!(a.len(), 1);
1047. 1047 assert_eq!(a[0].id, "c1");
1048. 1048 assert_eq!(reg.active_for("pB")[0].id, "c2");
1049. 1049 assert!(reg.active_for("pC").is_empty());
1050. 1050 }
1051. 1051}
1052. 1052
1053. 1053#[cfg(test)]
1054. 1054#[allow(clippy::unwrap_used)]
1055. 1055mod child_id_tests {
1056. 1056 use super::next_child_session_id;
1057. 1057
1058. 1058 #[test]
1059. 1059 fn child_session_ids_never_collide_even_when_generated_in_the_same_instant() {
1060. 1060 let ids: std::collections::HashSet<String> =
1061. 1061 (0..10_000).map(|_| next_child_session_id()).collect();
1062. 1062 assert_eq!(
1063. 1063 ids.len(),
1064. 1064 10_000,
1065. 1065 "ids must be unique regardless of clock resolution"
1066. 1066 );
1067. 1067 }
1068. 1068
1069. 1069 #[test]
1070. 1070 fn child_session_ids_are_unique_across_threads() {
1071. 1071 let handles: Vec<_> = (0..8)
1072. 1072 .map(|_| {
1073. 1073 std::thread::spawn(|| {
1074. 1074 (0..2_000)
1075. 1075 .map(|_| next_child_session_id())
1076. 1076 .collect::<Vec<_>>()
1077. 1077 })
1078. 1078 })
1079. 1079 .collect();
1080. 1080 let all: Vec<String> = handles
1081. 1081 .into_iter()
1082. 1082 .flat_map(|h| h.join().unwrap())
1083. 1083 .collect();
1084. 1084 let unique: std::collections::HashSet<_> = all.iter().collect();
1085. 1085 assert_eq!(unique.len(), all.len());
1086. 1086 }
1087. 1087}
1088. 1088