Testing Core Data in iOS: In-Memory Stores and Testable Architecture

Testing Core Data in iOS: In-Memory Stores and Testable Architecture

Core Data is notoriously hard to test: it requires a persistent store, managed object contexts, and careful lifecycle management. The solution is an in-memory NSPersistentStore that gives you a full Core Data stack with zero disk I/O, fast setup, and automatic cleanup when the test ends.

In-Memory Core Data Stack

// CoreDataStack.swift
import CoreData

class CoreDataStack {
    let container: NSPersistentContainer
    
    var viewContext: NSManagedObjectContext {
        container.viewContext
    }
    
    init(modelName: String = "MyApp", inMemory: Bool = false) {
        container = NSPersistentContainer(name: modelName)
        
        if inMemory {
            let description = NSPersistentStoreDescription()
            description.type = NSInMemoryStoreType
            container.persistentStoreDescriptions = [description]
        }
        
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Core Data failed to load: \(error)")
            }
        }
        
        container.viewContext.automaticallyMergesChangesFromParent = true
    }
    
    func newBackgroundContext() -> NSManagedObjectContext {
        container.newBackgroundContext()
    }
    
    func saveContext(_ context: NSManagedObjectContext) throws {
        if context.hasChanges {
            try context.save()
        }
    }
}

Test Fixture Setup

// CoreDataTestCase.swift
import XCTest
import CoreData
@testable import MyApp

class CoreDataTestCase: XCTestCase {
    var stack: CoreDataStack!
    var context: NSManagedObjectContext!
    
    override func setUpWithError() throws {
        stack = CoreDataStack(inMemory: true)
        context = stack.viewContext
    }
    
    override func tearDownWithError() throws {
        context = nil
        stack = nil
    }
    
    // Helper to create a User entity
    @discardableResult
    func makeUser(
        id: String = UUID().uuidString,
        name: String = "Test User",
        email: String = "test@example.com"
    ) -> UserEntity {
        let user = UserEntity(context: context)
        user.id = id
        user.name = name
        user.email = email
        user.createdAt = Date()
        return user
    }
    
    func save() throws {
        try stack.saveContext(context)
    }
}

Testing CRUD Operations

// UserRepositoryTests.swift
class UserRepositoryTests: CoreDataTestCase {
    var sut: UserRepository!
    
    override func setUpWithError() throws {
        try super.setUpWithError()
        sut = UserRepository(context: context)
    }
    
    func testCreateUserPersistsToStore() throws {
        let user = try sut.createUser(
            id: "user-1",
            name: "Alice",
            email: "alice@example.com"
        )
        try save()
        
        XCTAssertEqual(user.id, "user-1")
        XCTAssertEqual(user.name, "Alice")
        
        // Verify in store via fetch
        let fetchRequest: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
        fetchRequest.predicate = NSPredicate(format: "id == %@", "user-1")
        let results = try context.fetch(fetchRequest)
        
        XCTAssertEqual(results.count, 1)
        XCTAssertEqual(results.first?.email, "alice@example.com")
    }
    
    func testFetchUserByIdReturnsCorrectUser() throws {
        makeUser(id: "user-1", name: "Alice")
        makeUser(id: "user-2", name: "Bob")
        try save()
        
        let user = try sut.fetchUser(id: "user-1")
        
        XCTAssertNotNil(user)
        XCTAssertEqual(user?.name, "Alice")
    }
    
    func testFetchUserByIdReturnsNilForMissingUser() throws {
        let user = try sut.fetchUser(id: "nonexistent")
        XCTAssertNil(user)
    }
    
    func testUpdateUserPersistsChanges() throws {
        makeUser(id: "user-1", name: "Alice")
        try save()
        
        try sut.updateUser(id: "user-1", name: "Alice Updated")
        try save()
        
        let updated = try sut.fetchUser(id: "user-1")
        XCTAssertEqual(updated?.name, "Alice Updated")
    }
    
    func testDeleteUserRemovesFromStore() throws {
        makeUser(id: "user-1")
        makeUser(id: "user-2")
        try save()
        
        try sut.deleteUser(id: "user-1")
        try save()
        
        let user1 = try sut.fetchUser(id: "user-1")
        let user2 = try sut.fetchUser(id: "user-2")
        
        XCTAssertNil(user1)
        XCTAssertNotNil(user2)  // Other user unaffected
    }
    
    func testFetchAllUsersReturnsSortedByName() throws {
        makeUser(id: "3", name: "Carol")
        makeUser(id: "1", name: "Alice")
        makeUser(id: "2", name: "Bob")
        try save()
        
        let users = try sut.fetchAllUsers(sortedBy: .name)
        
        XCTAssertEqual(users.count, 3)
        XCTAssertEqual(users[0].name, "Alice")
        XCTAssertEqual(users[1].name, "Bob")
        XCTAssertEqual(users[2].name, "Carol")
    }
}

Testing Relationships

func testOrderBelongsToUser() throws {
    let user = makeUser(id: "user-1", name: "Alice")
    
    let order = OrderEntity(context: context)
    order.id = "order-1"
    order.total = 99.99
    order.user = user
    
    try save()
    
    // Fetch fresh from store
    let fetchedUser = try sut.fetchUser(id: "user-1")
    
    XCTAssertEqual(fetchedUser?.orders?.count, 1)
    XCTAssertEqual(
        (fetchedUser?.orders?.anyObject() as? OrderEntity)?.id,
        "order-1"
    )
}

func testDeleteUserCascadesToOrders() throws {
    let user = makeUser(id: "user-1")
    
    let order1 = OrderEntity(context: context)
    order1.id = "order-1"
    order1.user = user
    
    let order2 = OrderEntity(context: context)
    order2.id = "order-2"
    order2.user = user
    
    try save()
    
    // Verify cascade delete is configured in model
    context.delete(user)
    try save()
    
    let orderFetch: NSFetchRequest<OrderEntity> = OrderEntity.fetchRequest()
    let orphanOrders = try context.fetch(orderFetch)
    
    XCTAssertEqual(orphanOrders.count, 0, "Orders should be cascade-deleted with user")
}

Testing Fetch Request Predicates

func testFetchUsersWithActiveSubscription() throws {
    makeUser(id: "1", name: "Alice").subscriptionStatus = "active"
    makeUser(id: "2", name: "Bob").subscriptionStatus = "cancelled"
    makeUser(id: "3", name: "Carol").subscriptionStatus = "active"
    try save()
    
    let activeUsers = try sut.fetchUsers(withSubscriptionStatus: "active")
    
    XCTAssertEqual(activeUsers.count, 2)
    let names = activeUsers.map { $0.name }.sorted()
    XCTAssertEqual(names, ["Alice", "Carol"])
}

func testFetchRecentOrdersInDateRange() throws {
    let formatter = ISO8601DateFormatter()
    
    let oldOrder = OrderEntity(context: context)
    oldOrder.id = "old"
    oldOrder.createdAt = formatter.date(from: "2023-01-01T00:00:00Z")
    
    let recentOrder = OrderEntity(context: context)
    recentOrder.id = "recent"
    recentOrder.createdAt = formatter.date(from: "2024-06-01T00:00:00Z")
    
    try save()
    
    let startDate = formatter.date(from: "2024-01-01T00:00:00Z")!
    let orders = try sut.fetchOrders(since: startDate)
    
    XCTAssertEqual(orders.count, 1)
    XCTAssertEqual(orders.first?.id, "recent")
}

Testing Background Context Operations

func testBatchImportCreatesAllRecords() async throws {
    let userDataList = (1...100).map {
        UserData(id: "user-\($0)", name: "User \($0)", email: "user\($0)@test.com")
    }
    
    try await sut.batchImport(users: userDataList)
    
    let fetchRequest: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
    let count = try context.count(for: fetchRequest)
    
    XCTAssertEqual(count, 100)
}

func testBackgroundSaveVisibleOnMainContext() async throws {
    let backgroundContext = stack.newBackgroundContext()
    
    await backgroundContext.perform {
        let user = UserEntity(context: backgroundContext)
        user.id = "bg-user"
        user.name = "Background User"
        try? backgroundContext.save()
    }
    
    // With automaticallyMergesChangesFromParent = true,
    // main context should see the new record
    context.refreshAllObjects()
    
    let fetchRequest: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
    fetchRequest.predicate = NSPredicate(format: "id == %@", "bg-user")
    let results = try context.fetch(fetchRequest)
    
    XCTAssertEqual(results.count, 1)
    XCTAssertEqual(results.first?.name, "Background User")
}

Testing NSFetchedResultsController

class FetchedResultsTests: CoreDataTestCase {
    func testFetchedResultsControllerDetectsInsert() throws {
        let fetchRequest: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        
        let frc = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: context,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        
        try frc.performFetch()
        XCTAssertEqual(frc.fetchedObjects?.count, 0)
        
        makeUser(id: "1", name: "Alice")
        try save()
        
        XCTAssertEqual(frc.fetchedObjects?.count, 1)
        XCTAssertEqual(frc.fetchedObjects?.first?.name, "Alice")
    }
}

Testing Migrations

For lightweight migrations, verify the migrated store has the expected schema:

func testMigrationPreservesExistingData() throws {
    // Create a store with version 1 schema
    let v1Container = NSPersistentContainer(name: "MyApp")
    // Configure for v1...
    
    // Create test data in v1 format
    // ...
    
    // Perform migration to v2
    // ...
    
    // Verify data intact after migration
    let v2Container = NSPersistentContainer(name: "MyApp")
    // Load with new schema...
    
    let fetchRequest: NSFetchRequest<NSManagedObject> = NSFetchRequest(entityName: "User")
    let results = try v2Container.viewContext.fetch(fetchRequest)
    
    XCTAssertFalse(results.isEmpty, "Data should survive migration")
}

Common Mistakes

Mistake 1: Reusing context between tests Each test must get a fresh in-memory store. Reusing the context causes test pollution.

Mistake 2: Not saving before fetch assertions Core Data defers writes until save(). Always call try save() before asserting on fetch results.

Mistake 3: Forgetting to configure cascade delete rules Test delete behavior explicitly—it catches missing cascade rules before they cause orphan data in production.

Conclusion

In-memory Core Data stores give you a full persistent container that's fast, isolated, and auto-cleaned. The key patterns are: inherit from a CoreDataTestCase base class for consistent setup, always save() before asserting on fetched results, and test relationships and cascade behavior explicitly. These tests run in milliseconds and catch data model bugs that would otherwise surface only in production.

Read more

Start now free