Skip to content

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.swift
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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
+ )
+ }
+}