WIP: Fetching unit tests

2026-01-16 14:06:53 +01:00 · 2016-06-06 00:12:00 +09:00
parent 02a89accc8
commit b98805e489
13 changed files with 1842 additions and 74 deletions
--- a/CoreStoreTests/BaseTests/BaseTestCase.swift
+++ b/CoreStoreTests/BaseTests/BaseTestCase.swift
@@ -48,7 +48,9 @@ class BaseTestCase: XCTestCase {
                
                try stack.addStorageAndWait(
                    SQLiteStore(
-                        fileName: "\(self.dynamicType)_\($0).sqlite",
+                        fileURL: SQLiteStore.defaultRootDirectory
+                            .URLByAppendingPathComponent(NSUUID().UUIDString)
+                            .URLByAppendingPathComponent("\(self.dynamicType)_\(($0 ?? "-null-")).sqlite"),
                        configuration: $0,
                        localStorageOptions: .RecreateStoreOnModelMismatch
                    )
@@ -80,8 +82,8 @@ class BaseTestCase: XCTestCase {
    
    // MARK: Private
    
-    private func deleteStores(directory: NSURL = SQLiteStore.defaultRootDirectory) {
+    private func deleteStores() {
        
-        _ = try? NSFileManager.defaultManager().removeItemAtURL(directory)
+        _ = try? NSFileManager.defaultManager().removeItemAtURL(SQLiteStore.defaultRootDirectory)
    }
 }
--- a/CoreStoreTests/FetchTests.swift
+++ b/CoreStoreTests/FetchTests.swift
--- a/CoreStoreTests/FromTests.swift
+++ b/CoreStoreTests/FromTests.swift
@@ -85,7 +85,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -99,7 +100,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -121,7 +123,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -135,7 +138,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -149,7 +153,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -163,7 +168,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -177,7 +183,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -191,7 +198,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -213,7 +221,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -227,7 +236,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -241,7 +251,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -255,7 +266,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -269,7 +281,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -283,7 +296,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -305,7 +319,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -319,7 +334,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -333,7 +349,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity1>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -347,7 +364,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>()
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -361,7 +379,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config1")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertFalse(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
@@ -375,7 +394,8 @@ final class FromTests: BaseTestCase {
                let from = From<TestEntity2>("Config2")
                
                let request = NSFetchRequest()
-                from.applyToFetchRequest(request, context: dataStack.mainContext)
+                let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
+                XCTAssertTrue(storesFound)
                XCTAssertNotNil(request.entity)
                XCTAssertNotNil(request.affectedStores)
                
--- a/CoreStoreTests/SectionByTests.swift
+++ b/CoreStoreTests/SectionByTests.swift
@@ -0,0 +1,53 @@
+//
+//  SectionByTests.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import XCTest
+
+@testable
+import CoreStore
+
+
+//MARK: - SectionByTests
+
+final class SectionByTests: XCTestCase {
+    
+    @objc
+    dynamic func test_ThatSectionByClauses_ConfigureCorrectly() {
+        
+        do {
+            
+            let sectionBy = SectionBy("key")
+            XCTAssertEqual(sectionBy.sectionKeyPath, "key")
+            XCTAssertEqual(sectionBy.sectionIndexTransformer(sectionName: "key"), "key")
+        }
+        do {
+            
+            let sectionBy = SectionBy("key") { $0.flatMap { "\($0):suffix" } }
+            XCTAssertEqual(sectionBy.sectionKeyPath, "key")
+            XCTAssertEqual(sectionBy.sectionIndexTransformer(sectionName: "key"), "key:suffix")
+            XCTAssertNil(sectionBy.sectionIndexTransformer(sectionName: nil))
+        }
+    }
+}
--- a/CoreStoreTests/SetupTests.swift
+++ b/CoreStoreTests/SetupTests.swift
@@ -39,6 +39,10 @@ class SetupTests: BaseTestCase {
            let model = NSManagedObjectModel.mergedModelFromBundles([NSBundle(forClass: self.dynamicType)])!
            
            let stack = DataStack(model: model, migrationChain: nil)
+            XCTAssertEqual(stack.coordinator.managedObjectModel, model)
+            XCTAssertEqual(stack.rootSavingContext.persistentStoreCoordinator, stack.coordinator)
+            XCTAssertNil(stack.rootSavingContext.parentContext)
+            XCTAssertEqual(stack.mainContext.parentContext, stack.rootSavingContext)
            XCTAssertEqual(stack.model, model)
            XCTAssertTrue(stack.migrationChain.valid)
            XCTAssertTrue(stack.migrationChain.empty)
--- a/CoreStoreTests/TransactionTests.swift
+++ b/CoreStoreTests/TransactionTests.swift
@@ -27,6 +27,8 @@ import XCTest

@testable
 import CoreStore
+@testable
+import GCDKit


 //MARK: - TransactionTests
@@ -34,13 +36,592 @@ import CoreStore
 final class TransactionTests: BaseTestCase {
    
    @objc
-    dynamic func test_ThatSynchronousTransactions_ConfigureCorrectly() {
+    dynamic func test_ThatSynchronousTransactions_CanPerformCRUDs() {
        
        self.prepareStack { (stack) in
            
-            // TODO:
+            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 {
+                
+                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)
+            }
+            
+            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 {
+                
+                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())
+            }
+            
+            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 {
+                
+                XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                
+                let object = stack.fetchOne(From(TestEntity1))
+                XCTAssertNil(object)
+            }
+        }
+        self.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
+    }
+    
+    @objc
+    dynamic func test_ThatSynchronousTransactions_CanDiscardUncommittedChanges() {
+        
+        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 {
+                
+                XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                
+                let object = stack.fetchOne(From(TestEntity1))
+                XCTAssertNil(object)
+            }
+            
+            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(true):
+                    createExpectation.fulfill()
+                    
+                default:
+                    XCTFail()
+                }
+            }
+            
+            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 {
+                
+                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)
+            }
+            
+            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 {
+                
+                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)
+            }
+        }
+        self.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
+    }
+    
+    @objc
+    dynamic func test_ThatAsynchronousTransactions_CanPerformCRUDs() {
+        
+        self.prepareStack { (stack) in
+            
+            let testDate = NSDate()
+            let createExpectation = self.expectationWithDescription("create")
+            stack.beginAsynchronous { (transaction) in
+                
+                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 {
+                        
+                    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")
+                        XCTAssertEqual(object?.testNumber, 100)
+                        XCTAssertEqual(object?.testDate, testDate)
+                        createExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+            }
+            let updateExpectation = self.expectationWithDescription("update")
+            stack.beginAsynchronous { (transaction) in
+                
+                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                    
+                    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")
+            stack.beginAsynchronous { (transaction) in
+                
+                let object = transaction.fetchOne(From(TestEntity1))
+                transaction.delete(object)
+                
+                transaction.commit { (result) in
+                    
+                    switch result {
+                        
+                    case .Success(let hasChanges):
+                        XCTAssertTrue(hasChanges)
+                        
+                        XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                        
+                        let object = stack.fetchOne(From(TestEntity1))
+                        XCTAssertNil(object)
+                        deleteExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+            }
+        }
+        self.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
+    }
+    
+    @objc
+    dynamic func test_ThatAsynchronousTransactions_CanDiscardUncommittedChanges() {
+        
+        self.prepareStack { (stack) in
+            
+            let createDiscardExpectation = self.expectationWithDescription("create-discard")
+            stack.beginAsynchronous { (transaction) in
+                
+                let object = transaction.create(Into(TestEntity1))
+                object.testEntityID = NSNumber(integer: 1)
+                object.testString = "string1"
+                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 {
+                        
+                    case .Success(true):
+                        createExpectation.fulfill()
+                        
+                    default:
+                        XCTFail()
+                    }
+                }
+            }
+            
+            let updateDiscardExpectation = self.expectationWithDescription("update-discard")
+            stack.beginAsynchronous { (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()
+            }
+            
+            let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
+            stack.beginAsynchronous { (transaction) in
+                
+                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
+                
+                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                    
+                    XCTFail()
+                    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)
+                    
+                    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.waitForExpectationsWithTimeout(NSTimeInterval(Int8.max), handler: nil)
+    }
+    
+    @objc
+    dynamic func test_ThatUnsafeTransactions_CanPerformCRUDs() {
+        
+        self.prepareStack { (stack) in
+            
+            let transaction = stack.beginUnsafe()
+            
+            let testDate = NSDate()
+            do {
+                
+                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)
+                    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)
+                    
+                default:
+                    XCTFail()
+                }
+            }
+            do {
+                
+                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)
+                    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())
+                    
+                default:
+                    XCTFail()
+                }
+            }
+            do {
+                
+                let object = transaction.fetchOne(From(TestEntity1))
+                transaction.delete(object)
+                
+                switch transaction.commitAndWait() {
+                    
+                case .Success(let hasChanges):
+                    XCTAssertTrue(hasChanges)
+                    
+                    XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                    XCTAssertNil(stack.fetchOne(From(TestEntity1)))
+                    
+                default:
+                    XCTFail()
+                }
+            }
        }
    }
    
-    // MARK: Private
+    @objc
+    dynamic func test_ThatUnsafeTransactions_CanRollbackChanges() {
+        
+        self.prepareStack { (stack) in
+            
+            let transaction = stack.beginUnsafe(supportsUndo: true)
+            do {
+                
+                let object = transaction.create(Into(TestEntity1))
+                object.testEntityID = NSNumber(integer: 1)
+                object.testString = "string1"
+                object.testNumber = 100
+                object.testDate = NSDate()
+                
+                transaction.rollback()
+                
+                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
+                XCTAssertNil(transaction.fetchOne(From(TestEntity1)))
+                
+                XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
+                XCTAssertNil(stack.fetchOne(From(TestEntity1)))
+            }
+            
+            let testDate = NSDate()
+            do {
+                
+                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(true):
+                    break
+                    
+                default:
+                    XCTFail()
+                }
+            }
+            
+            do {
+                
+                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                    
+                    XCTFail()
+                    return
+                }
+                object.testString = "string1_edit"
+                object.testNumber = 200
+                object.testDate = NSDate.distantFuture()
+                
+                transaction.rollback()
+                
+                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
+                if let object = transaction.fetchOne(From(TestEntity1)) {
+                    
+                    XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
+                    XCTAssertEqual(object.testString, "string1")
+                    XCTAssertEqual(object.testNumber, 100)
+                    XCTAssertEqual(object.testDate, testDate)
+                }
+                else {
+                    
+                    XCTFail()
+                }
+                
+                XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                if let object = stack.fetchOne(From(TestEntity1)) {
+                    
+                    XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
+                    XCTAssertEqual(object.testString, "string1")
+                    XCTAssertEqual(object.testNumber, 100)
+                    XCTAssertEqual(object.testDate, testDate)
+                }
+                else {
+                    
+                    XCTFail()
+                }
+            }
+            
+            do {
+                
+                guard let object = transaction.fetchOne(From(TestEntity1)) else {
+                    
+                    XCTFail()
+                    return
+                }
+                transaction.delete(object)
+                
+                transaction.rollback()
+                
+                XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
+                if let object = transaction.fetchOne(From(TestEntity1)) {
+                    
+                    XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
+                    XCTAssertEqual(object.testString, "string1")
+                    XCTAssertEqual(object.testNumber, 100)
+                    XCTAssertEqual(object.testDate, testDate)
+                }
+                else {
+                    
+                    XCTFail()
+                }
+                
+                XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
+                if let object = stack.fetchOne(From(TestEntity1)) {
+                    
+                    XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
+                    XCTAssertEqual(object.testString, "string1")
+                    XCTAssertEqual(object.testNumber, 100)
+                    XCTAssertEqual(object.testDate, testDate)
+                }
+                else {
+                    
+                    XCTFail()
+                }
+            }
+        }
+    }
 }