test(core): expose ComponentContext test-util helpers cross-crate

Promote the seven ComponentContext::test_* constructors from #[cfg(test)] to a
non-default 'test-util' Cargo feature so downstream crates can build component
contexts in their own tests, mirroring the existing saluki-metrics 'test' feature
pattern. Migrate the eight hand-rolled SubsystemIdentifier/ComponentId call sites
across saluki-components and agent-data-plane to the shared helpers.

Add coverage unlocked by the change: heartbeat source tests (config default,
declared output, memory bounds) and double-take panic tests for take_health_handle
(all seven context types) and take_shutdown_handle (source and relay).

Resolves G1 (KI-1) of the test suite cleanup plan.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tobz

bin/agent-data-plane/Cargo.toml

@@ -80,4 +80,5 @@ chrono = { workspace = true }
 datadog-agent-config-testing = { workspace = true }
 derive-where = { workspace = true }
 saluki-components = { workspace = true }
+saluki-core = { workspace = true, features = ["test-util"] }
 saluki-metrics = { workspace = true, features = ["test"] }

bin/agent-data-plane/src/components/ottl_filter_processor/mod.rs

@@ -160,8 +160,7 @@ mod tests {
             trace::{AttributeValue, Span, Trace},
             Event,
         },
-        support::SubsystemIdentifier,
-        topology::{ComponentId, EventsBuffer},
+        topology::EventsBuffer,
     };
     use stringtheory::MetaString;
 
@@ -200,10 +199,7 @@ mod tests {
     }
 
     fn test_component_context() -> ComponentContext {
-        ComponentContext::transform(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("ottl_filter").unwrap(),
-        )
+        ComponentContext::test_transform("ottl_filter")
     }
 
     /// When `ottl_filter_config` is absent, config defaults to empty conditions and no spans are dropped.

bin/agent-data-plane/src/components/ottl_transform_processor/mod.rs

@@ -163,8 +163,7 @@ mod tests {
             trace::{AttributeValue, Span, Trace},
             Event,
         },
-        support::SubsystemIdentifier,
-        topology::{ComponentId, EventsBuffer},
+        topology::EventsBuffer,
     };
     use stringtheory::MetaString;
 
@@ -213,10 +212,7 @@ mod tests {
     }
 
     fn test_component_context() -> ComponentContext {
-        ComponentContext::transform(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("ottl_transform").unwrap(),
-        )
+        ComponentContext::test_transform("ottl_transform")
     }
 
     async fn build_transform(cfg_json: Option<serde_json::Value>) -> Box<dyn SynchronousTransform + Send> {

lib/saluki-components/Cargo.toml

@@ -95,6 +95,7 @@ derive-where = { workspace = true }
 proptest = { workspace = true }
 rcgen = { workspace = true, features = ["crypto", "pem"] }
 rustls = { workspace = true }
+saluki-core = { workspace = true, features = ["test-util"] }
 saluki-metrics = { workspace = true, features = ["test"] }
 saluki-tls = { workspace = true }
 tempfile = { workspace = true }

lib/saluki-components/src/common/datadog/io.rs

@@ -989,7 +989,7 @@ mod tests {
     };
     use saluki_common::buf::FrozenChunkedBytesBuffer;
     use saluki_config::ConfigurationLoader;
-    use saluki_core::{observability::ComponentMetricsExt as _, support::SubsystemIdentifier, topology::ComponentId};
+    use saluki_core::observability::ComponentMetricsExt as _;
     use saluki_io::net::client::http::TlsMinimumVersion;
     use saluki_metrics::test::TestRecorder;
     use serde_json::json;
@@ -1010,10 +1010,7 @@ mod tests {
     };
 
     fn test_component_context() -> ComponentContext {
-        ComponentContext::forwarder(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("test_forwarder").unwrap(),
-        )
+        ComponentContext::test_forwarder("test_forwarder")
     }
 
     fn uri(path: &'static str) -> Uri {

lib/saluki-components/src/common/otlp/mod.rs

@@ -342,8 +342,7 @@ impl<H: OtlpHandler> TraceService for GrpcServiceImpl<H> {
 mod tests {
     use std::sync::Arc;
 
-    use saluki_core::accounting::MemoryLimiter;
-    use saluki_core::{components::ComponentContext, support::SubsystemIdentifier, topology::ComponentId};
+    use saluki_core::{accounting::MemoryLimiter, components::ComponentContext};
     use saluki_metrics::test::TestRecorder;
 
     use super::*;
@@ -380,10 +379,7 @@ mod tests {
     }
 
     fn test_component_context() -> ComponentContext {
-        ComponentContext::source(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("otlp_test").unwrap(),
-        )
+        ComponentContext::test_source("otlp_test")
     }
 
     #[tokio::test]

lib/saluki-components/src/sources/dogstatsd/metrics.rs

@@ -362,16 +362,13 @@ fn error_tags(
 mod tests {
     use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 
-    use saluki_core::{components::ComponentContext, support::SubsystemIdentifier, topology::ComponentId};
+    use saluki_core::components::ComponentContext;
     use saluki_metrics::test::TestRecorder;
 
     use super::*;
 
     fn test_context() -> ComponentContext {
-        ComponentContext::source(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("dogstatsd_test").expect("valid component ID"),
-        )
+        ComponentContext::test_source("dogstatsd_test")
     }
 
     fn udp_listen_addr() -> ListenAddress {

lib/saluki-components/src/sources/dogstatsd/mod.rs

@@ -2054,8 +2054,6 @@ mod tests {
     use saluki_core::{
         components::ComponentContext,
         pooling::{helpers::get_pooled_object_via_builder, ObjectPool as _},
-        support::SubsystemIdentifier,
-        topology::ComponentId,
     };
     use saluki_env::workload::{CaptureEntityResolver, EntityId};
     use saluki_io::{
@@ -2089,10 +2087,7 @@ mod tests {
     }
 
     fn test_component_context() -> ComponentContext {
-        ComponentContext::source(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("dogstatsd_test").unwrap(),
-        )
+        ComponentContext::test_source("dogstatsd_test")
     }
 
     #[derive(Default)]

lib/saluki-components/src/sources/heartbeat/mod.rs

@@ -93,3 +93,49 @@ impl MemoryBounds for HeartbeatConfiguration {
         builder.minimum().with_single_value::<Heartbeat>("component struct");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::mem::size_of;
+
+    use saluki_core::accounting::ComponentRegistry;
+
+    use super::*;
+
+    #[test]
+    fn default_configuration_uses_ten_second_interval() {
+        let config = HeartbeatConfiguration::default();
+        assert_eq!(config.heartbeat_interval_secs, 10);
+    }
+
+    #[test]
+    fn declares_single_default_output_for_metrics() {
+        // The source's documented behavior is to emit a heartbeat metric, so it must declare exactly one output --
+        // the default (unnamed) one -- carrying metric events.
+        let config = HeartbeatConfiguration::default();
+        let outputs = config.outputs();
+
+        assert_eq!(outputs.len(), 1);
+        assert_eq!(
+            outputs[0].output_name(),
+            None,
+            "heartbeat emits on the default (unnamed) output"
+        );
+        assert_eq!(outputs[0].data_ty(), EventType::Metric);
+    }
+
+    #[test]
+    fn specify_bounds_accounts_only_for_the_boxed_component_struct() {
+        // The bounds are documented as a "minimal memory footprint": a single boxed `Heartbeat` value and nothing
+        // else. The firm limit includes the minimum, so with no additional firm usage both totals equal the struct
+        // size.
+        let config = HeartbeatConfiguration::default();
+
+        let mut registry = ComponentRegistry::default();
+        config.specify_bounds(&mut registry.bounds_builder());
+        let bounds = registry.as_bounds();
+
+        assert_eq!(bounds.total_minimum_required_bytes(), size_of::<Heartbeat>());
+        assert_eq!(bounds.total_firm_limit_bytes(), size_of::<Heartbeat>());
+    }
+}

lib/saluki-components/src/transforms/aggregate/mod.rs

@@ -908,8 +908,7 @@ mod tests {
     use float_cmp::ApproxEqRatio as _;
     use saluki_core::{
         components::ComponentContext,
-        support::SubsystemIdentifier,
-        topology::{interconnect::Dispatcher, ComponentId, OutputName},
+        topology::{interconnect::Dispatcher, OutputName},
     };
     use saluki_metrics::test::TestRecorder;
     use stringtheory::MetaString;
@@ -961,10 +960,7 @@ mod tests {
 
     /// Constructs a basic `Dispatcher` with a fixed-size event buffer.
     fn build_basic_dispatcher() -> (EventsDispatcher, DispatcherReceiver) {
-        let context = ComponentContext::transform(
-            &SubsystemIdentifier::from_segments(["test"]),
-            ComponentId::try_from("test").unwrap(),
-        );
+        let context = ComponentContext::test_transform("test");
         let mut dispatcher = Dispatcher::new(context);
 
         let (buffer_tx, buffer_rx) = mpsc::channel(1);