TablePro/TableProTests/Core/ChangeTracking/AnyChangeManagerTests.swift at 57a397fb8ec54e2916317c43f6dbf72e81009ad6 · TableProApp/TablePro · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
//
//  AnyChangeManagerTests.swift
//  TableProTests
//
//  Tests for AnyChangeManager type-erased wrapper and [weak self] sink fix.
//

import Foundation
@testable import TablePro
import Testing

@MainActor
@Suite("AnyChangeManager")
struct AnyChangeManagerTests {
    // MARK: - DataChangeManager Wrapper Tests

    @Test("DataChangeManager wrapper: hasChanges forwards correctly")
    func dataManagerHasChangesForwards() {
        let dataManager = DataChangeManager()
        dataManager.configureForTable(tableName: "users", columns: ["id", "name"], primaryKeyColumns: ["id"])
        let wrapper = AnyChangeManager(dataManager)

        #expect(wrapper.hasChanges == false)

        dataManager.recordCellChange(rowIndex: 0, columnIndex: 1, columnName: "name", oldValue: "Alice", newValue: "Bob")

        #expect(dataManager.hasChanges == true)
        #expect(wrapper.hasChanges == true)
    }

    @Test("DataChangeManager wrapper: reloadVersion forwards correctly")
    func dataManagerReloadVersionForwards() {
        let dataManager = DataChangeManager()
        dataManager.configureForTable(tableName: "users", columns: ["id", "name"], primaryKeyColumns: ["id"])
        let wrapper = AnyChangeManager(dataManager)

        let initialVersion = wrapper.reloadVersion
        dataManager.reloadVersion += 1

        #expect(wrapper.reloadVersion == initialVersion + 1)
    }

    @Test("isRowDeleted delegates correctly for DataChangeManager")
    func isRowDeletedDelegatesCorrectly() {
        let dataManager = DataChangeManager()
        dataManager.configureForTable(tableName: "users", columns: ["id", "name"], primaryKeyColumns: ["id"])
        let wrapper = AnyChangeManager(dataManager)

        #expect(wrapper.isRowDeleted(0) == false)

        dataManager.recordRowDeletion(rowIndex: 0, originalRow: ["1", "Alice"])

        #expect(wrapper.isRowDeleted(0) == true)
    }

    @Test("recordCellChange forwards to DataChangeManager")
    func recordCellChangeForwards() {
        let dataManager = DataChangeManager()
        dataManager.configureForTable(tableName: "users", columns: ["id", "name"], primaryKeyColumns: ["id"])
        let wrapper = AnyChangeManager(dataManager)

        wrapper.recordCellChange(rowIndex: 0, columnIndex: 1, columnName: "name", oldValue: "Alice", newValue: "Bob", originalRow: ["1", "Alice"])

        #expect(dataManager.hasChanges == true)
        #expect(!wrapper.rowChanges.isEmpty)
    }

    @Test("No retain cycle — wrapper can be deallocated")
    func noRetainCycleOnWrapper() {
        let dataManager = DataChangeManager()
        dataManager.configureForTable(tableName: "users", columns: ["id", "name"], primaryKeyColumns: ["id"])

        weak var weakWrapper: AnyChangeManager?

        do {
            let wrapper = AnyChangeManager(dataManager)
            weakWrapper = wrapper
            #expect(weakWrapper != nil)
        }

        #expect(weakWrapper == nil)
    }

    // MARK: - StructureChangeManager Wrapper Tests

    @Test("StructureChangeManager wrapper: isRowDeleted always returns false")
    func structureManagerIsRowDeletedAlwaysFalse() {
        let structureManager = StructureChangeManager()
        let wrapper = AnyChangeManager(structureManager)

        #expect(wrapper.isRowDeleted(0) == false)
        #expect(wrapper.isRowDeleted(100) == false)
    }

    @Test("StructureChangeManager wrapper: consumeChangedRowIndices returns empty set")
    func structureManagerConsumeChangedRowIndicesEmpty() {
        let structureManager = StructureChangeManager()
        let wrapper = AnyChangeManager(structureManager)

        let indices = wrapper.consumeChangedRowIndices()
        #expect(indices.isEmpty)
    }

    @Test("StructureChangeManager wrapper: hasChanges forwards correctly when false")
    func structureManagerHasChangesForwardsFalse() {
        let structureManager = StructureChangeManager()
        let wrapper = AnyChangeManager(structureManager)

        #expect(wrapper.hasChanges == false)
    }

    @Test("StructureChangeManager wrapper: hasChanges forwards correctly when true")
    func structureManagerHasChangesForwardsTrue() {
        let structureManager = StructureChangeManager()
        let wrapper = AnyChangeManager(structureManager)

        structureManager.addNewColumn()

        #expect(wrapper.hasChanges == true)
    }

    @Test("StructureChangeManager wrapper: reloadVersion forwards correctly")
    func structureManagerReloadVersionForwards() {
        let structureManager = StructureChangeManager()
        let wrapper = AnyChangeManager(structureManager)

        let initialVersion = wrapper.reloadVersion
        structureManager.reloadVersion = 5

        #expect(wrapper.reloadVersion == 5)
        #expect(wrapper.reloadVersion != initialVersion)
    }
}