A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.
C++
test(postgres): XCTest suite for SSLMode + race fix (PR #43 verification)
Tobibac9bcbf034d
diff --git a/Package.swift b/Package.swiftindex c62aec2..863ccc1 100644--- a/Package.swift+++ b/Package.swift@@ -45,6 +45,7 @@ let package = Package(path: "macos",exclude: ["Resources/Info.plist",+ "Tests",],resources: [.copy("Resources/Gridex.entitlements"),@@ -60,5 +61,10 @@ let package = Package(]),]),+ .testTarget(+ name: "GridexTests",+ dependencies: ["Gridex"],+ path: "macos/Tests/GridexTests"+ ),])diff --git a/macos/Tests/GridexTests/ConnectionRepositoryTests.swift b/macos/Tests/GridexTests/ConnectionRepositoryTests.swiftnew file mode 100644index 0000000..cf32bcf--- /dev/null+++ b/macos/Tests/GridexTests/ConnectionRepositoryTests.swift@@ -0,0 +1,130 @@+// ConnectionRepositoryTests.swift — verifies bug #3 in PR #43:+// the SwiftData entity now persists sslMode + sslKeyPath / sslCertPath / sslCACertPath,+// so a saved mTLS connection survives a "restart" (reload from store).++import XCTest+import SwiftData+@testable import Gridex++@MainActor+final class ConnectionRepositoryTests: XCTestCase {++ private var container: ModelContainer!+ private var repository: SwiftDataConnectionRepository!++ override func setUpWithError() throws {+ let schema = Schema([+ SavedConnectionEntity.self,+ QueryHistoryEntity.self,+ LLMProviderEntity.self,+ ])+ let cfg = ModelConfiguration("test-\(UUID().uuidString)",+ schema: schema,+ isStoredInMemoryOnly: true)+ container = try ModelContainer(for: schema, configurations: [cfg])+ repository = SwiftDataConnectionRepository(modelContainer: container)+ }++ // MARK: - Bug #3 — mTLS cert paths must round-trip++ func test_save_then_fetch_preservesAllCertPaths() async throws {+ let id = UUID()+ let original = ConnectionConfig(+ id: id,+ name: "mTLS Postgres",+ databaseType: .postgresql,+ host: "db.example.com",+ port: 5432,+ database: "app",+ username: "service",+ sslEnabled: true,+ sslMode: .verifyIdentity,+ sslKeyPath: "/Users/me/.teleport/key.pem",+ sslCertPath: "/Users/me/.teleport/cert.pem",+ sslCACertPath: "/Users/me/.teleport/ca.pem"+ )++ try await repository.save(original)+ let restored = try await repository.fetchByID(id)++ XCTAssertNotNil(restored, "saved row must be fetchable")+ XCTAssertEqual(restored?.sslMode, .verifyIdentity, "sslMode lost on round-trip")+ XCTAssertEqual(restored?.sslKeyPath, "/Users/me/.teleport/key.pem",+ "sslKeyPath lost on round-trip — bug #3 regression")+ XCTAssertEqual(restored?.sslCertPath, "/Users/me/.teleport/cert.pem",+ "sslCertPath lost on round-trip — bug #3 regression")+ XCTAssertEqual(restored?.sslCACertPath, "/Users/me/.teleport/ca.pem",+ "sslCACertPath lost on round-trip — bug #3 regression")+ }++ func test_update_preservesAllCertPaths() async throws {+ let id = UUID()+ let initial = ConnectionConfig(+ id: id, name: "first", databaseType: .postgresql,+ host: "h", username: "u", sslEnabled: true, sslMode: .preferred+ )+ try await repository.save(initial)++ // Edit: switch to mTLS by adding cert paths.+ let edited = ConnectionConfig(+ id: id, name: "edited-mtls", databaseType: .postgresql,+ host: "h", username: "u", sslEnabled: true, sslMode: .verifyCA,+ sslKeyPath: "/etc/pg/key.pem",+ sslCertPath: "/etc/pg/cert.pem",+ sslCACertPath: "/etc/pg/root.crt"+ )+ try await repository.update(edited)++ let restored = try await repository.fetchByID(id)+ XCTAssertEqual(restored?.name, "edited-mtls")+ XCTAssertEqual(restored?.sslMode, .verifyCA)+ XCTAssertEqual(restored?.sslKeyPath, "/etc/pg/key.pem",+ "update() dropped sslKeyPath")+ XCTAssertEqual(restored?.sslCertPath, "/etc/pg/cert.pem",+ "update() dropped sslCertPath")+ XCTAssertEqual(restored?.sslCACertPath, "/etc/pg/root.crt",+ "update() dropped sslCACertPath")+ }++ // MARK: - Bug #2 — sslMode persistence++ func test_save_then_fetch_preservesAllFiveSSLModes() async throws {+ let modes: [SSLMode] = [.disabled, .preferred, .required, .verifyCA, .verifyIdentity]+ for mode in modes {+ let id = UUID()+ let cfg = ConnectionConfig(+ id: id, name: mode.rawValue, databaseType: .postgresql,+ host: "h", username: "u",+ sslEnabled: mode != .disabled, sslMode: mode+ )+ try await repository.save(cfg)+ let restored = try await repository.fetchByID(id)+ XCTAssertEqual(restored?.sslMode, mode,+ "sslMode=\(mode) was not persisted correctly")+ XCTAssertEqual(restored?.effectiveSSLMode, mode,+ "effectiveSSLMode mismatch for \(mode)")+ }+ }++ // MARK: - Backward-compat — legacy row (no sslMode column written)++ func test_legacyRow_withoutSSLMode_fallsBackToPreferred() async throws {+ // Simulate a row saved by pre-PR Gridex: sslEnabled set, sslMode field nil.+ // The repository writes whatever the config has; pre-PR config wouldn't+ // have set sslMode at all → entity sslMode column stays nil.+ let id = UUID()+ let legacy = ConnectionConfig(+ id: id, name: "legacy", databaseType: .postgresql,+ host: "h", username: "u",+ sslEnabled: true, sslMode: nil // pre-PR shape+ )+ try await repository.save(legacy)+ let restored = try await repository.fetchByID(id)++ XCTAssertNil(restored?.sslMode,+ "legacy row must keep sslMode=nil, not silently upgrade")+ XCTAssertTrue(restored?.sslEnabled == true)+ XCTAssertEqual(restored?.effectiveSSLMode, .preferred,+ "legacy sslEnabled=true must read back as .preferred (matches pre-PR adapter)")+ }+}diff --git a/macos/Tests/GridexTests/PostgreSQLAdapterIntegrationTests.swift b/macos/Tests/GridexTests/PostgreSQLAdapterIntegrationTests.swiftnew file mode 100644index 0000000..a83f99d--- /dev/null+++ b/macos/Tests/GridexTests/PostgreSQLAdapterIntegrationTests.swift@@ -0,0 +1,208 @@+// PostgreSQLAdapterIntegrationTests.swift+//+// Integration tests for PR #43 against two local Postgres instances:+// :55434 ssl=off (no-SSL)+// :55435 ssl=on (cert CN=localhost, signed by /tmp/gridex-pg-certs/ca.crt)+//+// Skipped automatically when those instances aren't reachable (CI / dev machines+// without test PG running). To bring them up locally, see scripts/test-pg-setup.sh+// (added in this PR) or the inline shell in PR #43's review thread.++import XCTest+@testable import Gridex++final class PostgreSQLAdapterIntegrationTests: XCTestCase {++ // MARK: - Endpoints++ private let noSSLPort = 5432 // :55434 in shell, but Swift tests open it via 127.0.0.1+ private let sslPort = 5432 // overridden below+ private let caPath = "/tmp/gridex-pg-certs/ca.crt"++ private func makeBaseConfig(host: String, port: Int, sslMode: SSLMode,+ caPath: String? = nil) -> ConnectionConfig {+ ConnectionConfig(+ id: UUID(),+ name: "test",+ databaseType: .postgresql,+ host: host,+ port: port,+ database: "postgres",+ username: "postgres",+ sslEnabled: sslMode != .disabled,+ sslMode: sslMode,+ sslCACertPath: caPath+ )+ }++ private func skipIfNoServer(port: Int) throws {+ // Fast TCP probe — skip the test if the test PG isn't running.+ let s = socket(AF_INET, SOCK_STREAM, 0)+ defer { close(s) }+ var addr = sockaddr_in()+ addr.sin_family = sa_family_t(AF_INET)+ addr.sin_port = in_port_t(port).bigEndian+ addr.sin_addr.s_addr = inet_addr("127.0.0.1")+ let rc = withUnsafePointer(to: &addr) { ptr -> Int32 in+ ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in+ connect(s, sa, socklen_t(MemoryLayout<sockaddr_in>.size))+ }+ }+ try XCTSkipIf(rc != 0,+ "PG not reachable on 127.0.0.1:\(port) — skipping integration test")+ }++ // MARK: - Mode × server matrix++ // ---- vs no-SSL server (:55434) ----++ func test_disabled_vs_noSSLServer_succeeds() async throws {+ try skipIfNoServer(port: 55434)+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434, sslMode: .disabled)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected)+ try await adapter.disconnect()+ }++ func test_preferred_vs_noSSLServer_succeeds_overPlaintext() async throws {+ try skipIfNoServer(port: 55434)+ // libpq prefer: try TLS, fall back to plaintext when server refuses.+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434, sslMode: .preferred)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected, "preferred must fall back to plaintext")+ try await adapter.disconnect()+ }++ func test_required_vs_noSSLServer_FAILS() async throws {+ try skipIfNoServer(port: 55434)+ // libpq REQUIRED must reject a server that can't TLS.+ // This is the security regression PR #43 is fixing — pre-PR it silently+ // succeeded over plaintext because adapter used .prefer(tls).+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434, sslMode: .required)+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try? await adapter.disconnect()+ XCTFail("REQUIRED must reject a server with ssl=off; pre-PR this silently succeeded over plaintext")+ } catch {+ // expected+ }+ }++ func test_verifyCA_vs_noSSLServer_FAILS() async throws {+ try skipIfNoServer(port: 55434)+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434,+ sslMode: .verifyCA, caPath: caPath)+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try? await adapter.disconnect()+ XCTFail("VERIFY_CA must reject a server with ssl=off")+ } catch { /* expected */ }+ }++ func test_verifyIdentity_vs_noSSLServer_FAILS() async throws {+ try skipIfNoServer(port: 55434)+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434,+ sslMode: .verifyIdentity, caPath: caPath)+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try? await adapter.disconnect()+ XCTFail("VERIFY_IDENTITY must reject a server with ssl=off")+ } catch { /* expected */ }+ }++ // ---- vs SSL server (:55435) ----++ func test_disabled_vs_SSLServer_works() async throws {+ try skipIfNoServer(port: 55435)+ // PG with ssl=on still accepts plaintext clients by default (pg_hba allows both).+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55435, sslMode: .disabled)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected)+ try await adapter.disconnect()+ }++ func test_required_vs_SSLServer_succeeds() async throws {+ try skipIfNoServer(port: 55435)+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55435, sslMode: .required)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected)+ try await adapter.disconnect()+ }++ func test_verifyCA_withCorrectCA_succeeds_evenAtIPHost() async throws {+ try skipIfNoServer(port: 55435)+ // verifyCA: chain must validate, but hostname mismatch is OK+ // (cert is for "localhost", connecting via "127.0.0.1").+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55435,+ sslMode: .verifyCA, caPath: caPath)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected)+ try await adapter.disconnect()+ }++ func test_verifyIdentity_withMismatchedHostname_FAILS() async throws {+ try skipIfNoServer(port: 55435)+ // Cert CN=localhost, connect via 127.0.0.1 → must reject (matches psql verify-full).+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55435,+ sslMode: .verifyIdentity, caPath: caPath)+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try? await adapter.disconnect()+ XCTFail("VERIFY_IDENTITY must reject when host doesn't match cert SAN/CN")+ } catch { /* expected */ }+ }++ func test_verifyIdentity_withMatchingHostname_succeeds() async throws {+ try skipIfNoServer(port: 55435)+ let cfg = makeBaseConfig(host: "localhost", port: 55435,+ sslMode: .verifyIdentity, caPath: caPath)+ let adapter = PostgreSQLAdapter()+ try await adapter.connect(config: cfg, password: nil)+ XCTAssertTrue(adapter.isConnected)+ try await adapter.disconnect()+ }++ func test_verifyCA_withWrongCA_FAILS() async throws {+ try skipIfNoServer(port: 55435)+ // Provide an unrelated cert as the CA — must reject.+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55435,+ sslMode: .verifyCA,+ caPath: "/tmp/gridex-pg-certs/server-wrongcn.crt")+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try? await adapter.disconnect()+ XCTFail("VERIFY_CA must reject when supplied CA does not sign the server cert")+ } catch { /* expected */ }+ }++ // MARK: - Bug #1 — race fix++ func test_connect_doesNotRaiseConnectionPoolError_under_repeatedRapidConnects() async throws {+ try skipIfNoServer(port: 55434)+ // Pre-PR: spawning Task { run() } and immediately querying could surface+ // _ConnectionPoolModule.ConnectionPoolError on slow handshakes.+ // Repeat 20 times; if even one fails for a reason other than expected+ // server-side error, the gate didn't hold.+ for i in 1...20 {+ let cfg = makeBaseConfig(host: "127.0.0.1", port: 55434, sslMode: .disabled)+ let adapter = PostgreSQLAdapter()+ do {+ try await adapter.connect(config: cfg, password: nil)+ try await adapter.disconnect()+ } catch {+ XCTFail("iteration \(i) raised: \(error)")+ return+ }+ }+ }+}diff --git a/macos/Tests/GridexTests/SSLModeFallbackTests.swift b/macos/Tests/GridexTests/SSLModeFallbackTests.swiftnew file mode 100644index 0000000..60fed3a--- /dev/null+++ b/macos/Tests/GridexTests/SSLModeFallbackTests.swift@@ -0,0 +1,98 @@+// SSLModeFallbackTests.swift — pure-logic tests for ConnectionConfig.effectiveSSLMode.+// Verifies the back-compat ladder added in PR #43 / incident 6a4aad0.++import XCTest+@testable import Gridex++final class SSLModeFallbackTests: XCTestCase {++ // MARK: - effectiveSSLMode++ func test_effectiveSSLMode_prefersExplicitMode_overLegacyBool() {+ // Explicit sslMode wins regardless of legacy sslEnabled.+ let cases: [(SSLMode, Bool)] = [+ (.disabled, true),+ (.preferred, true),+ (.required, false),+ (.verifyCA, true),+ (.verifyIdentity, false),+ ]+ for (mode, legacy) in cases {+ let cfg = makeConfig(sslEnabled: legacy, sslMode: mode)+ XCTAssertEqual(cfg.effectiveSSLMode, mode,+ "explicit sslMode=\(mode) must win over sslEnabled=\(legacy)")+ }+ }++ func test_effectiveSSLMode_legacyTrue_mapsToPreferred() {+ // Pre-PR rows: sslEnabled=true / sslMode=nil → adapter used .prefer(tls).+ // effectiveSSLMode must preserve that exact behavior, not silently upgrade+ // to .required (would break users on servers without TLS).+ let cfg = makeConfig(sslEnabled: true, sslMode: nil)+ XCTAssertEqual(cfg.effectiveSSLMode, .preferred)+ }++ func test_effectiveSSLMode_legacyFalse_mapsToDisabled() {+ let cfg = makeConfig(sslEnabled: false, sslMode: nil)+ XCTAssertEqual(cfg.effectiveSSLMode, .disabled)+ }++ // MARK: - Codable back-compat++ func test_codable_decodesLegacyJSON_withoutSSLMode() throws {+ // A JSON payload as it would have looked before sslMode existed.+ let legacyJSON = """+ {+ "id": "00000000-0000-0000-0000-000000000001",+ "name": "Legacy",+ "databaseType": "postgresql",+ "host": "127.0.0.1",+ "port": 5432,+ "username": "postgres",+ "sslEnabled": true,+ "mcpMode": "locked"+ }+ """.data(using: .utf8)!++ let decoded = try JSONDecoder().decode(ConnectionConfig.self, from: legacyJSON)+ XCTAssertNil(decoded.sslMode, "missing field decodes as nil, not a default")+ XCTAssertTrue(decoded.sslEnabled)+ XCTAssertEqual(decoded.effectiveSSLMode, .preferred,+ "legacy sslEnabled=true must continue to behave as .preferred")+ }++ func test_codable_roundTripsExplicitMode() throws {+ let original = makeConfig(sslEnabled: true, sslMode: .verifyIdentity,+ certPaths: (key: "/tmp/k.pem", cert: "/tmp/c.pem", ca: "/tmp/ca.pem"))+ let data = try JSONEncoder().encode(original)+ let restored = try JSONDecoder().decode(ConnectionConfig.self, from: data)+ XCTAssertEqual(restored.sslMode, .verifyIdentity)+ XCTAssertEqual(restored.effectiveSSLMode, .verifyIdentity)+ XCTAssertEqual(restored.sslKeyPath, "/tmp/k.pem")+ XCTAssertEqual(restored.sslCertPath, "/tmp/c.pem")+ XCTAssertEqual(restored.sslCACertPath, "/tmp/ca.pem")+ }++ // MARK: - Helpers++ private func makeConfig(+ sslEnabled: Bool,+ sslMode: SSLMode?,+ certPaths: (key: String?, cert: String?, ca: String?) = (nil, nil, nil)+ ) -> ConnectionConfig {+ ConnectionConfig(+ id: UUID(),+ name: "test",+ databaseType: .postgresql,+ host: "127.0.0.1",+ port: 5432,+ database: "postgres",+ username: "postgres",+ sslEnabled: sslEnabled,+ sslMode: sslMode,+ sslKeyPath: certPaths.key,+ sslCertPath: certPaths.cert,+ sslCACertPath: certPaths.ca+ )+ }+}