starred/CoreStore-JohnEstropia
1
0
Fork 0
mirror of https://github.com/JohnEstropia/CoreStore.git synced 2026-03-28 04:11:18 +01:00
Code Issues 95 Packages Projects Releases 10 Wiki Activity

WIP

Browse Source
This commit is contained in:
John Rommel Estropia
2016-07-21 02:45:42 +09:00
parent 267c21063a
commit a638620858
85 changed files with 1621 additions and 1819 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
CoreStoreTests/BaseTests/BaseTestCase.swift
View File

@@ -36,11 +36,12 @@ class BaseTestCase: XCTestCase {
// MARK: Internal
@nonobjc
func prepareStack<T>(_ configurations: [String?] = [nil], @noescape _ closure: (dataStack: DataStack) -> T) -> T {
@discardableResult
func prepareStack<T>(configurations: [String?] = [nil], _ closure: @noescape (dataStack: DataStack) -> T) -> T {
let stack = DataStack(
modelName: "Model",
bundle: Bundle(forClass: self.dynamicType)
bundle: Bundle(for: self.dynamicType)
)
do {
@@ -48,9 +49,9 @@ class BaseTestCase: XCTestCase {
try stack.addStorageAndWait(
SQLiteStore(
fileURL: SQLiteStore.defaultRootDirectory
.URLByAppendingPathComponent(UUID().UUIDString)
.URLByAppendingPathComponent("\(self.dynamicType)_\(($0 ?? "-null-")).sqlite"),
fileURL: try SQLiteStore.defaultRootDirectory
.appendingPathComponent(UUID().uuidString)
.appendingPathComponent("\(self.dynamicType)_\(($0 ?? "-null-")).sqlite"),
configuration: $0,
localStorageOptions: .recreateStoreOnModelMismatch
)
@@ -65,7 +66,7 @@ class BaseTestCase: XCTestCase {
}
@nonobjc
func expectLogger<T>(_ expectations: [TestLogger.Expectation], @noescape closure: () -> T) -> T {
func expectLogger<T>(_ expectations: [TestLogger.Expectation], closure: @noescape () -> T) -> T {
CoreStore.logger = TestLogger(self.prepareLoggerExpectations(expectations))
defer {
@@ -126,7 +127,7 @@ class BaseTestCase: XCTestCase {
private func deleteStores() {
_ = try? FileManager.defaultManager().removeItemAtURL(SQLiteStore.defaultRootDirectory)
_ = try? FileManager.default.removeItem(at: SQLiteStore.defaultRootDirectory)
}
}
@@ -152,7 +153,7 @@ class TestLogger: CoreStoreLogger {
// MARK: CoreStoreLogger
func log(_ level: LogLevel, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
func log(level: LogLevel, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
switch level {
@@ -162,12 +163,12 @@ class TestLogger: CoreStoreLogger {
}
}
func log(_ error: CoreStoreError, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
func log(error: CoreStoreError, message: String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
self.fulfill(.logError)
}
func assert(@autoclosure _ condition: () -> Bool, @autoclosure message: () -> String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
func assert(_ condition: @autoclosure () -> Bool, message: @autoclosure () -> String, fileName: StaticString, lineNumber: Int, functionName: StaticString) {
if condition() {

16
CoreStoreTests/BaseTests/BaseTestDataTestCase.swift
View File

@@ -30,9 +30,9 @@ class BaseTestDataTestCase: BaseTestCase {
@nonobjc
func prepareTestDataForStack(_ stack: DataStack, configurations: [String?] = [nil]) {
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
for (configurationIndex, configuration) in configurations.enumerate() {
for (configurationIndex, configuration) in configurations.enumerated() {
let configurationOrdinal = configurationIndex + 1
if configuration == nil || configuration == "Config1" {
@@ -40,16 +40,16 @@ class BaseTestDataTestCase: BaseTestCase {
for idIndex in 1 ... 5 {
let object = transaction.create(Into<TestEntity1>(configuration))
object.testEntityID = NSNumber(integer: (configurationOrdinal * 100) + idIndex)
object.testEntityID = NSNumber(value: (configurationOrdinal * 100) + idIndex)
object.testNumber = idIndex
object.testDate = self.dateFormatter.dateFromString("2000-\(configurationOrdinal)-\(idIndex)T00:00:00Z")
object.testDate = self.dateFormatter.date(from: "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)
object.testData = (string as NSString).data(using: String.Encoding.utf8.rawValue)
}
}
if configuration == nil || configuration == "Config2" {
@@ -57,16 +57,16 @@ class BaseTestDataTestCase: BaseTestCase {
for idIndex in 1 ... 5 {
let object = transaction.create(Into<TestEntity2>(configuration))
object.testEntityID = NSNumber(integer: (configurationOrdinal * 200) + idIndex)
object.testEntityID = NSNumber(value: (configurationOrdinal * 200) + idIndex)
object.testNumber = idIndex
object.testDate = self.dateFormatter.dateFromString("2000-\(configurationOrdinal)-\(idIndex)T00:00:00Z")
object.testDate = self.dateFormatter.date(from: "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)
object.testData = (string as NSString).data(using: String.Encoding.utf8.rawValue)
}
}
}

42
CoreStoreTests/ErrorTests.swift
View File

@@ -36,22 +36,22 @@ final class ErrorTests: XCTestCase {
@objc
dynamic func test_ThatUnknownErrors_BridgeCorrectly() {
let error = CoreStoreError.Unknown
let error = CoreStoreError.unknown
XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.UnknownError.rawValue)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.unknownError.rawValue)
let userInfo: NSDictionary = [:]
let objcError = error.bridgeToObjectiveC
XCTAssertEqual(error, objcError.bridgeToSwift)
XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.UnknownError.rawValue)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.unknownError.rawValue)
XCTAssertEqual(objcError.userInfo, userInfo)
let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
XCTAssertEqual(error, objcError2.bridgeToSwift)
XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.UnknownError.rawValue)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.unknownError.rawValue)
XCTAssertEqual(objcError2.userInfo, userInfo)
}
@@ -60,9 +60,9 @@ final class ErrorTests: XCTestCase {
let dummyURL = URL(string: "file:///test1/test2.sqlite")!
let error = CoreStoreError.DifferentStorageExistsAtURL(existingPersistentStoreURL: dummyURL)
let error = CoreStoreError.differentStorageExistsAtURL(existingPersistentStoreURL: dummyURL)
XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.differentStorageExistsAtURL.rawValue)
let userInfo: NSDictionary = [
"existingPersistentStoreURL": dummyURL
@@ -70,13 +70,13 @@ final class ErrorTests: XCTestCase {
let objcError = error.bridgeToObjectiveC
XCTAssertEqual(error, objcError.bridgeToSwift)
XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.differentStorageExistsAtURL.rawValue)
XCTAssertEqual(objcError.userInfo, userInfo)
let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
XCTAssertEqual(error, objcError2.bridgeToSwift)
XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.DifferentPersistentStoreExistsAtURL.rawValue)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.differentStorageExistsAtURL.rawValue)
XCTAssertEqual(objcError2.userInfo, userInfo)
}
@@ -85,12 +85,12 @@ final class ErrorTests: XCTestCase {
let dummyURL = URL(string: "file:///test1/test2.sqlite")!
let model = NSManagedObjectModel.fromBundle(Bundle(forClass: self.dynamicType), modelName: "Model")
let model = NSManagedObjectModel.fromBundle(Bundle(for: self.dynamicType), modelName: "Model")
let version = "1.0.0"
let error = CoreStoreError.MappingModelNotFound(localStoreURL: dummyURL, targetModel: model, targetModelVersion: version)
let error = CoreStoreError.mappingModelNotFound(localStoreURL: dummyURL, targetModel: model, targetModelVersion: version)
XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.mappingModelNotFound.rawValue)
let userInfo: NSDictionary = [
"localStoreURL": dummyURL,
@@ -100,13 +100,13 @@ final class ErrorTests: XCTestCase {
let objcError = error.bridgeToObjectiveC
XCTAssertEqual(error, objcError.bridgeToSwift)
XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.mappingModelNotFound.rawValue)
XCTAssertEqual(objcError.userInfo, userInfo)
let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
XCTAssertEqual(error, objcError2.bridgeToSwift)
XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.MappingModelNotFound.rawValue)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.mappingModelNotFound.rawValue)
XCTAssertEqual(objcError2.userInfo, userInfo)
}
@@ -115,9 +115,9 @@ final class ErrorTests: XCTestCase {
let dummyURL = URL(string: "file:///test1/test2.sqlite")!
let error = CoreStoreError.ProgressiveMigrationRequired(localStoreURL: dummyURL)
let error = CoreStoreError.progressiveMigrationRequired(localStoreURL: dummyURL)
XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.progressiveMigrationRequired.rawValue)
let userInfo: NSDictionary = [
"localStoreURL": dummyURL
@@ -125,13 +125,13 @@ final class ErrorTests: XCTestCase {
let objcError = error.bridgeToObjectiveC
XCTAssertEqual(error, objcError.bridgeToSwift)
XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.progressiveMigrationRequired.rawValue)
XCTAssertEqual(objcError.userInfo, userInfo)
let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
XCTAssertEqual(error, objcError2.bridgeToSwift)
XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.ProgressiveMigrationRequired.rawValue)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.progressiveMigrationRequired.rawValue)
XCTAssertEqual(objcError2.userInfo, userInfo)
}
@@ -147,9 +147,9 @@ final class ErrorTests: XCTestCase {
"key3": Date()
]
)
let error = CoreStoreError.InternalError(NSError: internalError)
let error = CoreStoreError.internalError(NSError: internalError)
XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.InternalError.rawValue)
XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.internalError.rawValue)
let userInfo: NSDictionary = [
"NSError": internalError
@@ -157,13 +157,13 @@ final class ErrorTests: XCTestCase {
let objcError = error.bridgeToObjectiveC
XCTAssertEqual(error, objcError.bridgeToSwift)
XCTAssertEqual(objcError.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.InternalError.rawValue)
XCTAssertEqual(objcError.code, CoreStoreErrorCode.internalError.rawValue)
XCTAssertEqual(objcError.userInfo, userInfo)
let objcError2 = objcError.bridgeToSwift.bridgeToObjectiveC
XCTAssertEqual(error, objcError2.bridgeToSwift)
XCTAssertEqual(objcError2.domain, CoreStoreErrorDomain)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.InternalError.rawValue)
XCTAssertEqual(objcError2.code, CoreStoreErrorCode.internalError.rawValue)
XCTAssertEqual(objcError2.userInfo, userInfo)
}
}

536
CoreStoreTests/FetchTests.swift
View File

File diff suppressed because it is too large Load Diff

60
CoreStoreTests/FromTests.swift
View File

@@ -74,7 +74,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -89,8 +89,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config1")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity1>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -115,7 +115,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -130,7 +130,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config1")
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -145,8 +145,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config2")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity1>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -163,8 +163,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>()
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -181,8 +181,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config1")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -199,8 +199,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config2")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -225,7 +225,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -240,7 +240,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config1")
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -255,8 +255,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config2")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity1>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -273,7 +273,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity2>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -288,8 +288,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config1")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -306,8 +306,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config2")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -332,7 +332,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -347,7 +347,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config1")
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity1>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -362,8 +362,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity1>("Config2")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity1>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -380,7 +380,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>()
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity2>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)
@@ -395,8 +395,8 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config1")
let request = NSFetchRequest()
let storesFound = self.expectLogger([.LogWarning]) {
let request = NSFetchRequest<TestEntity2>()
let storesFound = self.expectLogger([.logWarning]) {
from.applyToFetchRequest(request, context: dataStack.mainContext)
}
@@ -413,7 +413,7 @@ final class FromTests: BaseTestCase {
let from = From<TestEntity2>("Config2")
let request = NSFetchRequest()
let request = NSFetchRequest<TestEntity2>()
let storesFound = from.applyToFetchRequest(request, context: dataStack.mainContext)
XCTAssertTrue(storesFound)
XCTAssertNotNil(request.entity)

4
CoreStoreTests/GroupByTests.swift
View File

@@ -68,8 +68,8 @@ final class GroupByTests: BaseTestCase {
let groupBy = GroupBy("testString")
let request = NSFetchRequest()
_ = From(TestEntity1).applyToFetchRequest(request, context: dataStack.mainContext)
let request = NSFetchRequest<TestEntity1>()
_ = From<TestEntity1>().applyToFetchRequest(request, context: dataStack.mainContext)
groupBy.applyToFetchRequest(request)
XCTAssertNotNil(request.propertiesToGroupBy)

434
CoreStoreTests/ImportTests.swift
View File

@@ -38,24 +38,24 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let object = try transaction.importObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!,
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!,
"skip_insert": ""
]
)
XCTAssertNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 0)
}
catch {
@@ -70,20 +70,20 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let _ = try transaction.importObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!,
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!,
"throw_on_insert": ""
]
)
@@ -92,9 +92,9 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestInsertError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
let object = transaction.fetchOne(From(TestEntity1))
let object = transaction.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertNil(object?.testEntityID)
XCTAssertNil(object?.testBoolean)
@@ -119,50 +119,50 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let object = try transaction.importObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!
]
)
XCTAssertNotNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
XCTAssertNil(object?.testEntityID)
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 1))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
XCTAssertEqual(object?.testNumber, NSNumber(value: 1))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "1"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:1")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!)
try transaction.importObject(
object!,
source: [
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 2),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 2),
"testDecimal": NSDecimalNumber(string: "2"),
"testString": "nil:TestEntity1:2",
"testData": ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")!
"testData": ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-02T00:00:00Z")!
]
)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
XCTAssertNil(object?.testEntityID)
XCTAssertEqual(object?.testBoolean, NSNumber(bool: false))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 2))
XCTAssertEqual(object?.testBoolean, NSNumber(value: false))
XCTAssertEqual(object?.testNumber, NSNumber(value: 2))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "2"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:2")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-02T00:00:00Z")!)
}
catch {
@@ -178,35 +178,35 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!,
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!,
"skip_insert": ""
],
[
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 2),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 2),
"testDecimal": NSDecimalNumber(string: "2"),
"testString": "nil:TestEntity1:2",
"testData": ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")!
"testData": ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-02T00:00:00Z")!
]
]
let objects = try transaction.importObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTAssertEqual(objects.count, 1)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
let object = objects[0]
let dictionary = sourceArray[1]
@@ -232,32 +232,32 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!,
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!,
"throw_on_insert": ""
],
[
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 2),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 2),
"testDecimal": NSDecimalNumber(string: "2"),
"testString": "nil:TestEntity1:2",
"testData": ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")!
"testData": ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-02T00:00:00Z")!
]
]
let _ = try transaction.importObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTFail()
@@ -265,9 +265,9 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestInsertError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
let object = transaction.fetchOne(From(TestEntity1))
let object = transaction.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertNil(object?.testEntityID)
XCTAssertNil(object?.testBoolean)
@@ -292,34 +292,34 @@ class ImportTests: BaseTestDataTestCase {
self.prepareStack { (stack) in
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 1),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 1),
"testDecimal": NSDecimalNumber(string: "1"),
"testString": "nil:TestEntity1:1",
"testData": ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!
"testData": ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!
],
[
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 2),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 2),
"testDecimal": NSDecimalNumber(string: "2"),
"testString": "nil:TestEntity1:2",
"testData": ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-02T00:00:00Z")!
"testData": ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-02T00:00:00Z")!
]
]
let objects = try transaction.importObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTAssertEqual(objects.count, sourceArray.count)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 2)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 2)
for i in 0 ..< sourceArray.count {
@@ -351,25 +351,25 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let object = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"skip_insert": ""
]
)
XCTAssertNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 5)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 5)
}
catch {
@@ -378,33 +378,33 @@ class ImportTests: BaseTestDataTestCase {
do {
let object = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 105),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 105),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"skip_update": ""
]
)
XCTAssertNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 5)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 5)
let existingObjects = transaction.fetchAll(From(TestEntity1), Where("testEntityID", isEqualTo: 105))
let existingObjects = transaction.fetchAll(From<TestEntity1>(), Where("testEntityID", isEqualTo: 105))
XCTAssertNotNil(existingObjects)
XCTAssertEqual(existingObjects?.count, 1)
let existingObject = existingObjects?[0]
XCTAssertEqual(existingObject?.testEntityID, NSNumber(integer: 105))
XCTAssertEqual(existingObject?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(existingObject?.testNumber, NSNumber(integer: 5))
XCTAssertEqual(existingObject?.testEntityID, NSNumber(value: 105))
XCTAssertEqual(existingObject?.testBoolean, NSNumber(value: true))
XCTAssertEqual(existingObject?.testNumber, NSNumber(value: 5))
XCTAssertEqual(existingObject?.testDecimal, NSDecimalNumber(string: "5"))
XCTAssertEqual(existingObject?.testString, "nil:TestEntity1:5")
XCTAssertEqual(existingObject?.testData, ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(existingObject?.testDate, self.dateFormatter.dateFromString("2000-01-05T00:00:00Z")!)
XCTAssertEqual(existingObject?.testData, ("nil:TestEntity1:5" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(existingObject?.testDate, self.dateFormatter.date(from: "2000-01-05T00:00:00Z")!)
}
catch {
@@ -421,23 +421,23 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let _ = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"throw_on_insert": ""
]
)
@@ -446,11 +446,11 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestInsertError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
let object = transaction.fetchOne(From(TestEntity1), Where("testEntityID", isEqualTo: 106))
let object = transaction.fetchOne(From<TestEntity1>(), Where("testEntityID", isEqualTo: 106))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 106))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 106))
XCTAssertNil(object?.testBoolean)
XCTAssertNil(object?.testNumber)
XCTAssertNil(object?.testDecimal)
@@ -466,19 +466,19 @@ class ImportTests: BaseTestDataTestCase {
}
do {
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let _ = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 105),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 105),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"throw_on_update": ""
]
)
@@ -487,21 +487,21 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestUpdateError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
let existingObjects = transaction.fetchAll(From(TestEntity1), Where("testEntityID", isEqualTo: 105))
let existingObjects = transaction.fetchAll(From<TestEntity1>(), Where("testEntityID", isEqualTo: 105))
XCTAssertNotNil(existingObjects)
XCTAssertEqual(existingObjects?.count, 1)
let existingObject = existingObjects?[0]
XCTAssertNotNil(existingObject)
XCTAssertEqual(existingObject?.testEntityID, NSNumber(integer: 105))
XCTAssertEqual(existingObject?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(existingObject?.testNumber, NSNumber(integer: 5))
XCTAssertEqual(existingObject?.testEntityID, NSNumber(value: 105))
XCTAssertEqual(existingObject?.testBoolean, NSNumber(value: true))
XCTAssertEqual(existingObject?.testNumber, NSNumber(value: 5))
XCTAssertEqual(existingObject?.testDecimal, NSDecimalNumber(string: "5"))
XCTAssertEqual(existingObject?.testString, "nil:TestEntity1:5")
XCTAssertEqual(existingObject?.testData, ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(existingObject?.testDate, self.dateFormatter.dateFromString("2000-01-05T00:00:00Z")!)
XCTAssertEqual(existingObject?.testData, ("nil:TestEntity1:5" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(existingObject?.testDate, self.dateFormatter.date(from: "2000-01-05T00:00:00Z")!)
}
catch {
@@ -521,32 +521,32 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let object = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!
]
)
XCTAssertNotNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 106))
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 6))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 106))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
XCTAssertEqual(object?.testNumber, NSNumber(value: 6))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "6"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:6")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!)
}
catch {
@@ -555,29 +555,29 @@ class ImportTests: BaseTestDataTestCase {
do {
let object = try transaction.importUniqueObject(
Into(TestEntity1),
Into<TestEntity1>(),
source: [
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 7),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 7),
"testDecimal": NSDecimalNumber(string: "7"),
"testString": "nil:TestEntity1:7",
"testData": ("nil:TestEntity1:7" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-07T00:00:00Z")!,
"testData": ("nil:TestEntity1:7" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-07T00:00:00Z")!,
]
)
XCTAssertNotNil(object)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 106))
XCTAssertEqual(object?.testBoolean, NSNumber(bool: false))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 7))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 106))
XCTAssertEqual(object?.testBoolean, NSNumber(value: false))
XCTAssertEqual(object?.testNumber, NSNumber(value: 7))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "7"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:7")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:7" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-07T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:7" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-07T00:00:00Z")!)
let existingObjects = transaction.fetchAll(From(TestEntity1), Where("testEntityID", isEqualTo: 106))
let existingObjects = transaction.fetchAll(From<TestEntity1>(), Where("testEntityID", isEqualTo: 106))
XCTAssertNotNil(existingObjects)
XCTAssertEqual(existingObjects?.count, 1)
@@ -600,37 +600,37 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"skip_insert": ""
],
[
"testEntityID": NSNumber(integer: 107),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 7),
"testEntityID": NSNumber(value: 107),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 7),
"testDecimal": NSDecimalNumber(string: "7"),
"testString": "nil:TestEntity1:7",
"testData": ("nil:TestEntity1:7" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-07T00:00:00Z")!
"testData": ("nil:TestEntity1:7" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-07T00:00:00Z")!
]
]
let objects = try transaction.importUniqueObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTAssertEqual(objects.count, 1)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
let object = objects[0]
let dictionary = sourceArray[1]
@@ -658,34 +658,34 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"throw_on_id": ""
],
[
"testEntityID": NSNumber(integer: 107),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 7),
"testEntityID": NSNumber(value: 107),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 7),
"testDecimal": NSDecimalNumber(string: "7"),
"testString": "nil:TestEntity1:7",
"testData": ("nil:TestEntity1:7" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-07T00:00:00Z")!
"testData": ("nil:TestEntity1:7" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-07T00:00:00Z")!
]
]
let _ = try transaction.importUniqueObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTFail()
@@ -693,10 +693,10 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestIDError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 5)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 5)
XCTAssertNil(transaction.fetchOne(From(TestEntity1), Where("testEntityID", isEqualTo: 106)))
XCTAssertNil(transaction.fetchOne(From(TestEntity1), Where("testEntityID", isEqualTo: 107)))
XCTAssertNil(transaction.fetchOne(From<TestEntity1>(), Where("testEntityID", isEqualTo: 106)))
XCTAssertNil(transaction.fetchOne(From<TestEntity1>(), Where("testEntityID", isEqualTo: 107)))
}
catch {
@@ -705,34 +705,34 @@ class ImportTests: BaseTestDataTestCase {
self.checkExpectationsImmediately()
transaction.context.reset()
}
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"throw_on_insert": ""
],
[
"testEntityID": NSNumber(integer: 107),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 7),
"testEntityID": NSNumber(value: 107),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 7),
"testDecimal": NSDecimalNumber(string: "7"),
"testString": "nil:TestEntity1:7",
"testData": ("nil:TestEntity1:7" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-07T00:00:00Z")!
"testData": ("nil:TestEntity1:7" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-07T00:00:00Z")!
]
]
let _ = try transaction.importUniqueObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTFail()
@@ -741,9 +741,9 @@ class ImportTests: BaseTestDataTestCase {
errorExpectation.fulfill()
let object = transaction.fetchOne(From(TestEntity1), Where("testEntityID", isEqualTo: 106))
let object = transaction.fetchOne(From<TestEntity1>(), Where("testEntityID", isEqualTo: 106))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 106))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 106))
XCTAssertNil(object?.testBoolean)
XCTAssertNil(object?.testNumber)
XCTAssertNil(object?.testDecimal)
@@ -758,25 +758,25 @@ class ImportTests: BaseTestDataTestCase {
self.checkExpectationsImmediately()
transaction.context.reset()
}
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
let errorExpectation = self.expectationWithDescription("error")
let errorExpectation = self.expectation(withDescription: "error")
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testEntityID": NSNumber(integer: 105),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 105),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!,
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!,
"throw_on_update": ""
]
]
let _ = try transaction.importUniqueObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTFail()
@@ -784,19 +784,19 @@ class ImportTests: BaseTestDataTestCase {
catch _ as TestUpdateError {
errorExpectation.fulfill()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 5)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 5)
let object = transaction.fetchOne(From(TestEntity1), Where("testEntityID", isEqualTo: 105))
let object = transaction.fetchOne(From<TestEntity1>(), Where("testEntityID", isEqualTo: 105))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 105))
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 5))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 105))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
XCTAssertEqual(object?.testNumber, NSNumber(value: 5))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "5"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:5")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-05T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:5" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-05T00:00:00Z")!)
let existingObjects = transaction.fetchAll(From(TestEntity1), Where("testEntityID", isEqualTo: 105))
let existingObjects = transaction.fetchAll(From<TestEntity1>(), Where("testEntityID", isEqualTo: 105))
XCTAssertNotNil(existingObjects)
XCTAssertEqual(existingObjects?.count, 1)
@@ -820,36 +820,36 @@ class ImportTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
stack.beginSynchronous { (transaction) in
_ = stack.beginSynchronous { (transaction) in
do {
let sourceArray: [TestEntity1.ImportSource] = [
[
"testEntityID": NSNumber(integer: 105),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 15),
"testEntityID": NSNumber(value: 105),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 15),
"testDecimal": NSDecimalNumber(string: "15"),
"testString": "nil:TestEntity1:15",
"testData": ("nil:TestEntity1:15" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-15T00:00:00Z")!
"testData": ("nil:TestEntity1:15" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-15T00:00:00Z")!
],
[
"testEntityID": NSNumber(integer: 106),
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 6),
"testEntityID": NSNumber(value: 106),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 6),
"testDecimal": NSDecimalNumber(string: "6"),
"testString": "nil:TestEntity1:6",
"testData": ("nil:TestEntity1:6" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-06T00:00:00Z")!
"testData": ("nil:TestEntity1:6" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-06T00:00:00Z")!
]
]
let objects = try transaction.importUniqueObjects(
Into(TestEntity1),
Into<TestEntity1>(),
sourceArray: sourceArray
)
XCTAssertEqual(objects.count, sourceArray.count)
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 6)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 6)
for i in 0 ..< sourceArray.count {
let object = objects[i]
@@ -863,7 +863,7 @@ class ImportTests: BaseTestDataTestCase {
XCTAssertEqual(object.testData, dictionary["testData"] as? NSData)
XCTAssertEqual(object.testDate, dictionary["testDate"] as? NSDate)
}
let existingObjects = transaction.fetchAll(From(TestEntity1), Where("testEntityID", isEqualTo: 105))
let existingObjects = transaction.fetchAll(From<TestEntity1>(), Where("testEntityID", isEqualTo: 105))
XCTAssertNotNil(existingObjects)
XCTAssertEqual(existingObjects?.count, 1)

8
CoreStoreTests/IntoTests.swift
View File

@@ -58,7 +58,7 @@ final class IntoTests: XCTestCase {
}
do {
let into = Into(TestEntity1)
let into = Into<TestEntity1>()
XCTAssert(into.entityClass === TestEntity1.self)
XCTAssertNil(into.configuration)
XCTAssertTrue(into.inferStoreIfPossible)
@@ -108,14 +108,14 @@ final class IntoTests: XCTestCase {
do {
let into = Into<TestEntity1>()
XCTAssertEqual(into, Into(TestEntity1))
XCTAssertEqual(into, Into<TestEntity1>())
XCTAssertEqual(into, Into(TestEntity1.self as AnyClass))
XCTAssertFalse(into == Into<TestEntity2>())
XCTAssertNotEqual(into, Into<TestEntity1>("Config1"))
}
do {
let into = Into(TestEntity1)
let into = Into<TestEntity1>()
XCTAssertEqual(into, Into<TestEntity1>())
XCTAssertEqual(into, Into(TestEntity1.self as AnyClass))
XCTAssertFalse(into == Into<TestEntity2>())
@@ -125,7 +125,7 @@ final class IntoTests: XCTestCase {
let into = Into(TestEntity1.self as AnyClass)
XCTAssert(into == Into<TestEntity1>())
XCTAssertEqual(into, Into(TestEntity1))
XCTAssertEqual(into, Into(TestEntity1.self))
XCTAssertFalse(into == Into<TestEntity2>())
XCTAssertFalse(into == Into<TestEntity1>("Config1"))
}

200
CoreStoreTests/ListObserverTests.swift
View File

@@ -42,9 +42,9 @@ class ListObserverTests: BaseTestDataTestCase {
let observer = TestListObserver()
let monitor = stack.monitorSectionedList(
From(TestEntity1),
From<TestEntity1>(),
SectionBy("testBoolean"),
OrderBy(.Ascending("testBoolean"), .Ascending("testEntityID"))
OrderBy(.ascending("testBoolean"), .ascending("testEntityID"))
)
monitor.addObserver(observer)
@@ -54,13 +54,13 @@ class ListObserverTests: BaseTestDataTestCase {
var events = 0
let willChangeExpectation = self.expectationForNotification(
"listMonitorWillChange:",
let willChangeExpectation = self.expectation(
forNotification: "listMonitorWillChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -68,14 +68,14 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 0
}
)
let didInsertSectionExpectation = self.expectationForNotification(
"listMonitor:didInsertSection:toSectionIndex:",
let didInsertSectionExpectation = self.expectation(
forNotification: "listMonitor:didInsertSection:toSectionIndex:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 1)
XCTAssertEqual(
(note.userInfo ?? [:]),
((note as NSNotification).userInfo ?? [:]),
[
"sectionInfo": monitor.sectionInfoAtIndex(0),
"sectionIndex": 0
@@ -88,14 +88,14 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 1
}
)
let didInsertObjectExpectation = self.expectationForNotification(
"listMonitor:didInsertObject:toIndexPath:",
let didInsertObjectExpectation = self.expectation(
forNotification: "listMonitor:didInsertObject:toIndexPath:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 2)
let userInfo = note.userInfo
let userInfo = (note as NSNotification).userInfo
XCTAssertNotNil(userInfo)
XCTAssertEqual(
Set(((userInfo as? [String: AnyObject]) ?? [:]).keys),
@@ -107,12 +107,12 @@ class ListObserverTests: BaseTestDataTestCase {
XCTAssertEqual(indexPath?.row, 0)
let object = userInfo?["object"] as? TestEntity1
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 1))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
XCTAssertEqual(object?.testNumber, NSNumber(value: 1))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "1"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:1")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!)
defer {
events += 1
@@ -120,12 +120,12 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 2
}
)
let didChangeExpectation = self.expectationForNotification(
"listMonitorDidChange:",
let didChangeExpectation = self.expectation(
forNotification: "listMonitorDidChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -133,26 +133,26 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 3
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testBoolean = NSNumber(bool: true)
object.testNumber = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testBoolean = NSNumber(value: true)
object.testNumber = NSNumber(value: 1)
object.testDecimal = NSDecimalNumber(string: "1")
object.testString = "nil:TestEntity1:1"
object.testData = ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!
object.testDate = self.dateFormatter.dateFromString("2000-01-01T00:00:00Z")!
object.testData = ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue)!
object.testDate = self.dateFormatter.date(from: "2000-01-01T00:00:00Z")!
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -170,9 +170,9 @@ class ListObserverTests: BaseTestDataTestCase {
let observer = TestListObserver()
let monitor = stack.monitorSectionedList(
From(TestEntity1),
From<TestEntity1>(),
SectionBy("testBoolean"),
OrderBy(.Ascending("testBoolean"), .Ascending("testEntityID"))
OrderBy(.ascending("testBoolean"), .ascending("testEntityID"))
)
monitor.addObserver(observer)
@@ -185,13 +185,13 @@ class ListObserverTests: BaseTestDataTestCase {
var events = 0
let willChangeExpectation = self.expectationForNotification(
"listMonitorWillChange:",
let willChangeExpectation = self.expectation(
forNotification: "listMonitorWillChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -201,14 +201,14 @@ class ListObserverTests: BaseTestDataTestCase {
)
for _ in 1 ... 2 {
let didUpdateObjectExpectation = self.expectationForNotification(
"listMonitor:didUpdateObject:atIndexPath:",
let didUpdateObjectExpectation = self.expectation(
forNotification: "listMonitor:didUpdateObject:atIndexPath:",
object: observer,
handler: { (note) -> Bool in
XCTAssert(events == 1 || events == 2)
let userInfo = note.userInfo
let userInfo = (note as NSNotification).userInfo
XCTAssertNotNil(userInfo)
XCTAssertEqual(
Set(((userInfo as? [String: AnyObject]) ?? [:]).keys),
@@ -220,27 +220,27 @@ class ListObserverTests: BaseTestDataTestCase {
switch object?.testEntityID {
case NSNumber(integer: 101)?:
case NSNumber(value: 101)?:
XCTAssertEqual(indexPath?.section, 1)
XCTAssertEqual(indexPath?.row, 0)
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 11))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
XCTAssertEqual(object?.testNumber, NSNumber(value: 11))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "11"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:11")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:11" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-11T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:11" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-11T00:00:00Z")!)
case NSNumber(integer: 102)?:
case NSNumber(value: 102)?:
XCTAssertEqual(indexPath?.section, 0)
XCTAssertEqual(indexPath?.row, 0)
XCTAssertEqual(object?.testBoolean, NSNumber(bool: false))
XCTAssertEqual(object?.testNumber, NSNumber(integer: 22))
XCTAssertEqual(object?.testBoolean, NSNumber(value: false))
XCTAssertEqual(object?.testNumber, NSNumber(value: 22))
XCTAssertEqual(object?.testDecimal, NSDecimalNumber(string: "22"))
XCTAssertEqual(object?.testString, "nil:TestEntity1:22")
XCTAssertEqual(object?.testData, ("nil:TestEntity1:22" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.dateFromString("2000-01-22T00:00:00Z")!)
XCTAssertEqual(object?.testData, ("nil:TestEntity1:22" as NSString).data(using: String.Encoding.utf8.rawValue)!)
XCTAssertEqual(object?.testDate, self.dateFormatter.date(from: "2000-01-22T00:00:00Z")!)
default:
XCTFail()
@@ -253,13 +253,13 @@ class ListObserverTests: BaseTestDataTestCase {
}
)
}
let didChangeExpectation = self.expectationForNotification(
"listMonitorDidChange:",
let didChangeExpectation = self.expectation(
forNotification: "listMonitorDidChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 3)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -267,32 +267,32 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 3
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
if let object = transaction.fetchOne(
From(TestEntity1),
From<TestEntity1>(),
Where("testEntityID", isEqualTo: 101)) {
object.testNumber = NSNumber(integer: 11)
object.testNumber = NSNumber(value: 11)
object.testDecimal = NSDecimalNumber(string: "11")
object.testString = "nil:TestEntity1:11"
object.testData = ("nil:TestEntity1:11" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!
object.testDate = self.dateFormatter.dateFromString("2000-01-11T00:00:00Z")!
object.testData = ("nil:TestEntity1:11" as NSString).data(using: String.Encoding.utf8.rawValue)!
object.testDate = self.dateFormatter.date(from: "2000-01-11T00:00:00Z")!
}
else {
XCTFail()
}
if let object = transaction.fetchOne(
From(TestEntity1),
From<TestEntity1>(),
Where("testEntityID", isEqualTo: 102)) {
object.testNumber = NSNumber(integer: 22)
object.testNumber = NSNumber(value: 22)
object.testDecimal = NSDecimalNumber(string: "22")
object.testString = "nil:TestEntity1:22"
object.testData = ("nil:TestEntity1:22" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!
object.testDate = self.dateFormatter.dateFromString("2000-01-22T00:00:00Z")!
object.testData = ("nil:TestEntity1:22" as NSString).data(using: String.Encoding.utf8.rawValue)!
object.testDate = self.dateFormatter.date(from: "2000-01-22T00:00:00Z")!
}
else {
@@ -302,11 +302,11 @@ class ListObserverTests: BaseTestDataTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -324,21 +324,21 @@ class ListObserverTests: BaseTestDataTestCase {
let observer = TestListObserver()
let monitor = stack.monitorSectionedList(
From(TestEntity1),
From<TestEntity1>(),
SectionBy("testBoolean"),
OrderBy(.Ascending("testBoolean"), .Ascending("testEntityID"))
OrderBy(.ascending("testBoolean"), .ascending("testEntityID"))
)
monitor.addObserver(observer)
var events = 0
let willChangeExpectation = self.expectationForNotification(
"listMonitorWillChange:",
let willChangeExpectation = self.expectation(
forNotification: "listMonitorWillChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -346,14 +346,14 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 0
}
)
let didMoveObjectExpectation = self.expectationForNotification(
"listMonitor:didMoveObject:fromIndexPath:toIndexPath:",
let didMoveObjectExpectation = self.expectation(
forNotification: "listMonitor:didMoveObject:fromIndexPath:toIndexPath:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 1)
let userInfo = note.userInfo
let userInfo = (note as NSNotification).userInfo
XCTAssertNotNil(userInfo)
XCTAssertEqual(
Set(((userInfo as? [String: AnyObject]) ?? [:]).keys),
@@ -369,8 +369,8 @@ class ListObserverTests: BaseTestDataTestCase {
XCTAssertEqual(toIndexPath?.row, 1)
let object = userInfo?["object"] as? TestEntity1
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 102))
XCTAssertEqual(object?.testBoolean, NSNumber(bool: true))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 102))
XCTAssertEqual(object?.testBoolean, NSNumber(value: true))
defer {
@@ -379,13 +379,13 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 1
}
)
let didChangeExpectation = self.expectationForNotification(
"listMonitorDidChange:",
let didChangeExpectation = self.expectation(
forNotification: "listMonitorDidChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 2)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -393,14 +393,14 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 2
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
if let object = transaction.fetchOne(
From(TestEntity1),
From<TestEntity1>(),
Where("testEntityID", isEqualTo: 102)) {
object.testBoolean = NSNumber(bool: true)
object.testBoolean = NSNumber(value: true)
}
else {
@@ -410,11 +410,11 @@ class ListObserverTests: BaseTestDataTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -432,21 +432,21 @@ class ListObserverTests: BaseTestDataTestCase {
let observer = TestListObserver()
let monitor = stack.monitorSectionedList(
From(TestEntity1),
From<TestEntity1>(),
SectionBy("testBoolean"),
OrderBy(.Ascending("testBoolean"), .Ascending("testEntityID"))
OrderBy(.ascending("testBoolean"), .ascending("testEntityID"))
)
monitor.addObserver(observer)
var events = 0
let willChangeExpectation = self.expectationForNotification(
"listMonitorWillChange:",
let willChangeExpectation = self.expectation(
forNotification: "listMonitorWillChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -456,14 +456,14 @@ class ListObserverTests: BaseTestDataTestCase {
)
for _ in 1 ... 2 {
let didUpdateObjectExpectation = self.expectationForNotification(
"listMonitor:didDeleteObject:fromIndexPath:",
let didUpdateObjectExpectation = self.expectation(
forNotification: "listMonitor:didDeleteObject:fromIndexPath:",
object: observer,
handler: { (note) -> Bool in
XCTAssert(events == 1 || events == 2)
let userInfo = note.userInfo
let userInfo = (note as NSNotification).userInfo
XCTAssertNotNil(userInfo)
XCTAssertEqual(
Set(((userInfo as? [String: AnyObject]) ?? [:]).keys),
@@ -476,7 +476,7 @@ class ListObserverTests: BaseTestDataTestCase {
XCTAssert(indexPath?.row == 0 || indexPath?.row == 1)
let object = userInfo?["object"] as? TestEntity1
XCTAssertEqual(object?.deleted, true)
XCTAssertEqual(object?.isDeleted, true)
defer {
@@ -486,14 +486,14 @@ class ListObserverTests: BaseTestDataTestCase {
}
)
}
let didDeleteSectionExpectation = self.expectationForNotification(
"listMonitor:didDeleteSection:fromSectionIndex:",
let didDeleteSectionExpectation = self.expectation(
forNotification: "listMonitor:didDeleteSection:fromSectionIndex:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 3)
let userInfo = note.userInfo
let userInfo = (note as NSNotification).userInfo
XCTAssertNotNil(userInfo)
XCTAssertEqual(
Set(((userInfo as? [String: AnyObject]) ?? [:]).keys),
@@ -505,7 +505,7 @@ class ListObserverTests: BaseTestDataTestCase {
XCTAssertEqual(sectionInfo?.name, "0")
let sectionIndex = userInfo?["sectionIndex"]
XCTAssertEqual(sectionIndex as? NSNumber, NSNumber(integer: 0))
XCTAssertEqual(sectionIndex as? NSNumber, NSNumber(value: 0))
defer {
@@ -514,13 +514,13 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 3
}
)
let didChangeExpectation = self.expectationForNotification(
"listMonitorDidChange:",
let didChangeExpectation = self.expectation(
forNotification: "listMonitorDidChange:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 4)
XCTAssertEqual((note.userInfo ?? [:]), NSDictionary())
XCTAssertEqual(((note as NSNotification).userInfo ?? [:]), NSDictionary())
defer {
events += 1
@@ -528,22 +528,22 @@ class ListObserverTests: BaseTestDataTestCase {
return events == 4
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
transaction.deleteAll(
From(TestEntity1),
From<TestEntity1>(),
Where("testBoolean", isEqualTo: false)
)
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -656,8 +656,8 @@ class TestListObserver: ListSectionObserver {
func listMonitor(_ monitor: ListMonitor<TestEntity1>, didInsertSection sectionInfo: NSFetchedResultsSectionInfo, toSectionIndex sectionIndex: Int) {
NotificationCenter.defaultCenter().postNotificationName(
"listMonitor:didInsertSection:toSectionIndex:",
NotificationCenter.default.post(
name: Notification.Name(rawValue: "listMonitor:didInsertSection:toSectionIndex:"),
object: self,
userInfo: [
"sectionInfo": sectionInfo,
@@ -668,8 +668,8 @@ class TestListObserver: ListSectionObserver {
func listMonitor(_ monitor: ListMonitor<TestEntity1>, didDeleteSection sectionInfo: NSFetchedResultsSectionInfo, fromSectionIndex sectionIndex: Int) {
NotificationCenter.defaultCenter().postNotificationName(
"listMonitor:didDeleteSection:fromSectionIndex:",
NotificationCenter.default.post(
name: Notification.Name(rawValue: "listMonitor:didDeleteSection:fromSectionIndex:"),
object: self,
userInfo: [
"sectionInfo": sectionInfo,

42
CoreStoreTests/ObjectObserverTests.swift
View File

@@ -43,7 +43,7 @@ class ObjectObserverTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
guard let object = stack.fetchOne(
From(TestEntity1),
From<TestEntity1>(),
Where("testEntityID", isEqualTo: 101)) else {
XCTFail()
@@ -58,14 +58,14 @@ class ObjectObserverTests: BaseTestDataTestCase {
var events = 0
let willUpdateExpectation = self.expectationForNotification(
"objectMonitor:willUpdateObject:",
let willUpdateExpectation = self.expectation(
forNotification: "objectMonitor:willUpdateObject:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual(
(note.userInfo ?? [:]),
((note as NSNotification).userInfo ?? [:]),
["object": object] as NSDictionary
)
defer {
@@ -75,14 +75,14 @@ class ObjectObserverTests: BaseTestDataTestCase {
return events == 0
}
)
let didUpdateExpectation = self.expectationForNotification(
"objectMonitor:didUpdateObject:changedPersistentKeys:",
let didUpdateExpectation = self.expectation(
forNotification: "objectMonitor:didUpdateObject:changedPersistentKeys:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 1)
XCTAssertEqual(
(note.userInfo ?? [:]),
((note as NSNotification).userInfo ?? [:]),
[
"object": object,
"changedPersistentKeys": Set(
@@ -94,7 +94,7 @@ class ObjectObserverTests: BaseTestDataTestCase {
] as NSDictionary
)
let object = note.userInfo?["object"] as? TestEntity1
XCTAssertEqual(object?.testNumber, NSNumber(integer: 10))
XCTAssertEqual(object?.testNumber, NSNumber(value: 10))
XCTAssertEqual(object?.testString, "nil:TestEntity1:10")
defer {
@@ -104,7 +104,7 @@ class ObjectObserverTests: BaseTestDataTestCase {
return events == 1
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
guard let object = transaction.edit(object) else {
@@ -112,18 +112,18 @@ class ObjectObserverTests: BaseTestDataTestCase {
XCTFail()
return
}
object.testNumber = NSNumber(integer: 10)
object.testNumber = NSNumber(value: 10)
object.testString = "nil:TestEntity1:10"
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -140,7 +140,7 @@ class ObjectObserverTests: BaseTestDataTestCase {
self.prepareTestDataForStack(stack)
guard let object = stack.fetchOne(
From(TestEntity1),
From<TestEntity1>(),
Where("testEntityID", isEqualTo: 101)) else {
XCTFail()
@@ -155,14 +155,14 @@ class ObjectObserverTests: BaseTestDataTestCase {
var events = 0
let didDeleteExpectation = self.expectationForNotification(
"objectMonitor:didDeleteObject:",
let didDeleteExpectation = self.expectation(
forNotification: "objectMonitor:didDeleteObject:",
object: observer,
handler: { (note) -> Bool in
XCTAssertEqual(events, 0)
XCTAssertEqual(
(note.userInfo ?? [:]),
((note as NSNotification).userInfo ?? [:]),
["object": object] as NSDictionary
)
defer {
@@ -172,7 +172,7 @@ class ObjectObserverTests: BaseTestDataTestCase {
return events == 0
}
)
let saveExpectation = self.expectationWithDescription("save")
let saveExpectation = self.expectation(withDescription: "save")
stack.beginAsynchronous { (transaction) in
guard let object = transaction.edit(object) else {
@@ -186,12 +186,12 @@ class ObjectObserverTests: BaseTestDataTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertTrue(monitor.isObjectDeleted)
saveExpectation.fulfill()
case .Failure:
case .failure:
XCTFail()
}
}
@@ -221,8 +221,8 @@ class TestObjectObserver: ObjectObserver {
func objectMonitor(_ monitor: ObjectMonitor<TestEntity1>, didUpdateObject object: TestEntity1, changedPersistentKeys: Set<KeyPath>) {
NotificationCenter.defaultCenter().postNotificationName(
"objectMonitor:didUpdateObject:changedPersistentKeys:",
NotificationCenter.default.post(
name: NSNotification.Name(rawValue: "objectMonitor:didUpdateObject:changedPersistentKeys:"),
object: self,
userInfo: [
"object": object,

60
CoreStoreTests/OrderByTests.swift
View File

@@ -39,7 +39,7 @@ final class OrderByTests: XCTestCase {
do {
let orderBy = OrderBy()
XCTAssertEqual(orderBy, OrderBy([] as [NSSortDescriptor]))
XCTAssertEqual(orderBy, OrderBy([SortDescriptor]()))
XCTAssertNotEqual(orderBy, OrderBy(SortDescriptor(key: "key", ascending: false)))
XCTAssertTrue(orderBy.sortDescriptors.isEmpty)
}
@@ -48,9 +48,9 @@ final class OrderByTests: XCTestCase {
let sortDescriptor = SortDescriptor(key: "key1", ascending: true)
let orderBy = OrderBy(sortDescriptor)
XCTAssertEqual(orderBy, OrderBy(sortDescriptor))
XCTAssertEqual(orderBy, OrderBy(.Ascending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.Descending("key1")))
XCTAssertEqual(orderBy, OrderBy(.ascending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.descending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(SortDescriptor(key: "key1", ascending: false)))
XCTAssertEqual(orderBy, OrderBy([sortDescriptor]))
XCTAssertEqual(orderBy.sortDescriptors, [sortDescriptor])
@@ -63,7 +63,7 @@ final class OrderByTests: XCTestCase {
]
let orderBy = OrderBy(sortDescriptors)
XCTAssertEqual(orderBy, OrderBy(sortDescriptors))
XCTAssertEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key2")))
XCTAssertEqual(orderBy, OrderBy(.ascending("key1"), .descending("key2")))
XCTAssertNotEqual(
orderBy,
OrderBy(
@@ -73,30 +73,30 @@ final class OrderByTests: XCTestCase {
]
)
)
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key3")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .descending("key3")))
XCTAssertEqual(orderBy.sortDescriptors, sortDescriptors)
}
do {
let orderBy = OrderBy(.Ascending("key1"))
let orderBy = OrderBy(.ascending("key1"))
let sortDescriptor = SortDescriptor(key: "key1", ascending: true)
XCTAssertEqual(orderBy, OrderBy(sortDescriptor))
XCTAssertEqual(orderBy, OrderBy(.Ascending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.Descending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key2")))
XCTAssertEqual(orderBy, OrderBy(.ascending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.descending("key1")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key2")))
XCTAssertEqual(orderBy, OrderBy([sortDescriptor]))
XCTAssertEqual(orderBy.sortDescriptors, [sortDescriptor])
}
do {
let orderBy = OrderBy(.Ascending("key1"), .Descending("key2"))
let orderBy = OrderBy(.ascending("key1"), .descending("key2"))
let sortDescriptors = [
SortDescriptor(key: "key1", ascending: true),
SortDescriptor(key: "key2", ascending: false)
]
XCTAssertEqual(orderBy, OrderBy(sortDescriptors))
XCTAssertEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key2")))
XCTAssertEqual(orderBy, OrderBy(.ascending("key1"), .descending("key2")))
XCTAssertNotEqual(
orderBy,
OrderBy(
@@ -106,20 +106,20 @@ final class OrderByTests: XCTestCase {
]
)
)
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key3")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .descending("key3")))
XCTAssertEqual(orderBy.sortDescriptors, sortDescriptors)
}
do {
let sortKeys: [SortKey] = [.Ascending("key1"), .Descending("key2")]
let sortKeys: [SortKey] = [.ascending("key1"), .descending("key2")]
let orderBy = OrderBy(sortKeys)
let sortDescriptors = [
SortDescriptor(key: "key1", ascending: true),
SortDescriptor(key: "key2", ascending: false)
]
XCTAssertEqual(orderBy, OrderBy(sortDescriptors))
XCTAssertEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key2")))
XCTAssertEqual(orderBy, OrderBy(.ascending("key1"), .descending("key2")))
XCTAssertNotEqual(
orderBy,
OrderBy(
@@ -129,8 +129,8 @@ final class OrderByTests: XCTestCase {
]
)
)
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.Ascending("key1"), .Descending("key3")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .ascending("key2")))
XCTAssertNotEqual(orderBy, OrderBy(.ascending("key1"), .descending("key3")))
XCTAssertEqual(orderBy.sortDescriptors, sortDescriptors)
}
}
@@ -138,15 +138,15 @@ final class OrderByTests: XCTestCase {
@objc
dynamic func test_ThatOrderByClauseOperations_ComputeCorrectly() {
let orderBy1 = OrderBy(.Ascending("key1"))
let orderBy2 = OrderBy(.Descending("key2"))
let orderBy3 = OrderBy(.Ascending("key3"))
let orderBy1 = OrderBy(.ascending("key1"))
let orderBy2 = OrderBy(.descending("key2"))
let orderBy3 = OrderBy(.ascending("key3"))
do {
let plusOrderBy = orderBy1 + orderBy2 + orderBy3
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1"), .Descending("key2"), .Ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1")) + OrderBy(.Descending("key2"), .Ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1"), .descending("key2"), .ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1")) + OrderBy(.descending("key2"), .ascending("key3")))
XCTAssertNotEqual(plusOrderBy, orderBy1 + orderBy3 + orderBy2)
XCTAssertNotEqual(plusOrderBy, orderBy2 + orderBy1 + orderBy3)
XCTAssertNotEqual(plusOrderBy, orderBy2 + orderBy3 + orderBy1)
@@ -158,14 +158,14 @@ final class OrderByTests: XCTestCase {
var plusOrderBy = orderBy1
plusOrderBy += orderBy2
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1"), .Descending("key2")))
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1")) + OrderBy(.Descending("key2")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1"), .descending("key2")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1")) + OrderBy(.descending("key2")))
XCTAssertNotEqual(plusOrderBy, orderBy2 + orderBy1)
XCTAssertEqual(plusOrderBy.sortDescriptors, orderBy1.sortDescriptors + orderBy2.sortDescriptors)
plusOrderBy += orderBy3
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1"), .Descending("key2"), .Ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.Ascending("key1"), .Descending("key2")) + OrderBy(.Ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1"), .descending("key2"), .ascending("key3")))
XCTAssertEqual(plusOrderBy, OrderBy(.ascending("key1"), .descending("key2")) + OrderBy(.ascending("key3")))
XCTAssertNotEqual(plusOrderBy, orderBy1 + orderBy3 + orderBy2)
XCTAssertNotEqual(plusOrderBy, orderBy2 + orderBy1 + orderBy3)
XCTAssertNotEqual(plusOrderBy, orderBy2 + orderBy3 + orderBy1)
@@ -178,8 +178,8 @@ final class OrderByTests: XCTestCase {
@objc
dynamic func test_ThatOrderByClauses_ApplyToFetchRequestsCorrectly() {
let orderBy = OrderBy(.Ascending("key"))
let request = NSFetchRequest()
let orderBy = OrderBy(.ascending("key"))
let request = NSFetchRequest<NSFetchRequestResult>()
orderBy.applyToFetchRequest(request)
XCTAssertNotNil(request.sortDescriptors)
XCTAssertEqual(request.sortDescriptors ?? [], orderBy.sortDescriptors)

230
CoreStoreTests/QueryTests.swift
View File

@@ -173,7 +173,7 @@ class QueryTests: BaseTestDataTestCase {
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, ("nil:TestEntity1:1" as NSString).dataUsingEncoding(NSUTF8StringEncoding))
XCTAssertEqual(value, ("nil:TestEntity1:1" as NSString).data(using: String.Encoding.utf8.rawValue))
}
do {
@@ -183,7 +183,7 @@ class QueryTests: BaseTestDataTestCase {
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-01T00:00:00Z"))
XCTAssertEqual(value, self.dateFormatter.date(from: "2000-01-01T00:00:00Z"))
}
do {
@@ -208,13 +208,13 @@ class QueryTests: BaseTestDataTestCase {
let from = From<TestEntity1>(configurations)
let queryClauses: [QueryClause] = [
Where("%K > %@", "testNumber", 1),
OrderBy(.Ascending("testEntityID"))
OrderBy(.ascending("testEntityID"))
]
do {
let value = stack.queryValue(
from,
Select<Bool>(.Average("testBoolean")),
Select<Bool>(.average("testBoolean")),
queryClauses
)
XCTAssertNotNil(value)
@@ -224,7 +224,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.Average("testNumber")),
Select<Int8>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -234,7 +234,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.Average("testNumber")),
Select<Int16>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -244,7 +244,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.Average("testNumber")),
Select<Int32>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -254,7 +254,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.Average("testNumber")),
Select<Int64>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -264,7 +264,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.Average("testNumber")),
Select<Int>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -274,7 +274,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.Average("testNumber")),
Select<Double>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -284,7 +284,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.Average("testNumber")),
Select<Float>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -294,7 +294,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.Average("testNumber")),
Select<NSNumber>(.average("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -304,7 +304,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.Average("testDecimal")),
Select<NSDecimalNumber>(.average("testDecimal")),
queryClauses
)
XCTAssertNotNil(value)
@@ -314,7 +314,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.Average("testString")),
Select<String>(.average("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -323,7 +323,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.Average("testString")),
Select<NSString>(.average("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -332,7 +332,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.Average("testData")),
Select<NSData>(.average("testData")),
queryClauses
)
XCTAssertNil(value)
@@ -341,7 +341,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDate>(.Average("testDate")),
Select<NSDate>(.average("testDate")),
queryClauses
)
XCTAssertNil(value)
@@ -374,7 +374,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Bool>(.Count("testBoolean")),
Select<Bool>(.count("testBoolean")),
queryClauses
)
XCTAssertNotNil(value)
@@ -384,7 +384,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.Count("testNumber")),
Select<Int8>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -394,7 +394,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.Count("testNumber")),
Select<Int16>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -404,7 +404,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.Count("testNumber")),
Select<Int32>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -414,7 +414,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.Count("testNumber")),
Select<Int64>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -424,7 +424,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.Count("testNumber")),
Select<Int>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -434,7 +434,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.Count("testNumber")),
Select<Double>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -444,7 +444,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.Count("testNumber")),
Select<Float>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -454,7 +454,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.Count("testNumber")),
Select<NSNumber>(.count("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -464,7 +464,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.Count("testDecimal")),
Select<NSDecimalNumber>(.count("testDecimal")),
queryClauses
)
XCTAssertNil(value)
@@ -473,7 +473,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.Count("testString")),
Select<String>(.count("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -482,7 +482,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.Count("testString")),
Select<NSString>(.count("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -491,7 +491,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.Count("testData")),
Select<NSData>(.count("testData")),
queryClauses
)
XCTAssertNil(value)
@@ -500,7 +500,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDate>(.Count("testDate")),
Select<NSDate>(.count("testDate")),
queryClauses
)
XCTAssertNil(value)
@@ -509,7 +509,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSManagedObjectID>(.Count("testEntityID")),
Select<NSManagedObjectID>(.count("testEntityID")),
queryClauses
)
XCTAssertNil(value)
@@ -533,7 +533,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Bool>(.Maximum("testBoolean")),
Select<Bool>(.maximum("testBoolean")),
queryClauses
)
XCTAssertNotNil(value)
@@ -543,7 +543,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.Maximum("testNumber")),
Select<Int8>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -553,7 +553,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.Maximum("testNumber")),
Select<Int16>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -563,7 +563,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.Maximum("testNumber")),
Select<Int32>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -573,7 +573,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.Maximum("testNumber")),
Select<Int64>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -583,7 +583,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.Maximum("testNumber")),
Select<Int>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -593,7 +593,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.Maximum("testNumber")),
Select<Double>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -603,7 +603,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.Maximum("testNumber")),
Select<Float>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -613,7 +613,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.Maximum("testNumber")),
Select<NSNumber>(.maximum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -623,7 +623,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.Maximum("testDecimal")),
Select<NSDecimalNumber>(.maximum("testDecimal")),
queryClauses
)
XCTAssertNotNil(value)
@@ -633,7 +633,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.Maximum("testString")),
Select<String>(.maximum("testString")),
queryClauses
)
XCTAssertNotNil(value)
@@ -643,7 +643,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.Maximum("testString")),
Select<NSString>(.maximum("testString")),
queryClauses
)
XCTAssertNotNil(value)
@@ -653,27 +653,27 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.Maximum("testData")),
Select<NSData>(.maximum("testData")),
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding))
XCTAssertEqual(value, ("nil:TestEntity1:5" as NSString).data(using: String.Encoding.utf8.rawValue))
}
do {
let value = stack.queryValue(
from,
Select<NSDate>(.Maximum("testDate")),
Select<NSDate>(.maximum("testDate")),
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-05T00:00:00Z"))
XCTAssertEqual(value, self.dateFormatter.date(from: "2000-01-05T00:00:00Z"))
}
do {
let value = stack.queryValue(
from,
Select<NSManagedObjectID>(.Maximum("testEntityID")),
Select<NSManagedObjectID>(.maximum("testEntityID")),
queryClauses
)
XCTAssertNil(value)
@@ -697,7 +697,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Bool>(.Minimum("testBoolean")),
Select<Bool>(.minimum("testBoolean")),
queryClauses
)
XCTAssertNotNil(value)
@@ -707,7 +707,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.Minimum("testNumber")),
Select<Int8>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -717,7 +717,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.Minimum("testNumber")),
Select<Int16>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -727,7 +727,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.Minimum("testNumber")),
Select<Int32>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -737,7 +737,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.Minimum("testNumber")),
Select<Int64>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -747,7 +747,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.Minimum("testNumber")),
Select<Int>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -757,7 +757,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.Minimum("testNumber")),
Select<Double>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -767,7 +767,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.Minimum("testNumber")),
Select<Float>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -777,7 +777,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.Minimum("testNumber")),
Select<NSNumber>(.minimum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -787,7 +787,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.Minimum("testDecimal")),
Select<NSDecimalNumber>(.minimum("testDecimal")),
queryClauses
)
XCTAssertNotNil(value)
@@ -797,7 +797,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.Minimum("testString")),
Select<String>(.minimum("testString")),
queryClauses
)
XCTAssertNotNil(value)
@@ -807,7 +807,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.Minimum("testString")),
Select<NSString>(.minimum("testString")),
queryClauses
)
XCTAssertNotNil(value)
@@ -817,27 +817,27 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.Minimum("testData")),
Select<NSData>(.minimum("testData")),
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, ("nil:TestEntity1:2" as NSString).dataUsingEncoding(NSUTF8StringEncoding))
XCTAssertEqual(value, ("nil:TestEntity1:2" as NSString).data(using: String.Encoding.utf8.rawValue))
}
do {
let value = stack.queryValue(
from,
Select<NSDate>(.Minimum("testDate")),
Select<NSDate>(.minimum("testDate")),
queryClauses
)
XCTAssertNotNil(value)
XCTAssertEqual(value, self.dateFormatter.dateFromString("2000-01-02T00:00:00Z"))
XCTAssertEqual(value, self.dateFormatter.date(from: "2000-01-02T00:00:00Z"))
}
do {
let value = stack.queryValue(
from,
Select<NSManagedObjectID>(.Minimum("testEntityID")),
Select<NSManagedObjectID>(.minimum("testEntityID")),
queryClauses
)
XCTAssertNil(value)
@@ -861,7 +861,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Bool>(.Sum("testBoolean")),
Select<Bool>(.sum("testBoolean")),
queryClauses
)
XCTAssertNotNil(value)
@@ -871,7 +871,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.Sum("testNumber")),
Select<Int8>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -881,7 +881,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.Sum("testNumber")),
Select<Int16>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -891,7 +891,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.Sum("testNumber")),
Select<Int32>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -901,7 +901,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.Sum("testNumber")),
Select<Int64>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -911,7 +911,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.Sum("testNumber")),
Select<Int>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -921,7 +921,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.Sum("testNumber")),
Select<Double>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -931,7 +931,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.Sum("testNumber")),
Select<Float>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -941,7 +941,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.Sum("testNumber")),
Select<NSNumber>(.sum("testNumber")),
queryClauses
)
XCTAssertNotNil(value)
@@ -951,7 +951,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.Sum("testDecimal")),
Select<NSDecimalNumber>(.sum("testDecimal")),
queryClauses
)
XCTAssertNotNil(value)
@@ -961,7 +961,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.Sum("testString")),
Select<String>(.sum("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -970,7 +970,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.Sum("testString")),
Select<NSString>(.sum("testString")),
queryClauses
)
XCTAssertNil(value)
@@ -979,7 +979,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.Sum("testData")),
Select<NSData>(.sum("testData")),
queryClauses
)
XCTAssertNil(value)
@@ -988,7 +988,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDate>(.Sum("testDate")),
Select<NSDate>(.sum("testDate")),
queryClauses
)
XCTAssertNil(value)
@@ -997,7 +997,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSManagedObjectID>(.Sum("testEntityID")),
Select<NSManagedObjectID>(.sum("testEntityID")),
queryClauses
)
XCTAssertNil(value)
@@ -1021,7 +1021,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Bool>(.ObjectID()),
Select<Bool>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1030,7 +1030,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int8>(.ObjectID()),
Select<Int8>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1039,7 +1039,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int16>(.ObjectID()),
Select<Int16>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1048,7 +1048,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int32>(.ObjectID()),
Select<Int32>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1057,7 +1057,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int64>(.ObjectID()),
Select<Int64>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1066,7 +1066,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Int>(.ObjectID()),
Select<Int>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1075,7 +1075,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Double>(.ObjectID()),
Select<Double>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1084,7 +1084,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<Float>(.ObjectID()),
Select<Float>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1093,7 +1093,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSNumber>(.ObjectID()),
Select<NSNumber>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1102,7 +1102,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDecimalNumber>(.ObjectID()),
Select<NSDecimalNumber>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1111,7 +1111,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<String>(.ObjectID()),
Select<String>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1120,7 +1120,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSString>(.ObjectID()),
Select<NSString>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1129,7 +1129,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSData>(.ObjectID()),
Select<NSData>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1138,7 +1138,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSDate>(.ObjectID()),
Select<NSDate>(.objectID()),
queryClauses
)
XCTAssertNil(value)
@@ -1147,7 +1147,7 @@ class QueryTests: BaseTestDataTestCase {
let value = stack.queryValue(
from,
Select<NSManagedObjectID>(.ObjectID()),
Select<NSManagedObjectID>(.objectID()),
queryClauses
)
XCTAssertNotNil(value)
@@ -1166,7 +1166,7 @@ class QueryTests: BaseTestDataTestCase {
let from = From<TestEntity1>(configurations)
let queryClauses: [QueryClause] = [
Where("%K > %@", "testNumber", 3),
OrderBy(.Ascending("testEntityID"))
OrderBy(.ascending("testEntityID"))
]
do {
@@ -1188,20 +1188,20 @@ class QueryTests: BaseTestDataTestCase {
values!,
[
[
"testBoolean": NSNumber(bool: false),
"testNumber": NSNumber(integer: 4),
"testBoolean": NSNumber(value: false),
"testNumber": NSNumber(value: 4),
"testDecimal": NSDecimalNumber(string: "4"),
"testString": "nil:TestEntity1:4",
"testData": ("nil:TestEntity1:4" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-04T00:00:00Z")!
"testData": ("nil:TestEntity1:4" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-04T00:00:00Z")!
],
[
"testBoolean": NSNumber(bool: true),
"testNumber": NSNumber(integer: 5),
"testBoolean": NSNumber(value: true),
"testNumber": NSNumber(value: 5),
"testDecimal": NSDecimalNumber(string: "5"),
"testString": "nil:TestEntity1:5",
"testData": ("nil:TestEntity1:5" as NSString).dataUsingEncoding(NSUTF8StringEncoding)!,
"testDate": self.dateFormatter.dateFromString("2000-01-05T00:00:00Z")!
"testData": ("nil:TestEntity1:5" as NSString).data(using: String.Encoding.utf8.rawValue)!,
"testDate": self.dateFormatter.date(from: "2000-01-05T00:00:00Z")!
]
]
)
@@ -1224,11 +1224,11 @@ class QueryTests: BaseTestDataTestCase {
let values = stack.queryAttributes(
from,
Select(
.Sum("testBoolean"),
.Count("testNumber"),
.Maximum("testNumber"),
.Minimum("testNumber"),
.Average("testDecimal")
.sum("testBoolean"),
.count("testNumber"),
.maximum("testNumber"),
.minimum("testNumber"),
.average("testDecimal")
),
queryClauses
)
@@ -1251,11 +1251,11 @@ class QueryTests: BaseTestDataTestCase {
let values = stack.queryAttributes(
from,
Select(
.Sum("testBoolean", As: "testSum"),
.Count("testNumber", As: "testCount"),
.Maximum("testNumber", As: "testMaximum"),
.Minimum("testNumber", As: "testMinimum"),
.Average("testDecimal", As: "testAverage")
.sum("testBoolean", As: "testSum"),
.count("testNumber", As: "testCount"),
.maximum("testNumber", As: "testMaximum"),
.minimum("testNumber", As: "testMinimum"),
.average("testDecimal", As: "testAverage")
),
queryClauses
)

300
CoreStoreTests/SelectTests.swift
View File

@@ -39,14 +39,14 @@ final class SelectTests: XCTestCase {
do {
let term: SelectTerm = "attribute"
XCTAssertEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
XCTAssertEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute2"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._attribute(let key):
@@ -58,14 +58,14 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Attribute("attribute")
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.attribute("attribute")
XCTAssertNotEqual(term, SelectTerm.attribute("attribute2"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._attribute(let key):
@@ -82,23 +82,23 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.Average("attribute")
XCTAssertEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.average("attribute")
XCTAssertEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.average("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "average:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "average(attribute)")
XCTAssertTrue(nativeType == .DecimalAttributeType)
XCTAssertTrue(nativeType == .decimalAttributeType)
default:
XCTFail()
@@ -106,23 +106,23 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Average("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.Average("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.average("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.average("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.average("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.average("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "average:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .DecimalAttributeType)
XCTAssertTrue(nativeType == .decimalAttributeType)
default:
XCTFail()
@@ -135,23 +135,23 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.Count("attribute")
XCTAssertEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.count("attribute")
XCTAssertEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.count("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "count:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "count(attribute)")
XCTAssertTrue(nativeType == .Integer64AttributeType)
XCTAssertTrue(nativeType == .integer64AttributeType)
default:
XCTFail()
@@ -159,23 +159,23 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Count("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.Count("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.count("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.count("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.count("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.count("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "count:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .Integer64AttributeType)
XCTAssertTrue(nativeType == .integer64AttributeType)
default:
XCTFail()
@@ -188,23 +188,23 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.Maximum("attribute")
XCTAssertEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.maximum("attribute")
XCTAssertEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "max:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "max(attribute)")
XCTAssertTrue(nativeType == .UndefinedAttributeType)
XCTAssertTrue(nativeType == .undefinedAttributeType)
default:
XCTFail()
@@ -212,23 +212,23 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Maximum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.Maximum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.maximum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.maximum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "max:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .UndefinedAttributeType)
XCTAssertTrue(nativeType == .undefinedAttributeType)
default:
XCTFail()
@@ -241,23 +241,23 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.Minimum("attribute")
XCTAssertEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.minimum("attribute")
XCTAssertEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "min:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "min(attribute)")
XCTAssertTrue(nativeType == .UndefinedAttributeType)
XCTAssertTrue(nativeType == .undefinedAttributeType)
default:
XCTFail()
@@ -265,23 +265,23 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Minimum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.Minimum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.minimum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.minimum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "min:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .UndefinedAttributeType)
XCTAssertTrue(nativeType == .undefinedAttributeType)
default:
XCTFail()
@@ -294,23 +294,23 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.Sum("attribute")
XCTAssertEqual(term, SelectTerm.Sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.sum("attribute")
XCTAssertEqual(term, SelectTerm.sum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "sum:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "sum(attribute)")
XCTAssertTrue(nativeType == .DecimalAttributeType)
XCTAssertTrue(nativeType == .decimalAttributeType)
default:
XCTFail()
@@ -318,23 +318,23 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.Sum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.Sum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
let term = SelectTerm.sum("attribute", As: "alias")
XCTAssertEqual(term, SelectTerm.sum("attribute", As: "alias"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute", As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute2"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.objectID())
switch term {
case ._aggregate(let function, let keyPath, let alias, let nativeType):
XCTAssertEqual(function, "sum:")
XCTAssertEqual(keyPath, "attribute")
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .DecimalAttributeType)
XCTAssertTrue(nativeType == .decimalAttributeType)
default:
XCTFail()
@@ -347,20 +347,20 @@ final class SelectTests: XCTestCase {
do {
let term = SelectTerm.ObjectID()
XCTAssertEqual(term, SelectTerm.ObjectID())
XCTAssertNotEqual(term, SelectTerm.ObjectID(As: "alias"))
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
let term = SelectTerm.objectID()
XCTAssertEqual(term, SelectTerm.objectID())
XCTAssertNotEqual(term, SelectTerm.objectID(As: "alias"))
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
switch term {
case ._identity(let alias, let nativeType):
XCTAssertEqual(alias, "objectID")
XCTAssertTrue(nativeType == .ObjectIDAttributeType)
XCTAssertTrue(nativeType == .objectIDAttributeType)
default:
XCTFail()
@@ -368,21 +368,21 @@ final class SelectTests: XCTestCase {
}
do {
let term = SelectTerm.ObjectID(As: "alias")
XCTAssertEqual(term, SelectTerm.ObjectID(As: "alias"))
XCTAssertNotEqual(term, SelectTerm.ObjectID(As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.ObjectID())
XCTAssertNotEqual(term, SelectTerm.Attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.Average("attribute"))
XCTAssertNotEqual(term, SelectTerm.Count("attribute"))
XCTAssertNotEqual(term, SelectTerm.Maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.Sum("attribute"))
let term = SelectTerm.objectID(As: "alias")
XCTAssertEqual(term, SelectTerm.objectID(As: "alias"))
XCTAssertNotEqual(term, SelectTerm.objectID(As: "alias2"))
XCTAssertNotEqual(term, SelectTerm.objectID())
XCTAssertNotEqual(term, SelectTerm.attribute("attribute"))
XCTAssertNotEqual(term, SelectTerm.average("attribute"))
XCTAssertNotEqual(term, SelectTerm.count("attribute"))
XCTAssertNotEqual(term, SelectTerm.maximum("attribute"))
XCTAssertNotEqual(term, SelectTerm.minimum("attribute"))
XCTAssertNotEqual(term, SelectTerm.sum("attribute"))
switch term {
case ._identity(let alias, let nativeType):
XCTAssertEqual(alias, "alias")
XCTAssertTrue(nativeType == .ObjectIDAttributeType)
XCTAssertTrue(nativeType == .objectIDAttributeType)
default:
XCTFail()
@@ -393,9 +393,9 @@ final class SelectTests: XCTestCase {
@objc
dynamic func test_ThatSelectClauses_ConfigureCorrectly() {
let term1 = SelectTerm.Attribute("attribute1")
let term2 = SelectTerm.Attribute("attribute2")
let term3 = SelectTerm.Attribute("attribute3")
let term1 = SelectTerm.attribute("attribute1")
let term2 = SelectTerm.attribute("attribute2")
let term3 = SelectTerm.attribute("attribute3")
do {
let select = Select<Int>(term1, term2, term3)

16
CoreStoreTests/SetupTests.swift
View File

@@ -36,13 +36,13 @@ class SetupTests: BaseTestCase {
do {
let model = NSManagedObjectModel.mergedModelFromBundles([Bundle(forClass: self.dynamicType)])!
let model = NSManagedObjectModel.mergedModel(from: [Bundle(for: self.dynamicType)])!
let stack = DataStack(model: model, migrationChain: nil)
XCTAssertEqual(stack.coordinator.managedObjectModel, model)
XCTAssertEqual(stack.rootSavingContext.persistentStoreCoordinator, stack.coordinator)
XCTAssertNil(stack.rootSavingContext.parentContext)
XCTAssertEqual(stack.mainContext.parentContext, stack.rootSavingContext)
XCTAssertNil(stack.rootSavingContext.parent)
XCTAssertEqual(stack.mainContext.parent, stack.rootSavingContext)
XCTAssertEqual(stack.model, model)
XCTAssertTrue(stack.migrationChain.valid)
XCTAssertTrue(stack.migrationChain.empty)
@@ -56,11 +56,11 @@ class SetupTests: BaseTestCase {
let migrationChain: MigrationChain = ["version1", "version2", "version3"]
let stack = self.expectLogger([.LogWarning]) {
let stack = self.expectLogger([.logWarning]) {
DataStack(
modelName: "Model",
bundle: Bundle(forClass: self.dynamicType),
bundle: Bundle(for: self.dynamicType),
migrationChain: migrationChain
)
}
@@ -77,7 +77,7 @@ class SetupTests: BaseTestCase {
let stack = DataStack(
modelName: "Model",
bundle: Bundle(forClass: self.dynamicType)
bundle: Bundle(for: self.dynamicType)
)
do {
@@ -132,7 +132,7 @@ class SetupTests: BaseTestCase {
let stack = DataStack(
modelName: "Model",
bundle: Bundle(forClass: self.dynamicType)
bundle: Bundle(for: self.dynamicType)
)
do {
@@ -194,7 +194,7 @@ class SetupTests: BaseTestCase {
let stack = DataStack(
modelName: "Model",
bundle: Bundle(forClass: self.dynamicType)
bundle: Bundle(for: self.dynamicType)
)
do {

18
CoreStoreTests/StorageInterfaceTests.swift
View File

@@ -86,8 +86,8 @@ final class StorageInterfaceTests: XCTestCase {
XCTAssertEqual(store.storeOptions, [NSSQLitePragmasOption: ["journal_mode": "WAL"]] as NSDictionary)
XCTAssertEqual(store.fileURL, SQLiteStore.defaultFileURL)
XCTAssertEqual(store.mappingModelBundles, Bundle.allBundles())
XCTAssertEqual(store.localStorageOptions, [.None])
XCTAssertEqual(store.mappingModelBundles, Bundle.allBundles)
XCTAssertEqual(store.localStorageOptions, .none)
}
@objc
@@ -129,7 +129,7 @@ final class StorageInterfaceTests: XCTestCase {
XCTAssertEqual(store.configuration, "config1")
XCTAssertEqual(store.storeOptions, [NSSQLitePragmasOption: ["journal_mode": "WAL"]] as NSDictionary)
XCTAssertEqual(store.fileURL.URLByDeletingLastPathComponent, SQLiteStore.defaultRootDirectory)
XCTAssertEqual(try! store.fileURL.deletingLastPathComponent(), SQLiteStore.defaultRootDirectory)
XCTAssertEqual(store.fileURL.lastPathComponent, fileName)
XCTAssertEqual(store.mappingModelBundles, bundles)
XCTAssertEqual(store.localStorageOptions, [.recreateStoreOnModelMismatch])
@@ -149,9 +149,9 @@ final class StorageInterfaceTests: XCTestCase {
inDomains: .userDomainMask
).first!
let legacyDefaultFileURL = legacyDefaultRootDirectory
.URLByAppendingPathComponent(DataStack.applicationName, isDirectory: false)
.URLByAppendingPathExtension("sqlite")
let legacyDefaultFileURL = try! legacyDefaultRootDirectory
.appendingPathComponent(DataStack.applicationName, isDirectory: false)
.appendingPathExtension("sqlite")
XCTAssertEqual(LegacySQLiteStore.defaultRootDirectory, legacyDefaultRootDirectory)
XCTAssertEqual(LegacySQLiteStore.defaultFileURL, legacyDefaultFileURL)
@@ -166,8 +166,8 @@ final class StorageInterfaceTests: XCTestCase {
XCTAssertEqual(store.storeOptions, [NSSQLitePragmasOption: ["journal_mode": "WAL"]] as NSDictionary)
XCTAssertEqual(store.fileURL, LegacySQLiteStore.defaultFileURL)
XCTAssertEqual(store.mappingModelBundles, Bundle.allBundles())
XCTAssertEqual(store.localStorageOptions, [.None])
XCTAssertEqual(store.mappingModelBundles, Bundle.allBundles)
XCTAssertEqual(store.localStorageOptions, .none)
}
@objc
@@ -209,7 +209,7 @@ final class StorageInterfaceTests: XCTestCase {
XCTAssertEqual(store.configuration, "config1")
XCTAssertEqual(store.storeOptions, [NSSQLitePragmasOption: ["journal_mode": "WAL"]] as NSDictionary)
XCTAssertEqual(store.fileURL.URLByDeletingLastPathComponent, LegacySQLiteStore.defaultRootDirectory)
XCTAssertEqual(try! store.fileURL.deletingLastPathComponent(), LegacySQLiteStore.defaultRootDirectory)
XCTAssertEqual(store.fileURL.lastPathComponent, fileName)
XCTAssertEqual(store.mappingModelBundles, bundles)
XCTAssertEqual(store.localStorageOptions, [.recreateStoreOnModelMismatch])

356
CoreStoreTests/TransactionTests.swift
View File

@@ -39,21 +39,21 @@ final class TransactionTests: BaseTestCase {
self.prepareStack { (stack) in
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
stack.beginSynchronous { (transaction) in
let createExpectation = self.expectation(withDescription: "create")
_ = stack.beginSynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
createExpectation.fulfill()
@@ -63,32 +63,32 @@ final class TransactionTests: BaseTestCase {
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
}
do {
let updateExpectation = self.expectationWithDescription("update")
stack.beginSynchronous { (transaction) in
let updateExpectation = self.expectation(withDescription: "update")
_ = stack.beginSynchronous { (transaction) in
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
updateExpectation.fulfill()
@@ -98,26 +98,26 @@ final class TransactionTests: BaseTestCase {
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
}
do {
let deleteExpectation = self.expectationWithDescription("delete")
stack.beginSynchronous { (transaction) in
let deleteExpectation = self.expectation(withDescription: "delete")
_ = stack.beginSynchronous { (transaction) in
let object = transaction.fetchOne(From(TestEntity1))
let object = transaction.fetchOne(From<TestEntity1>())
transaction.delete(object)
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
deleteExpectation.fulfill()
@@ -127,9 +127,9 @@ final class TransactionTests: BaseTestCase {
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 0)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNil(object)
}
}
@@ -140,21 +140,21 @@ final class TransactionTests: BaseTestCase {
self.prepareStack(configurations: [nil, "Config1"]) { (stack) in
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
stack.beginSynchronous { (transaction) in
let createExpectation = self.expectation(withDescription: "create")
_ = stack.beginSynchronous { (transaction) in
let object = transaction.create(Into<TestEntity1>("Config1"))
object.testEntityID = NSNumber(integer: 1)
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
createExpectation.fulfill()
@@ -169,15 +169,15 @@ final class TransactionTests: BaseTestCase {
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
}
do {
let updateExpectation = self.expectationWithDescription("update")
stack.beginSynchronous { (transaction) in
let updateExpectation = self.expectation(withDescription: "update")
_ = stack.beginSynchronous { (transaction) in
guard let object = transaction.fetchOne(From<TestEntity1>("Config1")) else {
@@ -186,11 +186,11 @@ final class TransactionTests: BaseTestCase {
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
updateExpectation.fulfill()
@@ -205,22 +205,22 @@ final class TransactionTests: BaseTestCase {
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
}
do {
let deleteExpectation = self.expectationWithDescription("delete")
stack.beginSynchronous { (transaction) in
let deleteExpectation = self.expectation(withDescription: "delete")
_ = stack.beginSynchronous { (transaction) in
let object = transaction.fetchOne(From<TestEntity1>("Config1"))
transaction.delete(object)
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
deleteExpectation.fulfill()
@@ -243,41 +243,41 @@ final class TransactionTests: BaseTestCase {
do {
let createDiscardExpectation = self.expectationWithDescription("create-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
stack.beginSynchronous { (transaction) in
let createDiscardExpectation = self.expectation(withDescription: "create-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
_ = stack.beginSynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = NSDate()
object.testDate = Date()
createDiscardExpectation.fulfill()
self.expectLogger(loggerExpectations)
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 0)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNil(object)
}
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
stack.beginSynchronous { (transaction) in
let createExpectation = self.expectation(withDescription: "create")
_ = stack.beginSynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(true):
case .success(true):
createExpectation.fulfill()
default:
@@ -288,40 +288,40 @@ final class TransactionTests: BaseTestCase {
}
do {
let updateDiscardExpectation = self.expectationWithDescription("update-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
stack.beginSynchronous { (transaction) in
let updateDiscardExpectation = self.expectation(withDescription: "update-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
_ = stack.beginSynchronous { (transaction) in
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
updateDiscardExpectation.fulfill()
self.expectLogger(loggerExpectations)
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
}
do {
let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
stack.beginSynchronous { (transaction) in
let deleteDiscardExpectation = self.expectation(withDescription: "delete-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
_ = stack.beginSynchronous { (transaction) in
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
@@ -333,11 +333,11 @@ final class TransactionTests: BaseTestCase {
}
self.checkExpectationsImmediately()
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -350,14 +350,14 @@ final class TransactionTests: BaseTestCase {
self.prepareStack { (stack) in
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
let createExpectation = self.expectation(withDescription: "create")
stack.beginAsynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
@@ -366,14 +366,14 @@ final class TransactionTests: BaseTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -387,33 +387,33 @@ final class TransactionTests: BaseTestCase {
}
do {
let updateExpectation = self.expectationWithDescription("update")
let updateExpectation = self.expectation(withDescription: "update")
stack.beginAsynchronous { (transaction) in
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
updateExpectation.fulfill()
default:
@@ -424,22 +424,22 @@ final class TransactionTests: BaseTestCase {
}
do {
let deleteExpectation = self.expectationWithDescription("delete")
let deleteExpectation = self.expectation(withDescription: "delete")
stack.beginAsynchronous { (transaction) in
let object = transaction.fetchOne(From(TestEntity1))
let object = transaction.fetchOne(From<TestEntity1>())
transaction.delete(object)
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 0)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNil(object)
deleteExpectation.fulfill()
@@ -458,14 +458,14 @@ final class TransactionTests: BaseTestCase {
self.prepareStack(configurations: [nil, "Config1"]) { (stack) in
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
let createExpectation = self.expectation(withDescription: "create")
stack.beginAsynchronous { (transaction) in
let object = transaction.create(Into<TestEntity1>("Config1"))
object.testEntityID = NSNumber(integer: 1)
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
@@ -474,7 +474,7 @@ final class TransactionTests: BaseTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 1)
@@ -482,7 +482,7 @@ final class TransactionTests: BaseTestCase {
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -496,7 +496,7 @@ final class TransactionTests: BaseTestCase {
}
do {
let updateExpectation = self.expectationWithDescription("update")
let updateExpectation = self.expectation(withDescription: "update")
stack.beginAsynchronous { (transaction) in
guard let object = transaction.fetchOne(From<TestEntity1>("Config1")) else {
@@ -506,13 +506,13 @@ final class TransactionTests: BaseTestCase {
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
transaction.commit { (result) in
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 1)
@@ -520,10 +520,10 @@ final class TransactionTests: BaseTestCase {
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
updateExpectation.fulfill()
default:
@@ -534,7 +534,7 @@ final class TransactionTests: BaseTestCase {
}
do {
let deleteExpectation = self.expectationWithDescription("delete")
let deleteExpectation = self.expectation(withDescription: "delete")
stack.beginAsynchronous { (transaction) in
let object = transaction.fetchOne(From<TestEntity1>("Config1"))
@@ -544,7 +544,7 @@ final class TransactionTests: BaseTestCase {
switch result {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 0)
@@ -569,31 +569,31 @@ final class TransactionTests: BaseTestCase {
do {
let createDiscardExpectation = self.expectationWithDescription("create-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
let createDiscardExpectation = self.expectation(withDescription: "create-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
stack.beginAsynchronous { (transaction) in
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = NSDate()
object.testDate = Date()
createDiscardExpectation.fulfill()
self.expectLogger(loggerExpectations)
}
}
let testDate = NSDate()
let testDate = Date()
do {
let createExpectation = self.expectationWithDescription("create")
let createExpectation = self.expectation(withDescription: "create")
stack.beginAsynchronous { (transaction) in
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
XCTAssertNil(transaction.fetchOne(From(TestEntity1)))
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 0)
XCTAssertNil(transaction.fetchOne(From<TestEntity1>()))
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
@@ -602,7 +602,7 @@ final class TransactionTests: BaseTestCase {
switch result {
case .Success(true):
case .success(true):
createExpectation.fulfill()
default:
@@ -613,18 +613,18 @@ final class TransactionTests: BaseTestCase {
}
do {
let updateDiscardExpectation = self.expectationWithDescription("update-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
let updateDiscardExpectation = self.expectation(withDescription: "update-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
stack.beginAsynchronous { (transaction) in
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
updateDiscardExpectation.fulfill()
self.expectLogger(loggerExpectations)
@@ -632,19 +632,19 @@ final class TransactionTests: BaseTestCase {
}
do {
let deleteDiscardExpectation = self.expectationWithDescription("delete-discard")
let loggerExpectations = self.prepareLoggerExpectations([.LogWarning])
let deleteDiscardExpectation = self.expectation(withDescription: "delete-discard")
let loggerExpectations = self.prepareLoggerExpectations([.logWarning])
stack.beginAsynchronous { (transaction) in
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
XCTAssertNotNil(object)
XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object.testString, "string1")
XCTAssertEqual(object.testNumber, 100)
XCTAssertEqual(object.testDate, testDate)
@@ -653,11 +653,11 @@ final class TransactionTests: BaseTestCase {
GCDQueue.main.async {
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -677,24 +677,24 @@ final class TransactionTests: BaseTestCase {
let transaction = stack.beginUnsafe()
let testDate = NSDate()
let testDate = Date()
do {
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -705,27 +705,27 @@ final class TransactionTests: BaseTestCase {
}
do {
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
let object = stack.fetchOne(From(TestEntity1))
let object = stack.fetchOne(From<TestEntity1>())
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
default:
XCTFail()
@@ -733,16 +733,16 @@ final class TransactionTests: BaseTestCase {
}
do {
let object = transaction.fetchOne(From(TestEntity1))
let object = transaction.fetchOne(From<TestEntity1>())
transaction.delete(object)
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
XCTAssertNil(stack.fetchOne(From(TestEntity1)))
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 0)
XCTAssertNil(stack.fetchOne(From<TestEntity1>()))
default:
XCTFail()
@@ -758,25 +758,25 @@ final class TransactionTests: BaseTestCase {
let transaction = stack.beginUnsafe()
let testDate = NSDate()
let testDate = Date()
do {
let object = transaction.create(Into<TestEntity1>("Config1"))
object.testEntityID = NSNumber(integer: 1)
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>(nil)), 0)
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1")
XCTAssertEqual(object?.testNumber, 100)
XCTAssertEqual(object?.testDate, testDate)
@@ -794,21 +794,21 @@ final class TransactionTests: BaseTestCase {
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 1)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>(nil)), 0)
let object = stack.fetchOne(From<TestEntity1>("Config1"))
XCTAssertNotNil(object)
XCTAssertEqual(object?.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object?.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object?.testString, "string1_edit")
XCTAssertEqual(object?.testNumber, 200)
XCTAssertEqual(object?.testDate, NSDate.distantFuture())
XCTAssertEqual(object?.testDate, Date.distantFuture)
default:
XCTFail()
@@ -821,7 +821,7 @@ final class TransactionTests: BaseTestCase {
switch transaction.commitAndWait() {
case .Success(let hasChanges):
case .success(let hasChanges):
XCTAssertTrue(hasChanges)
XCTAssertEqual(stack.fetchCount(From<TestEntity1>("Config1")), 0)
@@ -842,33 +842,33 @@ final class TransactionTests: BaseTestCase {
let transaction = stack.beginUnsafe(supportsUndo: true)
do {
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = NSDate()
object.testDate = Date()
transaction.rollback()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 0)
XCTAssertNil(transaction.fetchOne(From(TestEntity1)))
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 0)
XCTAssertNil(transaction.fetchOne(From<TestEntity1>()))
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 0)
XCTAssertNil(stack.fetchOne(From(TestEntity1)))
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 0)
XCTAssertNil(stack.fetchOne(From<TestEntity1>()))
}
let testDate = NSDate()
let testDate = Date()
do {
let object = transaction.create(Into(TestEntity1))
object.testEntityID = NSNumber(integer: 1)
let object = transaction.create(Into<TestEntity1>())
object.testEntityID = NSNumber(value: 1)
object.testString = "string1"
object.testNumber = 100
object.testDate = testDate
switch transaction.commitAndWait() {
case .Success(true):
case .success(true):
break
default:
@@ -878,21 +878,21 @@ final class TransactionTests: BaseTestCase {
do {
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
}
object.testString = "string1_edit"
object.testNumber = 200
object.testDate = NSDate.distantFuture()
object.testDate = Date.distantFuture
transaction.rollback()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
if let object = transaction.fetchOne(From(TestEntity1)) {
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
if let object = transaction.fetchOne(From<TestEntity1>()) {
XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object.testString, "string1")
XCTAssertEqual(object.testNumber, 100)
XCTAssertEqual(object.testDate, testDate)
@@ -902,10 +902,10 @@ final class TransactionTests: BaseTestCase {
XCTFail()
}
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
if let object = stack.fetchOne(From(TestEntity1)) {
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
if let object = stack.fetchOne(From<TestEntity1>()) {
XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object.testString, "string1")
XCTAssertEqual(object.testNumber, 100)
XCTAssertEqual(object.testDate, testDate)
@@ -918,7 +918,7 @@ final class TransactionTests: BaseTestCase {
do {
guard let object = transaction.fetchOne(From(TestEntity1)) else {
guard let object = transaction.fetchOne(From<TestEntity1>()) else {
XCTFail()
return
@@ -927,10 +927,10 @@ final class TransactionTests: BaseTestCase {
transaction.rollback()
XCTAssertEqual(transaction.fetchCount(From(TestEntity1)), 1)
if let object = transaction.fetchOne(From(TestEntity1)) {
XCTAssertEqual(transaction.fetchCount(From<TestEntity1>()), 1)
if let object = transaction.fetchOne(From<TestEntity1>()) {
XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object.testString, "string1")
XCTAssertEqual(object.testNumber, 100)
XCTAssertEqual(object.testDate, testDate)
@@ -940,10 +940,10 @@ final class TransactionTests: BaseTestCase {
XCTFail()
}
XCTAssertEqual(stack.fetchCount(From(TestEntity1)), 1)
if let object = stack.fetchOne(From(TestEntity1)) {
XCTAssertEqual(stack.fetchCount(From<TestEntity1>()), 1)
if let object = stack.fetchOne(From<TestEntity1>()) {
XCTAssertEqual(object.testEntityID, NSNumber(integer: 1))
XCTAssertEqual(object.testEntityID, NSNumber(value: 1))
XCTAssertEqual(object.testString, "string1")
XCTAssertEqual(object.testNumber, 100)
XCTAssertEqual(object.testDate, testDate)

2
CoreStoreTests/TweakTests.swift
View File

@@ -43,7 +43,7 @@ final class TweakTests: XCTestCase {
$0.fetchLimit = 200
$0.predicate = predicate
}
let request = NSFetchRequest()
let request = NSFetchRequest<NSFetchRequestResult>()
tweak.applyToFetchRequest(request)
XCTAssertEqual(request.fetchOffset, 100)
XCTAssertEqual(request.fetchLimit, 200)

12
CoreStoreTests/WhereTests.swift
View File

@@ -98,7 +98,7 @@ final class WhereTests: XCTestCase {
let notWhere = !whereClause1
let notPredicate = CompoundPredicate(
type: .NotPredicateType,
type: .not,
subpredicates: [whereClause1.predicate]
)
XCTAssertEqual(notWhere.predicate, notPredicate)
@@ -108,10 +108,10 @@ final class WhereTests: XCTestCase {
let andWhere = whereClause1 && whereClause2 && whereClause3
let andPredicate = CompoundPredicate(
type: .AndPredicateType,
type: .and,
subpredicates: [
CompoundPredicate(
type: .AndPredicateType,
type: .and,
subpredicates: [whereClause1.predicate, whereClause2.predicate]
),
whereClause3.predicate
@@ -124,10 +124,10 @@ final class WhereTests: XCTestCase {
let orWhere = whereClause1 || whereClause2 || whereClause3
let orPredicate = CompoundPredicate(
type: .OrPredicateType,
type: .or,
subpredicates: [
CompoundPredicate(
type: .OrPredicateType,
type: .or,
subpredicates: [whereClause1.predicate, whereClause2.predicate]
),
whereClause3.predicate
@@ -142,7 +142,7 @@ final class WhereTests: XCTestCase {
dynamic func test_ThatWhereClauses_ApplyToFetchRequestsCorrectly() {
let whereClause = Where("key", isEqualTo: "value")
let request = NSFetchRequest()
let request = NSFetchRequest<NSFetchRequestResult>()
whereClause.applyToFetchRequest(request)
XCTAssertNotNil(request.predicate)
XCTAssertEqual(request.predicate, whereClause.predicate)