fixed platform dependencies

2026-02-20 06:37:54 +01:00 · 2016-06-17 01:24:19 +09:00
parent 76a2bc1da2
commit 2dc09289bf
33 changed files with 662 additions and 48 deletions
--- a/CoreStoreTests/ObjectObserverTests.swift
+++ b/CoreStoreTests/ObjectObserverTests.swift
@@ -29,9 +29,215 @@ import XCTest
 import CoreStore


+#if os(iOS) || os(watchOS) || os(tvOS)
+
 // MARK: - ObjectObserverTests

 class ObjectObserverTests: BaseTestDataTestCase {
-
    
+    @objc
+    dynamic func test_ThatObjectObservers_CanReceiveUpdateNotifications() {
+        
+        self.prepareStack { (stack) in
+            
+            self.prepareTestDataForStack(stack, configurations: [nil])
+            
+            guard let object = stack.fetchOne(
+                From(TestEntity1),
+                Where("testEntityID", isEqualTo: 101)) else {
+                    
+                    XCTFail()
+                    return
+            }
+            let observer = TestObjectObserver()
+            let monitor = stack.monitorObject(object)
+            monitor.addObserver(observer)
+            
+            XCTAssertEqual(monitor.object, object)
+            XCTAssertFalse(monitor.isObjectDeleted)
+            
+            var events = 0
+            
+            let willUpdateExpectation = self.expectationForNotification(
+                "objectMonitor:willUpdateObject:",
+                object: observer,
+                handler: { (note) -> Bool in
+                    
+                    XCTAssertEqual(
+                        (note.userInfo ?? [:]),
+                        ["object": object] as NSDictionary
+                    )
+                    defer {
+                        
+                        events += 1
+                    }
+                    return events == 0
+                }
+            )
+            let didUpdateExpectation = self.expectationForNotification(
+                "objectMonitor:didUpdateObject:changedPersistentKeys:",
+                object: observer,
+                handler: { (note) -> Bool in
+                    
+                    XCTAssertEqual(
+                        (note.userInfo ?? [:]),
+                        [
+                            "object": object,
+                            "changedPersistentKeys": Set(
+                                [
+                                    "testNumber",
+                                    "testString"
+                                ]
+                            )
+                            ] as NSDictionary
+                    )
+                    let object = note.userInfo?["object"] as? TestEntity1
+                    XCTAssertEqual(object?.testNumber, NSNumber(integer: 10))
+                    XCTAssertEqual(object?.testString, "nil:TestEntity1:10")
+                    
+                    defer {
+                        
+                        events += 1
+                    }
+                    return events == 1
+                }
+            )
+            let saveExpectation = self.expectationWithDescription("save")
+            stack.beginAsynchronous { (transaction) in
+                
+                guard let object = transaction.edit(object) else {
+                    
+                    XCTFail()
+                    return
+                }
+                object.testNumber = NSNumber(integer: 10)
+                object.testString = "nil:TestEntity1:10"
+                
+                transaction.commit { (result) in
+                    
+                    switch result {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        saveExpectation.fulfill()
+                        
+                    case .Failure:
+                        XCTFail()
+                    }
+                }
+            }
+            self.waitAndCheckExpectations()
+        }
+    }
+    
+    @objc
+    dynamic func test_ThatObjectObservers_CanReceiveDeleteNotifications() {
+        
+        self.prepareStack { (stack) in
+            
+            self.prepareTestDataForStack(stack, configurations: [nil])
+            
+            guard let object = stack.fetchOne(
+                From(TestEntity1),
+                Where("testEntityID", isEqualTo: 101)) else {
+                    
+                    XCTFail()
+                    return
+            }
+            let observer = TestObjectObserver()
+            let monitor = stack.monitorObject(object)
+            monitor.addObserver(observer)
+            
+            XCTAssertEqual(monitor.object, object)
+            XCTAssertFalse(monitor.isObjectDeleted)
+            
+            var events = 0
+            
+            let didDeleteExpectation = self.expectationForNotification(
+                "objectMonitor:didDeleteObject:",
+                object: observer,
+                handler: { (note) -> Bool in
+                    
+                    XCTAssertEqual(
+                        (note.userInfo ?? [:]),
+                        ["object": object] as NSDictionary
+                    )
+                    defer {
+                        
+                        events += 1
+                    }
+                    return events == 0
+                }
+            )
+            let saveExpectation = self.expectationWithDescription("save")
+            stack.beginAsynchronous { (transaction) in
+                
+                guard let object = transaction.edit(object) else {
+                    
+                    XCTFail()
+                    return
+                }
+                transaction.delete(object)
+                
+                transaction.commit { (result) in
+                    
+                    switch result {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        XCTAssertTrue(monitor.isObjectDeleted)
+                        saveExpectation.fulfill()
+                        
+                    case .Failure:
+                        XCTFail()
+                    }
+                }
+            }
+            self.waitAndCheckExpectations()
+        }
+    }
 }
+
+
+// MARK: TestObjectObserver
+
+class TestObjectObserver: ObjectObserver {
+    
+    typealias ObjectEntityType = TestEntity1
+    
+    func objectMonitor(monitor: ObjectMonitor<TestEntity1>, willUpdateObject object: TestEntity1) {
+        
+        NSNotificationCenter.defaultCenter().postNotificationName(
+            "objectMonitor:willUpdateObject:",
+            object: self,
+            userInfo: [
+                "object": object
+            ]
+        )
+    }
+    
+    func objectMonitor(monitor: ObjectMonitor<TestEntity1>, didUpdateObject object: TestEntity1, changedPersistentKeys: Set<KeyPath>) {
+        
+        NSNotificationCenter.defaultCenter().postNotificationName(
+            "objectMonitor:didUpdateObject:changedPersistentKeys:",
+            object: self,
+            userInfo: [
+                "object": object,
+                "changedPersistentKeys": changedPersistentKeys
+            ]
+        )
+    }
+    
+    func objectMonitor(monitor: ObjectMonitor<TestEntity1>, didDeleteObject object: TestEntity1) {
+        
+        NSNotificationCenter.defaultCenter().postNotificationName(
+            "objectMonitor:didDeleteObject:",
+            object: self,
+            userInfo: [
+                "object": object
+            ]
+        )
+    }
+}
+
+#endif