std/src/encoding/url_test.nv - main - nv-lang/nova

std/src/encoding/url_test.nv
124 строки4 KB
Evgeniy Golovin
195: std/ -> std/src/ (git mv, module-path без изменений)
13 июл 2026, 01:13
13 июл 2026, 01:13be4fcab
// SPDX-License-Identifier: MIT OR Apache-2.0
// std/encoding/url_test.nv — публичный контракт Url.

module encoding.url_test

import std.encoding.url.{Url, ParseUrlError}

test "parse: простой HTTP URL" {
    ro u = Url.from("http://example.com/")!!
    assert(u.scheme == "http")
    assert(u.host == Some("example.com"))
    assert(u.port == None)
    assert(u.path == "/")
    assert(u.query == None)
    assert(u.fragment == None)
}

test "parse: HTTPS с портом и path" {
    ro u = Url.from("https://api.example.com:8443/v1/users")!!
    assert(u.scheme == "https")
    assert(u.host == Some("api.example.com"))
    assert(u.port == Some(8443))
    assert(u.path == "/v1/users")
}

test "parse: с query string и fragment" {
    ro u = Url.from("https://example.com/search?q=nova&lang=en#results")!!
    assert(u.path == "/search")
    assert(u.query == Some("q=nova&lang=en"))
    assert(u.fragment == Some("results"))
}

test "parse: userinfo (user:pass)" {
    ro u = Url.from("https://alice:s3cret@example.com/")!!
    assert(u.user == Some("alice"))
    assert(u.password == Some("s3cret"))
}

test "parse: только user без password" {
    ro u = Url.from("ftp://anonymous@ftp.example.org/")!!
    assert(u.user == Some("anonymous"))
    assert(u.password == None)
}

test "parse: file:// без host" {
    ro u = Url.from("file:///etc/hosts")!!
    assert(u.scheme == "file")
    assert(u.host == Some(""))
    assert(u.path == "/etc/hosts")
}

test "parse: scheme нормализуется в lowercase" {
    ro u = Url.from("HTTP://example.com/")!!
    assert(u.scheme == "http")
}

test "round-trip: стандартный URL" {
    ro s = "https://api.example.com:8443/v1/users?id=42&active=true#section1"
    ro u = Url.from(s)!!
    assert(u.to_str() == s)
}

test "round-trip: с userinfo" {
    ro s = "https://alice:s3cret@example.com/path"
    ro u = Url.from(s)!!
    assert(u.to_str() == s)
}

test "parse: ошибка — пустой ввод" {
    assert(match Url.from("") {
        Err(EmptyInput) => true
        _               => false
    })
}

test "parse: ошибка — нет scheme" {
    assert(match Url.from("example.com/path") {      // нет ":"
        Err(MissingScheme) => true
        _                  => false
    })
}

test "parse: ошибка — порт не число" {
    assert(match Url.from("http://example.com:abc/") {
        Err(InvalidPort { .. }) => true
        _                       => false
    })
}

test "parse: ошибка — порт > 65535" {
    assert(match Url.from("http://example.com:99999/") {
        Err(InvalidPort { .. }) => true
        _                       => false
    })
}

test "encode_query: ASCII unreserved неизменны" {
    assert(Url.encode_query("hello") == "hello")
    assert(Url.encode_query("a-b.c_d~e") == "a-b.c_d~e")
}

test "encode_query: пробел → +" {
    assert(Url.encode_query("hello world") == "hello+world")
}

test "encode_query: спецсимволы → %XX" {
    assert(Url.encode_query("a&b=c") == "a%26b%3Dc")
}

test "decode_query: round-trip" {
    ro cases = ["hello", "hello world", "a&b=c", "100%"]
    for s in cases {
        ro encoded = Url.encode_query(s)
        ro decoded = Url.decode_query(encoded)!!
        assert(decoded == s)
    }
}

test "decode_query: ошибка — обрезанное %X" {
    assert(match Url.decode_query("abc%2") {         // обрезано
        Err(InvalidPercentEncoding { .. }) => true
        _                                  => false
    })
}