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++
21.8 KB
Raw Blame
// RedisKeyDetailViewStateTests.swift
// Gridex

import XCTest
@testable import Gridex

@MainActor
final class RedisKeyDetailViewStateTests: XCTestCase {

    // MARK: - Load ownership

    func test_newerLoadKeepsOwnershipWhenOlderSuccessCompletesFirst() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()
        let newerGate = RedisOwnershipTestGate()

        let olderLoad = Task { @MainActor in
            await state.load(in: context) {
                await olderGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .success(stringDetail(key: "obsolete", value: "old"))
                )
            }
        }
        await olderGate.waitUntilEntered()

        let newerLoad = Task { @MainActor in
            await state.load(in: context) {
                await newerGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .success(stringDetail(key: "current", value: "new"))
                )
            }
        }
        await newerGate.waitUntilEntered()

        await olderGate.release()
        await olderLoad.value

        XCTAssertTrue(state.isLoading)
        XCTAssertNil(state.detail)
        XCTAssertNil(state.errorMessage)

        await newerGate.release()
        await newerLoad.value

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
    }

    func test_olderLoadFailureCompletingLastCannotReplaceNewerSuccess() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()

        let olderLoad = Task { @MainActor in
            await state.load(in: context) {
                await olderGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .failure(ExpectedDetailError.obsoleteLoad)
                )
            }
        }
        await olderGate.waitUntilEntered()

        await state.load(in: context) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "current", value: "new"))
            )
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)

        await olderGate.release()
        await olderLoad.value

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
    }

    func test_olderLoadSuccessCompletingLastCannotReplaceNewerFailure() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()

        await state.load(in: context) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "retained", value: "existing"))
            )
        }

        let olderLoad = Task { @MainActor in
            await state.load(in: context) {
                await olderGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .success(stringDetail(key: "obsolete", value: "old"))
                )
            }
        }
        await olderGate.waitUntilEntered()

        await state.load(in: context) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .failure(ExpectedDetailError.loadFailed)
            )
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.detail?.key, "retained")
        XCTAssertEqual(state.errorMessage, "detail load failed")

        await olderGate.release()
        await olderLoad.value

        XCTAssertFalse(state.isLoading)
        XCTAssertEqual(state.detail?.key, "retained")
        XCTAssertEqual(state.errorMessage, "detail load failed")
    }

    func test_currentStaleLoadStopsLoadingWithoutPublishingDetailOrError() async {
        let state = RedisKeyDetailViewState()

        await state.load(in: redisContext()) {
            Optional<Result<RedisKeyDetail, Error>>.none
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertNil(state.detail)
        XCTAssertNil(state.errorMessage)
    }

    func test_loadScopesRetainedDetailAndFailureToExactRedisContext() async {
        let state = RedisKeyDetailViewState()
        let db0 = redisContext(databaseName: "db0", databaseRevision: 3)
        let db1 = redisContext(databaseName: "db1", databaseRevision: 4)

        await state.load(in: db0) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "db0:key", value: "db0"))
            )
        }
        XCTAssertEqual(state.detail?.key, "db0:key")

        await state.load(in: db1) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .failure(ExpectedDetailError.loadFailed)
            )
        }

        XCTAssertFalse(state.isLoading)
        XCTAssertNil(state.detail)
        XCTAssertEqual(state.errorMessage, "detail load failed")
    }

    func test_loadRejectsSameDatabaseRevisionABAContext() async {
        let state = RedisKeyDetailViewState()
        let oldDB0 = redisContext(databaseName: "db0", databaseRevision: 3)
        let newDB0 = redisContext(databaseName: "db0", databaseRevision: 5)

        await state.load(in: oldDB0) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "old-session:key", value: "old"))
            )
        }
        await state.load(in: newDB0) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .failure(ExpectedDetailError.loadFailed)
            )
        }

        XCTAssertNil(state.detail)
        XCTAssertEqual(state.errorMessage, "detail load failed")
    }

    func test_loadRejectsSameDatabaseSessionABAContext() async {
        let state = RedisKeyDetailViewState()
        let oldSession = redisContext(databaseName: "db0", databaseRevision: 3)
        let newSession = redisContext(
            databaseName: "db0",
            databaseRevision: 3,
            sessionID: UUID(uuidString: "BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB")!
        )

        await state.load(in: oldSession) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "old-session:key", value: "old"))
            )
        }
        await state.load(in: newSession) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .failure(ExpectedDetailError.loadFailed)
            )
        }

        XCTAssertNil(state.detail)
        XCTAssertEqual(state.errorMessage, "detail load failed")
    }

    // MARK: - Mutation ownership

    func test_newerMutationKeepsOwnershipWhenOlderSuccessCompletesFirst() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()
        let newerGate = RedisOwnershipTestGate()
        var olderSideEffects = 0
        var newerSideEffects = 0

        let olderMutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await olderGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(stringDetail(key: "obsolete", value: "old"))
                    )
                },
                onCurrentSuccess: { olderSideEffects += 1 }
            )
        }
        await olderGate.waitUntilEntered()

        let newerMutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await newerGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(stringDetail(key: "current", value: "new"))
                    )
                },
                onCurrentSuccess: { newerSideEffects += 1 }
            )
        }
        await newerGate.waitUntilEntered()

        await olderGate.release()
        let olderApplied = await olderMutation.value

        XCTAssertFalse(olderApplied)
        XCTAssertTrue(state.isMutating)
        XCTAssertNil(state.detail)
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 0)

        await newerGate.release()
        let newerApplied = await newerMutation.value

        XCTAssertTrue(newerApplied)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 1)
    }

    func test_olderMutationFailureCompletingLastCannotReplaceNewerSuccess() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()
        var olderSideEffects = 0
        var newerSideEffects = 0

        let olderMutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await olderGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .failure(ExpectedDetailError.obsoleteMutation)
                    )
                },
                onCurrentSuccess: { olderSideEffects += 1 }
            )
        }
        await olderGate.waitUntilEntered()

        let newerApplied = await state.mutate(
            in: context,
            execute: {
                Optional<Result<RedisKeyDetail?, Error>>.some(
                    .success(stringDetail(key: "current", value: "new"))
                )
            },
            onCurrentSuccess: { newerSideEffects += 1 }
        )

        XCTAssertTrue(newerApplied)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 1)

        await olderGate.release()
        let olderApplied = await olderMutation.value

        XCTAssertFalse(olderApplied)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 1)
    }

    func test_olderMutationSuccessCompletingLastCannotReplaceNewerSuccess() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let olderGate = RedisOwnershipTestGate()
        var olderSideEffects = 0
        var newerSideEffects = 0

        let olderMutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await olderGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(stringDetail(key: "obsolete", value: "old"))
                    )
                },
                onCurrentSuccess: { olderSideEffects += 1 }
            )
        }
        await olderGate.waitUntilEntered()

        let newerApplied = await state.mutate(
            in: context,
            execute: {
                Optional<Result<RedisKeyDetail?, Error>>.some(
                    .success(stringDetail(key: "current", value: "new"))
                )
            },
            onCurrentSuccess: { newerSideEffects += 1 }
        )

        XCTAssertTrue(newerApplied)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 1)

        await olderGate.release()
        let olderApplied = await olderMutation.value

        XCTAssertFalse(olderApplied)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "current")
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(olderSideEffects, 0)
        XCTAssertEqual(newerSideEffects, 1)
    }

    func test_currentStaleMutationStopsMutatingWithoutPublishingOrRunningSideEffect() async {
        let state = RedisKeyDetailViewState()
        var sideEffects = 0

        let applied = await state.mutate(
            in: redisContext(),
            execute: { Optional<Result<RedisKeyDetail?, Error>>.none },
            onCurrentSuccess: { sideEffects += 1 }
        )

        XCTAssertFalse(applied)
        XCTAssertFalse(state.isMutating)
        XCTAssertNil(state.detail)
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(sideEffects, 0)
    }

    func test_currentMutationFailurePublishesErrorWithoutRunningSideEffect() async {
        let state = RedisKeyDetailViewState()
        var sideEffects = 0

        let applied = await state.mutate(
            in: redisContext(),
            execute: {
                Optional<Result<RedisKeyDetail?, Error>>.some(
                    .failure(ExpectedDetailError.mutationFailed)
                )
            },
            onCurrentSuccess: { sideEffects += 1 }
        )

        XCTAssertFalse(applied)
        XCTAssertFalse(state.isMutating)
        XCTAssertNil(state.detail)
        XCTAssertEqual(state.errorMessage, "detail mutation failed")
        XCTAssertEqual(sideEffects, 0)
    }

    func test_loadRequestDoesNotSupersedeMutationOwnership() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let mutationGate = RedisOwnershipTestGate()
        let loadGate = RedisOwnershipTestGate()
        var mutationSideEffects = 0

        let mutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await mutationGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(stringDetail(key: "mutated", value: "written"))
                    )
                },
                onCurrentSuccess: { mutationSideEffects += 1 }
            )
        }
        await mutationGate.waitUntilEntered()

        let load = Task { @MainActor in
            await state.load(in: context) {
                await loadGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .success(stringDetail(key: "loaded", value: "read"))
                )
            }
        }
        await loadGate.waitUntilEntered()

        await mutationGate.release()
        let mutationApplied = await mutation.value

        XCTAssertTrue(mutationApplied)
        XCTAssertFalse(state.isMutating)
        XCTAssertTrue(state.isLoading)
        XCTAssertEqual(state.detail?.key, "mutated")
        XCTAssertEqual(mutationSideEffects, 1)

        await loadGate.release()
        await load.value

        XCTAssertFalse(state.isLoading)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "loaded")
        XCTAssertEqual(mutationSideEffects, 1)
    }

    func test_mutationRequestDoesNotSupersedeLoadOwnership() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        let loadGate = RedisOwnershipTestGate()
        let mutationGate = RedisOwnershipTestGate()
        var mutationSideEffects = 0

        let load = Task { @MainActor in
            await state.load(in: context) {
                await loadGate.enterAndWait()
                return Optional<Result<RedisKeyDetail, Error>>.some(
                    .success(stringDetail(key: "loaded", value: "read"))
                )
            }
        }
        await loadGate.waitUntilEntered()

        let mutation = Task { @MainActor in
            await state.mutate(
                in: context,
                execute: {
                    await mutationGate.enterAndWait()
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(stringDetail(key: "mutated", value: "written"))
                    )
                },
                onCurrentSuccess: { mutationSideEffects += 1 }
            )
        }
        await mutationGate.waitUntilEntered()

        await loadGate.release()
        await load.value

        XCTAssertFalse(state.isLoading)
        XCTAssertTrue(state.isMutating)
        XCTAssertEqual(state.detail?.key, "loaded")
        XCTAssertEqual(mutationSideEffects, 0)

        await mutationGate.release()
        let mutationApplied = await mutation.value

        XCTAssertTrue(mutationApplied)
        XCTAssertFalse(state.isLoading)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "mutated")
        XCTAssertEqual(mutationSideEffects, 1)
    }

    // MARK: - Mutation result semantics

    func test_currentRenameSuccessRunsNotificationSideEffectWithoutReplacingDetail() async {
        let state = RedisKeyDetailViewState()
        let context = redisContext()
        var notificationCount = 0

        await state.load(in: context) {
            Optional<Result<RedisKeyDetail, Error>>.some(
                .success(stringDetail(key: "old-name", value: "value"))
            )
        }

        let applied = await state.mutate(
            in: context,
            execute: {
                Optional<Result<RedisKeyDetail?, Error>>.some(.success(nil))
            },
            onCurrentSuccess: { notificationCount += 1 }
        )

        XCTAssertTrue(applied)
        XCTAssertFalse(state.isMutating)
        XCTAssertEqual(state.detail?.key, "old-name")
        XCTAssertNil(state.errorMessage)
        XCTAssertEqual(notificationCount, 1)
    }

    func test_currentTTLHashSetAndZSetMutationsPublishFetchedDetailAndClearDraft() async {
        let scenarios: [(RedisKeyDetail, [String], Int?)] = [
            (
                RedisKeyDetail(
                    key: "ttl:key",
                    type: .string,
                    ttl: 120,
                    data: .string(value: "ttl-value"),
                    memoryBytes: 9
                ),
                ["string:ttl-value"],
                120
            ),
            (
                RedisKeyDetail(
                    key: "hash:key",
                    type: .hash,
                    ttl: nil,
                    data: .hash(fields: [(field: "name", value: "Gridex")]),
                    memoryBytes: 18
                ),
                ["hash:name=Gridex"],
                nil
            ),
            (
                RedisKeyDetail(
                    key: "set:key",
                    type: .set,
                    ttl: nil,
                    data: .set(members: ["alpha", "beta"]),
                    memoryBytes: 27
                ),
                ["set:alpha", "set:beta"],
                nil
            ),
            (
                RedisKeyDetail(
                    key: "zset:key",
                    type: .zset,
                    ttl: nil,
                    data: .zset(members: [(member: "ranked", score: 4.5)]),
                    memoryBytes: 36
                ),
                ["zset:ranked=4.5"],
                nil
            )
        ]

        for (fetchedDetail, expectedData, expectedTTL) in scenarios {
            let state = RedisKeyDetailViewState()
            var draft = "dirty"
            var executeCount = 0

            let applied = await state.mutate(
                in: redisContext(),
                execute: {
                    executeCount += 1
                    return Optional<Result<RedisKeyDetail?, Error>>.some(
                        .success(fetchedDetail)
                    )
                },
                onCurrentSuccess: { draft = "" }
            )

            XCTAssertTrue(applied)
            XCTAssertEqual(executeCount, 1)
            XCTAssertEqual(state.detail?.key, fetchedDetail.key)
            XCTAssertEqual(state.detail?.ttl, expectedTTL)
            XCTAssertEqual(detailDataSnapshot(state.detail?.data), expectedData)
            XCTAssertNil(state.errorMessage)
            XCTAssertFalse(state.isMutating)
            XCTAssertEqual(draft, "")
        }
    }

    // MARK: - Fixtures

    private func redisContext(
        databaseName: String = "db0",
        databaseRevision: UInt64 = 3,
        sessionID: UUID =
            UUID(uuidString: "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")!
    ) -> AppState.RedisTabContext {
        AppState.RedisTabContext(
            connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
            databaseName: databaseName,
            sessionID: sessionID,
            databaseRevision: databaseRevision
        )
    }

    private func stringDetail(
        key: String,
        value: String,
        ttl: Int? = nil
    ) -> RedisKeyDetail {
        RedisKeyDetail(
            key: key,
            type: .string,
            ttl: ttl,
            data: .string(value: value),
            memoryBytes: nil
        )
    }

    private func detailDataSnapshot(_ data: RedisKeyData?) -> [String] {
        guard let data else { return [] }
        switch data {
        case .string(let value):
            return ["string:\(value)"]
        case .hash(let fields):
            return fields.map { "hash:\($0.field)=\($0.value)" }
        case .list(let items):
            return items.map { "list:\($0)" }
        case .set(let members):
            return members.map { "set:\($0)" }
        case .zset(let members):
            return members.map { "zset:\($0.member)=\($0.score)" }
        }
    }
}

private enum ExpectedDetailError: LocalizedError {
    case loadFailed
    case obsoleteLoad
    case mutationFailed
    case obsoleteMutation

    var errorDescription: String? {
        switch self {
        case .loadFailed:
            "detail load failed"
        case .obsoleteLoad:
            "obsolete detail load failed"
        case .mutationFailed:
            "detail mutation failed"
        case .obsoleteMutation:
            "obsolete detail mutation failed"
        }
    }
}