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.