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(redis): expose browser request ownership races (RED)

Tobi95c7a7ab6943
diff --git a/macos/Tests/GridexTests/RedisKeyBrowserViewStateTests.swift b/macos/Tests/GridexTests/RedisKeyBrowserViewStateTests.swift
new file mode 100644
index 0000000..ca54830
--- /dev/null
+++ b/macos/Tests/GridexTests/RedisKeyBrowserViewStateTests.swift
@@ -0,0 +1,186 @@
+// RedisKeyBrowserViewStateTests.swift
+// Gridex
+
+import XCTest
+@testable import Gridex
+
+@MainActor
+final class RedisKeyBrowserViewStateTests: XCTestCase {
+
+ func test_newerScanKeepsOwnershipWhenOlderSuccessCompletesFirst() async {
+ let state = RedisKeyBrowserViewState()
+ let context = redisContext()
+ let olderGate = RedisOwnershipTestGate()
+ let newerGate = RedisOwnershipTestGate()
+
+ let olderScan = Task { @MainActor in
+ await state.scan(in: context) {
+ await olderGate.enterAndWait()
+ return Optional<Result<RedisKeyScanResult, Error>>.some(
+ .success(RedisKeyScanResult(
+ keys: ["obsolete:key"],
+ isTruncated: false
+ ))
+ )
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerScan = Task { @MainActor in
+ await state.scan(in: context) {
+ await newerGate.enterAndWait()
+ return Optional<Result<RedisKeyScanResult, Error>>.some(
+ .success(RedisKeyScanResult(
+ keys: ["current:key"],
+ isTruncated: false
+ ))
+ )
+ }
+ }
+ await newerGate.waitUntilEntered()
+
+ await olderGate.release()
+ await olderScan.value
+
+ XCTAssertTrue(state.isLoading)
+ XCTAssertNil(state.visibleResult(in: context))
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+
+ await newerGate.release()
+ await newerScan.value
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertEqual(state.visibleResult(in: context)?.keys, ["current:key"])
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+ }
+
+ func test_newerScanKeepsOwnershipWhenOlderFailureCompletesFirst() async {
+ let state = RedisKeyBrowserViewState()
+ let context = redisContext()
+ let olderGate = RedisOwnershipTestGate()
+ let newerGate = RedisOwnershipTestGate()
+
+ await state.scan(in: context) {
+ Optional<Result<RedisKeyScanResult, Error>>.some(
+ .success(RedisKeyScanResult(
+ keys: ["retained:key"],
+ isTruncated: false
+ ))
+ )
+ }
+
+ let olderScan = Task { @MainActor in
+ await state.scan(in: context) {
+ await olderGate.enterAndWait()
+ return Optional<Result<RedisKeyScanResult, Error>>.some(
+ .failure(ExpectedBrowserScanError.failed)
+ )
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerScan = Task { @MainActor in
+ await state.scan(in: context) {
+ await newerGate.enterAndWait()
+ return Optional<Result<RedisKeyScanResult, Error>>.some(
+ .success(RedisKeyScanResult(
+ keys: ["fresh:key"],
+ isTruncated: false
+ ))
+ )
+ }
+ }
+ await newerGate.waitUntilEntered()
+
+ await olderGate.release()
+ await olderScan.value
+
+ XCTAssertTrue(state.isLoading)
+ XCTAssertEqual(state.visibleResult(in: context)?.keys, ["retained:key"])
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+
+ await newerGate.release()
+ await newerScan.value
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertEqual(state.visibleResult(in: context)?.keys, ["fresh:key"])
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+ }
+
+ func test_currentStaleScanStopsLoadingWithoutPublishingContent() async {
+ let state = RedisKeyBrowserViewState()
+ let context = redisContext()
+
+ await state.scan(in: context) {
+ Optional<Result<RedisKeyScanResult, Error>>.none
+ }
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertNil(state.visibleResult(in: context))
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+ }
+
+ func test_currentFailurePublishesErrorAndStopsLoading() async {
+ let state = RedisKeyBrowserViewState()
+ let context = redisContext()
+
+ await state.scan(in: context) {
+ Optional<Result<RedisKeyScanResult, Error>>.some(
+ .failure(ExpectedBrowserScanError.failed)
+ )
+ }
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertNil(state.visibleResult(in: context))
+ XCTAssertEqual(
+ state.visibleErrorMessage(in: context),
+ "scan failed"
+ )
+ }
+
+ func test_deactivateInvalidatesRunningScanAndStopsItsLoadingState() async {
+ let state = RedisKeyBrowserViewState()
+ let context = redisContext()
+ let gate = RedisOwnershipTestGate()
+
+ let scan = Task { @MainActor in
+ await state.scan(in: context) {
+ await gate.enterAndWait()
+ return Optional<Result<RedisKeyScanResult, Error>>.some(
+ .success(RedisKeyScanResult(
+ keys: ["stale:key"],
+ isTruncated: false
+ ))
+ )
+ }
+ }
+ await gate.waitUntilEntered()
+
+ state.deactivate()
+ XCTAssertFalse(state.isLoading)
+
+ await gate.release()
+ await scan.value
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertNil(state.visibleResult(in: context))
+ XCTAssertNil(state.visibleErrorMessage(in: context))
+ }
+
+ private func redisContext() -> AppState.RedisTabContext {
+ AppState.RedisTabContext(
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0",
+ sessionID: UUID(uuidString: "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")!,
+ databaseRevision: 3
+ )
+ }
+}
+
+private enum ExpectedBrowserScanError: LocalizedError {
+ case failed
+
+ var errorDescription: String? {
+ "scan failed"
+ }
+}
diff --git a/macos/Tests/GridexTests/RedisOwnershipTestSupport.swift b/macos/Tests/GridexTests/RedisOwnershipTestSupport.swift
new file mode 100644
index 0000000..2f8d81f
--- /dev/null
+++ b/macos/Tests/GridexTests/RedisOwnershipTestSupport.swift
@@ -0,0 +1,36 @@
+// RedisOwnershipTestSupport.swift
+// Gridex
+
+import Foundation
+
+actor RedisOwnershipTestGate {
+ 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 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
+ }
+}
diff --git a/macos/Tests/GridexTests/RedisRequestCoordinatorTests.swift b/macos/Tests/GridexTests/RedisRequestCoordinatorTests.swift
new file mode 100644
index 0000000..7d23a3f
--- /dev/null
+++ b/macos/Tests/GridexTests/RedisRequestCoordinatorTests.swift
@@ -0,0 +1,106 @@
+// RedisRequestCoordinatorTests.swift
+// Gridex
+
+import XCTest
+@testable import Gridex
+
+@MainActor
+final class RedisRequestCoordinatorTests: XCTestCase {
+
+ func test_olderNilCompletionIsSupersededBeforeNilIsClassifiedAsStale() async {
+ let coordinator = RedisRequestCoordinator()
+ let context = redisContext()
+ let olderGate = RedisOwnershipTestGate()
+ let newerGate = RedisOwnershipTestGate()
+
+ let olderRequest = Task { @MainActor in
+ await coordinator.perform(for: context) {
+ await olderGate.enterAndWait()
+ return Optional<Result<String, Error>>.none
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerRequest = Task { @MainActor in
+ await coordinator.perform(for: context) {
+ await newerGate.enterAndWait()
+ return Optional<Result<String, Error>>.none
+ }
+ }
+ await newerGate.waitUntilEntered()
+
+ await olderGate.release()
+ let olderCompletion = await olderRequest.value
+
+ guard case .superseded = olderCompletion else {
+ return XCTFail("An older nil completion must not settle the newer request")
+ }
+
+ await newerGate.release()
+ let newerCompletion = await newerRequest.value
+
+ guard case .stale = newerCompletion else {
+ return XCTFail("The current nil completion should be classified as stale")
+ }
+ }
+
+ func test_currentSuccessIsReturnedAsCurrent() async {
+ let coordinator = RedisRequestCoordinator()
+
+ let completion = await coordinator.perform(for: redisContext()) {
+ Optional<Result<String, Error>>.some(.success("current value"))
+ }
+
+ guard case .current(.success(let value)) = completion else {
+ return XCTFail("Expected a current success")
+ }
+ XCTAssertEqual(value, "current value")
+ }
+
+ func test_currentFailureIsReturnedAsCurrent() async {
+ let coordinator = RedisRequestCoordinator()
+
+ let completion = await coordinator.perform(for: redisContext()) {
+ Optional<Result<String, Error>>.some(.failure(ExpectedRequestError.failed))
+ }
+
+ guard case .current(.failure(let error)) = completion else {
+ return XCTFail("Expected a current failure")
+ }
+ XCTAssertTrue(error is ExpectedRequestError)
+ }
+
+ func test_invalidateSupersedesRunningRequest() async {
+ let coordinator = RedisRequestCoordinator()
+ let gate = RedisOwnershipTestGate()
+
+ let request = Task { @MainActor in
+ await coordinator.perform(for: redisContext()) {
+ await gate.enterAndWait()
+ return Optional<Result<String, Error>>.some(.success("obsolete"))
+ }
+ }
+ await gate.waitUntilEntered()
+
+ coordinator.invalidate()
+ await gate.release()
+
+ let completion = await request.value
+ guard case .superseded = completion else {
+ return XCTFail("Invalidation must supersede an in-flight request")
+ }
+ }
+
+ private func redisContext() -> AppState.RedisTabContext {
+ AppState.RedisTabContext(
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0",
+ sessionID: UUID(uuidString: "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")!,
+ databaseRevision: 3
+ )
+ }
+}
+
+private enum ExpectedRequestError: Error {
+ case failed
+}