| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use diagnostics_reader::{assert_data_tree, AnyProperty, ArchiveReader, Inspect}; |
| use fidl_fuchsia_cobalt_test::LoggerQuerierMarker; |
| use fidl_fuchsia_component::BinderMarker; |
| use fidl_fuchsia_mockrebootcontroller::MockRebootControllerMarker; |
| use fidl_fuchsia_samplertestcontroller::SamplerTestControllerMarker; |
| |
| mod mocks; |
| mod test_topology; |
| mod utils; |
| |
| /// Runs the Sampler and a test component that can have its inspect properties |
| /// manipulated by the test via fidl, and uses cobalt mock and log querier to |
| /// verify that the sampler observers changes as expected, and logs them to |
| /// cobalt as expected. |
| #[fuchsia::test] |
| async fn event_count_sampler_test() { |
| let instance = test_topology::create().await.expect("initialized topology"); |
| let test_app_controller = |
| instance.root.connect_to_protocol_at_exposed_dir::<SamplerTestControllerMarker>().unwrap(); |
| let reboot_controller = |
| instance.root.connect_to_protocol_at_exposed_dir::<MockRebootControllerMarker>().unwrap(); |
| let logger_querier = |
| instance.root.connect_to_protocol_at_exposed_dir::<LoggerQuerierMarker>().unwrap(); |
| let _sampler_binder = instance |
| .root |
| .connect_to_named_protocol_at_exposed_dir::<BinderMarker>("fuchsia.component.SamplerBinder") |
| .unwrap(); |
| |
| test_app_controller.increment_int(1).unwrap(); |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 3 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 1, value: 1 } |
| )); |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 3, value: 20 } |
| )); |
| |
| // We want to guarantee a sample takes place before we increment the value again. |
| // This is to verify that despite two samples taking place, the count type isn't uploaded with no diff |
| // and the metric that is upload_once isn't sampled again. |
| test_app_controller.wait_for_sample().await.unwrap().unwrap(); |
| |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 1 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| test_app_controller.increment_int(1).unwrap(); |
| |
| test_app_controller.wait_for_sample().await.unwrap().unwrap(); |
| |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 2 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| // Even though we incremented metric-1 its value stays at 1 since it's being cached. |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 1, value: 1 } |
| )); |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| |
| // trigger_reboot calls the on_reboot callback that drives sampler shutdown. this |
| // should await until sampler has finished its cleanup, which means we should have some events |
| // present when we're done, and the sampler task should be finished. |
| reboot_controller.trigger_reboot().await.unwrap().unwrap(); |
| |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 2 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| // The metric configured to run every 3000 seconds gets polled, and gets an undiffed |
| // report of its values. |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 4, value: 2 } |
| )); |
| // The integer metric which is always getting undiffed sampling is sampled one last time. |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| } |
| |
| /// Runs the Sampler and a test component that can have its inspect properties |
| /// manipulated by the test via fidl, and uses mock services to determine that when |
| /// the reboot server goes down, sampler continues to run as expected. |
| #[fuchsia::test] |
| async fn reboot_server_crashed_test() { |
| let instance = test_topology::create().await.expect("initialized topology"); |
| let test_app_controller = |
| instance.root.connect_to_protocol_at_exposed_dir::<SamplerTestControllerMarker>().unwrap(); |
| let reboot_controller = |
| instance.root.connect_to_protocol_at_exposed_dir::<MockRebootControllerMarker>().unwrap(); |
| let logger_querier = |
| instance.root.connect_to_protocol_at_exposed_dir::<LoggerQuerierMarker>().unwrap(); |
| let _sampler_binder = instance |
| .root |
| .connect_to_named_protocol_at_exposed_dir::<BinderMarker>("fuchsia.component.SamplerBinder") |
| .unwrap(); |
| |
| // Crash the reboot server to verify that sampler continues to sample. |
| reboot_controller.crash_reboot_channel().await.unwrap().unwrap(); |
| |
| test_app_controller.increment_int(1).unwrap(); |
| |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 3 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 1, value: 1 } |
| )); |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 3, value: 20 } |
| )); |
| |
| // We want to guarantee a sample takes place before we increment the value again. |
| // This is to verify that despite two samples taking place, the count type isn't uploaded with |
| // no diff and the metric that is upload_once isn't sampled again. |
| test_app_controller.wait_for_sample().await.unwrap().unwrap(); |
| |
| let events = utils::gather_sample_group( |
| utils::LogQuerierConfig { project_id: 5, expected_batch_size: 1 }, |
| &logger_querier, |
| ) |
| .await; |
| |
| assert!(utils::verify_event_present_once( |
| &events, |
| utils::ExpectedEvent { metric_id: 2, value: 10 } |
| )); |
| } |
| |
| /// Runs the Sampler and a test component that can have its inspect properties |
| /// manipulated by the test via fidl, and uses mock services to determine that when |
| /// the reboot server goes down, sampler continues to run as expected. |
| #[fuchsia::test] |
| async fn sampler_inspect_test() { |
| let instance = test_topology::create().await.expect("initialized topology"); |
| let _sampler_binder = instance |
| .root |
| .connect_to_named_protocol_at_exposed_dir::<BinderMarker>("fuchsia.component.SamplerBinder") |
| .unwrap(); |
| |
| // Observe verification shows up in inspect. |
| let mut data = ArchiveReader::new() |
| .add_selector(format!( |
| "fuchsia_component_test_collection\\:{}/wrapper/sampler:root", |
| instance.root.child_name() |
| )) |
| .snapshot::<Inspect>() |
| .await |
| .expect("got inspect data"); |
| |
| let hierarchy = data.pop().expect("one result").payload.expect("payload is not none"); |
| |
| // TODO(42067): Introduce better fencing so we can |
| // guarantee we fetch the hierarchy after the metrics were sampled |
| // AND fully processed. |
| assert_data_tree!( |
| hierarchy, |
| root: { |
| sampler_executor_stats: { |
| healthily_exited_samplers: 0 as u64, |
| errorfully_exited_samplers: 0 as u64, |
| reboot_exited_samplers: 0 as u64, |
| total_project_samplers_configured: 2 as u64, |
| project_5: { |
| project_sampler_count: 2 as u64, |
| metrics_configured: 5 as u64, |
| cobalt_logs_sent: AnyProperty, |
| } |
| }, |
| "fuchsia.inspect.Health": { |
| start_timestamp_nanos: AnyProperty, |
| status: AnyProperty |
| } |
| } |
| ); |
| } |
