WIP: clauses unit tests

CoreStoreTests/BaseTestCase.swift

@@ -1,40 +0,0 @@
-//
-//  BaseTestCase.swift
-//  CoreStore
-//
-//  Created by John Rommel Estropia on 2016/05/08.
-//  Copyright © 2016 John Rommel Estropia. All rights reserved.
-//
-
-import XCTest
-
-@testable
-import CoreStore
-
-
-// MARK: - BaseTestCase
-
-class BaseTestCase: XCTestCase {
-    
-    // MARK: XCTestCase
-    
-    override func setUp() {
-        
-        super.setUp()
-        self.deleteStores()
-    }
-    
-    override func tearDown() {
-        
-        self.deleteStores()
-        super.tearDown()
-    }
-    
-    
-    // MARK: Private
-    
-    private func deleteStores() {
-        
-        _ = try? NSFileManager.defaultManager().removeItemAtURL(SQLiteStore.defaultRootDirectory)
-    }
-}

CoreStoreTests/BaseTests/BaseTestCase.swift

@@ -0,0 +1,84 @@
+//
+//  BaseTestCase.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: - BaseTestCase
+
+class BaseTestCase: XCTestCase {
+    
+    // MARK: Internal
+    
+    @nonobjc
+    func prepareStack(configuration: String = "Config1", @noescape _ closure: (dataStack: DataStack) -> Void) {
+        
+        let stack = DataStack(
+            modelName: "Model",
+            bundle: NSBundle(forClass: self.dynamicType)
+        )
+        do {
+            
+            try stack.addStorageAndWait(
+                SQLiteStore(
+                    fileName: "\(self.dynamicType).sqlite",
+                    configuration: configuration,
+                    localStorageOptions: .RecreateStoreOnModelMismatch
+                )
+            )
+        }
+        catch let error as NSError {
+            
+            XCTFail(error.coreStoreDumpString)
+        }
+        closure(dataStack: stack)
+    }
+    
+    
+    // MARK: XCTestCase
+    
+    override func setUp() {
+        
+        super.setUp()
+        self.deleteStores()
+    }
+    
+    override func tearDown() {
+        
+        self.deleteStores()
+        super.tearDown()
+    }
+    
+    
+    // MARK: Private
+    
+    private func deleteStores(directory: NSURL = SQLiteStore.defaultRootDirectory) {
+        
+        _ = try? NSFileManager.defaultManager().removeItemAtURL(directory)
+    }
+}

CoreStoreTests/ClauseTests.swift

@@ -0,0 +1,43 @@
+//
+//  ClauseTests.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: - ClauseTests
+
+final class ClauseTests: XCTestCase {
+    
+    // MARK: Into
+    
+    @objc
+    dynamic func test_IntoClauses_ConfigureCorrectly() {
+        
+        // TODO:
+    }
+}

CoreStoreTests/ErrorTests.swift

@@ -28,132 +28,142 @@ import XCTest
 @testable
 import CoreStore
 
-class ErrorTests: XCTestCase {
 
-    func testErrors() {
+// MARK: - ErrorTests
+
+final class ErrorTests: XCTestCase {
+
+    @objc
+    dynamic func test_ThatUnknownErrors_BridgeCorrectly() {
         
-        do {
-            
-            let error = CoreStoreError.Unknown
-            XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
-            XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.UnknownError.rawValue)
-            
-            let userInfo: NSDictionary = [:]
-            
-            let objcError = error.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError.bridgeToSwift)
-            XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError.code, CoreStoreErrorCode.UnknownError.rawValue)
-            XCTAssertEqual(objcError.userInfo, userInfo)
-            
-            let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError2.bridgeToSwift)
-            XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError2.code, CoreStoreErrorCode.UnknownError.rawValue)
-            XCTAssertEqual(objcError2.userInfo, userInfo)
-        }
+        let error = CoreStoreError.Unknown
+        XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
+        XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.UnknownError.rawValue)
+        
+        let userInfo: NSDictionary = [:]
+        
+        let objcError = error.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError.bridgeToSwift)
+        XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError.code, CoreStoreErrorCode.UnknownError.rawValue)
+        XCTAssertEqual(objcError.userInfo, userInfo)
+        
+        let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError2.bridgeToSwift)
+        XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError2.code, CoreStoreErrorCode.UnknownError.rawValue)
+        XCTAssertEqual(objcError2.userInfo, userInfo)
+    }
+    
+    @objc
+    dynamic func test_ThatDifferentStorageExistsAtURLErrors_BridgeCorrectly() {
         
         let dummyURL = NSURL(string: "file:///test1/test2.sqlite")!
-        do {
-            
-            let error = CoreStoreError.DifferentStorageExistsAtURL(existingPersistentStoreURL: dummyURL)
-            XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
-            XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
-            
-            let userInfo: NSDictionary = [
-                "existingPersistentStoreURL": dummyURL
-            ]
-            let objcError = error.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError.bridgeToSwift)
-            XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
-            XCTAssertEqual(objcError.userInfo, userInfo)
-            
-            let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError2.bridgeToSwift)
-            XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError2.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
-            XCTAssertEqual(objcError2.userInfo, userInfo)
-        }
         
-        do {
-            
-            let model = NSManagedObjectModel.fromBundle(NSBundle(forClass: self.dynamicType), modelName: "Model")
-            let version = "1.0.0"
-            
-            let error = CoreStoreError.MappingModelNotFound(localStoreURL: dummyURL, targetModel: model, targetModelVersion: version)
-            XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
-            XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
-            
-            let userInfo: NSDictionary = [
-                "localStoreURL": dummyURL,
-                "targetModel": model,
-                "targetModelVersion": version
-            ]
-            let objcError = error.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError.bridgeToSwift)
-            XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
-            XCTAssertEqual(objcError.userInfo, userInfo)
-            
-            let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError2.bridgeToSwift)
-            XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError2.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
-            XCTAssertEqual(objcError2.userInfo, userInfo)
-        }
+        let error = CoreStoreError.DifferentStorageExistsAtURL(existingPersistentStoreURL: dummyURL)
+        XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
+        XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
         
-        do {
-            
-            let error = CoreStoreError.ProgressiveMigrationRequired(localStoreURL: dummyURL)
-            XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
-            XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
-            
-            let userInfo: NSDictionary = [
-                "localStoreURL": dummyURL
-            ]
-            let objcError = error.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError.bridgeToSwift)
-            XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
-            XCTAssertEqual(objcError.userInfo, userInfo)
-            
-            let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError2.bridgeToSwift)
-            XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError2.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
-            XCTAssertEqual(objcError2.userInfo, userInfo)
-        }
+        let userInfo: NSDictionary = [
+            "existingPersistentStoreURL": dummyURL
+        ]
+        let objcError = error.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError.bridgeToSwift)
+        XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
+        XCTAssertEqual(objcError.userInfo, userInfo)
         
-        do {
-            
-            let internalError = NSError(
-                domain: "com.dummy",
-                code: 123,
-                userInfo: [
-                    "key1": "value1",
-                    "key2": 2,
-                    "key3": NSDate()
-                ]
-            )
-            let error = CoreStoreError.InternalError(NSError: internalError)
-            XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
-            XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.InternalError.rawValue)
-            
-            let userInfo: NSDictionary = [
-                "NSError": internalError
+        let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError2.bridgeToSwift)
+        XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError2.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
+        XCTAssertEqual(objcError2.userInfo, userInfo)
+    }
+    
+    @objc
+    dynamic func test_ThatMappingModelNotFoundErrors_BridgeCorrectly() {
+        
+        let dummyURL = NSURL(string: "file:///test1/test2.sqlite")!
+        
+        let model = NSManagedObjectModel.fromBundle(NSBundle(forClass: self.dynamicType), modelName: "Model")
+        let version = "1.0.0"
+        
+        let error = CoreStoreError.MappingModelNotFound(localStoreURL: dummyURL, targetModel: model, targetModelVersion: version)
+        XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
+        XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
+        
+        let userInfo: NSDictionary = [
+            "localStoreURL": dummyURL,
+            "targetModel": model,
+            "targetModelVersion": version
+        ]
+        let objcError = error.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError.bridgeToSwift)
+        XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
+        XCTAssertEqual(objcError.userInfo, userInfo)
+        
+        let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError2.bridgeToSwift)
+        XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError2.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
+        XCTAssertEqual(objcError2.userInfo, userInfo)
+    }
+    
+    @objc
+    dynamic func test_ThatProgressiveMigrationRequiredErrors_BridgeCorrectly() {
+        
+        let dummyURL = NSURL(string: "file:///test1/test2.sqlite")!
+        
+        let error = CoreStoreError.ProgressiveMigrationRequired(localStoreURL: dummyURL)
+        XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
+        XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
+        
+        let userInfo: NSDictionary = [
+            "localStoreURL": dummyURL
+        ]
+        let objcError = error.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError.bridgeToSwift)
+        XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
+        XCTAssertEqual(objcError.userInfo, userInfo)
+        
+        let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError2.bridgeToSwift)
+        XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError2.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
+        XCTAssertEqual(objcError2.userInfo, userInfo)
+    }
+    
+    @objc
+    dynamic func test_ThatInternalErrorErrors_BridgeCorrectly() {
+        
+        let internalError = NSError(
+            domain: "com.dummy",
+            code: 123,
+            userInfo: [
+                "key1": "value1",
+                "key2": 2,
+                "key3": NSDate()
             ]
-            let objcError = error.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError.bridgeToSwift)
-            XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError.code, CoreStoreErrorCode.InternalError.rawValue)
-            XCTAssertEqual(objcError.userInfo, userInfo)
-            
-            let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
-            XCTAssertEqual(error, objcError2.bridgeToSwift)
-            XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
-            XCTAssertEqual(objcError2.code, CoreStoreErrorCode.InternalError.rawValue)
-            XCTAssertEqual(objcError2.userInfo, userInfo)
-        }
+        )
+        let error = CoreStoreError.InternalError(NSError: internalError)
+        XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
+        XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.InternalError.rawValue)
+        
+        let userInfo: NSDictionary = [
+            "NSError": internalError
+        ]
+        let objcError = error.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError.bridgeToSwift)
+        XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError.code, CoreStoreErrorCode.InternalError.rawValue)
+        XCTAssertEqual(objcError.userInfo, userInfo)
+        
+        let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
+        XCTAssertEqual(error, objcError2.bridgeToSwift)
+        XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
+        XCTAssertEqual(objcError2.code, CoreStoreErrorCode.InternalError.rawValue)
+        XCTAssertEqual(objcError2.userInfo, userInfo)
     }
 }

CoreStoreTests/MigrationChainTests.swift

@@ -28,9 +28,13 @@ import XCTest
 @testable
 import CoreStore
 
-class MigrationChainTests: XCTestCase {
+
+// MARK: - MigrationChainTests
+
+final class MigrationChainTests: XCTestCase {
     
-    @objc dynamic func testEmptyChain() {
+    @objc
+    dynamic func test_ThatNilMigrationChains_HaveNoVersions() {
         
         let chain: MigrationChain = nil
         XCTAssertTrue(chain.valid)
@@ -40,7 +44,8 @@ class MigrationChainTests: XCTestCase {
         XCTAssertNil(chain.nextVersionFrom("version1"))
     }
     
-    @objc dynamic func testSingleChain() {
+    @objc
+    dynamic func test_ThatStringMigrationChains_HaveOneVersion() {
         
         let chain: MigrationChain = "version1"
         XCTAssertTrue(chain.valid)
@@ -53,7 +58,8 @@ class MigrationChainTests: XCTestCase {
         XCTAssertNil(chain.nextVersionFrom("version2"))
     }
     
-    @objc dynamic func testLinearChain() {
+    @objc
+    dynamic func test_ThatArrayMigrationChains_HaveLinearVersions() {
         
         let chain: MigrationChain = ["version1", "version2", "version3", "version4"]
         XCTAssertTrue(chain.valid)
@@ -72,7 +78,8 @@ class MigrationChainTests: XCTestCase {
         XCTAssertNil(chain.nextVersionFrom("version5"))
     }
     
-    @objc dynamic func testTreeChain() {
+    @objc
+    dynamic func test_ThatDictionaryMigrationChains_HaveTreeVersions() {
         
         let chain: MigrationChain = [
             "version1": "version4",
@@ -94,17 +101,47 @@ class MigrationChainTests: XCTestCase {
         XCTAssertNil(chain.nextVersionFrom("version4"))
         XCTAssertNil(chain.nextVersionFrom("version5"))
         
-        // The cases below will trigger assertion failures internally
+// The cases below will trigger assertion failures internally
+
+//        let linearLoopChain: MigrationChain = ["version1", "version2", "version1", "version3", "version4"]
+//        XCTAssertFalse(linearLoopChain.valid, "linearLoopChain.valid")
+//
+//        let treeAmbiguousChain: MigrationChain = [
+//            "version1": "version4",
+//            "version2": "version3",
+//            "version1": "version2",
+//            "version3": "version4"
+//        ]
+//        XCTAssertFalse(treeAmbiguousChain.valid, "treeAmbiguousChain.valid")
+    }
+    
+    @objc
+    dynamic func test_ThatMigrationChains_AreEquatable() {
         
-        //        let linearLoopChain: MigrationChain = ["version1", "version2", "version1", "version3", "version4"]
-        //        XCTAssertFalse(linearLoopChain.valid, "linearLoopChain.valid")
-        //
-        //        let treeAmbiguousChain: MigrationChain = [
-        //            "version1": "version4",
-        //            "version2": "version3",
-        //            "version1": "version2",
-        //            "version3": "version4"
-        //        ]
-        //        XCTAssertFalse(treeAmbiguousChain.valid, "treeAmbiguousChain.valid")
+        do {
+            
+            let chain1: MigrationChain = nil
+            let chain2: MigrationChain = []
+            let chain3: MigrationChain = [:]
+            XCTAssertEqual(chain1, chain2)
+            XCTAssertEqual(chain2, chain3)
+            XCTAssertEqual(chain3, chain1)
+        }
+        do {
+            
+            let chain1: MigrationChain = "version1"
+            let chain2: MigrationChain = ["version1"]
+            XCTAssertEqual(chain1, chain2)
+        }
+        do {
+            
+            let chain1: MigrationChain = ["version1", "version2", "version3", "version4"]
+            let chain2: MigrationChain = [
+                "version1": "version2",
+                "version2": "version3",
+                "version3": "version4"
+            ]
+            XCTAssertEqual(chain1, chain2)
+        }
     }
 }

CoreStoreTests/SetupTests.swift

@@ -31,28 +31,105 @@ import CoreStore
 
 class SetupTests: BaseTestCase {
     
-    func testInMemoryStores() {
+    @objc
+    dynamic func test_ThatDataStacks_ConfigureCorrectly() {
+        
+        do {
+            
+            let model = NSManagedObjectModel.mergedModelFromBundles([NSBundle(forClass: self.dynamicType)])!
+            
+            let stack = DataStack(model: model, migrationChain: nil)
+            XCTAssertEqual(stack.model, model)
+            XCTAssertTrue(stack.migrationChain.valid)
+            XCTAssertTrue(stack.migrationChain.empty)
+            XCTAssertTrue(stack.migrationChain.rootVersions.isEmpty)
+            XCTAssertTrue(stack.migrationChain.leafVersions.isEmpty)
+            
+            CoreStore.defaultStack = stack
+            XCTAssertEqual(CoreStore.defaultStack, stack)
+        }
+        do {
+            
+            let migrationChain: MigrationChain = ["version1", "version2", "version3"]
+            
+            let stack = DataStack(
+                modelName: "Model",
+                bundle: NSBundle(forClass: self.dynamicType),
+                migrationChain: migrationChain
+            )
+            XCTAssertEqual(stack.modelVersion, "Model")
+            XCTAssertEqual(stack.migrationChain, migrationChain)
+            
+            CoreStore.defaultStack = stack
+            XCTAssertEqual(CoreStore.defaultStack, stack)
+        }
+    }
+    
+    @objc
+    dynamic func test_ThatInMemoryStores_SetupCorrectly() {
         
         let stack = DataStack(
             modelName: "Model",
             bundle: NSBundle(forClass: self.dynamicType)
         )
-        CoreStore.defaultStack = stack
-        XCTAssertEqual(CoreStore.defaultStack, stack)
-        XCTAssertEqual(stack.modelVersion, "Model")
-        XCTAssert(stack.migrationChain.valid)
-        XCTAssert(stack.migrationChain.empty)
-        XCTAssert(stack.migrationChain.rootVersions.isEmpty)
-        XCTAssert(stack.migrationChain.leafVersions.isEmpty)
+        do {
+            
+            let inMemoryStore = InMemoryStore()
+            do {
+                
+                try stack.addStorageAndWait(inMemoryStore)
+            }
+            catch let error as NSError {
+                
+                XCTFail(error.description)
+            }
+            let persistentStore = stack.persistentStoreForStorage(inMemoryStore)
+            XCTAssertNotNil(persistentStore)
+        }
+        do {
+            
+            let inMemoryStore = InMemoryStore(
+                configuration: "Config1"
+            )
+            do {
+                
+                try stack.addStorageAndWait(inMemoryStore)
+            }
+            catch let error as NSError {
+                
+                XCTFail(error.description)
+            }
+            let persistentStore = stack.persistentStoreForStorage(inMemoryStore)
+            XCTAssertNotNil(persistentStore)
+        }
+        do {
+            
+            let inMemoryStore = InMemoryStore(
+                configuration: "Config2"
+            )
+            do {
+                
+                try stack.addStorageAndWait(inMemoryStore)
+            }
+            catch let error as NSError {
+                
+                XCTFail(error.description)
+            }
+            let persistentStore = stack.persistentStoreForStorage(inMemoryStore)
+            XCTAssertNotNil(persistentStore)
+        }
+    }
+    
+    @objc
+    dynamic func test_ThatSQLiteStores_SetupCorrectly() {
         
+        let stack = DataStack(
+            modelName: "Model",
+            bundle: NSBundle(forClass: self.dynamicType)
+        )
         do {
             
             let sqliteStore = SQLiteStore()
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultFileURL)
-            XCTAssertEqual(sqliteStore.configuration, nil)
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.None)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)
@@ -65,7 +142,6 @@ class SetupTests: BaseTestCase {
             XCTAssertNotNil(persistentStore)
             XCTAssert(sqliteStore.matchesPersistentStore(persistentStore!))
         }
-        
         do {
             
             let sqliteStore = SQLiteStore(
@@ -73,12 +149,6 @@ class SetupTests: BaseTestCase {
                 configuration: "Config1",
                 localStorageOptions: .RecreateStoreOnModelMismatch
             )
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultRootDirectory
-                .URLByAppendingPathComponent("ConfigStore1.sqlite", isDirectory: false))
-            XCTAssertEqual(sqliteStore.configuration, "Config1")
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.RecreateStoreOnModelMismatch)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)
@@ -91,7 +161,6 @@ class SetupTests: BaseTestCase {
             XCTAssertNotNil(persistentStore)
             XCTAssert(sqliteStore.matchesPersistentStore(persistentStore!))
         }
-        
         do {
             
             let sqliteStore = SQLiteStore(
@@ -99,12 +168,6 @@ class SetupTests: BaseTestCase {
                 configuration: "Config2",
                 localStorageOptions: .RecreateStoreOnModelMismatch
             )
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultRootDirectory
-                .URLByAppendingPathComponent("ConfigStore2.sqlite", isDirectory: false))
-            XCTAssertEqual(sqliteStore.configuration, "Config2")
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.RecreateStoreOnModelMismatch)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)
@@ -119,28 +182,16 @@ class SetupTests: BaseTestCase {
         }
     }
     
-    func testSQLiteStores() {
+    @objc
+    dynamic func test_ThatLegacySQLiteStores_SetupCorrectly() {
         
         let stack = DataStack(
             modelName: "Model",
             bundle: NSBundle(forClass: self.dynamicType)
         )
-        CoreStore.defaultStack = stack
-        XCTAssertEqual(CoreStore.defaultStack, stack)
-        XCTAssertEqual(stack.modelVersion, "Model")
-        XCTAssert(stack.migrationChain.valid)
-        XCTAssert(stack.migrationChain.empty)
-        XCTAssert(stack.migrationChain.rootVersions.isEmpty)
-        XCTAssert(stack.migrationChain.leafVersions.isEmpty)
-        
         do {
             
             let sqliteStore = SQLiteStore()
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultFileURL)
-            XCTAssertEqual(sqliteStore.configuration, nil)
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.None)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)
@@ -153,7 +204,6 @@ class SetupTests: BaseTestCase {
             XCTAssertNotNil(persistentStore)
             XCTAssert(sqliteStore.matchesPersistentStore(persistentStore!))
         }
-        
         do {
             
             let sqliteStore = SQLiteStore(
@@ -161,12 +211,6 @@ class SetupTests: BaseTestCase {
                 configuration: "Config1",
                 localStorageOptions: .RecreateStoreOnModelMismatch
             )
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultRootDirectory
-                .URLByAppendingPathComponent("ConfigStore1.sqlite", isDirectory: false))
-            XCTAssertEqual(sqliteStore.configuration, "Config1")
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.RecreateStoreOnModelMismatch)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)
@@ -179,7 +223,6 @@ class SetupTests: BaseTestCase {
             XCTAssertNotNil(persistentStore)
             XCTAssert(sqliteStore.matchesPersistentStore(persistentStore!))
         }
-        
         do {
             
             let sqliteStore = SQLiteStore(
@@ -187,12 +230,6 @@ class SetupTests: BaseTestCase {
                 configuration: "Config2",
                 localStorageOptions: .RecreateStoreOnModelMismatch
             )
-            XCTAssertEqual(sqliteStore.fileURL, SQLiteStore.defaultRootDirectory
-                .URLByAppendingPathComponent("ConfigStore2.sqlite", isDirectory: false))
-            XCTAssertEqual(sqliteStore.configuration, "Config2")
-            XCTAssertEqual(sqliteStore.mappingModelBundles, NSBundle.allBundles())
-            XCTAssertEqual(sqliteStore.localStorageOptions, LocalStorageOptions.RecreateStoreOnModelMismatch)
-            
             do {
                 
                 try stack.addStorageAndWait(sqliteStore)

CoreStoreTests/StorageInterfaceTests.swift

@@ -28,9 +28,13 @@ import XCTest
 @testable
 import CoreStore
 
-class StorageInterfaceTests: XCTestCase {
 
-    func testDefaultInMemoryStore() {
+//MARK: - StorageInterfaceTests
+
+final class StorageInterfaceTests: XCTestCase {
+    
+    @objc
+    dynamic func test_ThatDefaultInMemoryStores_ConfigureCorrectly() {
         
         let store = InMemoryStore()
         XCTAssertEqual(store.dynamicType.storeType, NSInMemoryStoreType)
@@ -38,7 +42,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertNil(store.storeOptions)
     }
     
-    func testInMemoryStoreConfiguration() {
+    @objc
+    dynamic func test_ThatCustomInMemoryStores_ConfigureCorrectly() {
         
         let store = InMemoryStore(configuration: "config1")
         XCTAssertEqual(store.dynamicType.storeType, NSInMemoryStoreType)
@@ -46,7 +51,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertNil(store.storeOptions)
     }
     
-    func testSQLiteStoreDefaultDirectories() {
+    @objc
+    dynamic func test_ThatSQLiteStoreDefaultDirectories_AreCorrect() {
         
         #if os(tvOS)
             let systemDirectorySearchPath = NSSearchPathDirectory.CachesDirectory
@@ -72,7 +78,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(SQLiteStore.defaultFileURL, defaultFileURL)
     }
     
-    func testDefaultSQLiteStore() {
+    @objc
+    dynamic func test_ThatDefaultSQLiteStores_ConfigureCorrectly() {
         
         let store = SQLiteStore()
         XCTAssertEqual(store.dynamicType.storeType, NSSQLiteStoreType)
@@ -84,7 +91,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(store.localStorageOptions, [.None])
     }
     
-    func testSQLiteStoreFileURL() {
+    @objc
+    dynamic func test_ThatFileURLSQLiteStores_ConfigureCorrectly() {
         
         let fileURL = NSURL(fileURLWithPath: NSTemporaryDirectory())
             .URLByAppendingPathComponent(NSUUID().UUIDString, isDirectory: false)
@@ -106,7 +114,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(store.localStorageOptions, [.RecreateStoreOnModelMismatch])
     }
     
-    func testSQLiteStoreFileName() {
+    @objc
+    dynamic func test_ThatFileNameSQLiteStores_ConfigureCorrectly() {
         
         let fileName = NSUUID().UUIDString + ".db"
         let bundles = [NSBundle(forClass: self.dynamicType)]
@@ -127,7 +136,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(store.localStorageOptions, [.RecreateStoreOnModelMismatch])
     }
     
-    func testLegacySQLiteStoreDefaultDirectories() {
+    @objc
+    dynamic func test_ThatLegacySQLiteStoreDefaultDirectories_AreCorrect() {
         
         #if os(tvOS)
             let systemDirectorySearchPath = NSSearchPathDirectory.CachesDirectory
@@ -148,7 +158,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(LegacySQLiteStore.defaultFileURL, legacyDefaultFileURL)
     }
     
-    func testDefaultLegacySQLiteStore() {
+    @objc
+    dynamic func test_ThatDefaultLegacySQLiteStores_ConfigureCorrectly() {
         
         let store = LegacySQLiteStore()
         XCTAssertEqual(store.dynamicType.storeType, NSSQLiteStoreType)
@@ -160,7 +171,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(store.localStorageOptions, [.None])
     }
     
-    func testLegacySQLiteStoreFileURL() {
+    @objc
+    dynamic func test_ThatFileURLLegacySQLiteStores_ConfigureCorrectly() {
         
         let fileURL = NSURL(fileURLWithPath: NSTemporaryDirectory())
             .URLByAppendingPathComponent(NSUUID().UUIDString, isDirectory: false)
@@ -182,7 +194,8 @@ class StorageInterfaceTests: XCTestCase {
         XCTAssertEqual(store.localStorageOptions, [.RecreateStoreOnModelMismatch])
     }
     
-    func testLegacySQLiteStoreFileName() {
+    @objc
+    dynamic func test_ThatFileNameLegacySQLiteStores_ConfigureCorrectly() {
         
         let fileName = NSUUID().UUIDString + ".db"
         let bundles = [NSBundle(forClass: self.dynamicType)]

CoreStoreTests/TransactionTests.swift

@@ -0,0 +1,46 @@
+//
+//  TransactionTests.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: - TransactionTests
+
+final class TransactionTests: BaseTestCase {
+    
+    @objc
+    dynamic func test_ThatSynchronousTransactions_ConfigureCorrectly() {
+        
+        self.prepareStack { (stack) in
+            
+            // TODO:
+        }
+    }
+    
+    // MARK: Private
+}