added testing for logger behaviors

CoreStoreDemo/CoreStoreDemo/Loggers Demo/CustomLoggerViewController.swift

@@ -88,11 +88,6 @@ class CustomLoggerViewController: UIViewController, CoreStoreLogger {
         }
     }
     
-    @noreturn func fatalError(message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
-        
-        Swift.fatalError("\((fileName.stringValue as NSString).lastPathComponent):\(lineNumber) \(functionName)\n  ↪︎ [Abort] \(message)")
-    }
-    
     
     // MARK: Private
     

CoreStoreTests/BaseTests/BaseTestCase.swift

@@ -36,7 +36,7 @@ class BaseTestCase: XCTestCase {
     // MARK: Internal
     
     @nonobjc
-    func prepareStack(configurations configurations: [String?] = [nil], @noescape _ closure: (dataStack: DataStack) -> Void) {
+    func prepareStack<T>(configurations configurations: [String?] = [nil], @noescape _ closure: (dataStack: DataStack) -> T) -> T {
         
         let stack = DataStack(
             modelName: "Model",
@@ -61,7 +61,36 @@ class BaseTestCase: XCTestCase {
             
             XCTFail(error.coreStoreDumpString)
         }
-        closure(dataStack: stack)
+        return closure(dataStack: stack)
+    }
+    
+    @nonobjc
+    func expectLogger<T>(expectations: [TestLogger.Expectation], @noescape closure: () -> T) -> T {
+        
+        CoreStore.logger = TestLogger(self.prepareLoggerExpectations(expectations))
+        defer {
+            
+            self.waitForExpectationsWithTimeout(0, handler: nil)
+            CoreStore.logger = DefaultLogger()
+        }
+        return closure()
+    }
+    
+    @nonobjc
+    func expectLogger(expectations: [TestLogger.Expectation: XCTestExpectation]) {
+        
+        CoreStore.logger = TestLogger(expectations)
+    }
+    
+    @nonobjc
+    func prepareLoggerExpectations(expectations: [TestLogger.Expectation]) -> [TestLogger.Expectation: XCTestExpectation] {
+        
+        var testExpectations: [TestLogger.Expectation: XCTestExpectation] = [:]
+        for expectation in expectations {
+            
+            testExpectations[expectation] = self.expectationWithDescription("Logger Expectation: \(expectation)")
+        }
+        return testExpectations
     }
     
     
@@ -71,10 +100,12 @@ class BaseTestCase: XCTestCase {
         
         super.setUp()
         self.deleteStores()
+        CoreStore.logger = TestLogger([:])
     }
     
     override func tearDown() {
         
+        CoreStore.logger = DefaultLogger()
         self.deleteStores()
         super.tearDown()
     }
@@ -87,3 +118,74 @@ class BaseTestCase: XCTestCase {
         _ = try? NSFileManager.defaultManager().removeItemAtURL(SQLiteStore.defaultRootDirectory)
     }
 }
+
+
+// MARK: - TestLogger
+
+class TestLogger: CoreStoreLogger {
+    
+    enum Expectation {
+        
+        case LogWarning
+        case LogFatal
+        case LogError
+        case AssertionFailure
+        case FatalError
+    }
+    
+    init(_ expectations: [Expectation: XCTestExpectation]) {
+        
+        self.expectations = expectations
+    }
+    
+    
+    // MARK: CoreStoreLogger
+    
+    func log(level level: LogLevel, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
+        
+        switch level {
+            
+        case .Warning:  self.fulfill(.LogWarning)
+        case .Fatal:    self.fulfill(.LogFatal)
+        default:        break
+        }
+    }
+    
+    func log(error error: CoreStoreError, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
+        
+        self.fulfill(.LogError)
+    }
+    
+    func assert(@autoclosure condition: () -> Bool, @autoclosure message: () -> String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
+        
+        if condition() {
+            
+            return
+        }
+        self.fulfill(.AssertionFailure)
+    }
+    
+    @noreturn func fatalError(message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
+        
+        self.fulfill(.FatalError)
+        Swift.fatalError()
+    }
+    
+    
+    // MARK: Private
+    
+    private var expectations: [Expectation: XCTestExpectation]
+    
+    private func fulfill(expectation: Expectation) {
+        
+        if let instance = self.expectations[expectation] {
+            
+            instance.fulfill()
+            self.expectations[expectation] = nil
+        }
+        else {
+            
+            XCTFail("Unexpected Logger Action: \(expectation)")
+        }
+    }
+}

CoreStoreTests/FetchTests.swift

@@ -138,7 +138,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K > %@", "testNumber", 1),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let object = stack.fetchOne(from, fetchClauses)
+                    let object = self.expectLogger([.LogWarning]) {
+                        
+                        stack.fetchOne(from, fetchClauses)
+                    }
                     XCTAssertNil(object)
                     
                     let objectID = stack.fetchObjectID(from, fetchClauses)
@@ -309,7 +312,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K > %@", "testNumber", 1),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let object = stack.fetchOne(from, fetchClauses)
+                    let object = self.expectLogger([.LogWarning]) {
+                        
+                        stack.fetchOne(from, fetchClauses)
+                    }
                     XCTAssertNil(object)
                     
                     let objectID = stack.fetchObjectID(from, fetchClauses)
@@ -631,7 +637,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K < %@", "testNumber", 4),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let objects = stack.fetchAll(from, fetchClauses)
+                    let objects = self.expectLogger([.LogWarning]) {
+                        
+                        stack.fetchAll(from, fetchClauses)
+                    }
                     XCTAssertNil(objects)
                     
                     let objectIDs = stack.fetchObjectIDs(from, fetchClauses)
@@ -869,7 +878,10 @@ final class FetchTests: BaseTestDataTestCase {
                     let fetchClauses: [FetchClause] = [
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let objects = stack.fetchAll(from, fetchClauses)
+                    let objects = self.expectLogger([.LogWarning]) {
+                        
+                        stack.fetchAll(from, fetchClauses)
+                    }
                     XCTAssertNil(objects)
                     
                     let objectIDs = stack.fetchObjectIDs(from, fetchClauses)
@@ -1186,11 +1198,14 @@ final class FetchTests: BaseTestDataTestCase {
                 let from = From<TestEntity1>("Config1")
                 do {
                     
-                    let count = stack.fetchCount(
+                    let count = self.expectLogger([.LogWarning]) {
-                        from,
+                        
-                        Where("%K < %@", "testNumber", 4),
+                        stack.fetchCount(
-                        OrderBy(.Ascending("testEntityID"))
+                            from,
-                    )
+                            Where("%K < %@", "testNumber", 4),
+                            OrderBy(.Ascending("testEntityID"))
+                        )
+                    }
                     XCTAssertNil(count)
                 }
                 do {
@@ -1327,11 +1342,14 @@ final class FetchTests: BaseTestDataTestCase {
                 let from = From<TestEntity1>("Config2")
                 do {
                     
-                    let count = stack.fetchCount(
+                    let count = self.expectLogger([.LogWarning]) {
-                        from,
+                        
-                        Where("%K < %@", "testNumber", 4),
+                        stack.fetchCount(
-                        OrderBy(.Ascending("testEntityID"))
+                            from,
-                    )
+                            Where("%K < %@", "testNumber", 4),
+                            OrderBy(.Ascending("testEntityID"))
+                        )
+                    }
                     XCTAssertNil(count)
                 }
                 do {
@@ -1571,7 +1589,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K > %@", "testNumber", 1),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let object = transaction.fetchOne(from, fetchClauses)
+                    let object = self.expectLogger([.LogWarning]) {
+                        
+                        transaction.fetchOne(from, fetchClauses)
+                    }
                     XCTAssertNil(object)
                     
                     let objectID = transaction.fetchObjectID(from, fetchClauses)
@@ -1742,7 +1763,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K > %@", "testNumber", 1),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let object = transaction.fetchOne(from, fetchClauses)
+                    let object = self.expectLogger([.LogWarning]) {
+                        
+                        transaction.fetchOne(from, fetchClauses)
+                    }
                     XCTAssertNil(object)
                     
                     let objectID = transaction.fetchObjectID(from, fetchClauses)
@@ -2064,7 +2088,10 @@ final class FetchTests: BaseTestDataTestCase {
                         Where("%K < %@", "testNumber", 4),
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let objects = transaction.fetchAll(from, fetchClauses)
+                    let objects = self.expectLogger([.LogWarning]) {
+                        
+                        transaction.fetchAll(from, fetchClauses)
+                    }
                     XCTAssertNil(objects)
                     
                     let objectIDs = transaction.fetchObjectIDs(from, fetchClauses)
@@ -2302,7 +2329,10 @@ final class FetchTests: BaseTestDataTestCase {
                     let fetchClauses: [FetchClause] = [
                         OrderBy(.Ascending("testEntityID"))
                     ]
-                    let objects = transaction.fetchAll(from, fetchClauses)
+                    let objects = self.expectLogger([.LogWarning]) {
+                        
+                        transaction.fetchAll(from, fetchClauses)
+                    }
                     XCTAssertNil(objects)
                     
                     let objectIDs = transaction.fetchObjectIDs(from, fetchClauses)
@@ -2619,11 +2649,14 @@ final class FetchTests: BaseTestDataTestCase {
                 let from = From<TestEntity1>("Config1")
                 do {
                     
-                    let count = transaction.fetchCount(
+                    let count = self.expectLogger([.LogWarning]) {
-                        from,
+                        
-                        Where("%K < %@", "testNumber", 4),
+                        transaction.fetchCount(
-                        OrderBy(.Ascending("testEntityID"))
+                            from,
-                    )
+                            Where("%K < %@", "testNumber", 4),
+                            OrderBy(.Ascending("testEntityID"))
+                        )
+                    }
                     XCTAssertNil(count)
                 }
                 do {
@@ -2760,11 +2793,14 @@ final class FetchTests: BaseTestDataTestCase {
                 let from = From<TestEntity1>("Config2")
                 do {
                     
-                    let count = transaction.fetchCount(
+                    let count = self.expectLogger([.LogWarning]) {
-                        from,
+                        
-                        Where("%K < %@", "testNumber", 4),
+                        transaction.fetchCount(
-                        OrderBy(.Ascending("testEntityID"))
+                            from,
-                    )
+                            Where("%K < %@", "testNumber", 4),
+                            OrderBy(.Ascending("testEntityID"))
+                        )
+                    }
                     XCTAssertNil(count)
                 }
                 do {

CoreStoreTests/FromTests.swift

@@ -100,7 +100,10 @@ final class FromTests: BaseTestCase {
                 let from = From<TestEntity1>("Config1")
                 
                 let request = NSFetchRequest()
-                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = self.expectLogger([.LogWarning]) {
+                    
+                    from.applyToFetchRequest(request, context: dataStack.mainContext)
+                }
                 XCTAssertFalse(storesFound)
                 XCTAssertNotNil(request.entity)
                 XCTAssertNotNil(request.affectedStores)
@@ -153,7 +156,10 @@ final class FromTests: BaseTestCase {
                 let from = From<TestEntity1>("Config2")
                 
                 let request = NSFetchRequest()
-                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = self.expectLogger([.LogWarning]) {
+                    
+                    from.applyToFetchRequest(request, context: dataStack.mainContext)
+                }
                 XCTAssertFalse(storesFound)
                 XCTAssertNotNil(request.entity)
                 XCTAssertNotNil(request.affectedStores)
@@ -251,7 +257,10 @@ final class FromTests: BaseTestCase {
                 let from = From<TestEntity1>("Config2")
                 
                 let request = NSFetchRequest()
-                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = self.expectLogger([.LogWarning]) {
+                    
+                    from.applyToFetchRequest(request, context: dataStack.mainContext)
+                }
                 XCTAssertFalse(storesFound)
                 XCTAssertNotNil(request.entity)
                 XCTAssertNotNil(request.affectedStores)
@@ -349,7 +358,10 @@ final class FromTests: BaseTestCase {
                 let from = From<TestEntity1>("Config2")
                 
                 let request = NSFetchRequest()
-                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = self.expectLogger([.LogWarning]) {
+                    
+                    from.applyToFetchRequest(request, context: dataStack.mainContext)
+                }
                 XCTAssertFalse(storesFound)
                 XCTAssertNotNil(request.entity)
                 XCTAssertNotNil(request.affectedStores)

CoreStoreTests/SetupTests.swift

@@ -56,11 +56,14 @@ class SetupTests: BaseTestCase {
             
             let migrationChain: MigrationChain = ["version1", "version2", "version3"]
             
-            let stack = DataStack(
+            let stack = self.expectLogger([.LogWarning]) {
-                modelName: "Model",
+                
-                bundle: NSBundle(forClass: self.dynamicType),
+                DataStack(
-                migrationChain: migrationChain
+                    modelName: "Model",
-            )
+                    bundle: NSBundle(forClass: self.dynamicType),
+                    migrationChain: migrationChain
+                )
+            }
             XCTAssertEqual(stack.modelVersion, "Model")
             XCTAssertEqual(stack.migrationChain, migrationChain)
             

CoreStoreTests/TransactionTests.swift

@@ -41,27 +41,29 @@ final class TransactionTests: BaseTestCase {
         self.prepareStack { (stack) in
             
             let testDate = NSDate()
-            let createExpectation = self.expectationWithDescription("create")
-            stack.beginSynchronous { (transaction) in
-            
-                let object = transaction.create(Into(TestEntity1))
-                object.testEntityID = NSNumber(integer: 1)
-                object.testString = "string1"
-                object.testNumber = 100
-                object.testDate = testDate
-                
-                switch transaction.commitAndWait() {
-                    
-                case .Success(let hasChanges):
-                    XCTAssertTrue(hasChanges)
-                    createExpectation.fulfill()
-                    
-                default:
-                    XCTFail()
-                }
-            }
             do {
                 
+                let createExpectation = self.expectationWithDescription("create")
+                stack.beginSynchronous { (transaction) in
+                    
+                    let object = transaction.create(Into(TestEntity1))
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = testDate
+                    
+                    switch transaction.commitAndWait() {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        createExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
                 
                 let object = stack.fetchOne(From(TestEntity1))
@@ -71,31 +73,32 @@ final class TransactionTests: BaseTestCase {
                 XCTAssertEqual(object?.testNumber, 100)
                 XCTAssertEqual(object?.testDate, testDate)
             }
-            
-            let updateExpectation = self.expectationWithDescription("update")
-            stack.beginSynchronous { (transaction) in
-                
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    
-                    XCTFail()
-                    return
-                }
-                object.testString = "string1_edit"
-                object.testNumber = 200
-                object.testDate = NSDate.distantFuture()
-                
-                switch transaction.commitAndWait() {
-                    
-                case .Success(let hasChanges):
-                    XCTAssertTrue(hasChanges)
-                    updateExpectation.fulfill()
-                    
-                default:
-                    XCTFail()
-                }
-            }
             do {
                 
+                let updateExpectation = self.expectationWithDescription("update")
+                stack.beginSynchronous { (transaction) in
+                    
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                        
+                        XCTFail()
+                        return
+                    }
+                    object.testString = "string1_edit"
+                    object.testNumber = 200
+                    object.testDate = NSDate.distantFuture()
+                    
+                    switch transaction.commitAndWait() {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        updateExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
                 
                 let object = stack.fetchOne(From(TestEntity1))
@@ -105,32 +108,32 @@ final class TransactionTests: BaseTestCase {
                 XCTAssertEqual(object?.testNumber, 200)
                 XCTAssertEqual(object?.testDate, NSDate.distantFuture())
             }
-            
-            let deleteExpectation = self.expectationWithDescription("delete")
-            stack.beginSynchronous { (transaction) in
-                
-                let object = transaction.fetchOne(From(TestEntity1))
-                transaction.delete(object)
-                
-                switch transaction.commitAndWait() {
-                    
-                case .Success(let hasChanges):
-                    XCTAssertTrue(hasChanges)
-                    deleteExpectation.fulfill()
-                    
-                default:
-                    XCTFail()
-                }
-            }
             do {
                 
+                let deleteExpectation = self.expectationWithDescription("delete")
+                stack.beginSynchronous { (transaction) in
+                    
+                    let object = transaction.fetchOne(From(TestEntity1))
+                    transaction.delete(object)
+                    
+                    switch transaction.commitAndWait() {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        deleteExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
                 
                 let object = stack.fetchOne(From(TestEntity1))
                 XCTAssertNil(object)
             }
         }
-        self.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
     }
     
     @objc
@@ -138,61 +141,71 @@ final class TransactionTests: BaseTestCase {
         
         self.prepareStack { (stack) in
             
-            let createDiscardExpectation = self.expectationWithDescription("create-discard")
-            stack.beginSynchronous { (transaction) in
-                
-                let object = transaction.create(Into(TestEntity1))
-                object.testEntityID = NSNumber(integer: 1)
-                object.testString = "string1"
-                object.testNumber = 100
-                object.testDate = NSDate()
-                
-                createDiscardExpectation.fulfill()
-            }
             do {
                 
+                let createDiscardExpectation = self.expectationWithDescription("create-discard")
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
+                stack.beginSynchronous { (transaction) in
+                    
+                    let object = transaction.create(Into(TestEntity1))
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = NSDate()
+                    
+                    createDiscardExpectation.fulfill()
+                    self.expectLogger(loggerExpectations)
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
                 
                 let object = stack.fetchOne(From(TestEntity1))
                 XCTAssertNil(object)
             }
-            
             let testDate = NSDate()
-            let createExpectation = self.expectationWithDescription("create")
+            do {
-            stack.beginSynchronous { (transaction) in
                 
-                let object = transaction.create(Into(TestEntity1))
+                let createExpectation = self.expectationWithDescription("create")
-                object.testEntityID = NSNumber(integer: 1)
+                stack.beginSynchronous { (transaction) in
-                object.testString = "string1"
-                object.testNumber = 100
-                object.testDate = testDate
-                
-                switch transaction.commitAndWait() {
                     
-                case .Success(true):
+                    let object = transaction.create(Into(TestEntity1))
-                    createExpectation.fulfill()
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = testDate
                     
-                default:
+                    switch transaction.commitAndWait() {
-                    XCTFail()
+                        
+                    case .Success(true):
+                        createExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
                 }
-            }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
-            
-            let updateDiscardExpectation = self.expectationWithDescription("update-discard")
-            stack.beginSynchronous { (transaction) in
-                
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    
-                    XCTFail()
-                    return
-                }
-                object.testString = "string1_edit"
-                object.testNumber = 200
-                object.testDate = NSDate.distantFuture()
-                
-                updateDiscardExpectation.fulfill()
             }
             do {
                 
+                let updateDiscardExpectation = self.expectationWithDescription("update-discard")
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
+                stack.beginSynchronous { (transaction) in
+                    
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                        
+                        XCTFail()
+                        return
+                    }
+                    object.testString = "string1_edit"
+                    object.testNumber = 200
+                    object.testDate = NSDate.distantFuture()
+                    
+                    updateDiscardExpectation.fulfill()
+                    self.expectLogger(loggerExpectations)
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
                 
                 let object = stack.fetchOne(From(TestEntity1))
@@ -202,21 +215,24 @@ final class TransactionTests: BaseTestCase {
                 XCTAssertEqual(object?.testNumber, 100)
                 XCTAssertEqual(object?.testDate, testDate)
             }
-            
-            let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
-            stack.beginSynchronous { (transaction) in
-                
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    
-                    XCTFail()
-                    return
-                }
-                transaction.delete(object)
-                
-                deleteDiscardExpectation.fulfill()
-            }
             do {
                 
+                let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
+                stack.beginSynchronous { (transaction) in
+                    
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                        
+                        XCTFail()
+                        return
+                    }
+                    transaction.delete(object)
+                    
+                    deleteDiscardExpectation.fulfill()
+                    self.expectLogger(loggerExpectations)
+                }
+                self.waitForExpectationsWithTimeout(0, handler: nil)
+                
                 XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
                 
                 let object = stack.fetchOne(From(TestEntity1))
@@ -227,7 +243,6 @@ final class TransactionTests: BaseTestCase {
                 XCTAssertEqual(object?.testDate, testDate)
             }
         }
-        self.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
     }
     
     @objc
@@ -236,92 +251,101 @@ final class TransactionTests: BaseTestCase {
         self.prepareStack { (stack) in
             
             let testDate = NSDate()
-            let createExpectation = self.expectationWithDescription("create")
+            do {
-            stack.beginAsynchronous { (transaction) in
                 
-                let object = transaction.create(Into(TestEntity1))
+                let createExpectation = self.expectationWithDescription("create")
-                object.testEntityID = NSNumber(integer: 1)
+                stack.beginAsynchronous { (transaction) in
-                object.testString = "string1"
-                object.testNumber = 100
-                object.testDate = testDate
-                
-                transaction.commit { (result) in
                     
-                    switch result {
+                    let object = transaction.create(Into(TestEntity1))
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = testDate
+                    
+                    transaction.commit { (result) in
                         
-                    case .Success(let hasChanges):
+                        switch result {
-                        XCTAssertTrue(hasChanges)
+                            
-                        
+                        case .Success(let hasChanges):
-                        XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                            XCTAssertTrue(hasChanges)
-                        
+                            
-                        let object = stack.fetchOne(From(TestEntity1))
+                            XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
-                        XCTAssertNotNil(object)
+                            
-                        XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
+                            let object = stack.fetchOne(From(TestEntity1))
-                        XCTAssertEqual(object?.testString, "string1")
+                            XCTAssertNotNil(object)
-                        XCTAssertEqual(object?.testNumber, 100)
+                            XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
-                        XCTAssertEqual(object?.testDate, testDate)
+                            XCTAssertEqual(object?.testString, "string1")
-                        createExpectation.fulfill()
+                            XCTAssertEqual(object?.testNumber, 100)
-                        
+                            XCTAssertEqual(object?.testDate, testDate)
-                    default:
+                            createExpectation.fulfill()
-                        XCTFail()
+                            
+                        default:
+                            XCTFail()
+                        }
                     }
                 }
             }
-            let updateExpectation = self.expectationWithDescription("update")
+            do {
-            stack.beginAsynchronous { (transaction) in
                 
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                let updateExpectation = self.expectationWithDescription("update")
+                stack.beginAsynchronous { (transaction) in
                     
-                    XCTFail()
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    return
-                }
-                object.testString = "string1_edit"
-                object.testNumber = 200
-                object.testDate = NSDate.distantFuture()
-                
-                transaction.commit { (result) in
-                    
-                    switch result {
                         
-                    case .Success(let hasChanges):
-                        XCTAssertTrue(hasChanges)
-                        
-                        XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
-                        
-                        let object = stack.fetchOne(From(TestEntity1))
-                        XCTAssertNotNil(object)
-                        XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
-                        XCTAssertEqual(object?.testString, "string1_edit")
-                        XCTAssertEqual(object?.testNumber, 200)
-                        XCTAssertEqual(object?.testDate, NSDate.distantFuture())
-                        updateExpectation.fulfill()
-                        
-                    default:
                         XCTFail()
+                        return
+                    }
+                    object.testString = "string1_edit"
+                    object.testNumber = 200
+                    object.testDate = NSDate.distantFuture()
+                    
+                    transaction.commit { (result) in
+                        
+                        switch result {
+                            
+                        case .Success(let hasChanges):
+                            XCTAssertTrue(hasChanges)
+                            
+                            XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                            
+                            let object = stack.fetchOne(From(TestEntity1))
+                            XCTAssertNotNil(object)
+                            XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
+                            XCTAssertEqual(object?.testString, "string1_edit")
+                            XCTAssertEqual(object?.testNumber, 200)
+                            XCTAssertEqual(object?.testDate, NSDate.distantFuture())
+                            updateExpectation.fulfill()
+                            
+                        default:
+                            XCTFail()
+                        }
                     }
                 }
             }
-            let deleteExpectation = self.expectationWithDescription("delete")
+            do {
-            stack.beginAsynchronous { (transaction) in
                 
-                let object = transaction.fetchOne(From(TestEntity1))
+                let deleteExpectation = self.expectationWithDescription("delete")
-                transaction.delete(object)
+                stack.beginAsynchronous { (transaction) in
-                
-                transaction.commit { (result) in
                     
-                    switch result {
+                    let object = transaction.fetchOne(From(TestEntity1))
+                    transaction.delete(object)
+                    
+                    transaction.commit { (result) in
                         
-                    case .Success(let hasChanges):
+                        switch result {
-                        XCTAssertTrue(hasChanges)
+                            
-                        
+                        case .Success(let hasChanges):
-                        XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                            XCTAssertTrue(hasChanges)
-                        
+                            
-                        let object = stack.fetchOne(From(TestEntity1))
+                            XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
-                        XCTAssertNil(object)
+                            
-                        deleteExpectation.fulfill()
+                            let object = stack.fetchOne(From(TestEntity1))
-                        
+                            XCTAssertNil(object)
-                    default:
+                            deleteExpectation.fulfill()
-                        XCTFail()
+                            
+                        default:
+                            XCTFail()
+                        }
                     }
                 }
             }
@@ -334,88 +358,103 @@ final class TransactionTests: BaseTestCase {
         
         self.prepareStack { (stack) in
             
-            let createDiscardExpectation = self.expectationWithDescription("create-discard")
+            do {
-            stack.beginAsynchronous { (transaction) in
                 
-                let object = transaction.create(Into(TestEntity1))
+                let createDiscardExpectation = self.expectationWithDescription("create-discard")
-                object.testEntityID = NSNumber(integer: 1)
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
-                object.testString = "string1"
+                stack.beginAsynchronous { (transaction) in
-                object.testNumber = 100
-                object.testDate = NSDate()
-                
-                createDiscardExpectation.fulfill()
-            }
-            
-            let testDate = NSDate()
-            let createExpectation = self.expectationWithDescription("create")
-            stack.beginAsynchronous { (transaction) in
-                
-                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
-                XCTAssertNil(transaction.fetchOne(From(TestEntity1)))
-                
-                let object = transaction.create(Into(TestEntity1))
-                object.testEntityID = NSNumber(integer: 1)
-                object.testString = "string1"
-                object.testNumber = 100
-                object.testDate = testDate
-                
-                transaction.commit { (result) in
                     
-                    switch result {
+                    let object = transaction.create(Into(TestEntity1))
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = NSDate()
+                    
+                    createDiscardExpectation.fulfill()
+                    self.expectLogger(loggerExpectations)
+                }
+            }
+            let testDate = NSDate()
+            do {
+                
+                let createExpectation = self.expectationWithDescription("create")
+                stack.beginAsynchronous { (transaction) in
+                    
+                    XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
+                    XCTAssertNil(transaction.fetchOne(From(TestEntity1)))
+                    
+                    let object = transaction.create(Into(TestEntity1))
+                    object.testEntityID = NSNumber(integer: 1)
+                    object.testString = "string1"
+                    object.testNumber = 100
+                    object.testDate = testDate
+                    
+                    transaction.commit { (result) in
                         
-                    case .Success(true):
+                        switch result {
-                        createExpectation.fulfill()
+                            
-                        
+                        case .Success(true):
-                    default:
+                            createExpectation.fulfill()
-                        XCTFail()
+                            
+                        default:
+                            XCTFail()
+                        }
                     }
                 }
             }
-            
+            do {
-            let updateDiscardExpectation = self.expectationWithDescription("update-discard")
-            stack.beginAsynchronous { (transaction) in
                 
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                let updateDiscardExpectation = self.expectationWithDescription("update-discard")
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
+                stack.beginAsynchronous { (transaction) in
                     
-                    XCTFail()
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    return
+                        
+                        XCTFail()
+                        return
+                    }
+                    object.testString = "string1_edit"
+                    object.testNumber = 200
+                    object.testDate = NSDate.distantFuture()
+                    
+                    updateDiscardExpectation.fulfill()
+                    self.expectLogger(loggerExpectations)
                 }
-                object.testString = "string1_edit"
-                object.testNumber = 200
-                object.testDate = NSDate.distantFuture()
-                
-                updateDiscardExpectation.fulfill()
             }
-            
+            do {
-            let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
-            stack.beginAsynchronous { (transaction) in
                 
-                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
+                let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
-                
+                let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
-                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                stack.beginAsynchronous { (transaction) in
                     
-                    XCTFail()
+                    XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
-                    return
-                }
-                XCTAssertNotNil(object)
-                XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
-                XCTAssertEqual(object.testString, "string1")
-                XCTAssertEqual(object.testNumber, 100)
-                XCTAssertEqual(object.testDate, testDate)
-                
-                transaction.delete(object)
-                
-                GCDQueue.Main.async {
                     
-                    XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                    guard let object = transaction.fetchOne(From(TestEntity1)) else {
-                    
+                        
-                    let object = stack.fetchOne(From(TestEntity1))
+                        XCTFail()
+                        return
+                    }
                     XCTAssertNotNil(object)
-                    XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
+                    XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
-                    XCTAssertEqual(object?.testString, "string1")
+                    XCTAssertEqual(object.testString, "string1")
-                    XCTAssertEqual(object?.testNumber, 100)
+                    XCTAssertEqual(object.testNumber, 100)
-                    XCTAssertEqual(object?.testDate, testDate)
+                    XCTAssertEqual(object.testDate, testDate)
-                    deleteDiscardExpectation.fulfill()
+                    
+                    transaction.delete(object)
+                    
+                    GCDQueue.Main.async {
+                        
+                        XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                        
+                        let object = stack.fetchOne(From(TestEntity1))
+                        XCTAssertNotNil(object)
+                        XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
+                        XCTAssertEqual(object?.testString, "string1")
+                        XCTAssertEqual(object?.testNumber, 100)
+                        XCTAssertEqual(object?.testDate, testDate)
+                        deleteDiscardExpectation.fulfill()
+                    }
+                    self.expectLogger(loggerExpectations)
                 }
             }
         }