test(core): Swift oracle — the filius-ipad core built on Linux as the reference
tools/swift-oracle builds the unchanged Swift runtime (pinned 3b5ded0) in Docker and replays JSON scenarios; the TypeScript engine must produce the same trace events, results and end state. Five scenarios, 884 events, identical. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,273 @@
|
||||
// Replays scenario files in the filius-ipad runtime engine and writes what
|
||||
// happened: every trace event, the result of every step, and the end state.
|
||||
// The TypeScript port replays the same files (packages/core/test/oracle.test.ts)
|
||||
// and must produce the same output.
|
||||
//
|
||||
// Usage: Oracle <directory> — reads <name>.scenario.json, writes <name>.swift.json
|
||||
|
||||
@testable import FiliusCore
|
||||
import Foundation
|
||||
|
||||
// MARK: - Scenario format (shared with packages/core/test/oracle/scenario.ts)
|
||||
|
||||
struct ScenarioPort: Decodable { let id: String; let label: String; let mac: String? }
|
||||
struct ScenarioNode: Decodable { let id: String; let kind: String; let ports: [ScenarioPort] }
|
||||
struct ScenarioLink: Decodable {
|
||||
let id: String
|
||||
let sourceNode: String; let sourcePort: String
|
||||
let targetNode: String; let targetPort: String
|
||||
}
|
||||
struct ScenarioDevice: Decodable { let ip: String; let mask: String; let gateway: String?; let dns: String? }
|
||||
struct ScenarioInterface: Decodable { let node: String; let port: String; let ip: String; let mask: String }
|
||||
struct ScenarioRoute: Decodable { let destination: String; let mask: String; let gateway: String; let interface: String }
|
||||
struct ScenarioSwitch: Decodable { let ssid: String; let retention: UInt64? }
|
||||
struct ScenarioFirewallRule: Decodable {
|
||||
let source: String?; let sourceMask: String?
|
||||
let destination: String?; let destinationMask: String?
|
||||
let port: Int?; let `protocol`: String?; let action: String?
|
||||
}
|
||||
struct ScenarioFirewall: Decodable {
|
||||
let active: Bool?; let defaultPolicy: String?; let dropIcmp: Bool?
|
||||
let synOnly: Bool?; let filterUdp: Bool?; let rules: [ScenarioFirewallRule]?
|
||||
}
|
||||
struct ScenarioStep: Decodable {
|
||||
let op: String
|
||||
let from: String?; let node: String?; let target: String?
|
||||
let ttl: UInt8?; let identifier: UInt16?; let sequence: UInt16?; let maxTtl: UInt8?
|
||||
let to: UInt64?; let enabled: Bool?; let percent: Int?
|
||||
}
|
||||
struct Scenario: Decodable {
|
||||
let seed: UInt64
|
||||
let speedPercent: Int?
|
||||
let nodes: [ScenarioNode]
|
||||
let links: [ScenarioLink]
|
||||
let devices: [String: ScenarioDevice]?
|
||||
let interfaces: [ScenarioInterface]?
|
||||
let routes: [String: [ScenarioRoute]]?
|
||||
let switches: [String: ScenarioSwitch]?
|
||||
let firewalls: [String: ScenarioFirewall]?
|
||||
let steps: [ScenarioStep]
|
||||
}
|
||||
|
||||
// MARK: - Building the snapshot
|
||||
|
||||
func uuid(_ value: String) -> UUID {
|
||||
guard let id = UUID(uuidString: value) else { fatalError("not a UUID: \(value)") }
|
||||
return id
|
||||
}
|
||||
|
||||
func firewallAction(_ value: String?) -> TopologyFirewallAction {
|
||||
value == "accept" ? .accept : .drop
|
||||
}
|
||||
|
||||
func firewallProtocol(_ value: String?) -> TopologyFirewallProtocol {
|
||||
switch value {
|
||||
case "all": return .all
|
||||
case "icmp": return .icmp
|
||||
case "udp": return .udp
|
||||
default: return .tcp
|
||||
}
|
||||
}
|
||||
|
||||
func snapshot(of scenario: Scenario) -> TopologyNetworkRuntimeTopologySnapshot {
|
||||
let nodes = scenario.nodes.map { node -> TopologyNetworkRuntimeNodeSnapshot in
|
||||
guard let kind = TopologyNodeKind(rawValue: node.kind) else { fatalError("unknown kind \(node.kind)") }
|
||||
return TopologyNetworkRuntimeNodeSnapshot(
|
||||
id: uuid(node.id),
|
||||
kind: kind,
|
||||
ports: node.ports.map { TopologyNetworkRuntimePortSnapshot(id: uuid($0.id), label: $0.label, macAddress: $0.mac) }
|
||||
)
|
||||
}
|
||||
let links = scenario.links.map {
|
||||
TopologyNetworkRuntimeLinkSnapshot(
|
||||
id: uuid($0.id),
|
||||
sourceNodeID: uuid($0.sourceNode), sourcePortID: uuid($0.sourcePort),
|
||||
targetNodeID: uuid($0.targetNode), targetPortID: uuid($0.targetPort)
|
||||
)
|
||||
}
|
||||
var devices: [UUID: TopologyRuntimeDeviceConfiguration] = [:]
|
||||
for (node, device) in scenario.devices ?? [:] {
|
||||
devices[uuid(node)] = TopologyRuntimeDeviceConfiguration(
|
||||
ipAddress: device.ip, subnetMask: device.mask,
|
||||
defaultGateway: device.gateway ?? "", dnsServer: device.dns ?? ""
|
||||
)
|
||||
}
|
||||
var interfaces: [TopologyRuntimeInterfaceKey: TopologyRuntimeInterfaceConfiguration] = [:]
|
||||
for item in scenario.interfaces ?? [] {
|
||||
interfaces[TopologyRuntimeInterfaceKey(nodeID: uuid(item.node), portID: uuid(item.port))] =
|
||||
TopologyRuntimeInterfaceConfiguration(ipAddress: item.ip, subnetMask: item.mask)
|
||||
}
|
||||
var routes: [UUID: [TopologyRuntimeManualRoute]] = [:]
|
||||
for (node, rows) in scenario.routes ?? [:] {
|
||||
routes[uuid(node)] = rows.map {
|
||||
TopologyRuntimeManualRoute(
|
||||
destinationNetwork: $0.destination, subnetMask: $0.mask,
|
||||
gateway: $0.gateway, interfaceIPAddress: $0.interface
|
||||
)
|
||||
}
|
||||
}
|
||||
var switches: [UUID: TopologySwitchConfiguration] = [:]
|
||||
for (node, config) in scenario.switches ?? [:] {
|
||||
switches[uuid(node)] = TopologySwitchConfiguration(
|
||||
ssid: config.ssid,
|
||||
retentionTimeMilliseconds: config.retention ?? TopologySwitchConfiguration.defaultRetentionTimeMilliseconds
|
||||
)
|
||||
}
|
||||
var firewalls: [UUID: TopologyFirewallConfiguration] = [:]
|
||||
for (node, config) in scenario.firewalls ?? [:] {
|
||||
firewalls[uuid(node)] = TopologyFirewallConfiguration(
|
||||
isActive: config.active ?? false,
|
||||
defaultPolicy: firewallAction(config.defaultPolicy),
|
||||
dropICMP: config.dropIcmp ?? false,
|
||||
filterSYNSegmentsOnly: config.synOnly ?? true,
|
||||
filterUDP: config.filterUdp ?? true,
|
||||
rules: (config.rules ?? []).map {
|
||||
TopologyFirewallRule(
|
||||
sourceIPAddress: $0.source ?? "", sourceSubnetMask: $0.sourceMask ?? "",
|
||||
destinationIPAddress: $0.destination ?? "", destinationSubnetMask: $0.destinationMask ?? "",
|
||||
port: $0.port ?? TopologyFirewallRule.allPorts,
|
||||
protocolType: firewallProtocol($0.protocol),
|
||||
action: firewallAction($0.action)
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
return TopologyNetworkRuntimeTopologySnapshot(
|
||||
nodes: nodes, links: links,
|
||||
deviceConfigurations: devices, interfaceConfigurations: interfaces,
|
||||
manualRoutesByNodeID: routes,
|
||||
firewallConfigurationsByNodeID: firewalls,
|
||||
switchConfigurationsByNodeID: switches
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Output
|
||||
|
||||
typealias JSON = [String: Any]
|
||||
|
||||
func headers(_ fields: [TopologyPacketHeaderField]) -> [[String]] {
|
||||
fields.map { [$0.name, $0.value] }
|
||||
}
|
||||
|
||||
func trace(_ event: TopologyPacketTraceEvent) -> JSON {
|
||||
var result: JSON = [
|
||||
"id": event.id,
|
||||
"time": event.timeMilliseconds,
|
||||
"node": event.nodeID.uuidString,
|
||||
"direction": event.direction.rawValue,
|
||||
"layer": event.layer.rawValue,
|
||||
"operation": event.operation.rawValue,
|
||||
"before": headers(event.beforeHeaders),
|
||||
"after": headers(event.afterHeaders),
|
||||
]
|
||||
if let frame = event.frameIdentity { result["frame"] = frame }
|
||||
if let packet = event.packetIdentity { result["packet"] = packet }
|
||||
if let interface = event.interfaceID { result["interface"] = interface.uuidString }
|
||||
if let detail = event.detail { result["detail"] = detail }
|
||||
return result
|
||||
}
|
||||
|
||||
func delivery(_ result: TopologyIPv4DeliveryResult) -> JSON {
|
||||
switch result {
|
||||
case let .delivered(packet, node): return ["type": "delivered", "packet": packet, "node": node.uuidString]
|
||||
case let .icmpError(packet, node, kind):
|
||||
return ["type": "icmpError", "packet": packet, "node": node.uuidString, "kind": kind.rawValue]
|
||||
case let .dropped(packet, node):
|
||||
var json: JSON = ["type": "dropped", "packet": packet]
|
||||
if let node { json["node"] = node.uuidString }
|
||||
return json
|
||||
}
|
||||
}
|
||||
|
||||
func observation(_ item: TopologyRuntimeICMPObservation) -> JSON {
|
||||
[
|
||||
"kind": item.message.kind.rawValue,
|
||||
"identifier": item.message.identifier,
|
||||
"sequence": item.message.sequenceNumber,
|
||||
"sender": item.packet.senderIPAddress,
|
||||
]
|
||||
}
|
||||
|
||||
func run(_ scenario: Scenario) -> JSON {
|
||||
var engine = TopologyNetworkRuntimeEngine(seed: scenario.seed)
|
||||
if let percent = scenario.speedPercent { engine.setSimulationSpeed(percent: percent) }
|
||||
engine.handle(.start(snapshot: snapshot(of: scenario), seed: scenario.seed, initialTimeMilliseconds: 0))
|
||||
|
||||
var results: [Any] = []
|
||||
for step in scenario.steps {
|
||||
switch step.op {
|
||||
case "ping":
|
||||
results.append(delivery(engine.sendICMPEcho(
|
||||
fromNodeID: uuid(step.from!), targetIPAddress: step.target!,
|
||||
timeToLive: step.ttl ?? 64, identifier: step.identifier ?? 1, sequenceNumber: step.sequence ?? 1
|
||||
)))
|
||||
case "traceroute":
|
||||
results.append(engine.traceICMPEcho(
|
||||
fromNodeID: uuid(step.from!), targetIPAddress: step.target!,
|
||||
maximumTimeToLive: step.maxTtl ?? 64, identifier: step.identifier ?? 1
|
||||
).map(observation))
|
||||
case "resolveMac":
|
||||
results.append(engine.resolveMACAddress(nodeID: uuid(step.node!), targetIPAddress: step.target!) ?? NSNull())
|
||||
case "advance":
|
||||
engine.handle(.advance(toMilliseconds: step.to!))
|
||||
results.append(engine.state.currentTimeMilliseconds)
|
||||
case "packetLoss":
|
||||
engine.setGlobalPacketLossEnabled(step.enabled!)
|
||||
results.append(engine.state.globalPacketLossEnabled)
|
||||
case "sat":
|
||||
results.append(engine.switchSATEntries(nodeID: uuid(step.node!)).map {
|
||||
["mac": $0.macAddress, "port": $0.portLabel, "updated": $0.updatedAtMilliseconds] as JSON
|
||||
})
|
||||
case "speed":
|
||||
engine.setSimulationSpeed(percent: step.percent!)
|
||||
results.append(engine.simulationSpeed.percent)
|
||||
default:
|
||||
fatalError("unknown step \(step.op)")
|
||||
}
|
||||
}
|
||||
|
||||
let state = engine.state
|
||||
var arp: JSON = [:]
|
||||
for (node, cache) in state.arpCachesByNodeID {
|
||||
arp[node.uuidString] = cache.mapValues { $0.macAddress }
|
||||
}
|
||||
var switchTables: JSON = [:]
|
||||
for (node, table) in state.switchForwardingTablesByNodeID {
|
||||
switchTables[node.uuidString] = table.mapValues { $0.uuidString }
|
||||
}
|
||||
var observations: JSON = [:]
|
||||
for (node, items) in state.icmpObservationsByNodeID {
|
||||
observations[node.uuidString] = items.map(observation)
|
||||
}
|
||||
return [
|
||||
"results": results,
|
||||
"traces": state.packetTraces.map(trace),
|
||||
"time": state.currentTimeMilliseconds,
|
||||
"pendingEvents": state.pendingEvents.count,
|
||||
"arp": arp,
|
||||
"switchTables": switchTables,
|
||||
"icmpObservations": observations,
|
||||
"firewallDecisions": state.firewallDecisions.map { decision -> JSON in
|
||||
var json: JSON = [
|
||||
"packet": decision.packetIdentity, "node": decision.nodeID.uuidString, "accepted": decision.accepted,
|
||||
]
|
||||
if let rule = decision.ruleIndex { json["rule"] = rule }
|
||||
return json
|
||||
},
|
||||
]
|
||||
}
|
||||
|
||||
// MARK: - Main
|
||||
|
||||
let directory = URL(fileURLWithPath: CommandLine.arguments.dropFirst().first ?? ".")
|
||||
let files = try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil)
|
||||
.filter { $0.lastPathComponent.hasSuffix(".scenario.json") }
|
||||
.sorted { $0.lastPathComponent < $1.lastPathComponent }
|
||||
for file in files {
|
||||
let scenario = try JSONDecoder().decode(Scenario.self, from: Data(contentsOf: file))
|
||||
let output = run(scenario)
|
||||
let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
|
||||
let name = file.lastPathComponent.replacingOccurrences(of: ".scenario.json", with: ".swift.json")
|
||||
try (data + Data("\n".utf8)).write(to: directory.appendingPathComponent(name))
|
||||
print("\(name): \((output["traces"] as? [Any])?.count ?? 0) trace events")
|
||||
}
|
||||
Reference in New Issue
Block a user