SPB Git

Repository Public License

LogicTests.swift 26.2 KB 513 lines swift

1// ORIX Secure2// File: Packages/ORIXNetworkLab/Tests/ORIXNetworkLabTests/LogicTests.swift3// Description: Deterministic tests: host name matching, address classification, latency statistics, DNS error mapping,4//              change-log diffing, proxy/VPN interpretation, HSTS and endpoint parsing, Bonjour helpers.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9import Network10@testable import ORIXNetworkLab11import ORIXSecureModel12import Testing1314@Suite("Host name matching (RFC 6125)")15struct HostnameMatcherTests {16    static let cases: [(host: String, pattern: String, expected: Bool)] = [17        ("example.com", "example.com", true),18        ("EXAMPLE.com", "example.COM", true),19        ("example.com.", "example.com", true),20        ("example.com", "example.com.", true),21        ("www.example.com", "example.com", false),22        ("example.com", "www.example.com", false),23        ("www.example.com", "*.example.com", true),24        ("WWW.Example.Com", "*.EXAMPLE.com", true),25        ("example.com", "*.example.com", false),26        ("a.b.example.com", "*.example.com", false),27        ("b.example.com", "*.b.example.com", false),28        ("a.b.example.com", "*.b.example.com", true),29        ("www.example.com", "w*.example.com", false),30        ("www.example.com", "*w.example.com", false),31        ("www.example.com", "www.*.com", false),32        ("www.example.com", "*.*.com", false),33        ("www.example.com", "*", false),34        ("example.com", "*.com", false),35        ("com", "*", false),36        ("foo.co.uk", "*.co.uk", false),37        ("foo.com.au", "*.com.au", false),38        ("foo.qc.ca", "*.qc.ca", false),39        ("shop.example.co.uk", "*.example.co.uk", true),40        ("xn--bcher-kva.example.com", "xn--bcher-kva.example.com", true),41        ("bücher.example.com", "xn--bcher-kva.example.com", true),42        ("xn--bcher-kva.example.com", "*.example.com", true),43        ("www.xn--bcher-kva.de", "*.xn--bcher-kva.de", true),44        ("www.example.com", "xn--*.example.com", false),45        ("192.168.1.1", "192.168.1.1", false),46        ("192.168.1.1", "*.168.1.1", false),47        ("1.example.com", "*.example.com", true),48        ("www.example.com", "", false),49        ("", "example.com", false),50        ("www..example.com", "*.example.com", false),51        ("www.example.com", "*.example.com.", true),52        ("www.example.com.", "*.example.com", true),53        ("evil.com", "*.example.com", false),54        ("wwwexample.com", "*.example.com", false),55        ("www.example.com\u{0}.evil.com", "*.evil.com", false),56        ("sub_domain.example.com", "*.example.com", true),57    ]5859    @Test func matchingTable() {60        #expect(Self.cases.count >= 25)61        for entry in Self.cases {62            let result = HostnameMatcher.matches(host: entry.host, pattern: entry.pattern)63            #expect(result == entry.expected, "host “\(entry.host)” against “\(entry.pattern)”")64        }65    }6667    @Test func coverageUsesIPSANsForAddressesOnly() {68        #expect(HostnameMatcher.covers(host: "192.0.2.10", dnsNames: ["192.0.2.10"], ipAddresses: []) == false)69        #expect(HostnameMatcher.covers(host: "192.0.2.10", dnsNames: [], ipAddresses: ["192.0.2.10"]))70        #expect(HostnameMatcher.covers(host: "192.0.2.11", dnsNames: [], ipAddresses: ["192.0.2.10"]) == false)71        #expect(HostnameMatcher.covers(host: "2001:DB8:0:0:0:0:0:10", dnsNames: [], ipAddresses: ["2001:db8::10"]))72        #expect(HostnameMatcher.covers(host: "[2001:db8::10]", dnsNames: [], ipAddresses: ["2001:db8::10"]))73        #expect(HostnameMatcher.covers(host: "::1", dnsNames: ["localhost"], ipAddresses: ["127.0.0.1"]) == false)74        #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: ["example.com", "*.example.com"], ipAddresses: []))75        #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: [], ipAddresses: ["192.0.2.10"]) == false)76        #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: [], ipAddresses: []) == false)77    }7879    @Test func normalization() {80        #expect(HostnameMatcher.normalize("Example.COM.") == "example.com")81        #expect(HostnameMatcher.normalize("bücher.example") == "xn--bcher-kva.example")82        #expect(HostnameMatcher.normalize("") == nil)83        #expect(HostnameMatcher.normalize("a..b") == nil)84        #expect(HostnameMatcher.normalize("a b.com") == nil)85        #expect(HostnameMatcher.normalize(String(repeating: "a", count: 64) + ".com") == nil)86        #expect(HostnameMatcher.isPublicSuffixLike("co.uk"))87        #expect(!HostnameMatcher.isPublicSuffixLike("example.com"))88        #expect(!HostnameMatcher.isPublicSuffixLike("example.co.uk"))89    }90}9192@Suite("Address classification")93struct AddressClassificationTests {94    static let cases: [(String, AddressFamily, AddressScope)] = [95        ("127.0.0.1", .ipv4, .loopback),96        ("127.255.255.254", .ipv4, .loopback),97        ("10.0.0.1", .ipv4, .privateRFC1918),98        ("10.255.255.255", .ipv4, .privateRFC1918),99        ("172.16.0.1", .ipv4, .privateRFC1918),100        ("172.31.255.255", .ipv4, .privateRFC1918),101        ("172.15.255.255", .ipv4, .global),102        ("172.32.0.1", .ipv4, .global),103        ("192.168.2.104", .ipv4, .privateRFC1918),104        ("192.169.0.1", .ipv4, .global),105        ("100.64.0.1", .ipv4, .carrierGradeNAT),106        ("100.127.255.255", .ipv4, .carrierGradeNAT),107        ("100.63.255.255", .ipv4, .global),108        ("100.128.0.1", .ipv4, .global),109        ("169.254.10.20", .ipv4, .linkLocal),110        ("224.0.0.251", .ipv4, .multicast),111        ("239.255.255.250", .ipv4, .multicast),112        ("255.255.255.255", .ipv4, .reserved),113        ("240.0.0.1", .ipv4, .reserved),114        ("0.0.0.0", .ipv4, .unspecified),115        ("192.0.2.1", .ipv4, .reserved),116        ("198.51.100.7", .ipv4, .reserved),117        ("203.0.113.9", .ipv4, .reserved),118        ("198.18.0.1", .ipv4, .reserved),119        ("8.8.8.8", .ipv4, .global),120        ("17.253.144.10", .ipv4, .global),121        ("::1", .ipv6, .loopback),122        ("::", .ipv6, .unspecified),123        ("fe80::1", .ipv6, .linkLocal),124        ("fe80::1%en0", .ipv6, .linkLocal),125        ("febf::1", .ipv6, .linkLocal),126        ("fec0::1", .ipv6, .reserved),127        ("fc00::1", .ipv6, .uniqueLocal),128        ("fd12:3456:789a::1", .ipv6, .uniqueLocal),129        ("ff02::fb", .ipv6, .multicast),130        ("2001:db8::1", .ipv6, .reserved),131        ("2607:f8b0:4004:800::200e", .ipv6, .global),132        ("2a01:b740:a41::10", .ipv6, .global),133        ("64:ff9b::808:808", .ipv6, .global),134        ("::ffff:192.168.1.1", .ipv6, .privateRFC1918),135        ("::ffff:8.8.8.8", .ipv6, .global),136        ("[2001:db8::1]", .ipv6, .reserved),137    ]138139    @Test func classificationTable() {140        for (text, family, scope) in Self.cases {141            let address = IPAddress(text)142            #expect(address != nil, "parse \(text)")143            #expect(address?.family == family, "family of \(text)")144            #expect(address?.scope == scope, "scope of \(text)")145        }146    }147148    @Test func parsingAndFormatting() {149        #expect(IPAddress("not an address") == nil)150        #expect(IPAddress("") == nil)151        #expect(IPAddress("256.1.1.1") == nil)152        #expect(IPAddress("1.2.3") == nil)153        #expect(IPAddress("example.com") == nil)154        #expect(IPAddress(bytes: [1, 2, 3]) == nil)155        #expect(IPAddress(bytes: [192, 168, 1, 20])?.description == "192.168.1.20")156        #expect(IPAddress("2001:0DB8:0000:0000:0000:0000:0000:0010")?.description == "2001:db8::10")157        #expect(IPAddress("2001:db8::10") == IPAddress("2001:DB8:0:0:0:0:0:10"))158        #expect(AddressScope.privateRFC1918.isRoutable && AddressScope.carrierGradeNAT.isRoutable && AddressScope.uniqueLocal.isRoutable && AddressScope.global.isRoutable)159        #expect(!AddressScope.linkLocal.isRoutable && !AddressScope.loopback.isRoutable && !AddressScope.multicast.isRoutable)160    }161162    @Test func prefixLengths() {163        #expect(InterfaceInspector.prefixLength(of: [255, 255, 255, 0]) == 24)164        #expect(InterfaceInspector.prefixLength(of: [255, 255, 240, 0]) == 20)165        #expect(InterfaceInspector.prefixLength(of: [255, 255, 255, 255]) == 32)166        #expect(InterfaceInspector.prefixLength(of: [0, 0, 0, 0]) == 0)167        #expect(InterfaceInspector.prefixLength(of: [255, 0, 255, 0]) == nil)168        #expect(InterfaceInspector.prefixLength(of: [255, 241, 0, 0]) == nil)169        #expect(InterfaceInspector.prefixLength(of: [UInt8](repeating: 255, count: 8) + [UInt8](repeating: 0, count: 8)) == 64)170    }171}172173@Suite("Latency statistics")174struct LatencyStatisticsTests {175    @Test func oddSampleCount() throws {176        let stats = try #require(LatencyStatistics(durations: [0.030, 0.010, 0.020, 0.050, 0.040]))177        #expect(stats.sampleCount == 5)178        #expect(stats.lossCount == 0)179        #expect(stats.minimum == 0.010)180        #expect(stats.maximum == 0.050)181        #expect(abs(stats.average - 0.030) < 1e-12)182        #expect(stats.median == 0.030)183        #expect(abs(stats.jitter - 0.0002.squareRoot()) < 1e-12)184        #expect(stats.lossFraction == 0)185    }186187    @Test func evenSampleCountWithLosses() throws {188        let stats = try #require(LatencyStatistics(durations: [0.100, nil, 0.200, 0.400, nil, 0.300]))189        #expect(stats.sampleCount == 6)190        #expect(stats.lossCount == 2)191        #expect(abs(stats.median - 0.250) < 1e-12)192        #expect(abs(stats.average - 0.250) < 1e-12)193        #expect(abs(stats.jitter - 0.0125.squareRoot()) < 1e-12)194        #expect(abs(stats.lossFraction - 1.0 / 3.0) < 1e-12)195    }196197    @Test func singleSampleAndNoSample() throws {198        let single = try #require(LatencyStatistics(durations: [0.042]))199        #expect(single.minimum == 0.042 && single.maximum == 0.042 && single.median == 0.042 && single.average == 0.042)200        #expect(single.jitter == 0)201        #expect(LatencyStatistics(durations: []) == nil)202        #expect(LatencyStatistics(durations: [nil, nil, nil]) == nil)203        let filtered = try #require(LatencyStatistics(durations: [0.010, .nan, -1, .infinity]))204        #expect(filtered.sampleCount == 4)205        #expect(filtered.lossCount == 3)206        #expect(filtered.average == 0.010)207    }208209    @Test func invalidInputIsReportedNotMeasured() async {210        let empty = await LatencyProbe.measure(host: "", samples: 2)211        #expect(empty.samples.isEmpty)212        #expect(empty.statistics.unavailability?.kind == .failed)213        let zeroPort = await LatencyProbe.measure(host: "apple.com", port: 0)214        #expect(!zeroPort.statistics.isMeasured)215    }216}217218@Suite("DNS error mapping")219struct DNSMappingTests {220    @Test func gaiCodes() {221        #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: true) == .notFound)222        #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: nil) == .notFound)223        #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: false) == .noNetwork)224        #expect(DNSProbe.classify(gaiCode: EAI_NODATA, networkSatisfied: true) == .notFound)225        #expect(DNSProbe.classify(gaiCode: EAI_AGAIN, networkSatisfied: true) == .temporaryFailure)226        #expect(DNSProbe.classify(gaiCode: EAI_AGAIN, networkSatisfied: false) == .noNetwork)227        #expect(DNSProbe.classify(gaiCode: EAI_FAIL, networkSatisfied: true) == .serverFailure)228        #expect(DNSProbe.classify(gaiCode: EAI_MEMORY, networkSatisfied: true) == .other)229        #expect(DNSProbe.classify(gaiCode: EAI_SYSTEM, networkSatisfied: false) == .other)230    }231232    @Test func everyKindHasAReadableReason() {233        for kind in DNSFailure.Kind.allCases {234            let failure = DNSProbe.failure(kind: kind, code: kind == .other ? EAI_MEMORY : nil)235            #expect(failure.kind == kind)236            #expect(failure.reason.count > 10)237        }238    }239240    @Test func invalidNamesAreRejectedWithoutALookup() async {241        for name in ["", "   ", "two words.com", "a..b", ".leading.com", String(repeating: "a", count: 300), "tab\there.com"] {242            let result = await DNSProbe.resolve(name)243            #expect(result.failure?.kind == .invalidName, "“\(name.prefix(20))”")244            #expect(result.addresses.isEmpty)245        }246        #expect(DNSProbe.isPlausibleHostName("apple.com"))247        #expect(DNSProbe.isPlausibleHostName("bücher.example"))248        #expect(DNSProbe.isPlausibleHostName("_dmarc.example.com"))249        #expect(DNSProbe.normalized(" apple.com. ") == "apple.com")250    }251252    @Test func addressLiteralsResolveToThemselvesOffline() async {253        let v4 = await DNSProbe.resolve("127.0.0.1")254        #expect(v4.ipv4Addresses == ["127.0.0.1"])255        #expect(v4.addresses.first?.scope == .loopback)256        let v6 = await DNSProbe.resolve("::1")257        #expect(v6.ipv6Addresses == ["::1"])258        let localhost = await DNSProbe.resolve("localhost")259        #expect(localhost.succeeded)260        print("MEASURED DNS localhost: \(ORIXFormat.milliseconds(localhost.duration)), addresses \(localhost.addresses.map(\.address))")261    }262}263264@Suite("Connectivity snapshots and change log")265struct ChangeLogTests {266    let wifi = ConnectivitySnapshot(267        status: .satisfied, interfaceKinds: [.wifi], isExpensive: false, isConstrained: false, supportsIPv4: true, supportsIPv6: true, supportsDNS: true,268        availableInterfaces: [PathInterface(name: "en0", kind: .wifi, index: 4)], timestamp: Date(timeIntervalSince1970: 1000)269    )270271    @Test func firstSnapshotIsAnInitialEntry() {272        let change = NetworkChange.between(nil, wifi)273        #expect(change?.kinds == [.initial])274        #expect(change?.previous == nil)275        #expect(change?.current == wifi)276        #expect(change?.descriptions.count == 1)277    }278279    @Test func identicalSnapshotsProduceNoEntry() {280        var later = wifi281        later.timestamp = Date(timeIntervalSince1970: 2000)282        #expect(NetworkChange.between(wifi, later) == nil)283    }284285    @Test func wifiToCellularListsEveryDifference() throws {286        let cellular = ConnectivitySnapshot(287            status: .satisfied, interfaceKinds: [.cellular], isExpensive: true, isConstrained: true, supportsIPv4: true, supportsIPv6: false, supportsDNS: true,288            availableInterfaces: [PathInterface(name: "pdp_ip0", kind: .cellular, index: 3)], timestamp: Date(timeIntervalSince1970: 3000)289        )290        let change = try #require(NetworkChange.between(wifi, cellular))291        #expect(change.kinds == [.interfaceKinds, .expensive, .constrained, .ipv6, .availableInterfaces])292        #expect(change.descriptions.count == change.kinds.count)293        #expect(change.timestamp == cellular.timestamp)294        #expect(change.previous == wifi)295    }296297    @Test func goingOfflineReportsStatusAndReason() throws {298        let offline = ConnectivitySnapshot(status: .unsatisfied, unsatisfiedReason: .notAvailable, timestamp: Date(timeIntervalSince1970: 4000))299        let change = try #require(NetworkChange.between(wifi, offline))300        #expect(change.kinds.contains(.status))301        #expect(change.kinds.contains(.unsatisfiedReason))302        #expect(change.kinds.contains(.dns))303        #expect(change.kinds.contains(.ipv4))304        let back = try #require(NetworkChange.between(offline, wifi))305        #expect(back.kinds.contains(.status))306        #expect(back.kinds.contains(.unsatisfiedReason))307    }308309    @Test func theLogIsBoundedAndOrdered() {310        let monitor = ConnectivityMonitor(logCapacity: 5)311        var snapshot = wifi312        for index in 0..<20 {313            snapshot.isExpensive.toggle()314            snapshot.timestamp = Date(timeIntervalSince1970: TimeInterval(5000 + index))315            monitor.ingest(snapshot)316        }317        let log = monitor.changeLog318        #expect(log.count == 5)319        #expect(log.map(\.timestamp) == log.map(\.timestamp).sorted())320        #expect(log.last?.current == snapshot)321        #expect(log.contains { $0.kinds == [.initial] } == false)322        monitor.ingest(snapshot)323        #expect(monitor.changeLog.count == 5)324        monitor.clearChangeLog()325        #expect(monitor.changeLog.isEmpty)326    }327328    @Test func streamsDeliverIngestedSnapshots() async {329        let monitor = ConnectivityMonitor()330        monitor.ingest(wifi)331        let stream = monitor.snapshots()332        var iterator = stream.makeAsyncIterator()333        let first = await iterator.next()334        #expect(first != nil)335        var changed = wifi336        changed.isConstrained = true337        monitor.ingest(changed)338        var sawChange = first == changed339        for _ in 0..<5 where !sawChange {340            if let next = await iterator.next(), next == changed { sawChange = true }341        }342        #expect(sawChange)343        monitor.stop()344        #expect(!monitor.isActive)345    }346347    @Test func snapshotsRoundTripThroughCodable() throws {348        let data = try JSONEncoder().encode(wifi)349        let decoded = try JSONDecoder().decode(ConnectivitySnapshot.self, from: data)350        #expect(decoded == wifi)351    }352}353354@Suite("Proxy, VPN indicator and parsing helpers")355struct InterpretationTests {356    func address(_ name: String, _ text: String, up: Bool = true) -> InterfaceAddress {357        let parsed = IPAddress(text)358        let flags = InterfaceFlags(raw: up ? UInt32(IFF_UP | IFF_RUNNING) : 0)359        return InterfaceAddress(name: name, family: parsed?.family ?? .ipv4, address: text, flags: flags, scope: parsed?.scope ?? .reserved)360    }361362    @Test func proxySettingsParsing() {363        let none = InterfaceInspector.parseProxySettings(["HTTPEnable": 0, "HTTPProxy": "ignored.example", "HTTPPort": 8080])364        #expect(!none.isProxyConfigured)365        #expect(none.httpProxy == nil)366        let manual = InterfaceInspector.parseProxySettings([367            "HTTPEnable": 1, "HTTPProxy": "proxy.corp.example", "HTTPPort": 8080,368            "HTTPSEnable": 1, "HTTPSProxy": "10.0.0.5", "HTTPSPort": 3128,369            "ExceptionsList": ["*.local", "169.254/16"],370            "__SCOPED__": ["en0": ["HTTPEnable": 1], "utun4": [String: Any]()],371        ])372        #expect(manual.isProxyConfigured)373        #expect(manual.httpProxy == ProxyEndpoint(host: "proxy.corp.example", port: 8080))374        #expect(manual.httpsProxy?.display == "10.0.0.5:3128")375        #expect(manual.socksProxy == nil)376        #expect(manual.exceptions == ["*.local", "169.254/16"])377        #expect(manual.scopedInterfaces == ["en0", "utun4"])378        let pac = InterfaceInspector.parseProxySettings(["ProxyAutoConfigEnable": 1, "ProxyAutoConfigURLString": "http://wpad.example/proxy.pac", "ProxyAutoDiscoveryEnable": 1])379        #expect(pac.pacURL == "http://wpad.example/proxy.pac")380        #expect(pac.isProxyConfigured)381        #expect(pac.autoDiscoveryEnabled)382        let discoveryOnly = InterfaceInspector.parseProxySettings(["ProxyAutoDiscoveryEnable": 1])383        #expect(!discoveryOnly.isProxyConfigured)384        let hostile = InterfaceInspector.parseProxySettings(["HTTPEnable": 1, "HTTPProxy": "evil\u{0}\nhost", "HTTPPort": 99999, "SOCKSEnable": "yes", "ExceptionsList": 12])385        #expect(hostile.httpProxy == ProxyEndpoint(host: "evilhost", port: nil))386        #expect(hostile.socksProxy == nil)387        #expect(hostile.exceptions.isEmpty)388    }389390    @Test func tunnelInterfaceNames() {391        for name in ["utun0", "utun12", "ipsec0", "ppp0", "tap1", "tun3", "UTUN2"] {392            #expect(InterfaceInspector.isTunnelInterfaceName(name), "\(name)")393        }394        for name in ["en0", "pdp_ip0", "lo0", "awdl0", "bridge100", "tunnel", "utunx", "llw0", "anpi0"] {395            #expect(!InterfaceInspector.isTunnelInterfaceName(name), "\(name)")396        }397    }398399    @Test func vpnIndicatorHeuristic() {400        let systemOnly = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("utun0", "fe80::1"), address("utun1", "fe80::2")], proxy: nil)401        #expect(!systemOnly.isIndicated)402        #expect(systemOnly.systemOnlyTunnelInterfaces == ["utun0", "utun1"])403        #expect(systemOnly.confidence == .heuristic)404405        let vpn = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("utun0", "fe80::1"), address("utun3", "10.67.0.34"), address("utun3", "fe80::3")], proxy: ProxyConfiguration())406        #expect(vpn.isIndicated)407        #expect(vpn.tunnelInterfacesWithRoutableAddress == ["utun3"])408        #expect(vpn.systemOnlyTunnelInterfaces == ["utun0"])409410        let cgnat = InterfaceInspector.vpnIndicator(addresses: [address("utun5", "100.69.26.91")], proxy: nil)411        #expect(cgnat.isIndicated)412        let ula = InterfaceInspector.vpnIndicator(addresses: [address("ipsec0", "fd00::2")], proxy: nil)413        #expect(ula.isIndicated)414415        let down = InterfaceInspector.vpnIndicator(addresses: [address("utun3", "10.67.0.34", up: false)], proxy: nil)416        #expect(!down.isIndicated)417418        let scoped = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20")], proxy: ProxyConfiguration(scopedInterfaces: ["en0", "utun2", "ppp0"]))419        #expect(scoped.isIndicated)420        #expect(scoped.scopedTunnelInterfaces == ["ppp0", "utun2"])421422        let nothing = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("pdp_ip0", "10.20.30.40")], proxy: ProxyConfiguration(scopedInterfaces: ["en0"]))423        #expect(!nothing.isIndicated)424        #expect(nothing.systemOnlyTunnelInterfaces.isEmpty)425    }426427    @Test func thisMachinesInterfacesAreReadable() throws {428        let addresses = try #require(InterfaceInspector.addresses().value)429        #expect(addresses.contains { $0.flags.isLoopback && $0.address == "127.0.0.1" && $0.scope == .loopback && $0.prefixLength == 8 })430        #expect(addresses.contains { $0.address == "::1" && $0.prefixLength == 128 })431        for entry in addresses {432            #expect(IPAddress(entry.address) != nil, "\(entry.name) \(entry.address)")433            #expect(!entry.name.isEmpty)434        }435        let proxy = InterfaceInspector.proxyConfiguration()436        #expect(proxy.isMeasured)437        let indicator = InterfaceInspector.vpnIndicator(addresses: addresses, proxy: proxy.value)438        print("MEASURED interfaces: \(addresses.count) addresses on \(Set(addresses.map(\.name)).count) interfaces; proxy configured: \(proxy.value?.isProxyConfigured ?? false); VPN indicator: \(indicator.isIndicated) \(indicator.tunnelInterfacesWithRoutableAddress)")439    }440441    @Test func hstsParsing() {442        let full = HSTSPolicy(header: "max-age=63072000; includeSubDomains; preload")443        #expect(full?.maxAge == 63_072_000)444        #expect(full?.includeSubDomains == true)445        #expect(full?.preload == true)446        #expect(full?.isEffective == true)447        let quoted = HSTSPolicy(header: " MAX-AGE=\"300\" ; INCLUDESUBDOMAINS ")448        #expect(quoted?.maxAge == 300)449        #expect(quoted?.includeSubDomains == true)450        #expect(quoted?.preload == false)451        let zero = HSTSPolicy(header: "max-age=0")452        #expect(zero?.isEffective == false)453        let broken = HSTSPolicy(header: "includeSubDomains; max-age=abc")454        #expect(broken?.maxAge == nil)455        #expect(broken?.isEffective == false)456        #expect(HSTSPolicy(header: "max-age=-5")?.maxAge == nil)457        #expect(HSTSPolicy(header: "   ") == nil)458    }459460    @Test func tlsEndpointParsing() {461        #expect(TLSEndpoint(parsing: "apple.com") == TLSEndpoint(host: "apple.com", port: 443))462        #expect(TLSEndpoint(parsing: " apple.com:8443 ") == TLSEndpoint(host: "apple.com", port: 8443))463        #expect(TLSEndpoint(parsing: "apple.com.") == TLSEndpoint(host: "apple.com", port: 443))464        #expect(TLSEndpoint(parsing: "https://www.apple.com/iphone?x=1") == TLSEndpoint(host: "www.apple.com", port: 443))465        #expect(TLSEndpoint(parsing: "https://example.com:9443/") == TLSEndpoint(host: "example.com", port: 9443))466        #expect(TLSEndpoint(parsing: "192.0.2.10:993") == TLSEndpoint(host: "192.0.2.10", port: 993))467        #expect(TLSEndpoint(parsing: "[2001:db8::10]:8443") == TLSEndpoint(host: "2001:db8::10", port: 8443))468        #expect(TLSEndpoint(parsing: "[2001:db8::10]") == TLSEndpoint(host: "2001:db8::10", port: 443))469        #expect(TLSEndpoint(parsing: "2001:db8::10") == TLSEndpoint(host: "2001:db8::10", port: 443))470        #expect(TLSEndpoint(parsing: "2001:db8::10")?.display == "[2001:db8::10]:443")471        #expect(TLSEndpoint(parsing: "2001:db8::10")?.isIPAddress == true)472        for invalid in ["", "   ", "apple.com:0", "apple.com:99999", "apple.com:abc", "[2001:db8::10", "[::1]x", "two words", "host/path", "https://"] {473            #expect(TLSEndpoint(parsing: invalid) == nil, "“\(invalid)”")474        }475    }476477    @Test func tlsVersionAndCipherNames() {478        #expect(TLSProtocolVersion(code: 0x0301) == .tls10)479        #expect(TLSProtocolVersion(code: 0x0302) == .tls11)480        #expect(TLSProtocolVersion(code: 0x0303) == .tls12)481        #expect(TLSProtocolVersion(code: 0x0304) == .tls13)482        #expect(TLSProtocolVersion(code: 0x0300) == .unknown)483        #expect(TLSProtocolVersion.tls10.isDeprecated && TLSProtocolVersion.tls11.isDeprecated)484        #expect(!TLSProtocolVersion.tls12.isDeprecated && !TLSProtocolVersion.tls13.isDeprecated)485        #expect(TLSCipherSuite(code: 0x1301).name == "TLS_AES_128_GCM_SHA256")486        #expect(TLSCipherSuite(code: 0xc02f).name == "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256")487        #expect(TLSCipherSuite(code: 0xabcd).name == "0xabcd")488    }489490    @Test func bonjourHelpers() {491        #expect(LocalNetworkBrowser.defaultServiceTypes.count == 14)492        #expect(Set(LocalNetworkBrowser.defaultServiceTypes).count == 14)493        for type in LocalNetworkBrowser.defaultServiceTypes {494            #expect(LocalNetworkBrowser.isValidServiceType(type), "\(type)")495            #expect(LocalNetworkBrowser.label(forServiceType: type) != type)496        }497        for invalid in ["", "http", "_http", "_http._tcp.", "_http._sctp", "http._tcp", "_._tcp", "_averyveryverylongname._tcp", "_ht tp._tcp", "_http._tcp.local"] {498            #expect(!LocalNetworkBrowser.isValidServiceType(invalid), "“\(invalid)”")499        }500        let denied = LocalNetworkBrowser.unavailability(for: NWError.dns(-65570))501        #expect(denied.kind == .permissionRequired)502        let other = LocalNetworkBrowser.unavailability(for: NWError.dns(-65563))503        #expect(other.kind == .failed)504        let posix = LocalNetworkBrowser.unavailability(for: NWError.posix(.ENETDOWN))505        #expect(posix.kind == .failed)506    }507508    @Test func browsingWithNoValidTypeIsUnavailable() async {509        let result = await LocalNetworkBrowser.summary(serviceTypes: ["nonsense", "_bad._sctp"], duration: .seconds(1))510        #expect(result.unavailability?.kind == .failed)511    }512}513
Files main
Menu

Theme