From f59b1b6320e34b8335c6f698c28b3cc0ad957723 Mon Sep 17 00:00:00 2001 From: John Rommel Estropia Date: Sat, 11 Jun 2016 19:09:56 +0900 Subject: [PATCH] WIP: query tests --- CoreStore.xcodeproj/project.pbxproj | 16 + .../BaseTests/BaseTestDataTestCase.swift | 76 + CoreStoreTests/FetchTests.swift | 4030 ++++++++++------- .../Model.xcdatamodel/contents | 12 +- CoreStoreTests/QueryTests.swift | 1156 +++++ CoreStoreTests/TestEntities/TestEntity1.swift | 3 + CoreStoreTests/TestEntities/TestEntity2.swift | 5 +- 7 files changed, 3742 insertions(+), 1556 deletions(-) create mode 100644 CoreStoreTests/BaseTests/BaseTestDataTestCase.swift create mode 100644 CoreStoreTests/QueryTests.swift diff --git a/CoreStore.xcodeproj/project.pbxproj b/CoreStore.xcodeproj/project.pbxproj index e3cc9fe..c562705 100644 --- a/CoreStore.xcodeproj/project.pbxproj +++ b/CoreStore.xcodeproj/project.pbxproj @@ -334,6 +334,12 @@ B5677D411CD3B1E400322BFC /* ICloudStoreObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5677D3C1CD3B1E400322BFC /* ICloudStoreObserver.swift */; }; B56964D41B22FFAD0075EE4A /* DataStack+Migration.swift in Sources */ = {isa = PBXBuildFile; fileRef = B56964D31B22FFAD0075EE4A /* DataStack+Migration.swift */; }; B56965241B356B820075EE4A /* MigrationResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = B56965231B356B820075EE4A /* MigrationResult.swift */; }; + B57D27BE1D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27BD1D0BBE8200539C58 /* BaseTestDataTestCase.swift */; }; + B57D27BF1D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27BD1D0BBE8200539C58 /* BaseTestDataTestCase.swift */; }; + B57D27C01D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27BD1D0BBE8200539C58 /* BaseTestDataTestCase.swift */; }; + B57D27C21D0BC20100539C58 /* QueryTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27C11D0BC20100539C58 /* QueryTests.swift */; }; + B57D27C31D0BC20100539C58 /* QueryTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27C11D0BC20100539C58 /* QueryTests.swift */; }; + B57D27C41D0BC20100539C58 /* QueryTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57D27C11D0BC20100539C58 /* QueryTests.swift */; }; B580857A1CDF808C004C2EEB /* SetupTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B58085741CDF7F00004C2EEB /* SetupTests.swift */; }; B580857B1CDF808D004C2EEB /* SetupTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B58085741CDF7F00004C2EEB /* SetupTests.swift */; }; B580857C1CDF808F004C2EEB /* SetupTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B58085741CDF7F00004C2EEB /* SetupTests.swift */; }; @@ -715,6 +721,8 @@ B5677D3C1CD3B1E400322BFC /* ICloudStoreObserver.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ICloudStoreObserver.swift; sourceTree = ""; }; B56964D31B22FFAD0075EE4A /* DataStack+Migration.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "DataStack+Migration.swift"; sourceTree = ""; }; B56965231B356B820075EE4A /* MigrationResult.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MigrationResult.swift; sourceTree = ""; }; + B57D27BD1D0BBE8200539C58 /* BaseTestDataTestCase.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BaseTestDataTestCase.swift; sourceTree = ""; }; + B57D27C11D0BC20100539C58 /* QueryTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = QueryTests.swift; sourceTree = ""; }; B58085741CDF7F00004C2EEB /* SetupTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SetupTests.swift; sourceTree = ""; }; B59AFF401C6593E400C0ABE2 /* NSPersistentStoreCoordinator+Setup.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "NSPersistentStoreCoordinator+Setup.swift"; sourceTree = ""; }; B59FA0AD1CCBAC95007C9BCA /* ICloudStore.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ICloudStore.swift; sourceTree = ""; }; @@ -954,6 +962,7 @@ B525576B1CFAF18F00E51965 /* IntoTests.swift */, B5DC47C51C93D22900FA3BF3 /* MigrationChainTests.swift */, B52557771D02826E00E51965 /* OrderByTests.swift */, + B57D27C11D0BC20100539C58 /* QueryTests.swift */, B52557831D02A07400E51965 /* SectionByTests.swift */, B525576F1D02561A00E51965 /* SelectTests.swift */, B58085741CDF7F00004C2EEB /* SetupTests.swift */, @@ -1051,6 +1060,7 @@ isa = PBXGroup; children = ( B5489F4B1CF5F743008B4978 /* BaseTestCase.swift */, + B57D27BD1D0BBE8200539C58 /* BaseTestDataTestCase.swift */, ); path = BaseTests; sourceTree = ""; @@ -1768,7 +1778,9 @@ B580857A1CDF808C004C2EEB /* SetupTests.swift in Sources */, B5489F4C1CF5F743008B4978 /* BaseTestCase.swift in Sources */, B5DBE2DF1C9939E100B5CEFA /* BridgingTests.m in Sources */, + B57D27BE1D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */, B5489F3F1CF5EEBC008B4978 /* TestEntity1.swift in Sources */, + B57D27C21D0BC20100539C58 /* QueryTests.swift in Sources */, B5DC47CA1C93D9C800FA3BF3 /* StorageInterfaceTests.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -1911,7 +1923,9 @@ 82BA18D91C4BBD9700A0916E /* CoreStoreTests.swift in Sources */, B5489F4D1CF5F743008B4978 /* BaseTestCase.swift in Sources */, 82BA18DC1C4BBD9C00A0916E /* Model.xcdatamodeld in Sources */, + B57D27BF1D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */, B5489F401CF5EEBC008B4978 /* TestEntity1.swift in Sources */, + B57D27C31D0BC20100539C58 /* QueryTests.swift in Sources */, B5DC47CB1C93D9C800FA3BF3 /* StorageInterfaceTests.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -2035,7 +2049,9 @@ B52DD1CC1BE1F94D00949AFE /* CoreStoreTests.swift in Sources */, B5489F4E1CF5F743008B4978 /* BaseTestCase.swift in Sources */, B5598BCC1BE2093D0092EFCE /* Model.xcdatamodeld in Sources */, + B57D27C01D0BBE8200539C58 /* BaseTestDataTestCase.swift in Sources */, B5489F411CF5EEBC008B4978 /* TestEntity1.swift in Sources */, + B57D27C41D0BC20100539C58 /* QueryTests.swift in Sources */, B5DC47CC1C93D9C800FA3BF3 /* StorageInterfaceTests.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; diff --git a/CoreStoreTests/BaseTests/BaseTestDataTestCase.swift b/CoreStoreTests/BaseTests/BaseTestDataTestCase.swift new file mode 100644 index 0000000..0d5460c --- /dev/null +++ b/CoreStoreTests/BaseTests/BaseTestDataTestCase.swift @@ -0,0 +1,76 @@ +// +// BaseTestDataTestCase.swift +// CoreStore +// +// Created by John Rommel Estropia on 2016/06/11. +// Copyright © 2016 John Rommel Estropia. All rights reserved. +// + +import UIKit + +@testable +import CoreStore + + +// MARK: - BaseTestDataTestCase + +class BaseTestDataTestCase: BaseTestCase { + + @nonobjc + let dateFormatter: NSDateFormatter = { + + let formatter = NSDateFormatter() + formatter.locale = NSLocale(localeIdentifier: "en_US_POSIX") + formatter.timeZone = NSTimeZone(name: "UTC") + formatter.calendar = NSCalendar(identifier: NSCalendarIdentifierGregorian) + formatter.dateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ssZ" + return formatter + }() + + @nonobjc + func prepareTestDataForStack(stack: DataStack, configurations: [String?]) { + + stack.beginSynchronous { (transaction) in + + for (configurationIndex, configuration) in configurations.enumerate() { + + let configurationOrdinal = configurationIndex + 1 + if configuration == nil || configuration == "Config1" { + + for idIndex in 1 ... 5 { + + let object = transaction.create(Into(configuration)) + object.testEntityID = NSNumber(integer: (configurationOrdinal * 100) + idIndex) + + object.testNumber = idIndex + object.testDate = self.dateFormatter.dateFromString("2000-\(configurationOrdinal)-\(idIndex)T00:00:00Z") + object.testBoolean = (idIndex % 2) == 1 + object.testDecimal = NSDecimalNumber(string: "\(idIndex)") + + let string = "\(configuration ?? "nil"):TestEntity1:\(idIndex)" + object.testString = string + object.testData = (string as NSString).dataUsingEncoding(NSUTF8StringEncoding) + } + } + if configuration == nil || configuration == "Config2" { + + for idIndex in 1 ... 5 { + + let object = transaction.create(Into(configuration)) + object.testEntityID = NSNumber(integer: (configurationOrdinal * 200) + idIndex) + + object.testNumber = idIndex + object.testDate = self.dateFormatter.dateFromString("2000-\(configurationOrdinal)-\(idIndex)T00:00:00Z") + object.testBoolean = (idIndex % 2) == 1 + object.testDecimal = NSDecimalNumber(string: "\(idIndex)") + + let string = "\(configuration ?? "nil"):TestEntity2:\(idIndex)" + object.testString = string + object.testData = (string as NSString).dataUsingEncoding(NSUTF8StringEncoding) + } + } + } + transaction.commitAndWait() + } + } +} diff --git a/CoreStoreTests/FetchTests.swift b/CoreStoreTests/FetchTests.swift index 0190c6e..e64a2a9 100644 --- a/CoreStoreTests/FetchTests.swift +++ b/CoreStoreTests/FetchTests.swift @@ -31,7 +31,7 @@ import CoreStore //MARK: - FetchTests -final class FetchTests: BaseTestCase { +final class FetchTests: BaseTestDataTestCase { @objc dynamic func test_ThatDataStacks_CanFetchOneFromDefaultConfiguration() { @@ -39,73 +39,123 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let object2 = stack.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = stack.fetchOne( - From(TestEntity1), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = stack.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let object2 = stack.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = stack.fetchOne( - From(nil), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = stack.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let nilObject1 = stack.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = stack.fetchOne( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -116,98 +166,167 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let object2 = stack.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testNumber, 2) // configuration ambiguous - - let object3 = stack.fetchOne( - From(TestEntity1), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testNumber, 3) // configuration ambiguous - - let nilObject = stack.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 2) // configuration ambiguous + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 3) // configuration + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let object2 = stack.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = stack.fetchOne( - From(nil), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = stack.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let object2 = stack.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "Config1:TestEntity1:2") - - let object3 = stack.fetchOne( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "Config1:TestEntity1:3") - - let nilObject = stack.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let nilObject1 = stack.fetchOne( - From("Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = stack.fetchOne( - From("Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -218,82 +337,139 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let object2 = stack.fetchOne( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testNumber, 2) // configuration is ambiguous - - let object3 = stack.fetchOne( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testNumber, 3) // configuration is ambiguous - - let nilObject = stack.fetchOne( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil, "Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 2) // configuration is ambiguous + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 3) // configuration is ambiguous + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let object2 = stack.fetchOne( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = stack.fetchOne( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = stack.fetchOne( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil, "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } do { - let object2 = stack.fetchOne( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "Config1:TestEntity1:2") - - let object3 = stack.fetchOne( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "Config1:TestEntity1:3") - - let nilObject = stack.fetchOne( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From("Config1", "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:2") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:3") + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = stack.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = stack.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -304,111 +480,175 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let objects2to4 = stack.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to4) - XCTAssertEqual(objects2to4?.count, 3) - XCTAssertEqual( - (objects2to4 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:3", - "nil:TestEntity1:4" + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects4to2 = stack.fetchAll( - From(TestEntity1), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to2) - XCTAssertEqual(objects4to2?.count, 3) - XCTAssertEqual( - (objects4to2 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:3", - "nil:TestEntity1:2" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:3", + "nil:TestEntity1:4" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:3", + "nil:TestEntity1:2" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let objects2to4 = stack.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to4) - XCTAssertEqual(objects2to4?.count, 3) - XCTAssertEqual( - (objects2to4 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:3", - "nil:TestEntity1:4" + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects4to2 = stack.fetchAll( - From(nil), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to2) - XCTAssertEqual(objects4to2?.count, 3) - XCTAssertEqual( - (objects4to2 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:3", - "nil:TestEntity1:2" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:3", + "nil:TestEntity1:4" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:3", + "nil:TestEntity1:2" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let nilObject1 = stack.fetchAll( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = stack.fetchAll( - From("Config1"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } } } } @@ -419,141 +659,233 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let objects4to5 = stack.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 3) - XCTAssertEqual( - Set((objects4to5 ?? []).map { $0.testNumber!.integerValue }), - [4, 5] as Set - ) // configuration is ambiguous - - let objects2to1 = stack.fetchAll( - From(TestEntity1), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 3) - XCTAssertEqual( - Set((objects2to1 ?? []).map { $0.testNumber!.integerValue }), - [1, 2] as Set - ) // configuration is ambiguous - - let emptyObjects = stack.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [4, 5] as Set + ) // configuration is ambiguous + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [1, 2] as Set + ) // configuration is ambiguous + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let objects4to5 = stack.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:5" + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = stack.fetchAll( - From(nil), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:1" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:5" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:1" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let objects4to5 = stack.fetchAll( - From("Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:4", - "Config1:TestEntity1:5" + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = stack.fetchAll( - From("Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:2", - "Config1:TestEntity1:1" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:4", + "Config1:TestEntity1:5" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:2", + "Config1:TestEntity1:1" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let object1 = stack.fetchOne( - From("Config2"), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(object1) - - let object5 = stack.fetchOne( - From("Config2"), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(object5) + let from = From("Config2") + do { + + let fetchClauses: [FetchClause] = [ + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } + do { + + let fetchClauses: [FetchClause] = [ + OrderBy(.Descending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } } } } @@ -564,127 +896,207 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let objects4to5 = stack.fetchAll( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 3) - XCTAssertEqual( - Set((objects4to5 ?? []).map { $0.testNumber!.integerValue }), - [4, 5] as Set - ) // configuration is ambiguous - - let objects2to1 = stack.fetchAll( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 3) - XCTAssertEqual( - Set((objects2to1 ?? []).map { $0.testNumber!.integerValue }), - [1, 2] as Set - ) // configuration is ambiguous - - let emptyObjects = stack.fetchAll( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let from = From(nil, "Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [4, 5] as Set + ) // configuration is ambiguous + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [1, 2] as Set + ) // configuration is ambiguous + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let objects4to5 = stack.fetchAll( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:5" + let from = From(nil, "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = stack.fetchAll( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:1" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:5" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:1" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } do { - let objects4to5 = stack.fetchAll( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:4", - "Config1:TestEntity1:5" + let from = From("Config1", "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = stack.fetchAll( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:2", - "Config1:TestEntity1:1" + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:4", + "Config1:TestEntity1:5" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = stack.fetchAll( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:2", + "Config1:TestEntity1:1" + ] + ) + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = stack.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = stack.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } } } @@ -695,79 +1107,101 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let count2to4 = stack.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to4) - XCTAssertEqual(count2to4, 3) - - let count4to2 = stack.fetchCount( - From(TestEntity1), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to2) - XCTAssertEqual(count4to2, 3) - - let emptyCount = stack.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(TestEntity1) + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let count2to4 = stack.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to4) - XCTAssertEqual(count2to4, 3) - - let count4to2 = stack.fetchCount( - From(nil), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to2) - XCTAssertEqual(count4to2, 3) - - let emptyCount = stack.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil) + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let nilCount1 = stack.fetchCount( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilCount1) - - let nilCount2 = stack.fetchCount( - From("Config1"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilCount2) + let from = From("Config1") + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNil(count) + } + do { + + let count = stack.fetchCount( + from, + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ) + XCTAssertNil(count) + } } } } @@ -778,107 +1212,137 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let count4to5 = stack.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 3) - - let count2to1 = stack.fetchCount( - From(TestEntity1), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 3) - - let emptyCount = stack.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(TestEntity1) + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let count4to5 = stack.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = stack.fetchCount( - From(nil), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = stack.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil) + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let count4to5 = stack.fetchCount( - From("Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = stack.fetchCount( - From("Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = stack.fetchCount( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From("Config1") + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let nilCount1 = stack.fetchCount( - From("Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilCount1) - - let nilCount2 = stack.fetchCount( - From("Config2"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilCount2) + let from = From("Config2") + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNil(count) + } + do { + + let count = stack.fetchCount( + from, + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ) + XCTAssertNil(count) + } } } } @@ -889,91 +1353,115 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) do { - let count4to5 = stack.fetchCount( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 3) - - let count2to1 = stack.fetchCount( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 3) - - let emptyCount = stack.fetchCount( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil, "Config1") + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let count4to5 = stack.fetchCount( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = stack.fetchCount( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = stack.fetchCount( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil, "Config2") + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } do { - let count4to5 = stack.fetchCount( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = stack.fetchCount( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = stack.fetchCount( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From("Config1", "Config2") + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = stack.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } } } @@ -984,73 +1472,123 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = transaction.fetchOne( - From(TestEntity1), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = transaction.fetchOne( - From(nil), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let nilObject1 = transaction.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = transaction.fetchOne( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -1061,98 +1599,167 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testNumber, 2) // configuration ambiguous - - let object3 = transaction.fetchOne( - From(TestEntity1), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testNumber, 3) // configuration ambiguous - - let nilObject = transaction.fetchOne( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 2) // configuration ambiguous + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 3) // configuration + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = transaction.fetchOne( - From(nil), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "Config1:TestEntity1:2") - - let object3 = transaction.fetchOne( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "Config1:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let nilObject1 = transaction.fetchOne( - From("Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = transaction.fetchOne( - From("Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -1163,82 +1770,139 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testNumber, 2) // configuration is ambiguous - - let object3 = transaction.fetchOne( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testNumber, 3) // configuration is ambiguous - - let nilObject = transaction.fetchOne( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil, "Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 2) // configuration is ambiguous + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testNumber, 3) // configuration is ambiguous + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "nil:TestEntity1:2") - - let object3 = transaction.fetchOne( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "nil:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From(nil, "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "nil:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } stack.beginSynchronous { (transaction) in - let object2 = transaction.fetchOne( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(object2) - XCTAssertEqual(object2?.testString, "Config1:TestEntity1:2") - - let object3 = transaction.fetchOne( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNotNil(object3) - XCTAssertEqual(object3?.testString, "Config1:TestEntity1:3") - - let nilObject = transaction.fetchOne( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject) + let from = From("Config1", "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:2") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Descending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNotNil(object) + XCTAssertEqual(object?.testString, "Config1:TestEntity1:3") + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNotNil(objectID) + XCTAssertEqual(objectID, object?.objectID) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let object = transaction.fetchOne(from, fetchClauses) + XCTAssertNil(object) + + let objectID = transaction.fetchObjectID(from, fetchClauses) + XCTAssertNil(objectID) + } } } } @@ -1249,111 +1913,175 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let objects2to4 = transaction.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to4) - XCTAssertEqual(objects2to4?.count, 3) - XCTAssertEqual( - (objects2to4 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:3", - "nil:TestEntity1:4" + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects4to2 = transaction.fetchAll( - From(TestEntity1), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to2) - XCTAssertEqual(objects4to2?.count, 3) - XCTAssertEqual( - (objects4to2 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:3", - "nil:TestEntity1:2" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:3", + "nil:TestEntity1:4" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:3", + "nil:TestEntity1:2" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let objects2to4 = transaction.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to4) - XCTAssertEqual(objects2to4?.count, 3) - XCTAssertEqual( - (objects2to4 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:3", - "nil:TestEntity1:4" + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects4to2 = transaction.fetchAll( - From(nil), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to2) - XCTAssertEqual(objects4to2?.count, 3) - XCTAssertEqual( - (objects4to2 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:3", - "nil:TestEntity1:2" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:3", + "nil:TestEntity1:4" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:3", + "nil:TestEntity1:2" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let nilObject1 = transaction.fetchAll( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilObject1) - - let nilObject2 = transaction.fetchAll( - From("Config1"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilObject2) + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } } } } @@ -1364,141 +2092,233 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 3) - XCTAssertEqual( - Set((objects4to5 ?? []).map { $0.testNumber!.integerValue }), - [4, 5] as Set - ) // configuration is ambiguous - - let objects2to1 = transaction.fetchAll( - From(TestEntity1), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 3) - XCTAssertEqual( - Set((objects2to1 ?? []).map { $0.testNumber!.integerValue }), - [1, 2] as Set - ) // configuration is ambiguous - - let emptyObjects = transaction.fetchAll( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let from = From(TestEntity1) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [4, 5] as Set + ) // configuration is ambiguous + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [1, 2] as Set + ) // configuration is ambiguous + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:5" + let from = From(nil) + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = transaction.fetchAll( - From(nil), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:1" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:5" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:1" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From("Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:4", - "Config1:TestEntity1:5" + let from = From("Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = transaction.fetchAll( - From("Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:2", - "Config1:TestEntity1:1" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:4", + "Config1:TestEntity1:5" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:2", + "Config1:TestEntity1:1" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let object1 = transaction.fetchOne( - From("Config2"), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(object1) - - let object5 = transaction.fetchOne( - From("Config2"), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(object5) + let from = From("Config2") + do { + + let fetchClauses: [FetchClause] = [ + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } + do { + + let fetchClauses: [FetchClause] = [ + OrderBy(.Descending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNil(objects) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNil(objectIDs) + } } } } @@ -1509,127 +2329,207 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 3) - XCTAssertEqual( - Set((objects4to5 ?? []).map { $0.testNumber!.integerValue }), - [4, 5] as Set - ) // configuration is ambiguous - - let objects2to1 = transaction.fetchAll( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 3) - XCTAssertEqual( - Set((objects2to1 ?? []).map { $0.testNumber!.integerValue }), - [1, 2] as Set - ) // configuration is ambiguous - - let emptyObjects = transaction.fetchAll( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let from = From(nil, "Config1") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [4, 5] as Set + ) // configuration is ambiguous + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 3) + XCTAssertEqual( + Set((objects ?? []).map { $0.testNumber!.integerValue }), + [1, 2] as Set + ) // configuration is ambiguous + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 3) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:4", - "nil:TestEntity1:5" + let from = From(nil, "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = transaction.fetchAll( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "nil:TestEntity1:2", - "nil:TestEntity1:1" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:4", + "nil:TestEntity1:5" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "nil:TestEntity1:2", + "nil:TestEntity1:1" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } stack.beginSynchronous { (transaction) in - let objects4to5 = transaction.fetchAll( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects4to5) - XCTAssertEqual(objects4to5?.count, 2) - XCTAssertEqual( - (objects4to5 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:4", - "Config1:TestEntity1:5" + let from = From("Config1", "Config2") + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let objects2to1 = transaction.fetchAll( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(objects2to1) - XCTAssertEqual(objects2to1?.count, 2) - XCTAssertEqual( - (objects2to1 ?? []).map { $0.testString ?? "" }, - [ - "Config1:TestEntity1:2", - "Config1:TestEntity1:1" + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:4", + "Config1:TestEntity1:5" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } ] - ) - - let emptyObjects = transaction.fetchAll( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyObjects) - XCTAssertEqual(emptyObjects?.count, 0) + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 2) + XCTAssertEqual( + (objects ?? []).map { $0.testString ?? "" }, + [ + "Config1:TestEntity1:2", + "Config1:TestEntity1:1" + ] + ) + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 2) + XCTAssertEqual( + (objectIDs ?? []), + (objects ?? []).map { $0.objectID } + ) + } + do { + + let fetchClauses: [FetchClause] = [ + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ] + let objects = transaction.fetchAll(from, fetchClauses) + XCTAssertNotNil(objects) + XCTAssertEqual(objects?.count, 0) + + let objectIDs = transaction.fetchObjectIDs(from, fetchClauses) + XCTAssertNotNil(objectIDs) + XCTAssertEqual(objectIDs?.count, 0) + } } } } @@ -1640,79 +2540,101 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let count2to4 = transaction.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to4) - XCTAssertEqual(count2to4, 3) - - let count4to2 = transaction.fetchCount( - From(TestEntity1), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to2) - XCTAssertEqual(count4to2, 3) - - let emptyCount = transaction.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(TestEntity1) + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let count2to4 = transaction.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 1), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to4) - XCTAssertEqual(count2to4, 3) - - let count4to2 = transaction.fetchCount( - From(nil), - Where("%K < %@", "testNumber", 5), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to2) - XCTAssertEqual(count4to2, 3) - - let emptyCount = transaction.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil) + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 1), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 5), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let nilCount1 = transaction.fetchCount( - From("Config1"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilCount1) - - let nilCount2 = transaction.fetchCount( - From("Config1"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilCount2) + let from = From("Config1") + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNil(count) + } + do { + + let count = transaction.fetchCount( + from, + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ) + XCTAssertNil(count) + } } } } @@ -1723,107 +2645,137 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 3) - - let count2to1 = transaction.fetchCount( - From(TestEntity1), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 3) - - let emptyCount = transaction.fetchCount( - From(TestEntity1), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(TestEntity1) + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = transaction.fetchCount( - From(nil), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = transaction.fetchCount( - From(nil), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil) + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From("Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = transaction.fetchCount( - From("Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = transaction.fetchCount( - From("Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From("Config1") + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let nilCount1 = transaction.fetchCount( - From("Config2"), - Where("%K < %@", "testNumber", 4), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNil(nilCount1) - - let nilCount2 = transaction.fetchCount( - From("Config2"), - Where("testNumber", isEqualTo: 0), - OrderBy(.Descending("testEntityID")) - ) - XCTAssertNil(nilCount2) + let from = From("Config2") + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 4), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNil(count) + } + do { + + let count = transaction.fetchCount( + from, + Where("testNumber", isEqualTo: 0), + OrderBy(.Descending("testEntityID")) + ) + XCTAssertNil(count) + } } } } @@ -1834,140 +2786,116 @@ final class FetchTests: BaseTestCase { let configurations: [String?] = [nil, "Config1", "Config2"] self.prepareStack(configurations: configurations) { (stack) in - self.prepareStubsForStack(stack, configurations: configurations) + self.prepareTestDataForStack(stack, configurations: configurations) stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 3) - - let count2to1 = transaction.fetchCount( - From(nil, "Config1"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 3) - - let emptyCount = transaction.fetchCount( - From(nil, "Config1"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil, "Config1") + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 3) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = transaction.fetchCount( - From(nil, "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = transaction.fetchCount( - From(nil, "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) + let from = From(nil, "Config2") + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) + } } stack.beginSynchronous { (transaction) in - let count4to5 = transaction.fetchCount( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 3), - OrderBy(.Ascending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count4to5) - XCTAssertEqual(count4to5, 2) - - let count2to1 = transaction.fetchCount( - From("Config1", "Config2"), - Where("%K < %@", "testNumber", 3), - OrderBy(.Descending("testEntityID")), - Tweak { $0.fetchLimit = 3 } - ) - XCTAssertNotNil(count2to1) - XCTAssertEqual(count2to1, 2) - - let emptyCount = transaction.fetchCount( - From("Config1", "Config2"), - Where("%K > %@", "testNumber", 5), - OrderBy(.Ascending("testEntityID")) - ) - XCTAssertNotNil(emptyCount) - XCTAssertEqual(emptyCount, 0) - } - } - } - - - // MARK: Private - - @nonobjc - private let dateFormatter: NSDateFormatter = { - - let formatter = NSDateFormatter() - formatter.locale = NSLocale(localeIdentifier: "en_US_POSIX") - formatter.timeZone = NSTimeZone(name: "UTC") - formatter.calendar = NSCalendar(identifier: NSCalendarIdentifierGregorian) - formatter.dateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ssZ" - return formatter - }() - - @nonobjc - private func prepareStubsForStack(stack: DataStack, configurations: [String?]) { - - stack.beginSynchronous { (transaction) in - - for (configurationIndex, configuration) in configurations.enumerate() { - - if configuration == nil || configuration == "Config1" { + let from = From("Config1", "Config2") + do { - for idIndex in 1 ... 5 { - - let object = transaction.create(Into(configuration)) - object.testEntityID = NSNumber(integer: (configurationIndex * 100) + idIndex) - object.testString = "\(configuration ?? "nil"):TestEntity1:\(idIndex)" - object.testNumber = idIndex - object.testDate = self.dateFormatter.dateFromString("2000-\(configurationIndex)-\(idIndex)T00:00:00Z") - } + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 3), + OrderBy(.Ascending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) } - if configuration == nil || configuration == "Config2" { + do { - for idIndex in 1 ... 5 { - - let object = transaction.create(Into(configuration)) - object.testEntityID = NSNumber(integer: (configurationIndex * 200) + idIndex) - object.testString = "\(configuration ?? "nil"):TestEntity2:\(idIndex)" - object.testNumber = idIndex - object.testDate = self.dateFormatter.dateFromString("2000-\(configurationIndex)-\(idIndex)T00:00:00Z") - } + let count = transaction.fetchCount( + from, + Where("%K < %@", "testNumber", 3), + OrderBy(.Descending("testEntityID")), + Tweak { $0.fetchLimit = 3 } + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 2) + } + do { + + let count = transaction.fetchCount( + from, + Where("%K > %@", "testNumber", 5), + OrderBy(.Ascending("testEntityID")) + ) + XCTAssertNotNil(count) + XCTAssertEqual(count, 0) } } - transaction.commitAndWait() } } } diff --git a/CoreStoreTests/Model.xcdatamodeld/Model.xcdatamodel/contents b/CoreStoreTests/Model.xcdatamodeld/Model.xcdatamodel/contents index 4e59c31..a32a044 100644 --- a/CoreStoreTests/Model.xcdatamodeld/Model.xcdatamodel/contents +++ b/CoreStoreTests/Model.xcdatamodeld/Model.xcdatamodel/contents @@ -1,13 +1,19 @@ - + + + + + + + @@ -19,7 +25,7 @@ - - + + \ No newline at end of file diff --git a/CoreStoreTests/QueryTests.swift b/CoreStoreTests/QueryTests.swift new file mode 100644 index 0000000..052b23b --- /dev/null +++ b/CoreStoreTests/QueryTests.swift @@ -0,0 +1,1156 @@ +// +// QueryTests.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: - QueryTests + +class QueryTests: BaseTestDataTestCase { + + @objc + dynamic func test_ThatDataStacks_CanQueryAttributeValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("testEntityID", isEqualTo: 101) + ] + do { + + let value = stack.queryValue( + from, + Select("testBoolean"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, true) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testNumber"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 1) + } + do { + + let value = stack.queryValue( + from, + Select("testDecimal"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, NSDecimalNumber(string: "1")) + } + do { + + let value = stack.queryValue( + from, + Select("testString"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:1") + } + do { + + let value = stack.queryValue( + from, + Select("testString"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:1") + } + do { + + let value = stack.queryValue( + from, + Select("testData"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)) + } + do { + + let value = stack.queryValue( + from, + Select("testDate"), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")) + } + do { + + let value = stack.queryValue( + from, + Select("testDate"), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQueryAverageValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.Average("testBoolean")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, true) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3.5) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3.5) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 3.5) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testDecimal")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, NSDecimalNumber(string: "3.5")) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testData")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Average("testDate")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select("testEntityID"), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQueryCountValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.Count("testBoolean")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, true) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 4) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testDecimal")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testData")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testDate")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Count("testEntityID")), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQueryMaximumValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testBoolean")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, true) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 5) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testDecimal")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, NSDecimalNumber(string: "5")) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testString")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:5") + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testString")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:5") + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testData")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding)) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testDate")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-05T00:00:00Z")) + } + do { + + let value = stack.queryValue( + from, + Select(.Maximum("testEntityID")), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQueryMinimumValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testBoolean")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, false) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 2) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testDecimal")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, NSDecimalNumber(string: "2")) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testString")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:2") + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testString")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, "nil:TestEntity1:2") + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testData")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testDate")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")) + } + do { + + let value = stack.queryValue( + from, + Select(.Minimum("testEntityID")), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQuerySumValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.Sum("testBoolean")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, true) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testNumber")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, 14) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testDecimal")), + queryClauses + ) + XCTAssertNotNil(value) + XCTAssertEqual(value, NSDecimalNumber(string: "14")) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testString")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testData")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testDate")), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.Sum("testEntityID")), + queryClauses + ) + XCTAssertNil(value) + } + } + } + + @objc + dynamic func test_ThatDataStacks_CanQueryObjectIDValue() { + + let configurations: [String?] = [nil] + self.prepareStack(configurations: configurations) { (stack) in + + self.prepareTestDataForStack(stack, configurations: configurations) + + let from = From(configurations) + let queryClauses: [QueryClause] = [ + Where("%K > %@", "testNumber", 1) + ] + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNil(value) + } + do { + + let value = stack.queryValue( + from, + Select(.ObjectID()), + queryClauses + ) + XCTAssertNotNil(value) + } + } + } +} diff --git a/CoreStoreTests/TestEntities/TestEntity1.swift b/CoreStoreTests/TestEntities/TestEntity1.swift index c94a779..a8c200d 100644 --- a/CoreStoreTests/TestEntities/TestEntity1.swift +++ b/CoreStoreTests/TestEntities/TestEntity1.swift @@ -32,4 +32,7 @@ class TestEntity1: NSManagedObject { @NSManaged var testString: String? @NSManaged var testNumber: NSNumber? @NSManaged var testDate: NSDate? + @NSManaged var testBoolean: NSNumber? + @NSManaged var testDecimal: NSDecimalNumber? + @NSManaged var testData: NSData? } diff --git a/CoreStoreTests/TestEntities/TestEntity2.swift b/CoreStoreTests/TestEntities/TestEntity2.swift index a101c0f..50739d0 100644 --- a/CoreStoreTests/TestEntities/TestEntity2.swift +++ b/CoreStoreTests/TestEntities/TestEntity2.swift @@ -32,6 +32,7 @@ class TestEntity2: NSManagedObject { @NSManaged var testString: String? @NSManaged var testNumber: NSNumber? @NSManaged var testDate: NSDate? - - var testProperty: NSNumber? + @NSManaged var testBoolean: NSNumber? + @NSManaged var testDecimal: NSDecimalNumber? + @NSManaged var testData: NSData? }