fn test_do_work()

in nfm-controller/src/lib.rs [412:471]
55 lines of code
9 McCabe index (conditional complexity)

    fn test_do_work() {
        let event_provider = EventProviderNoOp::default();
        let nat_resolver = NatResolverNoOp::default();
        let event_filter = EventFilterNoOp::default();
        let publisher = PublisherNoOp::default();
        let metadata_provider = MultiMetadataProviderNoOp::default();
        let host_stats_provider = HostStatsProviderNoOp::default();

        // Clone the struct to pass it to the thread
        let event_provider_clone = event_provider.clone();
        let nat_resolver_clone = nat_resolver.clone();
        let event_filter_clone = event_filter.clone();
        let publisher_clone = publisher.clone();
        let metadata_provider_clone = metadata_provider.clone();
        let host_stats_provider_clone = host_stats_provider.clone();

        thread::spawn(move || {
            do_work(
                event_provider_clone,
                Box::new(nat_resolver_clone),
                event_filter_clone,
                publisher_clone,
                metadata_provider_clone,
                host_stats_provider_clone,
                Options {
                    log_reports: OnOff::Off,
                    publish_reports: OnOff::Off,
                    endpoint: "a".to_string(),
                    endpoint_region: "b".to_string(),
                    cgroup: "c".to_string(),
                    proxy: "d".to_string(),
                    top_k: 100,
                    notrack_secs: 0,
                    usage_data: OnOff::On,
                    aggregate_msecs: 0,
                    publish_secs: 0,
                    jitter_secs: 0,
                    report_compression: ReportCompression::None,
                    kubernetes_metadata: OnOff::On,
                    resolve_nat: OnOff::On,
                },
            );
        });

        let duration = Duration::from_millis(2000);
        let start = Instant::now();
        while start.elapsed() < duration {
            // allow thread start to be delayed for 2sec at worst, to prevent failures at test
            if *event_provider.calls.lock().unwrap() >= 1
                && *nat_resolver.calls.lock().unwrap() >= 1
                && *event_filter.calls.lock().unwrap() >= 1
                && *publisher.calls.lock().unwrap() >= 1
                && *metadata_provider.calls.lock().unwrap() >= 1
                && *host_stats_provider.calls.lock().unwrap() >= 1
            {
                return; // success
            };
        }
        assert!(false); // failure
    }