Update test

Author: ra1028

Sources/Atoms/Core/StoreContext.swift

@@ -34,7 +34,6 @@ internal struct StoreContext {
         // The dependencies added in `willSet/didSet` will not be released until the value is invalidated and
         // is going to be a bug, so `AtomTransactionContenxt` will no longer be passed.
         // https://github.com/ra1028/swiftui-atom-properties/issues/18
-        let store = getStore()
         let key = AtomKey(atom)
         let transaction = Transaction(key: key) {
             // Do nothing.
@@ -43,8 +42,6 @@ internal struct StoreContext {
             update(atom: atom, with: value, updatesChildrenOnNextRunLoop: updatesChildrenOnNextRunLoop)
         }
 
-        store.state.transactions[key] = transaction
-
         context.transaction { context in
             atom.willSet(newValue: value, oldValue: oldValue, context: context)
             update(atom: atom, with: value)

Tests/AtomsTests/Context/AtomRelationContextTests.swift

@@ -79,24 +79,6 @@ final class AtomTestContextTests: XCTestCase {
     }
 
     func testObserve() {
-        final class TestObserver: AtomObserver {
-            var asignedAtomKeys = [AtomKey]()
-            var unassignedAtomKeys = [AtomKey]()
-            var changedAtomKeys = [AtomKey]()
-
-            func atomAssigned<Node: Atom>(atom: Node) {
-                asignedAtomKeys.append(AtomKey(atom))
-            }
-
-            func atomUnassigned<Node: Atom>(atom: Node) {
-                unassignedAtomKeys.append(AtomKey(atom))
-            }
-
-            func atomChanged<Node: Atom>(snapshot: Snapshot<Node>) {
-                changedAtomKeys.append(AtomKey(snapshot.atom))
-            }
-        }
-
         let atom = TestStateAtom(defaultValue: 100)
         let key = AtomKey(atom)
         let observers = [TestObserver(), TestObserver()]
@@ -109,23 +91,23 @@ final class AtomTestContextTests: XCTestCase {
         context.watch(atom)
 
         for observer in observers {
-            XCTAssertEqual(observer.asignedAtomKeys, [key])
+            XCTAssertEqual(observer.assignedAtomKeys, [key])
             XCTAssertEqual(observer.unassignedAtomKeys, [])
             XCTAssertEqual(observer.changedAtomKeys, [key])
         }
 
         context[atom] = 200
 
         for observer in observers {
-            XCTAssertEqual(observer.asignedAtomKeys, [key])
+            XCTAssertEqual(observer.assignedAtomKeys, [key])
             XCTAssertEqual(observer.unassignedAtomKeys, [])
             XCTAssertEqual(observer.changedAtomKeys, [key, key])
         }
 
         context.unwatch(atom)
 
         for observer in observers {
-            XCTAssertEqual(observer.asignedAtomKeys, [key])
+            XCTAssertEqual(observer.assignedAtomKeys, [key])
             XCTAssertEqual(observer.unassignedAtomKeys, [key])
             XCTAssertEqual(observer.changedAtomKeys, [key, key])
         }

Tests/AtomsTests/Context/AtomTestContextTests.swift

@@ -0,0 +1,105 @@
+import XCTest
+
+@testable import Atoms
+
+@MainActor
+final class AtomTransactionContextTests: XCTestCase {
+    func testRead() {
+        let atom = TestValueAtom(value: 100)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        XCTAssertEqual(context.read(atom), 100)
+    }
+
+    func testSet() {
+        let atom = TestStateAtom(defaultValue: 100)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        XCTAssertEqual(context.watch(atom), 100)
+
+        context.set(200, for: atom)
+
+        XCTAssertEqual(context.watch(atom), 200)
+    }
+
+    func testRefresh() async {
+        let atom = TestTaskAtom(value: 100)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        let value = await context.refresh(atom).value
+
+        XCTAssertEqual(value, 100)
+    }
+
+    func testReset() {
+        let atom = TestStateAtom(defaultValue: 0)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        XCTAssertEqual(context.watch(atom), 0)
+
+        context[atom] = 100
+
+        XCTAssertEqual(context.watch(atom), 100)
+
+        context.reset(atom)
+
+        XCTAssertEqual(context.read(atom), 0)
+    }
+
+    func testWatch() {
+        let atom0 = TestValueAtom(value: 100)
+        let atom1 = TestStateAtom(defaultValue: 200)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom0)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        let value = context.watch(atom1)
+
+        XCTAssertEqual(value, 200)
+        XCTAssertEqual(store.graph.children, [AtomKey(atom1): [AtomKey(atom0)]])
+        XCTAssertEqual(store.graph.dependencies, [AtomKey(atom0): [AtomKey(atom1)]])
+    }
+
+    func testAddTermination() {
+        let atom = TestValueAtom(value: 100)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+
+        context.addTermination {}
+
+        XCTAssertEqual(transaction.terminations.count, 1)
+
+        transaction.terminate()
+        context.addTermination {}
+
+        XCTAssertEqual(transaction.terminations.count, 0)
+    }
+
+    func testKeepUntilTermination() {
+        let atom = TestValueAtom(value: 100)
+        let store = Store()
+        let transaction = Transaction(key: AtomKey(atom)) {}
+        let context = AtomTransactionContext(store: StoreContext(store), transaction: transaction)
+        var object: Object? = Object()
+        weak var objectRef = object
+
+        context.keepUntilTermination(object!)
+
+        XCTAssertNotNil(objectRef)
+
+        object = nil
+        XCTAssertNotNil(objectRef)
+
+        transaction.terminate()
+        XCTAssertNil(objectRef)
+    }
+}