fn test_top_loss_filter()

in nfm-controller/src/events/event_filter_top_loss.rs [126:214]

• 80 lines of code
• 1 McCabe index (conditional complexity)

    fn test_top_loss_filter() {
        // Give each agg-result a flow with a unique local port so's to easily identify the flow in
        // test results.
        let empty_flow = empty_flow();
        let result_all_good = AggregateResults {
            flow: FlowProperties {
                local_port: 1,
                ..empty_flow.clone()
            },
            stats: Default::default(),
        };
        let result_retrans = AggregateResults {
            flow: FlowProperties {
                local_port: 2,
                ..empty_flow.clone()
            },
            stats: NetworkStats {
                retrans_syn: 20,
                ..Default::default()
            },
        };
        let result_rto = AggregateResults {
            flow: FlowProperties {
                local_port: 3,
                ..empty_flow.clone()
            },
            stats: NetworkStats {
                retrans_syn: 20,
                ..Default::default()
            },
        };
        let result_disconnect = AggregateResults {
            flow: FlowProperties {
                local_port: 4,
                ..empty_flow.clone()
            },
            stats: NetworkStats {
                severed_establish: 20,
                ..Default::default()
            },
        };
        let result_all_good_more_bytes = AggregateResults {
            flow: FlowProperties {
                local_port: 5,
                ..empty_flow.clone()
            },
            stats: NetworkStats {
                bytes_received: 1,
                ..Default::default()
            },
        };

        let mut event_list = vec![
            result_rto.clone(),
            result_all_good_more_bytes.clone(),
            result_disconnect.clone(),
            result_all_good.clone(),
            result_retrans.clone(),
        ];
        let mut filter = EventFilterTopLoss::new(event_list.len() as u32);
        let mut top_loss_result = filter.filter_events(event_list);

        // Confirm results are in the expected order.
        let expected_ids = vec![4, 3, 2, 5, 1];
        let actual_ids = top_loss_result
            .iter()
            .map(|r| r.flow.local_port)
            .collect::<Vec<u16>>();
        assert_eq!(actual_ids, expected_ids);

        // Test with a smaller max.
        event_list = vec![
            result_rto,
            result_all_good_more_bytes,
            result_disconnect,
            result_all_good,
            result_retrans,
        ];
        filter = EventFilterTopLoss { max_items: 3 };
        top_loss_result = filter.filter_events(event_list);

        // Confirm results are in the expected order.
        let expected_ids = vec![4, 3, 2];
        let actual_ids = top_loss_result
            .iter()
            .map(|r| r.flow.local_port)
            .collect::<Vec<u16>>();
        assert_eq!(actual_ids, expected_ids);
    }