M1: Projektgerüst + Connect-Schritt (REST/SSH-Autodetect)

XcodeGen-basiertes SwiftUI-Projekt für den RouterOS-Interview-Assistenten.
Erster Wizard-Schritt: Verbindung zu Mikrotik-Geräten per REST-API
(RouterOS >=7.1) mit SSH-CLI-Fallback für ältere Firmware, Zertifikats-
TOFU-Bestätigung, Zugangsdaten im Keychain. Unit-Tests für CLI-Parser
und Fallback-Logik.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HReLXMbmPvtQ23p1iWiJNW

RouterOSAssistantTests/ConnectionServiceTests.swift

@@ -0,0 +1,78 @@
+import XCTest
+@testable import RouterOSAssistant
+
+private final class MockTransport: RouterOSTransport {
+    let kind: RouterOSTransportKind
+    var connectError: Error?
+    var deviceInfo = RouterDeviceInfo(boardName: "Mock", routerOSVersion: "7.0", architecture: "arm64", uptime: "1h")
+
+    init(kind: RouterOSTransportKind, connectError: Error? = nil) {
+        self.kind = kind
+        self.connectError = connectError
+    }
+
+    func connect() async throws {
+        if let connectError { throw connectError }
+    }
+
+    func fetchDeviceInfo() async throws -> RouterDeviceInfo { deviceInfo }
+    func fetchInterfaces() async throws -> [NetworkInterface] { [] }
+    func disconnect() async {}
+}
+
+@MainActor
+final class ConnectionServiceTests: XCTestCase {
+    private let credentials = RouterOSCredentials(host: "192.168.88.1", username: "admin", password: "")
+
+    func testFallsBackToSSHWhenRestFails() async {
+        let service = ConnectionService()
+        let sshTransport = MockTransport(kind: .ssh)
+
+        await service.connect(
+            with: credentials,
+            makeRestTransport: { MockTransport(kind: .rest, connectError: RouterOSError.transportUnavailable("kein REST")) },
+            makeSSHTransport: { sshTransport }
+        )
+
+        XCTAssertEqual(service.state, .connected(kind: .ssh))
+    }
+
+    func testUsesRestWhenAvailable() async {
+        let service = ConnectionService()
+
+        await service.connect(
+            with: credentials,
+            makeRestTransport: { MockTransport(kind: .rest) },
+            makeSSHTransport: { MockTransport(kind: .ssh) }
+        )
+
+        XCTAssertEqual(service.state, .connected(kind: .rest))
+    }
+
+    func testUntrustedCertificateAsksForConfirmationInsteadOfFallingBackToSSH() async {
+        let service = ConnectionService()
+
+        await service.connect(
+            with: credentials,
+            makeRestTransport: { MockTransport(kind: .rest, connectError: RouterOSError.untrustedCertificate(fingerprint: "AA:BB")) },
+            makeSSHTransport: { MockTransport(kind: .ssh) }
+        )
+
+        XCTAssertEqual(service.state, .needsCertificateConfirmation(fingerprint: "AA:BB"))
+    }
+
+    func testFailsWhenBothTransportsFail() async {
+        let service = ConnectionService()
+
+        await service.connect(
+            with: credentials,
+            makeRestTransport: { MockTransport(kind: .rest, connectError: RouterOSError.transportUnavailable("kein REST")) },
+            makeSSHTransport: { MockTransport(kind: .ssh, connectError: RouterOSError.transportUnavailable("kein SSH")) }
+        )
+
+        guard case .failed = service.state else {
+            XCTFail("Erwarteter Zustand .failed, war \(service.state)")
+            return
+        }
+    }
+}

RouterOSAssistantTests/RouterOSCliParserTests.swift

@@ -0,0 +1,37 @@
+import XCTest
+@testable import RouterOSAssistant
+
+final class RouterOSCliParserTests: XCTestCase {
+    func testParseDeviceInfo() {
+        let raw = """
+                        uptime: 1w2d3h4m5s
+                       version: 7.24.2 (stable)
+              architecture-name: arm64
+                    board-name: RB750Gr3
+        """
+
+        let info = RouterOSCliParser.parseDeviceInfo(raw)
+
+        XCTAssertEqual(info.boardName, "RB750Gr3")
+        XCTAssertEqual(info.routerOSVersion, "7.24.2 (stable)")
+        XCTAssertEqual(info.architecture, "arm64")
+        XCTAssertEqual(info.uptime, "1w2d3h4m5s")
+    }
+
+    func testParseInterfaces() {
+        let raw = """
+        0  R name="ether1" type="ether" mtu=1500 mac-address="AA:BB:CC:DD:EE:01" running=true disabled=no
+        1    name="ether2" type="ether" mtu=1500 mac-address="AA:BB:CC:DD:EE:02" running=false disabled=yes
+        """
+
+        let interfaces = RouterOSCliParser.parseInterfaces(raw)
+
+        XCTAssertEqual(interfaces.count, 2)
+        XCTAssertEqual(interfaces[0].name, "ether1")
+        XCTAssertTrue(interfaces[0].running)
+        XCTAssertFalse(interfaces[0].disabled)
+        XCTAssertEqual(interfaces[1].name, "ether2")
+        XCTAssertFalse(interfaces[1].running)
+        XCTAssertTrue(interfaces[1].disabled)
+    }
+}