Reinstate PR #19765

Author: crazytonyli

WordPress/Classes/Utility/ContextManager.swift

@@ -107,6 +107,12 @@ private extension ContextManager {
             }
         }
 
+        /// Ensure that the `context`'s concurrency type is not `confinementConcurrencyType`, since it will crash if `perform` or `performAndWait` is called.
+        guard context.concurrencyType == .mainQueueConcurrencyType || context.concurrencyType == .privateQueueConcurrencyType else {
+            block()
+            return
+        }
+
         if wait {
             context.performAndWait(block)
         } else {

WordPress/WordPressTest/ContainerContextFactoryTests.swift

@@ -1,112 +1,43 @@
 import XCTest
+import Nimble
 
 @testable import WordPress
 
-final class ContainerContextFactoryTests: XCTestCase {
+final class ReaderPostBackupTests: XCTestCase {
+    private let storeURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("ReaderPostBackup.sqlite")
+    private let backupURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("ReaderPostBackup-backup.sqlite")
+    private var coreDataStack: CoreDataStack!
 
-    private var persistentContainer: NSPersistentContainer!
-    private var factory: ContainerContextFactory!
-
-    override func setUp() {
-        super.setUp()
-
-        persistentContainer = makeInMemoryContainer()
-        factory = ContainerContextFactory(persistentContainer: persistentContainer)
-    }
-
-    override func tearDown() {
-        persistentContainer = nil
-        factory = nil
-
-        super.tearDown()
-    }
-
-    // MARK: - `save` Tests
-
-    func test_save_givenMainQueueConcurrencyType_shouldCallPerform() {
-        let context = makeMockContext(concurrencyType: .mainQueueConcurrencyType)
-
-        factory.save(context, andWait: false, withCompletionBlock: nil)
-
-        XCTAssertTrue(context.performCalled)
-        XCTAssertFalse(context.performAndWaitCalled)
-    }
-
-    func test_save_givenMainQueueConcurrencyType_andWaitIsSetToTrue_shouldCallPerformAndWait() {
-        let context = makeMockContext(concurrencyType: .mainQueueConcurrencyType)
-
-        factory.save(context, andWait: true, withCompletionBlock: nil)
-
-        XCTAssertFalse(context.performCalled)
-        XCTAssertTrue(context.performAndWaitCalled)
-    }
-
-    func test_save_givenPrivateQueueConcurrencyType_shouldCallPerform() {
-        let context = makeMockContext(concurrencyType: .privateQueueConcurrencyType)
-
-        factory.save(context, andWait: false, withCompletionBlock: nil)
-
-        XCTAssertTrue(context.performCalled)
-        XCTAssertFalse(context.performAndWaitCalled)
-    }
-
-    func test_save_givenPrivateQueueConcurrencyType_andWaitIsSetToTrue_shouldCallPerformAndWait() {
-        let context = makeMockContext(concurrencyType: .privateQueueConcurrencyType)
-
-        factory.save(context, andWait: true, withCompletionBlock: nil)
-
-        XCTAssertFalse(context.performCalled)
-        XCTAssertTrue(context.performAndWaitCalled)
-    }
-
-    func test_save_givenDeprecatedConcurrencyType_shouldNotCallPerform() {
-        /// creates a context with `.confinementConcurrencyType`. The enum is created from its raw value
-        /// to prevent Xcode from complaining since the enum value is deprecated.
-        let context = makeMockContext(concurrencyType: NSManagedObjectContextConcurrencyType(rawValue: 0)!)
-
-        factory.save(context, andWait: false, withCompletionBlock: nil)
-
-        XCTAssertFalse(context.performCalled)
-        XCTAssertFalse(context.performAndWaitCalled)
-    }
-}
-
-// MARK: - Private Helpers
-
-private extension ContainerContextFactoryTests {
-
-    class MockManagedObjectContext: NSManagedObjectContext {
-
-        var performCalled = false
-        var performAndWaitCalled = false
-
-        override func perform(_ block: @escaping () -> Void) {
-            performCalled = true
+    override func setUpWithError() throws {
+        let fileManager = FileManager.default
+        if fileManager.fileExists(at: storeURL) {
+            try fileManager.removeItem(at: storeURL)
         }
-
-        override func performAndWait(_ block: () -> Void) {
-            performAndWaitCalled = true
+        if fileManager.fileExists(at: backupURL) {
+            try fileManager.removeItem(at: backupURL)
         }
 
-        override func save() throws {
-            // do nothing. let's make sure nothing gets saved.
-        }
+        coreDataStack = ContextManager(modelName: ContextManagerModelNameCurrent, store: storeURL)
     }
 
-    /// Creates an "in-memory" NSPersistentContainer.
-    /// This follows the approach used in WWDC'18: https://developer.apple.com/videos/play/wwdc2018/224/
-    ///
-    /// - Returns: An instance of NSPersistentContainer that stores data in memory.
-    func makeInMemoryContainer() -> NSPersistentContainer {
-        let container = NSPersistentContainer(name: "WordPress")
-        let description = NSPersistentStoreDescription(url: .init(fileURLWithPath: "/dev/null"))
-        container.persistentStoreDescriptions = [description]
-
-        return container
-    }
+    func testBackupReaderPost() {
+        coreDataStack.performAndSave { context in
+            let post: ReaderPost = ReaderPostBuilder(context).build()
+            let card = ReaderCard(context: context)
+            card.post = post
+            post.content = "test post"
+            post.card = [card]
+        }
 
-    func makeMockContext(concurrencyType: NSManagedObjectContextConcurrencyType) -> MockManagedObjectContext {
-        return MockManagedObjectContext(concurrencyType: concurrencyType)
+        let migrator = DataMigrator(coreDataStack: coreDataStack, backupLocation: backupURL)
+        waitUntil { done in
+            migrator.exportData { result in
+                XCTAssertNoThrow {
+                    try result.get()
+                }
+                done()
+            }
+        }
     }
 
 }