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++
9.9 KB
Raw Blame
// 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_olderSuccessCompletingLastCannotReplaceNewerFailure() async {
        let state = RedisKeyBrowserViewState()
        let context = redisContext()
        let olderGate = 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(
                    .success(RedisKeyScanResult(
                        keys: ["obsolete:key"],
                        isTruncated: false
                    ))
                )
            }
        }
        await olderGate.waitUntilEntered()

        await state.scan(in: context) {
            Optional<Result<RedisKeyScanResult, Error>>.some(
                .failure(ExpectedBrowserScanError.failed)
            )
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.visibleResult(in: context)?.keys, ["retained:key"])
        XCTAssertEqual(state.visibleErrorMessage(in: context), "scan failed")

        await olderGate.release()
        await olderScan.value

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.visibleResult(in: context)?.keys, ["retained:key"])
        XCTAssertEqual(state.visibleErrorMessage(in: context), "scan failed")
    }

    func test_olderFailureCompletingLastCannotReplaceNewerSuccess() async {
        let state = RedisKeyBrowserViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()

        let olderScan = Task { @MainActor in
            await state.scan(in: context) {
                await olderGate.enterAndWait()
                return Optional<Result<RedisKeyScanResult, Error>>.some(
                    .failure(ExpectedBrowserScanError.obsolete)
                )
            }
        }
        await olderGate.waitUntilEntered()

        await state.scan(in: context) {
            Optional<Result<RedisKeyScanResult, Error>>.some(
                .success(RedisKeyScanResult(
                    keys: ["current:key"],
                    isTruncated: false
                ))
            )
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.visibleResult(in: context)?.keys, ["current:key"])
        XCTAssertNil(state.visibleErrorMessage(in: context))

        await olderGate.release()
        await olderScan.value

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.visibleResult(in: context)?.keys, ["current: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_refreshInvalidationRejectsCurrentSuccessBeforeReplacementRegisters() async {
        let state = RedisKeyBrowserViewState()
        let context = redisContext()
        let gate = RedisOwnershipTestGate()
        var refreshNonce = 0

        let scan = Task { @MainActor in
            await state.scan(
                in: context,
                isCurrent: { refreshNonce == 0 }
            ) {
                await gate.enterAndWait()
                return Optional<Result<RedisKeyScanResult, Error>>.some(
                    .success(RedisKeyScanResult(
                        keys: ["obsolete:key"],
                        isTruncated: false
                    ))
                )
            }
        }
        await gate.waitUntilEntered()

        refreshNonce = 1
        await gate.release()
        await scan.value

        XCTAssertFalse(state.isLoading)
        XCTAssertNil(state.visibleResult(in: context))
        XCTAssertNil(state.visibleErrorMessage(in: context))
    }

    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
    case obsolete

    var errorDescription: String? {
        switch self {
        case .failed:
            "scan failed"
        case .obsolete:
            "obsolete scan failed"
        }
    }
}