Migrate tests to swift-testing

feature/swift-testing

Author: roanutil

Tests/CoreDataRepositoryTests/AggregateTests.swift

@@ -0,0 +1,10 @@
+// CoreDataRepositoryTests.swift
+// CoreDataRepository
+//
+// This source code is licensed under the MIT License (MIT) found in the
+// LICENSE file in the root directory of this source tree.
+
+import Testing
+
+@Suite(.serialized)
+struct CoreDataRepositoryTests {}

Tests/CoreDataRepositoryTests/BatchRequestTests.swift

@@ -0,0 +1,142 @@
+// CoreDataTestSuite.swift
+// CoreDataRepository
+//
+// This source code is licensed under the MIT License (MIT) found in the
+// LICENSE file in the root directory of this source tree.
+
+import CoreData
+import CoreDataRepository
+import CustomDump
+import Internal
+import Testing
+
+protocol CoreDataTestSuite {
+    var container: NSPersistentContainer { get }
+    var repositoryContext: NSManagedObjectContext { get }
+    var repository: CoreDataRepository { get }
+
+    mutating func extraSetup() async throws
+
+    init() async throws
+    init(container: NSPersistentContainer, repositoryContext: NSManagedObjectContext, repository: CoreDataRepository)
+}
+
+extension CoreDataTestSuite {
+    init() async throws {
+        let stack = CoreDataStack(
+            storeName: "coredata_repository_tests",
+            type: .sqliteEphemeral,
+            container: CoreDataStack.persistentContainer(
+                storeName: "coredata_repository_tests",
+                type: .sqliteEphemeral,
+                model: .model_UuidId
+            )
+        )
+        let _container = stack.container
+        let _repositoryContext = _container.newBackgroundContext()
+        _repositoryContext.automaticallyMergesChangesFromParent = true
+        let _repository = CoreDataRepository(context: _repositoryContext)
+        self.init(container: _container, repositoryContext: _repositoryContext, repository: _repository)
+
+        try await extraSetup()
+    }
+
+    mutating func extraSetup() async throws {
+        // empty by default
+    }
+
+    func mapInContext<I, O>(_ input: I, transform: (I) throws -> O) throws -> O {
+        try repositoryContext.performAndWait {
+            try transform(input)
+        }
+    }
+
+    func verify<T>(_ item: T) async throws where T: FetchableUnmanagedModel, T: Equatable {
+        repositoryContext.performAndWait {
+            var managed: T.ManagedModel?
+            do {
+                managed = try repositoryContext.fetch(T.managedFetchRequest()).first { try T(managed: $0) == item }
+            } catch {
+                Issue.record(
+                    "Failed to verify item in store because fetching failed. Error: \(error.localizedDescription)"
+                )
+                return
+            }
+
+            guard managed != nil else {
+                Issue.record("Failed to verify item in store because it was not found.")
+                return
+            }
+        }
+    }
+
+    func verify<T>(_ item: T) async throws where T: ReadableUnmanagedModel, T: Equatable {
+        try repositoryContext.performAndWait {
+            var _managed: T.ManagedModel?
+            do {
+                _managed = try item.readManaged(from: repositoryContext)
+            } catch {
+                Issue.record(
+                    "Failed to verify item in store because reading it failed. Error: \(error.localizedDescription)"
+                )
+                return
+            }
+
+            guard let managed = _managed else {
+                Issue.record("Failed to verify item in store because it was not found.")
+                return
+            }
+            try expectNoDifference(item, T(managed: managed))
+        }
+    }
+
+    func verify(transactionAuthor: String?, timeStamp: Date) throws {
+        let historyRequest = NSPersistentHistoryChangeRequest.fetchHistory(after: timeStamp)
+        try repositoryContext.performAndWait {
+            let historyResult = try #require(repositoryContext.execute(historyRequest) as? NSPersistentHistoryResult)
+            let history = try #require(historyResult.result as? [NSPersistentHistoryTransaction])
+            #expect(history.count > 0)
+            for historyTransaction in history {
+                #expect(historyTransaction.author == transactionAuthor)
+            }
+        }
+    }
+
+    func verifyDoesNotExist<T>(_ item: T) async throws where T: FetchableUnmanagedModel, T: Equatable {
+        repositoryContext.performAndWait {
+            var _managed: T.ManagedModel?
+            do {
+                _managed = try repositoryContext.fetch(T.managedFetchRequest()).first { try T(managed: $0) == item }
+            } catch {
+                return
+            }
+
+            if let _managed, !_managed.isDeleted {
+                Issue.record("Item does exist and is not deleted which is not expected")
+            }
+        }
+    }
+
+    func verifyDoesNotExist<T>(_ item: T) async throws where T: ReadableUnmanagedModel, T: Equatable {
+        repositoryContext.performAndWait {
+            var _managed: T.ManagedModel?
+            do {
+                _managed = try item.readManaged(from: repositoryContext)
+            } catch {
+                return
+            }
+
+            if let _managed, !_managed.isDeleted {
+                Issue.record("Item does exist and is not deleted which is not expected")
+            }
+        }
+    }
+
+    func delete(managedId: NSManagedObjectID) throws {
+        try repositoryContext.performAndWait {
+            let managed = repositoryContext.object(with: managedId)
+            repositoryContext.delete(managed)
+            try repositoryContext.save()
+        }
+    }
+}