fn temporary_until_authenticated()

in quic/s2n-quic-transport/src/path/manager/tests.rs [1568:1679]
95 lines of code
1 McCabe index (conditional complexity)

fn temporary_until_authenticated() {
    let mut publisher = Publisher::snapshot();
    let now = NoopClock {}.get_time();
    let datagram = DatagramInfo {
        timestamp: now,
        payload_len: 0,
        ecn: ExplicitCongestionNotification::default(),
        destination_connection_id: connection::LocalId::TEST_ID,
        destination_connection_id_classification: connection::id::Classification::Local,
        source_connection_id: None,
    };

    // create an initial path
    let first_addr: SocketAddr = "127.0.0.1:8001".parse().unwrap();
    let first_addr = SocketAddress::from(first_addr);
    let first_addr = RemoteAddress::from(first_addr);
    let first_path = ServerPath::new(
        first_addr,
        connection::PeerId::try_from_bytes(&[1]).unwrap(),
        connection::LocalId::TEST_ID,
        RttEstimator::default(),
        Default::default(),
        false,
        mtu::Config::default(),
        ANTI_AMPLIFICATION_MULTIPLIER,
    );
    let mut manager = manager_server(first_path);

    let second_addr: SocketAddr = "127.0.0.2:8001".parse().unwrap();
    let second_addr = SocketAddress::from(second_addr);
    let second_addr = RemoteAddress::from(second_addr);

    // create a second path without calling on_processed_packet
    let (second_path_id, _amplification_outcome) = manager
        .on_datagram_received(
            &second_addr,
            &datagram,
            true,
            &mut Default::default(),
            &mut migration::allow_all::Validator,
            &mut mtu::Manager::new(mtu::Config::default()),
            &Limits::default(),
            &mut publisher,
        )
        .unwrap();

    assert!(
        !manager[second_path_id].is_challenge_pending(),
        "pending paths should not issue a challenge"
    );

    let third_addr: SocketAddr = "127.0.0.3:8001".parse().unwrap();
    let third_addr = SocketAddress::from(third_addr);
    let third_addr = RemoteAddress::from(third_addr);

    // create a third path
    let (third_path_id, _amplification_outcome) = manager
        .on_datagram_received(
            &third_addr,
            &datagram,
            true,
            &mut Default::default(),
            &mut migration::allow_all::Validator,
            &mut mtu::Manager::new(mtu::Config::default()),
            &Limits::default(),
            &mut publisher,
        )
        .unwrap();

    assert_eq!(
        second_path_id, third_path_id,
        "third path should replace the second"
    );

    assert!(
        !manager[third_path_id].is_challenge_pending(),
        "pending paths should not issue a challenge"
    );

    // notify the manager that the packet was processed
    let _ = manager.on_processed_packet(
        third_path_id,
        None,
        path_validation::Probe::NonProbing,
        &mut random::testing::Generator(123),
        &mut publisher,
    );

    assert!(
        manager[third_path_id].is_challenge_pending(),
        "after processing a packet the path should issue a challenge"
    );

    // receive another datagram with the second_addr
    let (fourth_path_id, _unblocked) = manager
        .on_datagram_received(
            &second_addr,
            &datagram,
            true,
            &mut Default::default(),
            &mut migration::allow_all::Validator,
            &mut mtu::Manager::new(mtu::Config::default()),
            &Limits::default(),
            &mut publisher,
        )
        .unwrap();

    assert_ne!(
        fourth_path_id, third_path_id,
        "a new path should be created"
    );
}