diff --git a/CoreStoreDemo/CoreStoreDemo/Loggers Demo/CustomLoggerViewController.swift b/CoreStoreDemo/CoreStoreDemo/Loggers Demo/CustomLoggerViewController.swift index 81fcf29..a0c3c10 100644 --- a/CoreStoreDemo/CoreStoreDemo/Loggers Demo/CustomLoggerViewController.swift +++ b/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 diff --git a/CoreStoreTests/BaseTests/BaseTestCase.swift b/CoreStoreTests/BaseTests/BaseTestCase.swift index 0ed5fc6..f0edb87 100644 --- a/CoreStoreTests/BaseTests/BaseTestCase.swift +++ b/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(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(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)") + } + } +} diff --git a/CoreStoreTests/FetchTests.swift b/CoreStoreTests/FetchTests.swift index e64a2a9..3dd970d 100644 --- a/CoreStoreTests/FetchTests.swift +++ b/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("Config1") do { - let count = stack.fetchCount( - from, - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) + let count = self.expectLogger([.LogWarning]) { + + stack.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + } XCTAssertNil(count) } do { @@ -1327,11 +1342,14 @@ final class FetchTests: BaseTestDataTestCase { let from = From("Config2") do { - let count = stack.fetchCount( - from, - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) + let count = self.expectLogger([.LogWarning]) { + + stack.fetchCount( + 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("Config1") do { - let count = transaction.fetchCount( - from, - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) + let count = self.expectLogger([.LogWarning]) { + + transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + } XCTAssertNil(count) } do { @@ -2760,11 +2793,14 @@ final class FetchTests: BaseTestDataTestCase { let from = From("Config2") do { - let count = transaction.fetchCount( - from, - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) + let count = self.expectLogger([.LogWarning]) { + + transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + } XCTAssertNil(count) } do { diff --git a/CoreStoreTests/FromTests.swift b/CoreStoreTests/FromTests.swift index de7613a..7ba6802 100644 --- a/CoreStoreTests/FromTests.swift +++ b/CoreStoreTests/FromTests.swift @@ -100,7 +100,10 @@ final class FromTests: BaseTestCase { let from = From("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("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("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("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) diff --git a/CoreStoreTests/SetupTests.swift b/CoreStoreTests/SetupTests.swift index 8163436..c5a3938 100644 --- a/CoreStoreTests/SetupTests.swift +++ b/CoreStoreTests/SetupTests.swift @@ -56,11 +56,14 @@ class SetupTests: BaseTestCase { let migrationChain: MigrationChain = ["version1", "version2", "version3"] - let stack = DataStack( - modelName: "Model", - bundle: NSBundle(forClass: self.dynamicType), - migrationChain: migrationChain - ) + let stack = self.expectLogger([.LogWarning]) { + + DataStack( + modelName: "Model", + bundle: NSBundle(forClass: self.dynamicType), + migrationChain: migrationChain + ) + } XCTAssertEqual(stack.modelVersion, "Model") XCTAssertEqual(stack.migrationChain, migrationChain) diff --git a/CoreStoreTests/TransactionTests.swift b/CoreStoreTests/TransactionTests.swift index 963211b..b15440f 100644 --- a/CoreStoreTests/TransactionTests.swift +++ b/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") - stack.beginSynchronous { (transaction) in + do { - let object = transaction.create(Into(TestEntity1)) - object.testEntityID = NSNumber(integer: 1) - object.testString = "string1" - object.testNumber = 100 - object.testDate = testDate - - switch transaction.commitAndWait() { + let createExpectation = self.expectationWithDescription("create") + stack.beginSynchronous { (transaction) in - case .Success(true): - createExpectation.fulfill() + let object = transaction.create(Into(TestEntity1)) + object.testEntityID = NSNumber(integer: 1) + object.testString = "string1" + object.testNumber = 100 + object.testDate = testDate - default: - XCTFail() + 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() + self.waitForExpectationsWithTimeout(0, handler: nil) } 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") - stack.beginAsynchronous { (transaction) in + do { - let object = transaction.create(Into(TestEntity1)) - object.testEntityID = NSNumber(integer: 1) - object.testString = "string1" - object.testNumber = 100 - object.testDate = testDate - - transaction.commit { (result) in + let createExpectation = self.expectationWithDescription("create") + stack.beginAsynchronous { (transaction) 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): - 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() + 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 + do { - guard let object = transaction.fetchOne(From(TestEntity1)) else { + let updateExpectation = self.expectationWithDescription("update") + stack.beginAsynchronous { (transaction) in - XCTFail() - return - } - object.testString = "string1_edit" - object.testNumber = 200 - object.testDate = NSDate.distantFuture() - - transaction.commit { (result) in - - switch result { + guard let object = transaction.fetchOne(From(TestEntity1)) else { - 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") - stack.beginAsynchronous { (transaction) in + do { - let object = transaction.fetchOne(From(TestEntity1)) - transaction.delete(object) - - transaction.commit { (result) in + let deleteExpectation = self.expectationWithDescription("delete") + stack.beginAsynchronous { (transaction) in - switch result { + let object = transaction.fetchOne(From(TestEntity1)) + transaction.delete(object) + + transaction.commit { (result) in - case .Success(let hasChanges): - XCTAssertTrue(hasChanges) - - XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0) - - let object = stack.fetchOne(From(TestEntity1)) - XCTAssertNil(object) - deleteExpectation.fulfill() - - default: - XCTFail() + 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() + } } } } @@ -334,88 +358,103 @@ final class TransactionTests: BaseTestCase { self.prepareStack { (stack) in - let createDiscardExpectation = self.expectationWithDescription("create-discard") - stack.beginAsynchronous { (transaction) in + do { - 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 + let createDiscardExpectation = self.expectationWithDescription("create-discard") + let loggerExpectations = self.prepareLoggerExpectations([.LogWarning]) + stack.beginAsynchronous { (transaction) 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): - createExpectation.fulfill() - - default: - XCTFail() + switch result { + + case .Success(true): + createExpectation.fulfill() + + default: + XCTFail() + } } } } - - let updateDiscardExpectation = self.expectationWithDescription("update-discard") - stack.beginAsynchronous { (transaction) in + do { - guard let object = transaction.fetchOne(From(TestEntity1)) else { + let updateDiscardExpectation = self.expectationWithDescription("update-discard") + let loggerExpectations = self.prepareLoggerExpectations([.LogWarning]) + stack.beginAsynchronous { (transaction) in - XCTFail() - return + 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) } - object.testString = "string1_edit" - object.testNumber = 200 - object.testDate = NSDate.distantFuture() - - updateDiscardExpectation.fulfill() } - - let deleteDiscardExpectation = self.expectationWithDescription("delete-discard") - stack.beginAsynchronous { (transaction) in + do { - XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1) - - guard let object = transaction.fetchOne(From(TestEntity1)) else { + let deleteDiscardExpectation = self.expectationWithDescription("delete-discard") + let loggerExpectations = self.prepareLoggerExpectations([.LogWarning]) + stack.beginAsynchronous { (transaction) in - 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(transaction.fetchCount(From(TestEntity1)), 1) - XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1) - - let object = stack.fetchOne(From(TestEntity1)) + 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) - deleteDiscardExpectation.fulfill() + 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.expectLogger(loggerExpectations) } } }