src/error_test.nv - main - nv-lang/nova-tls

src/error_test.nv
110 строк6 KB
Evgeniy Golovin
202 Ф.3 fix: применить содержимое root-peer миграции (декл + импорт + докс)
13 июл 2026, 08:11
13 июл 2026, 08:1194b73db
// SPDX-License-Identifier: MIT OR Apache-2.0
// nova-tls: TlsError — to_str, from_shim-классификация, Q3-проекция.
// Pure: без сети, без эффектов, без шима (данные-only). Extracted from
// monorepo std/tls (Plan 193 Ф.1).
//
// Стиль «ro-байндинг перед .method()» — не прихоть: chained-вызов прямо на
// свежесконструированном варианте (`TlsError.CloseNotify.to_str()`) ловит
// pre-existing ICE [M-176-xmod-payload-variant-ctor] (P67-LEGACY «Path call
// return type unknown»); обход тот же, что в std/net/error_test.nv.

module tls

import std.net.{NetError}

test "to_str — nullary variants" {
    ro expired = TlsError.CertificateExpired
    assert(expired.to_str() == "certificate expired")
    ro ver = TlsError.UnsupportedProtocolVersion
    assert(ver.to_str() == "unsupported protocol version")
    ro alpn = TlsError.AlpnNoCommonProtocol
    assert(alpn.to_str() == "no common alpn protocol")
    ro cn = TlsError.CloseNotify
    assert(cn.to_str() == "tls stream closed")
}

test "to_str — payload variants" {
    ro cert = TlsError.CertificateInvalid("self-signed")
    assert(cert.to_str() == "certificate invalid: self-signed")
    ro host = TlsError.HostnameMismatch("api.example.com")
    assert(host.to_str() == "hostname mismatch: api.example.com")
    ro hs = TlsError.HandshakeFailure("alert received")
    assert(hs.to_str() == "handshake failure: alert received")
    ro peer = TlsError.PeerMisbehaved("truncated")
    assert(peer.to_str() == "peer misbehaved: truncated")
    ro pem = TlsError.InvalidPem("no certificates")
    assert(pem.to_str() == "invalid pem: no certificates")
    ro sni = TlsError.InvalidServerName("bad name!")
    assert(sni.to_str() == "invalid server name: bad name!")
    ro internal = TlsError.Internal("shim")
    assert(internal.to_str() == "tls internal error: shim")
}

test "to_str — Net delegates to NetError strings" {
    ro refused = TlsError.Net(NetError.ConnectionRefused)
    assert(refused.to_str() == "connection refused")
    ro timed = TlsError.Net(NetError.TimedOut)
    assert(timed.to_str() == "operation timed out")
}

test "from_shim — каждый стабильный код шима даёт свой вариант" {
    // Коды — контракт native/tls_c_shim.c (TLS_ERR_*).
    assert(match TlsError.from_shim(-3, "chain") { CertificateInvalid(m) => m == "chain", _ => false })
    assert(match TlsError.from_shim(-4, "") { CertificateExpired => true, _ => false })
    assert(match TlsError.from_shim(-5, "example.com") { HostnameMismatch(m) => m == "example.com", _ => false })
    assert(match TlsError.from_shim(-6, "") { UnsupportedProtocolVersion => true, _ => false })
    assert(match TlsError.from_shim(-7, "alert") { HandshakeFailure(m) => m == "alert", _ => false })
    assert(match TlsError.from_shim(-8, "") { AlpnNoCommonProtocol => true, _ => false })
    assert(match TlsError.from_shim(-9, "reset") { PeerMisbehaved(m) => m == "reset", _ => false })
    assert(match TlsError.from_shim(-10, "garbage") { InvalidPem(m) => m == "garbage", _ => false })
    assert(match TlsError.from_shim(-12, "spaces in name") { InvalidServerName(m) => m == "spaces in name", _ => false })
}

test "from_shim — internal / unsupported / unknown коды сворачиваются в Internal" {
    assert(match TlsError.from_shim(-1, "boom") { Internal(m) => m == "boom", _ => false })
    assert(match TlsError.from_shim(-2, "badarg") { Internal(_) => true, _ => false })
    // TLS_ERR_UNSUPPORTED (-11): текст дополняется префиксом.
    assert(match TlsError.from_shim(-11, "pinning") {
        Internal(m) => m.contains("unsupported") && m.contains("pinning")
        _ => false
    })
    // Forward-compat: неизвестный код НЕ паникует.
    assert(match TlsError.from_shim(-99, "future") { Internal(m) => m == "future", _ => false })
}

test "to_error_kind — проекция Q3" {
    ro cert = TlsError.CertificateInvalid("x")
    assert(match cert.to_error_kind() { InvalidData => true, _ => false })
    ro host = TlsError.HostnameMismatch("x")
    assert(match host.to_error_kind() { InvalidData => true, _ => false })
    ro alpn = TlsError.AlpnNoCommonProtocol
    assert(match alpn.to_error_kind() { InvalidData => true, _ => false })
    ro cn = TlsError.CloseNotify
    assert(match cn.to_error_kind() { UnexpectedEof => true, _ => false })
    ro pem = TlsError.InvalidPem("x")
    assert(match pem.to_error_kind() { InvalidInput => true, _ => false })
    ro sni = TlsError.InvalidServerName("x")
    assert(match sni.to_error_kind() { InvalidInput => true, _ => false })
    ro internal = TlsError.Internal("x")
    assert(match internal.to_error_kind() { Other(_) => true, _ => false })
}

test "to_error_kind — Net(e) делегирует транспортной проекции" {
    ro timed = TlsError.Net(NetError.TimedOut)
    assert(match timed.to_error_kind() { TimedOut => true, _ => false })
    ro pipe = TlsError.Net(NetError.BrokenPipe)
    assert(match pipe.to_error_kind() { BrokenPipe => true, _ => false })
    ro eof = TlsError.Net(NetError.Eof)
    assert(match eof.to_error_kind() { UnexpectedEof => true, _ => false })
}

test "to_io_error — kind + op для diagnostics" {
    ro expired = TlsError.CertificateExpired
    ro io_err = expired.to_io_error("handshake")
    assert(match io_err.kind { InvalidData => true, _ => false })
    assert(io_err.op == "handshake")
    ro reset = TlsError.Net(NetError.ConnectionReset)
    ro net_err = reset.to_io_error("read")
    assert(match net_err.kind { ConnectionReset => true, _ => false })
    assert(net_err.op == "read")
}