Add tests for atomic batch operations and fix API inconsistencies

3.0-preview

Author: roanutil

Sources/CoreDataRepository/CoreDataRepository+Batch.swift

@@ -68,7 +68,7 @@ extension CoreDataRepository {
     }
 
     /// Create a batch of unmanaged models.
-    public func createAtomiclly<Model: UnmanagedModel>(
+    public func createAtomically<Model: UnmanagedModel>(
         _ items: [Model],
         transactionAuthor: String? = nil
     ) async -> Result<[Model], CoreDataError> {
@@ -131,8 +131,8 @@ extension CoreDataRepository {
 
     /// Read a batch of unmanaged models.
     public func readAtomically<Model: UnmanagedModel>(
-        _ urls: [URL],
-        of _: Model.Type
+        urls: [URL],
+        as _: Model.Type
     ) async -> Result<[Model], CoreDataError> {
         await context.performInChild(schedule: .enqueued) { readContext in
             try urls.map { url in
@@ -160,33 +160,6 @@ extension CoreDataRepository {
         }
     }
 
-    /// Update the store with a batch of unmanaged models.
-    public func updateAtomically<Model: UnmanagedModel>(
-        _ items: [Model],
-        transactionAuthor: String? = nil
-    ) async -> Result<[Model], CoreDataError> {
-        await context.performInScratchPad(schedule: .enqueued) { [context] scratchPad in
-            scratchPad.transactionAuthor = transactionAuthor
-            let objects = try items.map { item in
-                guard let url = item.managedIdUrl else {
-                    throw CoreDataError.noUrlOnItemToMapToObjectId
-                }
-                let id = try scratchPad.objectId(from: url).get()
-                let object = try scratchPad.notDeletedObject(for: id)
-                let managed: Model.ManagedModel = try object.asManagedModel()
-                try item.updating(managed: managed)
-                return managed
-            }
-            try scratchPad.save()
-            try context.performAndWait {
-                context.transactionAuthor = transactionAuthor
-                try context.save()
-                context.transactionAuthor = nil
-            }
-            return try objects.map(Model.init(managed:))
-        }
-    }
-
     /// Update the store with a batch of unmanaged models.
     ///
     /// This operation is non-atomic. Each instance may succeed or fail individually.
@@ -231,6 +204,33 @@ extension CoreDataRepository {
         return (success: successes, failed: failures)
     }
 
+    /// Update the store with a batch of unmanaged models.
+    public func updateAtomically<Model: UnmanagedModel>(
+        _ items: [Model],
+        transactionAuthor: String? = nil
+    ) async -> Result<[Model], CoreDataError> {
+        await context.performInScratchPad(schedule: .enqueued) { [context] scratchPad in
+            scratchPad.transactionAuthor = transactionAuthor
+            let objects = try items.map { item in
+                guard let url = item.managedIdUrl else {
+                    throw CoreDataError.noUrlOnItemToMapToObjectId
+                }
+                let id = try scratchPad.objectId(from: url).get()
+                let object = try scratchPad.notDeletedObject(for: id)
+                let managed: Model.ManagedModel = try object.asManagedModel()
+                try item.updating(managed: managed)
+                return managed
+            }
+            try scratchPad.save()
+            try context.performAndWait {
+                context.transactionAuthor = transactionAuthor
+                try context.save()
+                context.transactionAuthor = nil
+            }
+            return try objects.map(Model.init(managed:))
+        }
+    }
+
     /// Execute a NSBatchDeleteRequest against the store.
     public func delete(
         _ request: NSBatchDeleteRequest,
@@ -290,7 +290,7 @@ extension CoreDataRepository {
 
     /// Delete from the store with a batch of unmanaged models.
     public func deleteAtomically(
-        _ urls: [URL],
+        urls: [URL],
         transactionAuthor: String? = nil
     ) async -> Result<Void, CoreDataError> {
         await context.performInScratchPad(schedule: .enqueued) { [context] scratchPad in

Tests/CoreDataRepositoryTests/BatchRepositoryTests.swift

@@ -141,6 +141,55 @@ final class BatchRepositoryTests: CoreDataXCTestCase {
         try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
     }
 
+    func testCreateAtomicallySuccess() async throws {
+        let fetchRequest = Movie.managedFetchRequest()
+        try await repositoryContext().perform {
+            let count = try self.repositoryContext().count(for: fetchRequest)
+            XCTAssertEqual(count, 0, "Count of objects in CoreData should be zero at the start of each test.")
+        }
+
+        let historyTimeStamp = Date()
+        let transactionAuthor: String = #function
+
+        let newMovies = try movies.map(mapDictToMovie(_:))
+        let createdMovies: [Movie]
+        switch try await repository()
+            .createAtomically(newMovies, transactionAuthor: transactionAuthor)
+        {
+        case let .success(_createdMovies):
+            createdMovies = _createdMovies
+        case let .failure(error):
+            XCTFail("Not expecting failure: \(error.localizedDescription)")
+            return
+        }
+
+        XCTAssertEqual(createdMovies.count, newMovies.count)
+
+        for movie in createdMovies {
+            try await verify(movie)
+        }
+
+        let createdMoviesForEquality = createdMovies.map { movie in
+            var movie = movie
+            XCTAssertNotNil(movie.url)
+            movie.url = nil
+            return movie
+        }
+
+        XCTAssertNoDifference(createdMoviesForEquality, newMovies)
+
+        try await repositoryContext().perform {
+            let data = try self.repositoryContext().fetch(fetchRequest)
+            XCTAssertEqual(
+                data.map { $0.title ?? "" }.sorted(),
+                ["A", "B", "C", "D", "E"],
+                "Inserted titles should match expectation"
+            )
+        }
+
+        try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
+    }
+
     func testReadSuccess() async throws {
         let fetchRequest = Movie.managedFetchRequest()
         var movies = [Movie]()
@@ -162,6 +211,33 @@ final class BatchRepositoryTests: CoreDataXCTestCase {
         XCTAssertEqual(Set(movies), Set(result.success))
     }
 
+    func testReadAtomicallySuccess() async throws {
+        let fetchRequest = Movie.managedFetchRequest()
+        var movies = [Movie]()
+        try await repositoryContext().perform {
+            let count = try self.repositoryContext().count(for: fetchRequest)
+            XCTAssertEqual(count, 0, "Count of objects in CoreData should be zero at the start of each test.")
+
+            let managedMovies = try self.movies
+                .map(self.mapDictToManagedMovie(_:))
+            try self.repositoryContext().save()
+            movies = try managedMovies.map(Movie.init(managed:))
+        }
+
+        let readMovies: [Movie]
+        switch try await repository().readAtomically(urls: movies.compactMap(\.url), as: Movie.self) {
+        case let .success(_readMovies):
+            readMovies = _readMovies
+        case let .failure(error):
+            XCTFail("Not expecting failure: \(error.localizedDescription)")
+            return
+        }
+
+        XCTAssertEqual(readMovies.count, movies.count)
+
+        XCTAssertNoDifference(readMovies, movies)
+    }
+
     func testUpdateSuccess() async throws {
         let fetchRequest = Movie.managedFetchRequest()
         try await repositoryContext().perform {
@@ -226,6 +302,44 @@ final class BatchRepositoryTests: CoreDataXCTestCase {
         try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
     }
 
+    func testAltUpdateAtomicallySuccess() async throws {
+        let fetchRequest = Movie.managedFetchRequest()
+        var movies = [Movie]()
+        try await repositoryContext().perform {
+            let count = try self.repositoryContext().count(for: fetchRequest)
+            XCTAssertEqual(count, 0, "Count of objects in CoreData should be zero at the start of each test.")
+
+            let managedMovies = try self.movies
+                .map(self.mapDictToManagedMovie(_:))
+            try self.repositoryContext().save()
+            movies = try managedMovies.map(Movie.init(managed:))
+        }
+
+        var editedMovies = movies
+        let newTitles = ["ZA", "ZB", "ZC", "ZD", "ZE"]
+        newTitles.enumerated().forEach { index, title in editedMovies[index].title = title }
+
+        let historyTimeStamp = Date()
+        let transactionAuthor: String = #function
+
+        let updatedMovies: [Movie]
+        switch try await repository()
+            .updateAtomically(editedMovies, transactionAuthor: transactionAuthor)
+        {
+        case let .success(_updatedMovies):
+            updatedMovies = _updatedMovies
+        case let .failure(error):
+            XCTFail("Not expecting failure: \(error.localizedDescription)")
+            return
+        }
+
+        XCTAssertEqual(updatedMovies.count, movies.count)
+
+        XCTAssertNoDifference(updatedMovies, editedMovies)
+
+        try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
+    }
+
     func testDeleteSuccess() async throws {
         let fetchRequest = Movie.managedFetchRequest()
         try await repositoryContext().perform {
@@ -284,4 +398,37 @@ final class BatchRepositoryTests: CoreDataXCTestCase {
         }
         try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
     }
+
+    func testAltDeleteAtomicallySuccess() async throws {
+        let fetchRequest = Movie.managedFetchRequest()
+        var movies = [Movie]()
+        try await repositoryContext().perform {
+            let count = try self.repositoryContext().count(for: fetchRequest)
+            XCTAssertEqual(count, 0, "Count of objects in CoreData should be zero at the start of each test.")
+
+            let managedMovies = try self.movies
+                .map(self.mapDictToManagedMovie(_:))
+            try self.repositoryContext().save()
+            movies = try managedMovies.map(Movie.init(managed:))
+        }
+
+        let historyTimeStamp = Date()
+        let transactionAuthor: String = #function
+
+        switch try await repository()
+            .deleteAtomically(urls: movies.compactMap(\.url), transactionAuthor: transactionAuthor)
+        {
+        case .success:
+            break
+        case let .failure(error):
+            XCTFail("Not expecting failure: \(error.localizedDescription)")
+            return
+        }
+
+        try await repositoryContext().perform {
+            let data = try self.repositoryContext().fetch(fetchRequest)
+            XCTAssertEqual(data.map { $0.title ?? "" }.sorted(), [], "There should be no remaining values.")
+        }
+        try verify(transactionAuthor: transactionAuthor, timeStamp: historyTimeStamp)
+    }
 }