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++
Merge main into codex/feat-69-redis-key-tree
Tobi47c7111aaa4e
diff --cc CHANGELOG.mdindex fa5c141,9c1a58b..870d626--- a/CHANGELOG.md+++ b/CHANGELOG.md@@@ -4,9 -4,10 +4,13 @@@ All notable changes to Gridex are docum## [Unreleased]+### Added+- **Redis namespace key tree (macOS)** — Redis keys can be browsed as a collapsible sidebar tree using a local configurable delimiter (default `:`). Leaf keys open the existing detail view; the flat SCAN-filtered key list remains available.++ ### Fixed+ - **macOS data grids** — Reloading data with Command-R retains the selected column and ascending/descending server-side sort.+ - **macOS tabs** — Clicking a tab reliably activates it; Control-Tab and Control-Shift-Tab cycle forward/backward; tab close controls retain their expected left/middle-click behavior.+ - **macOS MySQL passwordless accounts** — Blank passwords now authenticate correctly for non-TLS caching_sha2_password accounts.## [0.23.0] - 2026-04-12### Addeddiff --cc macos/App/State/AppState.swiftindex 0a47d93,13b5945..35e162d--- a/macos/App/State/AppState.swift+++ b/macos/App/State/AppState.swift@@@ -59,11 -64,11 +64,13 @@@ final class AppState: ObservableObject// MARK: - Connection State@Published var activeConnectionId: UUID?- @Published var activeAdapter: (any DatabaseAdapter)?+ @Published var activeAdapter: (any DatabaseAdapter)? {+ didSet { rotateRedisSession(for: activeAdapter) }+ }@Published var activeConfig: ConnectionConfig?@Published var sidebarItems: [SidebarItem] = []+ @Published private(set) var sidebarSchemas: [String] = []+ @Published var selectedSidebarSchema: String?@Published var connectionTitle: String = "Gridex"@Published var isConnecting: Bool = false@Published var connectionError: String?@@@ -271,7 -200,7 +310,8 @@@let schema: String?var databaseName: String?var initialViewMode: String? // "data" or "structure"- var redisContext: RedisTabContext?++ var redisContext: RedisTabContext? = nil+ var sidebarItemType: SidebarItemType? = nil}struct TabGroup: Identifiable {@@@ -384,12 -308,9 +424,12 @@@connectionTitle = "Gridex — \(config.name)"statusConnection = config.displayHostisConnecting = false+ let redisMetadataToken = config.databaseType == .redis+ ? currentRedisSessionRevisionToken+ : nil// Load sidebar immediately (most important for user)- await loadSidebar(config: config, adapter: connection.adapter)+ await reloadSidebar(config: config, adapter: connection.adapter)// Fetch metadata in background — all parallelTask { [weak self] in@@@ -472,19 -373,140 +512,189 @@@}}+ func loadSidebar(config: ConnectionConfig, adapter: any DatabaseAdapter) async {+ if config.databaseType == .redis {++ if refreshRedisSidebar(config: config, adapter: adapter) {++ return++ }++ guard activeConnectionId == nil,++ activeConfig == nil,++ activeAdapter == nil else { return }++ sidebarLoadGeneration &+= 1++ pendingSidebarReload = nil++ publishedSidebarContext = nil++ publishedSidebarSnapshot = nil++ selectedSidebarItem = nil++ selectedSidebarItemSchema = nil++ sidebarSchemas = []++ selectedSidebarSchema = nil+ sidebarItems = []+ requestRedisKeyBrowserRefresh()+ return+ }++ await reloadSidebar(config: config, adapter: adapter)++ }+++ func loadSidebarSchemas(+ config: ConnectionConfig,+ adapter: any DatabaseAdapter,+ preferredSchema: String? = nil+ ) async -> SidebarReloadHandle? {+ guard let reload = await prepareSidebarReload(+ config: config,+ adapter: adapter,+ preferredSchema: preferredSchema+ ) else { return nil }+ pendingSidebarReload = reload+ return SidebarReloadHandle(generation: reload.generation)+ }++ func loadSidebar(+ config: ConnectionConfig,+ adapter: any DatabaseAdapter,+ schema: String? = nil,+ using handle: SidebarReloadHandle?+ ) async {+ let connection = sidebarConnectionContext(config: config, adapter: adapter)+ guard let handle,+ var reload = pendingSidebarReload,+ reload.generation == handle.generation,+ reload.connection == connection,+ isCurrentSidebarReload(reload) else { return }++ // Consume the exact prepared operation before any item query suspends.+ // A duplicate or superseded caller can no longer reuse this token.+ pendingSidebarReload = nil+ if let schema,+ config.databaseType == .postgresql,+ reload.schemas.contains(schema) {+ reload.schema = schema+ }+ await loadSidebarItems(using: reload, adapter: adapter)+ }++ private func reloadSidebar(+ config: ConnectionConfig,+ adapter: any DatabaseAdapter,+ preferredSchema: String? = nil+ ) async {+ guard let reload = await prepareSidebarReload(+ config: config,+ adapter: adapter,+ preferredSchema: preferredSchema+ ) else { return }+ await loadSidebarItems(using: reload, adapter: adapter)+ }++ private func prepareSidebarReload(+ config: ConnectionConfig,+ adapter: any DatabaseAdapter,+ preferredSchema: String?+ ) async -> SidebarReload? {++ if config.databaseType == .redis {++ refreshRedisSidebar(config: config, adapter: adapter)++ return nil++ }+++ guard var reload = beginSidebarReload(+ config: config,+ adapter: adapter,+ preferredSchema: preferredSchema+ ) else { return nil }++ do {+ let schemas: [String]+ if config.databaseType == .postgresql {+ schemas = Array(Set(try await adapter.listSchemas(database: config.database))).sorted()+ } else {+ schemas = []+ }++ guard isCurrentSidebarReload(reload) else { return nil }+ reload.schemas = schemas+ reload.schema = SidebarSchemaSelection.resolve(+ previous: reload.requestedSchema,+ for: config.databaseType,+ schemas: schemas+ )+ return reload+ } catch {+ guard isCurrentSidebarReload(reload) else { return nil }+ publishSidebarSnapshot(reload.previous, using: reload)+ print("Sidebar schema load error: \(error)")+ return nil+ }+ }+++ @discardableResult++ private func refreshRedisSidebar(++ config: ConnectionConfig,++ adapter: any DatabaseAdapter++ ) -> Bool {++ let connection = sidebarConnectionContext(config: config, adapter: adapter)++ guard isActiveSidebarConnection(connection) else { return false }++++ sidebarLoadGeneration &+= 1++ pendingSidebarReload = nil++ selectedSidebarItem = nil++ selectedSidebarItemSchema = nil++ sidebarSchemas = []++ selectedSidebarSchema = nil++ sidebarItems = []++ publishedSidebarContext = connection++ publishedSidebarSnapshot = .empty++ requestRedisKeyBrowserRefresh()++ return true++ }+++ private func beginSidebarReload(+ config: ConnectionConfig,+ adapter: any DatabaseAdapter,+ preferredSchema: String?+ ) -> SidebarReload? {+ let connection = sidebarConnectionContext(config: config, adapter: adapter)+ guard isActiveSidebarConnection(connection) else { return nil }++ let requestedSchema = preferredSchema ?? selectedSidebarSchema+ let previous: SidebarSnapshot+ if publishedSidebarContext == connection, let publishedSidebarSnapshot {+ previous = publishedSidebarSnapshot+ } else {+ previous = .empty+ }++ let connectionChanged = publishedSidebarContext != connection+ sidebarLoadGeneration &+= 1+ pendingSidebarReload = nil+ let reload = SidebarReload(+ generation: sidebarLoadGeneration,+ connection: connection,+ requestedSchema: requestedSchema,+ previous: previous,+ schemas: [],+ schema: nil+ )+ guard isCurrentSidebarReload(reload) else { return nil }+ if connectionChanged {+ selectedSidebarItem = nil+ selectedSidebarItemSchema = nil+ }+ guard publishSidebarSnapshot(previous, using: reload) else { return nil }+ return reload+ }++ private func loadSidebarItems(+ using reload: SidebarReload,+ adapter: any DatabaseAdapter+ ) async {+ guard isCurrentSidebarReload(reload) else { return }+ let schema = reload.schemado {- // Run all queries in parallel instead of sequential- async let tablesTask = adapter.listTables(schema: nil)- async let viewsTask = adapter.listViews(schema: nil)- async let functionsTask = adapter.listFunctions(schema: nil)- async let proceduresTask = adapter.listProcedures(schema: nil)+ async let tablesTask = adapter.listTables(schema: schema)+ async let viewsTask = adapter.listViews(schema: schema)+ async let functionsTask = adapter.listFunctions(schema: schema)+ async let proceduresTask = adapter.listProcedures(schema: schema)let tables = try await tablesTasklet views = try await viewsTask@@@ -1295,15 -773,25 +1572,34 @@@if let db = currentDatabaseName { ensureTabGroup(for: db) }}+ func rebindRedisQueryTab(id: UUID, to context: RedisTabContext) {+ guard let index = tabs.firstIndex(where: {+ $0.id == id && $0.type == .queryEditor && $0.redisContext != nil+ }) else { return }+ tabs[index].databaseName = context.databaseName+ tabs[index].redisContext = context+ ensureTabGroup(for: context.databaseName)+ }++ func selectTab(id: UUID) {+ guard tabs.contains(where: { $0.id == id }) else { return }+ activeTabId = id+ }++ func selectNextTab() {+ guard let activeTabId,+ let index = tabs.firstIndex(where: { $0.id == activeTabId }),+ tabs.count > 1 else { return }+ self.activeTabId = tabs[(index + 1) % tabs.count].id+ }++ func selectPreviousTab() {+ guard let activeTabId,+ let index = tabs.firstIndex(where: { $0.id == activeTabId }),+ tabs.count > 1 else { return }+ self.activeTabId = tabs[(index - 1 + tabs.count) % tabs.count].id+ }+func closeTab(id: UUID) {tabs.removeAll { $0.id == id }if let state = dataGridCache.removeValue(forKey: id) {@@@ -1489,13 -981,15 +1792,21 @@@redisDBSize = nil}- func refreshSidebar() {+ func refreshSidebar(preferredSchema: String? = nil) {guard let adapter = activeAdapter, let config = activeConfig else { return }+ if config.databaseType == .redis {- requestRedisKeyBrowserRefresh()++ if !refreshRedisSidebar(config: config, adapter: adapter) {++ requestRedisKeyBrowserRefresh()++ }+ return+ }- Task { await loadSidebar(config: config, adapter: adapter) }+ Task {+ await reloadSidebar(+ config: config,+ adapter: adapter,+ preferredSchema: preferredSchema+ )+ }}/// Re-fetch the database list from the active adapter and publish it.diff --cc macos/Presentation/Views/DataGrid/DataGridView.swiftindex d778f7b,e0e8f05..e70e72d--- a/macos/Presentation/Views/DataGrid/DataGridView.swift+++ b/macos/Presentation/Views/DataGrid/DataGridView.swift@@@ -484,118 -480,129 +530,231 @@@ final class DataGridViewState: Observabstatic func clearMetadataCache() {metadataCache.removeAll()+ metadataCacheGenerations.removeAll()+ metadataPublicationEpochs.removeAll()}+ func bindRedisContext(_ context: AppState.RedisTabContext) {+ // Redis's flat key grid never owns an editable Details callback. Clear+ // any SQL grid selection even when this cached grid is rebound to the+ // same context (for example when reopening its existing tab).+ appState?.selectedRowDetails = nil+ appState?.onDetailFieldEdit = nil++ guard redisContext != context else { return }++ redisRequestCoordinator.invalidate()+ redisContext = context+ adapter = nil+ columns = []+ rows = []+ totalRows = 0+ currentPage = 0+ isLoading = false+ executionTime = 0+ errorMessage = nil+ tableDescription = nil+ primaryKeyColumns = []+ foreignKeyColumns = [:]+ foreignKeyRefColumns = [:]+ columnDefaults = [:]+ columnEnumValues = [:]+ selectedRows = []+ editingCell = nil+ insertedRowIndices = []+ columnWidths = [:]+ displayCache = []+ changeTracker.discardAll()+ commitSQL = []+ commitError = nil+ showCommitPreview = false+ isCommitting = false+ }++ func performRedisLoad(+ in context: AppState.RedisTabContext,+ page: Int = 0,+ execute: () async -> Result<QueryResult, Error>?+ ) async {+ guard redisContext == context else { return }++ isLoading = true+ totalRows = 0+ errorMessage = nil++ switch await redisRequestCoordinator.perform(for: context, execute: execute) {+ case .current(.success(let result)):+ guard redisContext == context else { return }+ columns = result.columns+ rows = result.rows+ rebuildDisplayCache()+ totalRows = 0+ currentPage = page+ executionTime = result.executionTime+ errorMessage = nil+ computeColumnWidths(columns: result.columns, rows: result.rows)+ isLoading = false+ case .current(.failure(let error)):+ guard redisContext == context else { return }+ totalRows = 0+ errorMessage = (error as? LocalizedError)?.errorDescription+ ?? error.localizedDescription+ isLoading = false+ case .stale:+ guard redisContext == context else { return }+ totalRows = 0+ isLoading = false+ case .superseded:+ break+ }+ }+struct CellID: Equatable {let row: Intlet col: Int}- func load(tableName: String, schema: String?, adapter: (any DatabaseAdapter)?) async {+ private var effectiveSortDescriptors: [QuerySortDescriptor]? {+ if let column = sortColumn {+ return [QuerySortDescriptor(+ column: column,+ direction: sortAscending ? .ascending : .descending+ )]+ }+ if let primaryKey = primaryKeyColumns.first {+ return [QuerySortDescriptor(column: primaryKey, direction: .ascending)]+ }+ return nil+ }++ private func nextLoadGeneration() -> Int {+ loadGeneration += 1+ return loadGeneration+ }++ private func beginLoading(for generation: Int) {+ loadingGeneration = generation+ isLoading = true+ }++ private func finishLoading(for generation: Int) {+ guard loadingGeneration == generation else { return }+ loadingGeneration = nil+ isLoading = false+ }++ private func isCurrentMetadataScope(cacheKey: MetadataCacheKey, cacheGeneration: Int) -> Bool {+ guard let adapter else { return false }+ let currentCacheKey = metadataCacheKey(+ adapter: adapter,+ tableName: tableName,+ schema: schema+ )+ return currentCacheKey == cacheKey+ && Self.metadataCacheGenerations[cacheKey, default: 0] == cacheGeneration+ }++ private func isCurrentMetadataPublication(+ cacheKey: MetadataCacheKey,+ cacheGeneration: Int,+ publicationEpoch: Int+ ) -> Bool {+ isCurrentMetadataScope(cacheKey: cacheKey, cacheGeneration: cacheGeneration)+ && Self.metadataPublicationEpochs[cacheKey, default: 0] == publicationEpoch+ }++ private func isCurrentRowRequest(_ generation: Int, cacheKey: MetadataCacheKey, cacheGeneration: Int) -> Bool {+ generation == loadGeneration+ && isCurrentMetadataScope(cacheKey: cacheKey, cacheGeneration: cacheGeneration)+ }++ private func continueIfCurrentRowRequest(+ _ generation: Int,+ cacheKey: MetadataCacheKey,+ cacheGeneration: Int+ ) -> Bool {+ guard isCurrentRowRequest(+ generation,+ cacheKey: cacheKey,+ cacheGeneration: cacheGeneration+ ) else {+ finishLoading(for: generation)+ return false+ }+ return true+ }++ private static func invalidateMetadataCache(for key: MetadataCacheKey) -> Int {+ metadataCache.removeValue(forKey: key)+ metadataCacheGenerations[key, default: 0] += 1+ return metadataCacheGenerations[key, default: 0]+ }++ private static func nextMetadataPublicationEpoch(for key: MetadataCacheKey) -> Int {+ metadataPublicationEpochs[key, default: 0] &+= 1+ return metadataPublicationEpochs[key, default: 0]+ }++ func load(+ tableName: String,+ schema: String?,+ adapter: (any DatabaseAdapter)?,+ prefetchedDescription: TableDescription? = nil,+ generation: Int? = nil,+ cacheGeneration: Int? = nil,+ metadataPublicationEpoch: Int? = nil+ ) async {guard let adapter else { return }- self.adapter = adapter- self.tableName = tableName- self.schema = schema++ if redisContext != nil || adapter.databaseType == .redis {++ self.adapter = adapter++ self.tableName = tableName++ self.schema = schema+ guard let redisContext, let appState else {+ totalRows = 0+ isLoading = false+ return+ }+ let request = RowFetchRequest(+ table: tableName,+ schema: schema,+ columns: nil,+ filter: activeFilter,+ orderBy: nil,+ limit: pageSize,+ offset: 0+ )+ await performRedisLoad(in: redisContext, page: 0) {+ await appState.performRedisOperation(for: redisContext) { redis in+ try await self.redisRowFetcher(redis, request)+ }+ }+ return+ }+- isLoading = true+ let requestGeneration: Int+ if let generation {+ requestGeneration = generation+ } else {+ requestGeneration = nextLoadGeneration()+ latestPageRequest = nil+ self.adapter = adapter+ self.tableName = tableName+ self.schema = schema+ }+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)+ let requestCacheGeneration = cacheGeneration ?? Self.metadataCacheGenerations[requestCacheKey, default: 0]+ let requestMetadataPublicationEpoch = metadataPublicationEpoch+ ?? Self.nextMetadataPublicationEpoch(for: requestCacheKey)+ guard isCurrentMetadataPublication(+ cacheKey: requestCacheKey,+ cacheGeneration: requestCacheGeneration,+ publicationEpoch: requestMetadataPublicationEpoch+ ) else {+ finishLoading(for: requestGeneration)+ return+ }+ let requestFilter = activeFilter// Apply cache immediately if available (before any query)let hasCachedMeta: Bool@@@ -718,10 -775,18 +927,19 @@@}func reloadStructure() async {+ guard redisContext == nil else { return }guard let adapter else { return }+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)+ let requestCacheGeneration = Self.metadataCacheGenerations[requestCacheKey, default: 0]+ let requestMetadataPublicationEpoch = Self.nextMetadataPublicationEpoch(for: requestCacheKey)do {- tableDescription = try await adapter.describeTable(name: tableName, schema: schema)+ let description = try await adapter.describeTable(name: tableName, schema: schema)+ guard isCurrentMetadataPublication(+ cacheKey: requestCacheKey,+ cacheGeneration: requestCacheGeneration,+ publicationEpoch: requestMetadataPublicationEpoch+ ) else { return }+ tableDescription = description} catch {// Structure reload error — silently ignore}@@@ -729,50 -794,107 +947,144 @@@/// Invalidate cache and reload everything (after structure changes like ADD COLUMN)func reloadAfterStructureChange() async {- if redisContext == nil {- Self.metadataCache.removeValue(forKey: cacheKey)- }guard let adapter else { return }- await load(tableName: tableName, schema: schema, adapter: adapter)++ if redisContext != nil || adapter.databaseType == .redis {++ await loadPage(0)++ return++ }+ let requestTableName = tableName+ let requestSchema = schema+ let previousPrimaryKeyColumns = primaryKeyColumns+ let requestGeneration = nextLoadGeneration()+ latestPageRequest = nil+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: requestTableName, schema: requestSchema)+ let requestCacheGeneration = Self.invalidateMetadataCache(for: requestCacheKey)+ let requestMetadataPublicationEpoch = Self.nextMetadataPublicationEpoch(for: requestCacheKey)+ beginLoading(for: requestGeneration)++ let description: TableDescription+ var rowReplayRequest: PageRequest?+ do {+ description = try await adapter.describeTable(name: requestTableName, schema: requestSchema)+ guard isCurrentMetadataPublication(+ cacheKey: requestCacheKey,+ cacheGeneration: requestCacheGeneration,+ publicationEpoch: requestMetadataPublicationEpoch+ ) else {+ finishLoading(for: requestGeneration)+ return+ }+ let refreshedPrimaryKeyColumns = description.columns.filter { $0.isPrimaryKey }.map { $0.name }+ let hasInvalidExplicitSort = sortColumn.map { sortColumn in+ !description.columns.contains(where: { $0.name == sortColumn })+ } ?? false+ let hasChangedImplicitSort = sortColumn == nil+ && previousPrimaryKeyColumns != refreshedPrimaryKeyColumns+ if requestGeneration != loadGeneration,+ (hasInvalidExplicitSort || hasChangedImplicitSort),+ let latestPageRequest,+ latestPageRequest.generation == loadGeneration {+ rowReplayRequest = latestPageRequest+ }++ self.primaryKeyColumns = refreshedPrimaryKeyColumns+ self.tableDescription = description+ if let sortColumn, hasInvalidExplicitSort {+ pendingProgrammaticSortClear = ProgrammaticSortClear(+ clearedColumn: sortColumn+ )+ self.sortColumn = nil+ }+ } catch {+ guard isCurrentMetadataPublication(+ cacheKey: requestCacheKey,+ cacheGeneration: requestCacheGeneration,+ publicationEpoch: requestMetadataPublicationEpoch+ ) else {+ finishLoading(for: requestGeneration)+ return+ }+ errorMessage = Self.detailedErrorMessage(error)+ finishLoading(for: requestGeneration)+ return+ }++ await load(+ tableName: requestTableName,+ schema: requestSchema,+ adapter: adapter,+ prefetchedDescription: description,+ generation: requestGeneration,+ cacheGeneration: requestCacheGeneration,+ metadataPublicationEpoch: requestMetadataPublicationEpoch+ )++ if let rowReplayRequest,+ rowReplayRequest.generation == loadGeneration,+ isCurrentMetadataPublication(+ cacheKey: requestCacheKey,+ cacheGeneration: requestCacheGeneration,+ publicationEpoch: requestMetadataPublicationEpoch+ ) {+ await loadPage(rowReplayRequest.page)+ }+ }++ func handleSortColumnChange(from previousSortColumn: String?, to sortColumn: String?) async {+ if let pendingProgrammaticSortClear {+ self.pendingProgrammaticSortClear = nil+ if previousSortColumn == pendingProgrammaticSortClear.clearedColumn,+ sortColumn == nil {+ return+ }+ }+ await loadPage(0)+ }++ func handleSortColumnChange(_ sortColumn: String?) async {+ await handleSortColumnChange(from: pendingProgrammaticSortClear?.clearedColumn, to: sortColumn)}func loadPage(_ page: Int) async {guard let adapter else { return }++ if redisContext != nil || adapter.databaseType == .redis {+ guard let redisContext, let appState else {+ totalRows = 0+ isLoading = false+ return+ }+ let offset = page * pageSize+ let sort: [QuerySortDescriptor]? = if let col = sortColumn {+ [QuerySortDescriptor(+ column: col,+ direction: sortAscending ? .ascending : .descending+ )]+ } else {+ nil+ }+ let request = RowFetchRequest(+ table: tableName,+ schema: schema,+ columns: nil,+ filter: activeFilter,+ orderBy: sort,+ limit: pageSize,+ offset: offset+ )+ await performRedisLoad(in: redisContext, page: page) {+ await appState.performRedisOperation(for: redisContext) { redis in+ try await self.redisRowFetcher(redis, request)+ }+ }+ return+ }+- isLoading = true- defer { isLoading = false }+ let requestGeneration = nextLoadGeneration()+ latestPageRequest = PageRequest(generation: requestGeneration, page: page)+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)+ let requestCacheGeneration = Self.metadataCacheGenerations[requestCacheKey, default: 0]+ beginLoading(for: requestGeneration)do {let offset = page * pageSizediff --cc macos/Tests/GridexTests/RedisAppStateTests.swiftindex 5618652,0000000..8091f1amode 100644,000000..100644--- a/macos/Tests/GridexTests/RedisAppStateTests.swift+++ b/macos/Tests/GridexTests/RedisAppStateTests.swift@@@ -1,1405 -1,0 +1,1441 @@@+// RedisAppStateTests.swift+// Gridex++import XCTest+@testable import Gridex++@MainActor+final class RedisAppStateTests: XCTestCase {++ func test_requestRedisKeyBrowserRefresh_incrementsNonce() {+ let state = AppState()+ let originalNonce = state.redisKeyBrowserRefreshNonce++ state.requestRedisKeyBrowserRefresh()++ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)+ }++ func test_loadSidebar_forRedisClearsGenericItemsAndRequestsBrowserRefresh() async {+ let state = AppState()++ let config = redisConfig()++ let adapter = RedisAdapter()++ state.activeConnectionId = config.id++ state.activeConfig = config++ state.activeAdapter = adapter+ state.sidebarItems = [+ SidebarItem(title: "Legacy", type: .group("legacy"))+ ]++ state.selectedSidebarSchema = "legacy"++ state.selectSidebarItem(.table("Legacy"), schema: "legacy")+ let originalNonce = state.redisKeyBrowserRefreshNonce+- await state.loadSidebar(config: redisConfig(), adapter: RedisAdapter())++ await state.loadSidebar(config: config, adapter: adapter)++ XCTAssertTrue(state.sidebarItems.isEmpty)++ XCTAssertNil(state.selectedSidebarSchema)++ XCTAssertNil(state.selectedSidebarItem)++ XCTAssertNil(state.selectedSidebarItemSchema)+ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)+ }+++ func test_loadSidebar_forStaleRedisCannotClearActiveSQLSidebar() async {++ let state = AppState()++ let activeConfig = ConnectionConfig(++ name: "SQLite",++ databaseType: .sqlite,++ filePath: ":memory:"++ )++ state.activeConnectionId = activeConfig.id++ state.activeConfig = activeConfig++ state.activeAdapter = SQLiteAdapter()++ state.sidebarItems = [++ SidebarItem(title: "Current", type: .table("Current"), schema: "main")++ ]++ state.selectedSidebarSchema = "main"++ state.selectSidebarItem(.table("Current"), schema: "main")++ let originalNonce = state.redisKeyBrowserRefreshNonce++++ await state.loadSidebar(config: redisConfig(), adapter: RedisAdapter())++++ XCTAssertEqual(state.sidebarItems.map(\.title), ["Current"])++ XCTAssertEqual(state.selectedSidebarSchema, "main")++ XCTAssertEqual(state.selectedSidebarItem, .table("Current"))++ XCTAssertEqual(state.selectedSidebarItemSchema, "main")++ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce)++ }+++ func test_refreshSidebar_forRedisRequestsBrowserRefreshImmediately() {+ let state = AppState()+ state.activeAdapter = RedisAdapter()+ state.activeConfig = redisConfig()+ let originalNonce = state.redisKeyBrowserRefreshNonce++ state.refreshSidebar()++ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)+ }++ func test_openRedisFlatKeyList_reusesKeysTabAndShowsItsFilterBar() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ state.openRedisFlatKeyList()++ let firstTabID = try XCTUnwrap(state.activeTabId)+ XCTAssertEqual(state.tabs.count, 1)+ XCTAssertEqual(state.tabs.first?.type, .dataGrid)+ XCTAssertEqual(state.tabs.first?.tableName, "Keys")+ XCTAssertTrue(state.cachedDataGridState(for: firstTabID).showFilterBar)++ state.cachedDataGridState(for: firstTabID).showFilterBar = false+ state.openRedisFlatKeyList()++ XCTAssertEqual(state.tabs.count, 1)+ XCTAssertEqual(state.activeTabId, firstTabID)+ XCTAssertTrue(state.cachedDataGridState(for: firstTabID).showFilterBar)+ }++ func test_openRedisFlatKeyList_reusesOnlyWithinTheCurrentDatabase() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ state.openRedisFlatKeyList()+ let db0TabID = try XCTUnwrap(state.activeTabId)++ state.currentDatabaseName = "db1"+ state.openRedisFlatKeyList()+ let db1TabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertNotEqual(db1TabID, db0TabID)+ XCTAssertEqual(state.tabs.first(where: { $0.id == db0TabID })?.databaseName, "db0")+ XCTAssertEqual(state.tabs.first(where: { $0.id == db1TabID })?.databaseName, "db1")++ state.currentDatabaseName = "db0"+ state.openRedisFlatKeyList()++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertEqual(state.activeTabId, db0TabID)+ }++ func test_openRedisFlatKeyList_reusesOnlyWithinTheActiveConnection() throws {+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!+ let firstAdapter = RedisAdapter()+ let secondAdapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: firstConnection,+ databaseName: "db0"+ )++ state.openRedisFlatKeyList()+ let firstConnectionTabID = try XCTUnwrap(state.activeTabId)+ let firstConnectionContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == firstConnectionTabID })?.redisContext+ )+ XCTAssertEqual(firstConnectionContext.connectionID, firstConnection)+ XCTAssertEqual(firstConnectionContext.databaseName, "db0")+ XCTAssertTrue(state.activeRedisAdapter(for: firstConnectionContext) === firstAdapter)++ state.activeConnectionId = secondConnection+ state.activeAdapter = secondAdapter+ XCTAssertFalse(state.isRedisFlatKeyListOpen)+ state.openRedisFlatKeyList()+ let secondConnectionTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertNotEqual(secondConnectionTabID, firstConnectionTabID)+ let secondConnectionContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == secondConnectionTabID })?.redisContext+ )+ XCTAssertEqual(secondConnectionContext.connectionID, secondConnection)+ XCTAssertEqual(secondConnectionContext.databaseName, "db0")+ XCTAssertTrue(state.activeRedisAdapter(for: secondConnectionContext) === secondAdapter)+ XCTAssertTrue(state.isRedisFlatKeyListOpen)++ state.activeConnectionId = firstConnection+ state.activeAdapter = firstAdapter+ XCTAssertNil(state.activeRedisAdapter(for: firstConnectionContext))+ state.openRedisFlatKeyList()+ let reacceptedFirstConnectionTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 3)+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, firstConnectionTabID)+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, secondConnectionTabID)+ }++ func test_openRedisKeyDetail_reusesSameNamedKeyOnlyWithinCurrentDatabase() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ state.openRedisKeyDetail(key: "session:42")+ let db0TabID = try XCTUnwrap(state.activeTabId)++ state.currentDatabaseName = "db1"+ state.openRedisKeyDetail(key: "session:42")+ let db1TabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertNotEqual(db1TabID, db0TabID)+ XCTAssertEqual(state.tabs.first(where: { $0.id == db0TabID })?.databaseName, "db0")+ XCTAssertEqual(state.tabs.first(where: { $0.id == db1TabID })?.databaseName, "db1")++ state.currentDatabaseName = "db0"+ state.openRedisKeyDetail(key: "session:42")++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertEqual(state.activeTabId, db0TabID)+ }++ func test_openRedisKeyDetail_reusesSameNamedKeyOnlyWithinActiveConnection() throws {+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!+ let firstAdapter = RedisAdapter()+ let secondAdapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: firstConnection,+ databaseName: "db0"+ )++ state.openRedisKeyDetail(key: "session:42")+ let firstConnectionTabID = try XCTUnwrap(state.activeTabId)+ let firstConnectionContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == firstConnectionTabID })?.redisContext+ )+ XCTAssertEqual(firstConnectionContext.connectionID, firstConnection)+ XCTAssertEqual(firstConnectionContext.databaseName, "db0")+ XCTAssertTrue(state.activeRedisAdapter(for: firstConnectionContext) === firstAdapter)++ state.activeConnectionId = secondConnection+ state.activeAdapter = secondAdapter+ state.openRedisKeyDetail(key: "session:42")+ let secondConnectionTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 2)+ XCTAssertNotEqual(secondConnectionTabID, firstConnectionTabID)+ let secondConnectionContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == secondConnectionTabID })?.redisContext+ )+ XCTAssertEqual(secondConnectionContext.connectionID, secondConnection)+ XCTAssertEqual(secondConnectionContext.databaseName, "db0")+ XCTAssertTrue(state.activeRedisAdapter(for: secondConnectionContext) === secondAdapter)++ state.activeConnectionId = firstConnection+ state.activeAdapter = firstAdapter+ XCTAssertNil(state.activeRedisAdapter(for: firstConnectionContext))+ state.openRedisKeyDetail(key: "session:42")+ let reacceptedFirstConnectionTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 3)+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, firstConnectionTabID)+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, secondConnectionTabID)+ }++ func test_activeRedisAdapterForTabContext_rejectsConnectionAndDatabaseChanges() throws {+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!+ let adapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: adapter,+ connectionID: firstConnection,+ databaseName: "db0"+ )+ state.openRedisKeyDetail(key: "session:42")+ let tabID = try XCTUnwrap(state.activeTabId)+ let capturedContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == tabID })?.redisContext+ )++ XCTAssertTrue(state.activeRedisAdapter(for: capturedContext) === adapter)++ state.activeConnectionId = secondConnection+ XCTAssertNil(state.activeRedisAdapter(for: capturedContext))++ state.activeConnectionId = firstConnection+ state.currentDatabaseName = "db1"+ XCTAssertNil(state.activeRedisAdapter(for: capturedContext))+ }++ func test_replacingRedisAdapterInvalidatesSameConnectionAndDatabaseTabs() throws {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let firstAdapter = RedisAdapter()+ let secondAdapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )++ state.openRedisFlatKeyList()+ let firstFlatTabID = try XCTUnwrap(state.activeTabId)+ state.openRedisKeyDetail(key: "session:42")+ let firstDetailTabID = try XCTUnwrap(state.activeTabId)+ let firstFlatContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == firstFlatTabID })?.redisContext+ )+ let firstDetailContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == firstDetailTabID })?.redisContext+ )++ state.activeAdapter = secondAdapter++ XCTAssertFalse(state.isRedisFlatKeyListOpen)+ XCTAssertNil(state.activeRedisAdapter(for: firstFlatContext))+ XCTAssertNil(state.activeRedisAdapter(for: firstDetailContext))++ state.openRedisFlatKeyList()+ let secondFlatTabID = try XCTUnwrap(state.activeTabId)+ state.openRedisKeyDetail(key: "session:42")+ let secondDetailTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertEqual(state.tabs.count, 4)+ XCTAssertNotEqual(secondFlatTabID, firstFlatTabID)+ XCTAssertNotEqual(secondDetailTabID, firstDetailTabID)+ let secondFlatContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == secondFlatTabID })?.redisContext+ )+ let secondDetailContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == secondDetailTabID })?.redisContext+ )+ XCTAssertEqual(secondFlatContext.connectionID, connectionID)+ XCTAssertEqual(secondFlatContext.databaseName, "db0")+ XCTAssertEqual(secondDetailContext.connectionID, connectionID)+ XCTAssertEqual(secondDetailContext.databaseName, "db0")+ XCTAssertTrue(state.activeRedisAdapter(for: secondFlatContext) === secondAdapter)+ XCTAssertTrue(state.activeRedisAdapter(for: secondDetailContext) === secondAdapter)+ }++ func test_redisDatabaseTransitionInvalidatesOldContextBeforeAwaitingSelect() async throws {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let adapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: adapter,+ connectionID: connectionID,+ databaseName: "db0"+ )+ state.openRedisFlatKeyList()+ let flatTabID = try XCTUnwrap(state.activeTabId)+ state.openRedisKeyDetail(key: "session:42")+ let detailTabID = try XCTUnwrap(state.activeTabId)+ let flatContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == flatTabID })?.redisContext+ )+ let detailContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == detailTabID })?.redisContext+ )+ var selectWasInvoked = false++ try await state.performRedisDatabaseTransition(to: "db1") {+ selectWasInvoked = true+ XCTAssertFalse(state.isRedisFlatKeyListOpen)+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))++ await Task.yield()++ XCTAssertNil(state.activeRedisAdapter(for: flatContext))+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))+ }++ XCTAssertTrue(selectWasInvoked)+ XCTAssertEqual(state.currentDatabaseName, "db1")+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))+ }++ func test_overlappingRedisTransitions_newerSuccessOutranksOlderSuccess() async {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let olderGate = AsyncTestGate()+ let newerGate = AsyncTestGate()++ let olderTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await olderGate.enterAndWait()+ }+ }+ await olderGate.waitUntilEntered()++ let newerTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db2") {+ await newerGate.enterAndWait()+ }+ }++ await olderGate.release()+ await olderTransition.value++ await newerGate.waitUntilEntered()+ await newerGate.release()+ await newerTransition.value++ XCTAssertEqual(state.currentDatabaseName, "db2")+ }++ func test_overlappingRedisTransitions_olderFailureCannotRestoreOverNewerSuccess() async {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let olderGate = AsyncTestGate()+ let newerGate = AsyncTestGate()++ let olderTransition = Task { @MainActor in+ do {+ try await state.performRedisDatabaseTransition(to: "db1") {+ await olderGate.enterAndWait()+ throw ExpectedTransitionError.selectFailed+ }+ return false+ } catch ExpectedTransitionError.selectFailed {+ return true+ } catch {+ return false+ }+ }+ await olderGate.waitUntilEntered()++ let newerTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db2") {+ await newerGate.enterAndWait()+ }+ }++ await olderGate.release()+ let olderFailedAsExpected = await olderTransition.value++ await newerGate.waitUntilEntered()+ await newerGate.release()+ await newerTransition.value++ XCTAssertEqual(state.currentDatabaseName, "db2")+ XCTAssertTrue(olderFailedAsExpected)+ XCTAssertEqual(state.currentDatabaseName, "db2")+ }++ func test_overlappingRedisTransitions_newerFailureKeepsOlderSuccessfulDatabase() async {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let olderGate = AsyncTestGate()+ let newerGate = AsyncTestGate()++ let olderTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await olderGate.enterAndWait()+ }+ }+ await olderGate.waitUntilEntered()++ let newerTransition = Task { @MainActor in+ do {+ try await state.performRedisDatabaseTransition(to: "db2") {+ await newerGate.enterAndWait()+ throw ExpectedTransitionError.selectFailed+ }+ return false+ } catch ExpectedTransitionError.selectFailed {+ return true+ } catch {+ return false+ }+ }++ await olderGate.release()+ await olderTransition.value+ XCTAssertEqual(state.currentDatabaseName, "db1")++ await newerGate.waitUntilEntered()+ await newerGate.release()+ let newerFailedAsExpected = await newerTransition.value++ XCTAssertTrue(newerFailedAsExpected)+ XCTAssertEqual(state.currentDatabaseName, "db1")+ }++ func test_overlappingRedisTransitions_twoFailuresKeepOriginalDatabase() async {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let olderGate = AsyncTestGate()+ let newerGate = AsyncTestGate()++ let olderTransition = Task { @MainActor in+ do {+ try await state.performRedisDatabaseTransition(to: "db1") {+ await olderGate.enterAndWait()+ throw ExpectedTransitionError.selectFailed+ }+ return false+ } catch ExpectedTransitionError.selectFailed {+ return true+ } catch {+ return false+ }+ }+ await olderGate.waitUntilEntered()++ let newerTransition = Task { @MainActor in+ do {+ try await state.performRedisDatabaseTransition(to: "db2") {+ await newerGate.enterAndWait()+ throw ExpectedTransitionError.selectFailed+ }+ return false+ } catch ExpectedTransitionError.selectFailed {+ return true+ } catch {+ return false+ }+ }++ await olderGate.release()+ let olderFailedAsExpected = await olderTransition.value+ XCTAssertTrue(olderFailedAsExpected)+ XCTAssertEqual(state.currentDatabaseName, "db0")++ await newerGate.waitUntilEntered()+ await newerGate.release()+ let newerFailedAsExpected = await newerTransition.value++ XCTAssertTrue(newerFailedAsExpected)+ XCTAssertEqual(state.currentDatabaseName, "db0")+ }++ func test_overlappingRedisTransitions_serializeActualSelectClosuresInRevisionOrder() async {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let olderGate = AsyncTestGate()+ let newerGate = AsyncTestGate()+ let events = AsyncTestEventRecorder()++ let olderTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await events.record("db1:start")+ await olderGate.enterAndWait()+ await events.record("db1:end")+ }+ }+ await olderGate.waitUntilEntered()++ let newerTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db2") {+ await events.record("db2:start")+ await newerGate.enterAndWait()+ await events.record("db2:end")+ }+ }+ while state.redisDatabaseRevision < 2 {+ await Task.yield()+ }++ let newerEnteredBeforeOlderFinished = await newerGate.enteredSnapshot()+ XCTAssertFalse(newerEnteredBeforeOlderFinished)++ await olderGate.release()+ await olderTransition.value+ await newerGate.waitUntilEntered()+ await newerGate.release()+ await newerTransition.value++ let recordedEvents = await events.snapshot()+ XCTAssertEqual(+ recordedEvents,+ ["db1:start", "db1:end", "db2:start", "db2:end"]+ )+ XCTAssertEqual(state.currentDatabaseName, "db2")+ }++ func test_redisOperation_serializesWithTransitionAndDiscardsStaleResult() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let context = try XCTUnwrap(state.currentRedisContext)+ let operationGate = AsyncTestGate()+ let selectGate = AsyncTestGate()+ let events = AsyncTestEventRecorder()++ let operation = Task { @MainActor in+ await state.performRedisOperation(for: context) { _ in+ await events.record("operation:start")+ await operationGate.enterAndWait()+ await events.record("operation:end")+ return "db0-value"+ }+ }+ await operationGate.waitUntilEntered()++ let transition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await events.record("select:start")+ await selectGate.enterAndWait()+ await events.record("select:end")+ }+ }+ while state.redisDatabaseRevision < 1 {+ await Task.yield()+ }++ let selectEnteredBeforeOperationFinished = await selectGate.enteredSnapshot()+ XCTAssertFalse(selectEnteredBeforeOperationFinished)++ await operationGate.release()+ let result = await operation.value+ await selectGate.waitUntilEntered()+ await selectGate.release()+ await transition.value++ XCTAssertNil(result)+ let recordedEvents = await events.snapshot()+ XCTAssertEqual(+ recordedEvents,+ ["operation:start", "operation:end", "select:start", "select:end"]+ )+ XCTAssertEqual(state.currentDatabaseName, "db1")+ }++ func test_nestedRedisOperationInSameTask_completesWithoutSelfDeadlock() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let context = try XCTUnwrap(state.currentRedisContext)+ let completed = expectation(description: "nested Redis operation completed")+ var nestedOperationSucceeded = false++ let operation = Task { @MainActor in+ let outerResult = await state.performRedisOperation(for: context) { _ in+ await state.performRedisOperation(for: context) { _ in+ "nested-value"+ }+ }+ if case .success(let innerResult)? = outerResult,+ case .success("nested-value")? = innerResult {+ nestedOperationSucceeded = true+ }+ completed.fulfill()+ }+ defer { operation.cancel() }++ await fulfillment(of: [completed], timeout: 1.0)++ XCTAssertTrue(nestedOperationSucceeded)+ }++ func test_cancelledQueuedRedisTransition_completesAndRestoresContextBeforeLeaseRelease() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let context = try XCTUnwrap(state.currentRedisContext)+ let holderGate = AsyncTestGate()+ let holder = Task { @MainActor in+ await state.performRedisOperation(for: context) { _ in+ await holderGate.enterAndWait()+ }+ }+ await holderGate.waitUntilEntered()++ let transitionCompleted = expectation(description: "cancelled queued transition completed")+ var didCompleteTransition = false+ var didInvokeSelect = false+ let transition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ didInvokeSelect = true+ }+ didCompleteTransition = true+ transitionCompleted.fulfill()+ }+ while state.redisDatabaseRevision < 1 {+ await Task.yield()+ }++ transition.cancel()+ await fulfillment(of: [transitionCompleted], timeout: 1.0)+ let databaseNameBeforeHolderRelease = state.currentDatabaseName+ let completedBeforeHolderRelease = didCompleteTransition++ await holderGate.release()+ _ = await holder.value+ _ = await transition.value++ XCTAssertTrue(completedBeforeHolderRelease)+ XCTAssertEqual(databaseNameBeforeHolderRelease, "db0")+ XCTAssertFalse(didInvokeSelect)+ XCTAssertEqual(state.currentDatabaseName, "db0")+ }++ func test_redisConnectionMetadataLoad_serializesWithTransitionAndDiscardsStaleRevision() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ state.availableDatabases = ["sentinel"]+ state.redisDBSize = 7+ let token = try XCTUnwrap(state.currentRedisSessionRevisionToken)+ let metadataGate = AsyncTestGate()+ let selectGate = AsyncTestGate()+ let events = AsyncTestEventRecorder()++ let metadataLoad = Task { @MainActor in+ await state.loadRedisConnectionMetadata(for: token) { _ in+ await events.record("metadata:start")+ await metadataGate.enterAndWait()+ await events.record("metadata:end")+ return AppState.RedisConnectionMetadataSnapshot(+ databaseName: "db0",+ availableDatabases: ["stale"],+ databaseSize: 999+ )+ }+ }+ await metadataGate.waitUntilEntered()++ let transition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await events.record("select:start")+ await selectGate.enterAndWait()+ await events.record("select:end")+ }+ }+ while state.redisDatabaseRevision < 1 {+ await Task.yield()+ }++ let selectEnteredBeforeMetadataFinished = await selectGate.enteredSnapshot()+ XCTAssertFalse(selectEnteredBeforeMetadataFinished)++ await metadataGate.release()+ let published = await metadataLoad.value+ await selectGate.waitUntilEntered()+ await selectGate.release()+ await transition.value++ XCTAssertFalse(published)+ XCTAssertEqual(state.currentDatabaseName, "db1")+ XCTAssertNotEqual(state.availableDatabases, ["stale"])+ XCTAssertNotEqual(state.redisDBSize, 999)+ let recordedEvents = await events.snapshot()+ XCTAssertEqual(+ recordedEvents,+ ["metadata:start", "metadata:end", "select:start", "select:end"]+ )+ }++ func test_redisConnectionMetadataLoad_rejectsSameAdapterSessionABA() async throws {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let firstAdapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )+ state.availableDatabases = ["sentinel"]+ state.redisDBSize = 7+ let token = try XCTUnwrap(state.currentRedisSessionRevisionToken)+ let metadataGate = AsyncTestGate()++ let metadataLoad = Task { @MainActor in+ await state.loadRedisConnectionMetadata(for: token) { _ in+ await metadataGate.enterAndWait()+ return AppState.RedisConnectionMetadataSnapshot(+ databaseName: "db0",+ availableDatabases: ["stale"],+ databaseSize: 999+ )+ }+ }+ await metadataGate.waitUntilEntered()++ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: connectionID,+ databaseName: "db0"+ )+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )++ await metadataGate.release()+ let published = await metadataLoad.value++ XCTAssertFalse(published)+ XCTAssertEqual(state.currentDatabaseName, "db0")+ XCTAssertEqual(state.availableDatabases, ["sentinel"])+ XCTAssertEqual(state.redisDBSize, 7)+ }++ func test_reacceptingSameRedisAdapterInvalidatesCapturedTabContexts() throws {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let adapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: adapter,+ connectionID: connectionID,+ databaseName: "db0"+ )+ state.openRedisFlatKeyList()+ let flatTabID = try XCTUnwrap(state.activeTabId)+ state.openRedisKeyDetail(key: "session:42")+ let detailTabID = try XCTUnwrap(state.activeTabId)+ let flatContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == flatTabID })?.redisContext+ )+ let detailContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == detailTabID })?.redisContext+ )++ state.activeAdapter = nil+ state.activeConnectionId = nil+ state.currentDatabaseName = nil+ establishRedisContext(+ on: state,+ adapter: adapter,+ connectionID: connectionID,+ databaseName: "db0"+ )++ XCTAssertNil(state.activeRedisAdapter(for: flatContext))+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))+ XCTAssertFalse(state.isRedisFlatKeyListOpen)+ }++ func test_redisSessionABA_doesNotReauthorizeFirstAdapterContexts() throws {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ let firstAdapter = RedisAdapter()+ let interveningAdapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )+ state.openRedisKeyDetail(key: "session:42")+ let firstTabID = try XCTUnwrap(state.activeTabId)+ let firstContext = try XCTUnwrap(+ state.tabs.first(where: { $0.id == firstTabID })?.redisContext+ )++ establishRedisContext(+ on: state,+ adapter: interveningAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )+ XCTAssertNil(state.activeRedisAdapter(for: firstContext))++ establishRedisContext(+ on: state,+ adapter: firstAdapter,+ connectionID: connectionID,+ databaseName: "db0"+ )++ XCTAssertNil(state.activeRedisAdapter(for: firstContext))+ }++ func test_openRedisTabsRefuseIncompleteContext() {+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!++ let missingEverything = AppState()+ missingEverything.openRedisFlatKeyList()+ missingEverything.openRedisKeyDetail(key: "session:42")+ XCTAssertTrue(missingEverything.tabs.isEmpty)+ XCTAssertNil(missingEverything.activeTabId)+ XCTAssertFalse(missingEverything.isRedisFlatKeyListOpen)++ let missingAdapter = AppState()+ missingAdapter.activeConnectionId = connectionID+ missingAdapter.currentDatabaseName = "db0"+ missingAdapter.openRedisFlatKeyList()+ missingAdapter.openRedisKeyDetail(key: "session:42")+ XCTAssertTrue(missingAdapter.tabs.isEmpty)++ let missingConnection = AppState()+ missingConnection.activeAdapter = RedisAdapter()+ missingConnection.currentDatabaseName = "db0"+ missingConnection.openRedisFlatKeyList()+ missingConnection.openRedisKeyDetail(key: "session:42")+ XCTAssertTrue(missingConnection.tabs.isEmpty)++ let missingDatabase = AppState()+ missingDatabase.activeAdapter = RedisAdapter()+ missingDatabase.activeConnectionId = connectionID+ missingDatabase.openRedisFlatKeyList()+ missingDatabase.openRedisKeyDetail(key: "session:42")+ XCTAssertTrue(missingDatabase.tabs.isEmpty)+ }++ func test_flatKeyListOpenStateBecomesFalseAfterCloseAndCanReopen() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db3"+ )++ XCTAssertFalse(state.isRedisFlatKeyListOpen)+ state.openRedisFlatKeyList()+ let closedTabID = try XCTUnwrap(state.activeTabId)+ XCTAssertTrue(state.isRedisFlatKeyListOpen)++ state.closeTab(id: closedTabID)++ XCTAssertFalse(state.isRedisFlatKeyListOpen)++ state.openRedisFlatKeyList()+ let reopenedTabID = try XCTUnwrap(state.activeTabId)++ XCTAssertTrue(state.isRedisFlatKeyListOpen)+ XCTAssertNotEqual(reopenedTabID, closedTabID)+ XCTAssertEqual(state.tabs.first(where: { $0.id == reopenedTabID })?.databaseName, "db3")+ }++ func test_redisCLISelectPublishesOwnedDatabaseContextAndInvalidatesOldRevision() async throws {+ let adapter = RedisAdapter()+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: adapter,+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let oldContext = try XCTUnwrap(state.currentRedisContext)+ var receivedStatement: String?+ var usedActiveAdapter = false++ let result = await state.performRedisCLIStatement(" select 5 ") { receivedAdapter, statement in+ receivedStatement = statement+ usedActiveAdapter = receivedAdapter === adapter+ return self.redisCLIResult(value: "OK")+ }++ guard case .success(let queryResult)? = result else {+ return XCTFail("Expected the owned SELECT result to remain current")+ }+ XCTAssertEqual(queryResult.rows, [[.string("OK")]])+ XCTAssertEqual(receivedStatement, "select 5")+ XCTAssertTrue(usedActiveAdapter)+ XCTAssertEqual(state.currentDatabaseName, "db5")+ XCTAssertEqual(state.redisDatabaseRevision, oldContext.databaseRevision + 1)+ XCTAssertNil(state.activeRedisAdapter(for: oldContext))+ }++ func test_redisCLISelectServerErrorKeepsThePreviouslySelectedDatabase() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ let result = await state.performRedisCLIStatement("SELECT 999") { _, _ in+ QueryResult(+ columns: [ColumnHeader(name: "error", dataType: "string")],+ rows: [[.string("ERR DB index is out of range")]],+ rowsAffected: 0,+ executionTime: 0.01,+ queryType: .select+ )+ }++ guard case .success(let queryResult)? = result else {+ return XCTFail("Expected the Redis error response to remain displayable")+ }+ XCTAssertEqual(queryResult.columns.first?.name, "error")+ XCTAssertEqual(state.currentDatabaseName, "db0")+ XCTAssertEqual(state.currentRedisContext?.databaseName, "db0")+ }++ func test_redisCLIQuotedSelectPublishesTheAdapterTokenizedDatabase() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let oldRevision = try XCTUnwrap(state.currentRedisContext).databaseRevision+ var receivedStatement: String?++ let result = await state.performRedisCLIStatement("SELECT \"4\"") { _, statement in+ receivedStatement = statement+ return self.redisCLIResult(value: "OK")+ }++ guard case .success? = result else {+ return XCTFail("Expected quoted SELECT to complete as an owned transition")+ }+ XCTAssertEqual(receivedStatement, "SELECT \"4\"")+ XCTAssertEqual(state.currentDatabaseName, "db4")+ XCTAssertEqual(state.redisDatabaseRevision, oldRevision + 1)+ }++ func test_redisCLINonSelectSerializesWithTransitionAndDiscardsStaleResult() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let commandGate = AsyncTestGate()+ let selectGate = AsyncTestGate()+ let events = AsyncTestEventRecorder()++ let command = Task { @MainActor in+ await state.performRedisCLIStatement("GET session:42") { _, _ in+ await events.record("command:start")+ await commandGate.enterAndWait()+ await events.record("command:end")+ return self.redisCLIResult(value: "value")+ }+ }+ await commandGate.waitUntilEntered()++ let transition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await events.record("select:start")+ await selectGate.enterAndWait()+ await events.record("select:end")+ }+ }+ while state.redisDatabaseRevision < 1 {+ await Task.yield()+ }++ let selectEnteredBeforeCommandFinished = await selectGate.enteredSnapshot()+ XCTAssertFalse(selectEnteredBeforeCommandFinished)++ await commandGate.release()+ let commandResult = await command.value+ await selectGate.waitUntilEntered()+ await selectGate.release()+ await transition.value++ XCTAssertNil(commandResult)+ let recordedEvents = await events.snapshot()+ XCTAssertEqual(+ recordedEvents,+ ["command:start", "command:end", "select:start", "select:end"]+ )+ XCTAssertEqual(state.currentDatabaseName, "db1")+ }++ func test_redisCLISelectParserAcceptsOnlyOneNonnegativeDatabaseIndex() {+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT 5"), "db5")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: " select 005 "), "db5")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT \"6\""), "db6")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "'SELECT' 7"), "db7")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SEL\"ECT\" 8"), "db8")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT '9"), "db9")+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "\u{017F}elect 10"), "db10")+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT"))+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT -1"))+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT five"))+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT 1 extra"))+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "GET SELECT 1"))+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT\t1"))+ }++ func test_redisQueryTabsCaptureTheirExactDatabaseContext() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ state.openNewQueryTab()+ let db0Tab = try XCTUnwrap(state.tabs.last)++ state.currentDatabaseName = "db1"+ state.openNewQueryTab()+ let db1Tab = try XCTUnwrap(state.tabs.last)++ XCTAssertEqual(db0Tab.redisContext?.databaseName, "db0")+ XCTAssertEqual(db1Tab.redisContext?.databaseName, "db1")+ XCTAssertNotEqual(db0Tab.redisContext, db1Tab.redisContext)+ }++ func test_openRedisQueryTabRefusesAContextWhileDatabaseSelectionIsPending() {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ state.currentDatabaseName = nil++ state.openNewQueryTab()++ XCTAssertTrue(state.tabs.isEmpty)+ }++ func test_rebindRedisQueryTabAdoptsTheLatestRevisionAfterSelectFailure() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ state.openNewQueryTab()+ let tabID = try XCTUnwrap(state.tabs.last?.id)+ let oldContext = try XCTUnwrap(state.tabs.last?.redisContext)++ _ = await state.performRedisCLIStatement("SELECT 999") { _, _ in+ QueryResult(+ columns: [ColumnHeader(name: "error", dataType: "string")],+ rows: [[.string("ERR DB index is out of range")]],+ rowsAffected: 0,+ executionTime: 0.01,+ queryType: .select+ )+ }+ let currentContext = try XCTUnwrap(state.currentRedisContext)++ state.rebindRedisQueryTab(id: tabID, to: currentContext)++ XCTAssertNotEqual(currentContext.databaseRevision, oldContext.databaseRevision)+ XCTAssertEqual(state.tabs.last?.redisContext, currentContext)+ XCTAssertEqual(state.tabs.last?.databaseName, "db0")+ }++ func test_redisCLINonSelectingSequenceKeepsOneLeaseUntilAllCommandsFinish() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let context = try XCTUnwrap(state.currentRedisContext)+ let firstCommandGate = AsyncTestGate()+ let secondCommandGate = AsyncTestGate()+ let selectGate = AsyncTestGate()+ let events = AsyncTestEventRecorder()++ let sequence = Task { @MainActor in+ await state.performRedisCLIStatements(+ ["GET first", "GET second"],+ from: context+ ) { _, statement in+ await events.record("\(statement):start")+ if statement == "GET first" {+ await firstCommandGate.enterAndWait()+ } else {+ await secondCommandGate.enterAndWait()+ }+ await events.record("\(statement):end")+ return self.redisCLIResult(value: statement)+ }+ }+ await firstCommandGate.waitUntilEntered()++ let transition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await events.record("select:start")+ await selectGate.enterAndWait()+ await events.record("select:end")+ }+ }+ while state.redisDatabaseRevision < 1 {+ await Task.yield()+ }++ await firstCommandGate.release()+ await secondCommandGate.waitUntilEntered()+ let selectEnteredBeforeSequenceFinished = await selectGate.enteredSnapshot()+ XCTAssertFalse(selectEnteredBeforeSequenceFinished)+ await secondCommandGate.release()++ let sequenceResult = await sequence.value+ XCTAssertNil(sequenceResult)+ await selectGate.waitUntilEntered()+ await selectGate.release()+ await transition.value++ let recordedEvents = await events.snapshot()+ XCTAssertEqual(+ recordedEvents,+ [+ "GET first:start",+ "GET first:end",+ "GET second:start",+ "GET second:end",+ "select:start",+ "select:end",+ ]+ )+ XCTAssertEqual(state.currentDatabaseName, "db1")+ }++ func test_redisCLISequenceCapturesTheDatabaseOwnedByEachStatement() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let context = try XCTUnwrap(state.currentRedisContext)++ let result = await state.performRedisCLIStatements(+ ["GET before", "SELECT 2", "GET after"],+ from: context+ ) { _, statement in+ self.redisCLIResult(value: statement.uppercased().hasPrefix("SELECT") ? "OK" : "value")+ }+ let executions = try XCTUnwrap(result)++ XCTAssertEqual(executions.map(\.databaseName), ["db0", "db2", "db2"])+ XCTAssertEqual(state.currentDatabaseName, "db2")+ }++ func test_redisCLISelectCannotLeapfrogAPendingExternalTransition() async throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )+ let oldContext = try XCTUnwrap(state.currentRedisContext)+ let externalSelectGate = AsyncTestGate()+ var cliSelectExecuted = false++ let externalTransition = Task { @MainActor in+ await state.performRedisDatabaseTransition(to: "db1") {+ await externalSelectGate.enterAndWait()+ }+ }+ await externalSelectGate.waitUntilEntered()++ let cliBatch = Task { @MainActor in+ await state.performRedisCLIStatements(+ ["SELECT 5"],+ from: oldContext+ ) { _, _ in+ cliSelectExecuted = true+ return self.redisCLIResult(value: "OK")+ }+ }++ await Task.yield()+ XCTAssertFalse(cliSelectExecuted)+ await externalSelectGate.release()+ await externalTransition.value+ let result = await cliBatch.value+ XCTAssertNil(result)+ XCTAssertFalse(cliSelectExecuted)+ XCTAssertEqual(state.currentDatabaseName, "db1")+ }++ func test_redisOperationalTabsAreScopedToExactDatabaseContext() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db0"+ )++ state.openRedisServerInfo()+ let db0Info = try XCTUnwrap(state.tabs.last)+ state.openRedisSlowLog()+ let db0SlowLog = try XCTUnwrap(state.tabs.last)++ state.currentDatabaseName = "db1"+ state.openRedisServerInfo()+ let db1Info = try XCTUnwrap(state.tabs.last)+ state.openRedisSlowLog()+ let db1SlowLog = try XCTUnwrap(state.tabs.last)++ XCTAssertEqual(db0Info.redisContext?.databaseName, "db0")+ XCTAssertEqual(db0SlowLog.redisContext?.databaseName, "db0")+ XCTAssertEqual(db1Info.redisContext?.databaseName, "db1")+ XCTAssertEqual(db1SlowLog.redisContext?.databaseName, "db1")+ XCTAssertNotEqual(db0Info.id, db1Info.id)+ XCTAssertNotEqual(db0SlowLog.id, db1SlowLog.id)+ XCTAssertEqual(state.tabs.count, 4)+ }++ func test_redisMutationPromptsCaptureAndClearExactContext() throws {+ let state = AppState()+ establishRedisContext(+ on: state,+ adapter: RedisAdapter(),+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: "db3"+ )+ let expected = try XCTUnwrap(state.currentRedisContext)++ state.presentRedisAddKey()+ state.presentRedisFlushConfirmation()++ XCTAssertTrue(state.showRedisAddKey)+ XCTAssertTrue(state.showFlushDBConfirm)+ XCTAssertEqual(state.redisAddKeyContext, expected)+ XCTAssertEqual(state.redisFlushContext, expected)++ state.dismissRedisAddKey()+ state.dismissRedisFlushConfirmation()++ XCTAssertFalse(state.showRedisAddKey)+ XCTAssertFalse(state.showFlushDBConfirm)+ XCTAssertNil(state.redisAddKeyContext)+ XCTAssertNil(state.redisFlushContext)+ }++ private func establishRedisContext(+ on state: AppState,+ adapter: RedisAdapter,+ connectionID: UUID,+ databaseName: String+ ) {+ state.activeAdapter = adapter+ state.activeConnectionId = connectionID+ state.currentDatabaseName = databaseName+ }++ private func redisConfig() -> ConnectionConfig {+ ConnectionConfig(name: "Redis", databaseType: .redis)+ }++ private func redisCLIResult(value: String) -> QueryResult {+ QueryResult(+ columns: [ColumnHeader(name: "result", dataType: "string")],+ rows: [[.string(value)]],+ rowsAffected: 0,+ executionTime: 0.01,+ queryType: .select+ )+ }+}++private enum ExpectedTransitionError: Error {+ case selectFailed+}++private actor AsyncTestGate {+ private var hasEntered = false+ private var hasBeenReleased = false+ private var entryWaiters: [CheckedContinuation<Void, Never>] = []+ private var releaseWaiter: CheckedContinuation<Void, Never>?++ func waitUntilEntered() async {+ guard !hasEntered else { return }+ await withCheckedContinuation { continuation in+ entryWaiters.append(continuation)+ }+ }++ func enteredSnapshot() -> Bool {+ hasEntered+ }++ func enterAndWait() async {+ hasEntered = true+ let waiters = entryWaiters+ entryWaiters.removeAll()+ waiters.forEach { $0.resume() }++ guard !hasBeenReleased else { return }+ await withCheckedContinuation { continuation in+ releaseWaiter = continuation+ }+ }++ func release() {+ hasBeenReleased = true+ releaseWaiter?.resume()+ releaseWaiter = nil+ }+}++private actor AsyncTestEventRecorder {+ private var events: [String] = []++ func record(_ event: String) {+ events.append(event)+ }++ func snapshot() -> [String] {+ events+ }+}diff --cc macos/Tests/GridexTests/RedisDataGridLifecycleTests.swiftindex c948356,0000000..c75a83amode 100644,000000..100644--- a/macos/Tests/GridexTests/RedisDataGridLifecycleTests.swift+++ b/macos/Tests/GridexTests/RedisDataGridLifecycleTests.swift@@@ -1,344 -1,0 +1,367 @@@+// RedisDataGridLifecycleTests.swift+// Gridex++import XCTest+@testable import Gridex++@MainActor+final class RedisDataGridLifecycleTests: XCTestCase {++ func test_openRedisFlatKeyListBindsExactTabContextToCachedGridBeforeDisplay() throws {+ let appState = AppState()+ establishRedisContext(on: appState, databaseName: "db0")+ let expectedContext = try XCTUnwrap(appState.currentRedisContext)++ appState.openRedisFlatKeyList()++ let tab = try XCTUnwrap(appState.tabs.first)+ XCTAssertEqual(tab.redisContext, expectedContext)+ XCTAssertEqual(+ appState.cachedDataGridState(for: tab.id).redisContext,+ expectedContext+ )+ }++ func test_openRedisFlatKeyListClearsStaleGlobalRowCountBeforeDisplay() {+ let appState = AppState()+ establishRedisContext(on: appState, databaseName: "db0")+ appState.statusRowCount = 42++ appState.openRedisFlatKeyList()++ XCTAssertNil(appState.statusRowCount)+ }++ func test_rebindingSameRedisContextClearsStaleDetailEditorState() {+ let appState = AppState()+ let state = DataGridViewState()+ let context = redisContext(databaseName: "db0", revision: 1)+ state.appState = appState+ state.bindRedisContext(context)++ appState.selectedRowDetails = [(column: "name", value: "obsolete")]+ appState.onDetailFieldEdit = { _, _ in }++ state.bindRedisContext(context)++ XCTAssertNil(appState.selectedRowDetails)+ XCTAssertNil(appState.onDetailFieldEdit)+ }++ func test_redisContextMakesGridReadOnlyAndAllMutationEntryPointsNoOp() async {+ let state = DataGridViewState()+ state.bindRedisContext(redisContext(databaseName: "db0", revision: 1))+ state.columns = [ColumnHeader(name: "key", dataType: "string")]+ state.rows = [[.string("session:42")]]+ state.rebuildDisplayCache()++ XCTAssertFalse(state.allowsMutations)++ state.commitCellEdit(rowIndex: 0, colIdx: 0, newText: "changed")+ state.commitDateEdit(rowIndex: 0, colIdx: 0, newValue: .string("dated"))+ state.addNewRow()+ state.commitNewRowEdit(rowIndex: 0, colIdx: 0, newText: "inserted")+ state.selectedRows = [0]+ state.deleteSelectedRows()+ state.prepareCommit()+ await state.executeCommit()++ XCTAssertEqual(state.rows, [[.string("session:42")]])+ XCTAssertEqual(state.totalRows, 0)+ XCTAssertTrue(state.insertedRowIndices.isEmpty)+ XCTAssertFalse(state.hasPendingChanges)+ XCTAssertTrue(state.commitSQL.isEmpty)+ XCTAssertFalse(state.showCommitPreview)++ XCTAssertTrue(DataGridViewState().allowsMutations)+ }++ func test_liveRedisLoadUsesOneOperationOnlyForTheExactBoundContext() async throws {+ DataGridViewState.clearMetadataCache()+ let appState = AppState()+ let adapter = establishRedisContext(on: appState, databaseName: "db0")+ let staleContext = try XCTUnwrap(appState.currentRedisContext)+ var fetchCount = 0+ var fetchedWithActiveAdapter = false+ let state = DataGridViewState { receivedAdapter, _ in+ fetchCount += 1+ fetchedWithActiveAdapter = receivedAdapter === adapter+ return self.queryResult(key: "current:key")+ }+ state.appState = appState+ state.bindRedisContext(staleContext)++ appState.currentDatabaseName = "db1"+ await state.load(tableName: "Keys", schema: nil, adapter: adapter)++ XCTAssertEqual(fetchCount, 0)+ XCTAssertTrue(state.rows.isEmpty)+ XCTAssertFalse(state.isLoading)++ let currentContext = try XCTUnwrap(appState.currentRedisContext)+ state.bindRedisContext(currentContext)+ await state.load(tableName: "Keys", schema: nil, adapter: adapter)++ XCTAssertEqual(fetchCount, 1)+ XCTAssertTrue(fetchedWithActiveAdapter)+ XCTAssertEqual(state.redisContext, currentContext)+ XCTAssertEqual(state.rows, [[.string("current:key")]])+ XCTAssertFalse(state.isLoading)+ }+++ func test_reloadAfterStructureChangeForRedisReloadsOwnedPageZero() async throws {++ DataGridViewState.clearMetadataCache()++ let appState = AppState()++ let adapter = establishRedisContext(on: appState, databaseName: "db0")++ let context = try XCTUnwrap(appState.currentRedisContext)++ var fetchedOffsets: [Int] = []++ let state = DataGridViewState { receivedAdapter, request in++ XCTAssertTrue(receivedAdapter === adapter)++ fetchedOffsets.append(request.offset)++ return self.queryResult(key: "publication-\(fetchedOffsets.count)")++ }++ state.appState = appState++ state.bindRedisContext(context)++++ await state.load(tableName: "Keys", schema: nil, adapter: adapter)++ await state.reloadAfterStructureChange()++++ XCTAssertEqual(fetchedOffsets, [0, 0])++ XCTAssertEqual(state.currentPage, 0)++ XCTAssertEqual(state.rows, [[.string("publication-2")]])++ XCTAssertFalse(state.isLoading)++ }+++ func test_fullAndPageLoadsShareLatestOwnershipWhenOlderFailureCompletesFirst() async {+ let state = DataGridViewState()+ let context = redisContext(databaseName: "db0", revision: 1)+ let olderGate = RedisOwnershipTestGate()+ let newerGate = RedisOwnershipTestGate()+ state.bindRedisContext(context)++ await state.performRedisLoad(in: context) {+ Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "retained:key"))+ )+ }++ let fullLoad = Task { @MainActor in+ await state.performRedisLoad(in: context) {+ await olderGate.enterAndWait()+ return Optional<Result<QueryResult, Error>>.some(+ .failure(ExpectedRedisDataGridError.obsolete)+ )+ }+ }+ await olderGate.waitUntilEntered()++ let pageLoad = Task { @MainActor in+ await state.performRedisLoad(in: context) {+ await newerGate.enterAndWait()+ return Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "page:key"))+ )+ }+ }+ await newerGate.waitUntilEntered()++ await olderGate.release()+ await fullLoad.value++ XCTAssertTrue(state.isLoading)+ XCTAssertEqual(state.rows, [[.string("retained:key")]])+ XCTAssertNil(state.errorMessage)++ await newerGate.release()+ await pageLoad.value++ XCTAssertFalse(state.isLoading)+ XCTAssertEqual(state.rows, [[.string("page:key")]])+ XCTAssertNil(state.errorMessage)+ }++ func test_olderFullLoadCompletingLastCannotReplaceNewerPageFailure() async {+ let state = DataGridViewState()+ let context = redisContext(databaseName: "db0", revision: 1)+ let olderGate = RedisOwnershipTestGate()+ state.bindRedisContext(context)++ await state.performRedisLoad(in: context) {+ Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "retained:key"))+ )+ }++ let fullLoad = Task { @MainActor in+ await state.performRedisLoad(in: context) {+ await olderGate.enterAndWait()+ return Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "obsolete:key"))+ )+ }+ }+ await olderGate.waitUntilEntered()++ await state.performRedisLoad(in: context) {+ Optional<Result<QueryResult, Error>>.some(+ .failure(ExpectedRedisDataGridError.current)+ )+ }++ XCTAssertFalse(state.isLoading)+ XCTAssertEqual(state.rows, [[.string("retained:key")]])+ XCTAssertEqual(state.errorMessage, "current page failed")++ await olderGate.release()+ await fullLoad.value++ XCTAssertFalse(state.isLoading)+ XCTAssertEqual(state.rows, [[.string("retained:key")]])+ XCTAssertEqual(state.errorMessage, "current page failed")+ }++ func test_oldDb0LoadCannotPublishAfterDb1ThenNewDb0Context() async {+ let state = DataGridViewState()+ let oldDB0 = redisContext(databaseName: "db0", revision: 1)+ let db1 = redisContext(databaseName: "db1", revision: 2)+ let newDB0 = redisContext(databaseName: "db0", revision: 3)+ let oldGate = RedisOwnershipTestGate()+ state.bindRedisContext(oldDB0)++ let oldLoad = Task { @MainActor in+ await state.performRedisLoad(in: oldDB0) {+ await oldGate.enterAndWait()+ return Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "old-db0:key"))+ )+ }+ }+ await oldGate.waitUntilEntered()++ state.bindRedisContext(db1)+ XCTAssertTrue(state.rows.isEmpty)+ await state.performRedisLoad(in: db1) {+ Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "db1:key"))+ )+ }+ state.bindRedisContext(newDB0)+ XCTAssertTrue(state.rows.isEmpty)+ await state.performRedisLoad(in: newDB0) {+ Optional<Result<QueryResult, Error>>.some(+ .success(self.queryResult(key: "new-db0:key"))+ )+ }++ await oldGate.release()+ await oldLoad.value++ XCTAssertEqual(state.redisContext, newDB0)+ XCTAssertEqual(state.rows, [[.string("new-db0:key")]])+ XCTAssertNil(state.errorMessage)+ XCTAssertFalse(state.isLoading)+ }++ func test_filteredRedisLoadsKeepTotalUnknownAndNeverReusePageCount() async throws {+ DataGridViewState.clearMetadataCache()+ let appState = AppState()+ let adapter = establishRedisContext(on: appState, databaseName: "db0")+ let db0 = try XCTUnwrap(appState.currentRedisContext)+ var fetchCount = 0++ let makeState: () -> DataGridViewState = {+ let state = DataGridViewState { _, _ in+ fetchCount += 1+ return self.queryResult(key: "result-\(fetchCount)")+ }+ state.appState = appState+ state.activeFilter = FilterExpression(+ conditions: [+ FilterCondition(+ column: "key",+ op: .like,+ value: .string("session:*")+ )+ ],+ combinator: .and+ )+ return state+ }++ let firstState = makeState()+ firstState.bindRedisContext(db0)+ await firstState.load(tableName: "Keys", schema: nil, adapter: adapter)++ XCTAssertEqual(fetchCount, 1)+ XCTAssertEqual(firstState.totalRows, 0)+ XCTAssertNil(firstState.statusRowCount)++ firstState.totalRows = 9_999+ await firstState.loadPage(1)++ XCTAssertEqual(fetchCount, 2)+ XCTAssertEqual(firstState.rows, [[.string("result-2")]])+ XCTAssertEqual(firstState.totalRows, 0)+ XCTAssertNil(firstState.statusRowCount)++ appState.currentDatabaseName = "db1"+ let db1 = try XCTUnwrap(appState.currentRedisContext)+ let secondState = makeState()+ secondState.bindRedisContext(db1)+ await secondState.load(tableName: "Keys", schema: nil, adapter: adapter)++ XCTAssertEqual(fetchCount, 3)+ XCTAssertEqual(secondState.rows, [[.string("result-3")]])+ XCTAssertEqual(secondState.totalRows, 0)+ XCTAssertNil(secondState.statusRowCount)+ }++ @discardableResult+ private func establishRedisContext(+ on state: AppState,+ databaseName: String+ ) -> RedisAdapter {+ let adapter = RedisAdapter()+ state.activeConnectionId =+ UUID(uuidString: "11111111-1111-1111-1111-111111111111")!+ state.activeAdapter = adapter+ state.currentDatabaseName = databaseName+ return adapter+ }++ private func redisContext(+ databaseName: String,+ revision: UInt64+ ) -> AppState.RedisTabContext {+ AppState.RedisTabContext(+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,+ databaseName: databaseName,+ sessionID: UUID(uuidString: "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")!,+ databaseRevision: revision+ )+ }++ private func queryResult(key: String) -> QueryResult {+ QueryResult(+ columns: [ColumnHeader(name: "key", dataType: "string")],+ rows: [[.string(key)]],+ rowsAffected: 0,+ executionTime: 0.01,+ queryType: .select+ )+ }+}++private enum ExpectedRedisDataGridError: LocalizedError {+ case current+ case obsolete++ var errorDescription: String? {+ switch self {+ case .current:+ "current page failed"+ case .obsolete:+ "obsolete full load failed"+ }+ }+}