ip2asn 0.1.2

A high-performance, memory-efficient Rust crate for mapping IP addresses to Autonomous System (AS) information.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Integration tests for the line parser.

use ip2asn::parser::{parse_line, ParsedLine};
use std::net::{Ipv4Addr, Ipv6Addr};

#[test]
fn test_parse_line_happy_path() {
    let line = "1.0.0.0\t1.0.0.255\t13335\tUS\tCLOUDFLARENET";
    let result = parse_line(line).unwrap();

    assert_eq!(
        result,
        ParsedLine {
            start_ip: Ipv4Addr::new(1, 0, 0, 0).into(),
            end_ip: Ipv4Addr::new(1, 0, 0, 255).into(),
            asn: 13335,
            country_code: [b'U', b'S'],
            organization: "CLOUDFLARENET",
        }
    );
}

#[test]
fn test_parse_line_incorrect_column_count() {
    let line = "1.0.0.0\t1.0.0.255\t13335"; // Missing columns
    let result = parse_line(line);
    assert!(result.is_err());
    // We'll assert the specific error kind later
}

#[test]
fn test_parse_line_invalid_start_ip() {
    let line = "not-an-ip\t1.0.0.255\t13335\tUS\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::InvalidIpAddress { .. })
    ));
}

#[test]
fn test_parse_line_invalid_end_ip() {
    let line = "1.0.0.0\tnot-an-ip\t13335\tUS\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::InvalidIpAddress { .. })
    ));
}

#[test]
fn test_parse_line_invalid_asn() {
    let line = "1.0.0.0\t1.0.0.255\tnot-a-number\tUS\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::InvalidAsnNumber { .. })
    ));
}

#[test]
fn test_parse_line_ip_family_mismatch() {
    let line = "1.0.0.0\t::1\t13335\tUS\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::IpFamilyMismatch)
    ));
}

#[test]
fn test_parse_line_invalid_range() {
    let line = "1.0.0.255\t1.0.0.0\t13335\tUS\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::InvalidRange { .. })
    ));
}

#[test]
fn test_country_code_normalization() {
    let line = "1.0.0.0\t1.0.0.255\t13335\tNone\tCLOUDFLARENET";
    let result = parse_line(line).unwrap();
    assert_eq!(result.country_code, [b'Z', b'Z']);
}

#[test]
fn test_parse_line_from_real_data() {
    // Case 1: Standard IPv4
    let line1 = "185.237.4.0\t185.237.4.255\t14618\tUS\tAMAZON-AES";
    let result1 = parse_line(line1).unwrap();
    assert_eq!(result1.start_ip, Ipv4Addr::new(185, 237, 4, 0));
    assert_eq!(result1.end_ip, Ipv4Addr::new(185, 237, 4, 255));
    assert_eq!(result1.asn, 14618);
    assert_eq!(result1.country_code, [b'U', b'S']);
    assert_eq!(result1.organization, "AMAZON-AES");

    // Case 2: Standard IPv6
    let line2 = "2803:c280::\t2803:c280:2:ffff:ffff:ffff:ffff:ffff\t265775\tEC\tAUSTRONET";
    let result2 = parse_line(line2).unwrap();
    assert_eq!(
        result2.start_ip,
        Ipv6Addr::new(0x2803, 0xc280, 0, 0, 0, 0, 0, 0)
    );
    assert_eq!(
        result2.end_ip,
        Ipv6Addr::new(0x2803, 0xc280, 0x0002, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff)
    );
    assert_eq!(result2.asn, 265775);
    assert_eq!(result2.country_code, [b'E', b'C']);
    assert_eq!(result2.organization, "AUSTRONET");

    // Case 3: IPv6 with "None" country code
    let line3 = "2a02:fe80:22::\t2a02:fe80:100f:ffff:ffff:ffff:ffff:ffff\t0\tNone\tNot routed";
    let result3 = parse_line(line3).unwrap();
    assert_eq!(result3.country_code, [b'Z', b'Z']);
    assert_eq!(result3.asn, 0);
    assert_eq!(result3.organization, "Not routed");

    // Case 4: Multi-word organization
    let line4 = "213.230.0.0\t213.230.0.255\t28938\tSA\tMEDUNET-AS Program for Medical and Educational Telecommunications Riyadh, Saudi Arabia";
    let result4 = parse_line(line4).unwrap();
    assert_eq!(result4.asn, 28938);
    assert_eq!(result4.country_code, [b'S', b'A']);
    assert_eq!(
        result4.organization,
        "MEDUNET-AS Program for Medical and Educational Telecommunications Riyadh, Saudi Arabia"
    );
}

#[test]
fn test_parse_line_empty() {
    let line = "";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::IncorrectColumnCount { .. })
    ));
}

#[test]
fn test_parse_line_malformed_country_code() {
    let line = "1.0.0.0\t1.0.0.255\t13335\tUSA\tCLOUDFLARENET";
    let result = parse_line(line);
    assert!(matches!(
        result,
        Err(ip2asn::ParseErrorKind::InvalidCountryCode { .. })
    ));
}