a7n 0.25.0

// SPDX-License-Identifier: GPL-3.0-or-later

use a7n_ipc::{ErrorKind, FileTransfer, FinishedSend, SendOutcome, StatusInfo, TransferDirection};

use super::*;

#[test]
fn parse_addr_ip_and_port_forms_resolve_or_reject() {
    // Arrange
    let cases = [
        (
            "127.0.0.1",
            Some(SocketAddr::from(([127, 0, 0, 1], DEFAULT_UDP_PORT))),
        ),
        (
            "127.0.0.1:1234",
            Some(SocketAddr::from(([127, 0, 0, 1], 1234))),
        ),
        (
            "::1",
            Some(SocketAddr::new(
                IpAddr::V6(std::net::Ipv6Addr::LOCALHOST),
                DEFAULT_UDP_PORT,
            )),
        ),
        (
            "[::1]:1234",
            Some(SocketAddr::new(
                IpAddr::V6(std::net::Ipv6Addr::LOCALHOST),
                1234,
            )),
        ),
        (
            "2001:db8::1234",
            Some(SocketAddr::new(
                "2001:db8::1234".parse().unwrap(),
                DEFAULT_UDP_PORT,
            )),
        ),
        ("", None),
        ("localhost:1234", None),
        ("999.0.0.1", None),
        ("127.0.0.1:65536", None),
        ("[::1]:no", None),
        ("[::1]", None),
    ];
    for (input, expected) in cases {
        // Act
        let result = parse_addr(input);

        // Assert
        assert_eq!(result.ok(), expected, "{input}");
    }
}

#[test]
fn resolve_target_addresses_and_nearby_prefixes_resolve_or_reject() {
    // Arrange
    let first_addr = "127.0.0.1:1234".parse().unwrap();
    let second_addr = "[::1]:4321".parse().unwrap();
    let nearby = [
        NearbyMachine {
            id: "abcd456789abcdef0123456789abcdef".parse().unwrap(),
            addr: first_addr,
        },
        NearbyMachine {
            id: "abcd556789abcdef0123456789abcdef".parse().unwrap(),
            addr: second_addr,
        },
    ];
    let invalid = "expected an IP address, IP:port, or machine id prefix of 4 to 32 hex digits";
    let cases = [
        ("127.0.0.1:1234", Ok(first_addr)),
        (
            "127.0.0.1",
            Ok(SocketAddr::from(([127, 0, 0, 1], DEFAULT_UDP_PORT))),
        ),
        ("[::1]:4321", Ok(second_addr)),
        ("abcd456789abcdef0123456789abcdef", Ok(first_addr)),
        ("abcd4", Ok(first_addr)),
        ("ABCD5", Ok(second_addr)),
        (
            "abcd",
            Err("ambiguous nearby machine id prefix; use more hex digits"),
        ),
        ("ffff", Err("no nearby machine matches that id prefix")),
        ("abc", Err(invalid)),
        ("", Err(invalid)),
        ("xyz0", Err(invalid)),
        ("éabc", Err(invalid)),
        ("abcd456789abcdef0123456789abcdef0", Err(invalid)),
    ];
    for (target, expected) in cases {
        // Act
        let result = resolve_target(target, &nearby);

        // Assert
        assert_eq!(result, expected, "{target}");
    }
}

#[test]
fn write_response_daemon_error_returns_message_without_stdout() {
    // Arrange
    let response = Response::Error {
        kind: ErrorKind::PairingRefused,
        message: "pairing refused".into(),
    };
    let mut output = Vec::new();

    // Act
    let result = write_response(&mut output, &response);

    // Assert
    assert_eq!(result.unwrap_err().to_string(), "pairing refused");
    assert_eq!(output, [] as [u8; 0]);
}

#[test]
fn resolve_machine_id_names_and_prefixes_resolve_or_reject() {
    // Arrange
    let a = "abcd456789abcdef0123456789abcdef".parse().unwrap();
    let b = "abcd556789abcdef0123456789abcdef".parse().unwrap();
    let machines = [(a, "workstation"), (b, "laptop")];
    let cases = [
        ("workstation", Some(a)),
        ("ABCD4", Some(a)),
        ("abcd556789abcdef0123456789abcdef", Some(b)),
        ("abcd", None),
        ("abc", None),
        ("unknown", None),
    ];
    for (target, expected) in cases {
        // Act
        let result = resolve_machine_id(target, machines.into_iter());

        // Assert
        assert_eq!(result.ok(), expected);
    }
}

#[test]
fn poll_send_offer_states_map_to_progress_outcome_or_waiting() {
    // Arrange
    let peer = "0123456789abcdef0123456789abcdef".parse().unwrap();
    let transfer = FileTransfer {
        id: 3,
        offer_id: Some(9),
        peer,
        direction: TransferDirection::Send,
        files_done: 0,
        files_total: 1,
        bytes_done: 0,
        bytes_total: 1,
    };
    let finished = |offer_id, outcome| FinishedSend {
        offer_id,
        peer,
        outcome,
    };
    let status = |transfers: Vec<FileTransfer>, finished_sends: Vec<FinishedSend>| StatusInfo {
        held_clipboard: None,
        transfers,
        held_files: Vec::new(),
        finished_sends,
        input: None,
        paused: false,
        focused: peer,
        pid: 0,
        machine: peer,
        name: "local".into(),
        peers: Vec::new(),
        nearby: Vec::new(),
        missing_permissions: Vec::new(),
        firewall: Vec::new(),
    };
    let cases = [
        (status(vec![], vec![]), files::Poll::Waiting),
        (
            status(vec![transfer.clone()], vec![]),
            files::Poll::Progress(&transfer),
        ),
        (
            status(vec![], vec![finished(9, SendOutcome::Failed)]),
            files::Poll::Finished(SendOutcome::Failed),
        ),
        (
            status(
                vec![transfer.clone()],
                vec![finished(8, SendOutcome::Completed)],
            ),
            files::Poll::Progress(&transfer),
        ),
    ];
    for (status, expected) in &cases {
        // Act
        let result = files::poll_send(status, 9);

        // Assert
        assert_eq!(&result, expected);
    }
}