Testing code that uses Core Data - preventing inconsistent state - core-data

Question

My app uses Core Data for persistence and I have been writing unit tests to check that view models that touch the persistence layer of the app behave as expected.
I am using an in-memory persistent store for test as recommended and the state of the store varies depending on the test I am performing. For example, in some instances I start with an empty store; in others I want to use a pre-populated store and then check the behaviour of the code that observes the store's state as it is mutated.
Although the "live" code is behaving as expected, I've had issues with the store not being in the expected state before the unit test runs and this would appear to be due to async optimisations of the stack. Changing the test order will influence which tests pass or fail and this certainly supports my suspicion that concurrency is causing the problem.
I can eliminate the errors by saving the view context after CRUD operations and wrapping this in a test expectation that waits for the NSManagedObjectContextDidSave notification thereby preventing concurrent operations. However, this makes me feel uncomfortable as it's not the way the code operates in the production app - saving the view context is expensive and so only happens when the app is terminated / pushed to background. As the tests do not accurately reflect what's happening in the live app, there's a chance that bugs could be missed despite apparent coverage.
I've been unable to find any solutions or recommendations about managing this problem in unit tests beyond using expectations. Is there a better solution?
Example tests - removing the 'executeAndWaitForSave' call in the second test method will cause the first test to fail - the MOC will contain more objects than expected:
class ParameterGridViewModelTests: XCTestCase {
var dependencies: AppDependencies?
var viewContext: NSManagedObjectContext?
var patient: Patient?
var parameter: Parameter?
override func setUp() {
dependencies = AppDependencies.emptyPersistentStore
viewContext = dependencies!.persistenceService.viewContext
patient = Patient.instanceForTest(using: dependencies!.persistenceService.viewContext)
parameter = Parameter.instanceForTest(using: dependencies!.persistenceService.viewContext)
}
override func tearDown() {
dependencies = nil
viewContext = nil
patient = nil
parameter = nil
}
func testEnvironmentPropertiesMatchExpectations() {
let persistenceService = dependencies!.persistenceService
XCTAssertEqual(persistenceService.count(for: Observation.fetchRequest()), 0, "There should be no Observation instances in store")
XCTAssertEqual(persistenceService.count(for: Parameter.fetchRequest()), 1, "There shouldn't be ONE Parameter instance in store")
}
func testObservationsPropertyIsUpdatedWhenAnObservationIsMade() {
// given
let sut = ParameterGridView.ViewModel(patient: patient!, dependencies: dependencies!)
let sutMirror = ParameterGridViewModelMirror(viewModel: sut)
// when
let numberOfObservations = 5
for _ in 1...numberOfObservations {
_ = Observation.create(
in: viewContext!,
patient: patient!,
parameter: parameter!,
numericValue: Double.random(in: 5...50)
)
}
// then
XCTAssertEqual(sutMirror.observations!.count, numberOfObservations, "Observations property of view model does not contain correct number of elements")
}
func testHistoricalObservationsEmptyWhenObservationTimeExceedsFourHoursInPast() {
// given
let sut = ParameterGridView.ViewModel(patient: patient!, dependencies: dependencies!)
// when
executeAndWaitForSave(managedObjectContext: viewContext!) {
let firstObservationTime = Date.now
.offset(.hour, direction: .past, value: 4)!
.offset(.minute, direction: .past, value: 10)!
let secondObservationTime = Date.now
.offset(.hour, direction: .past, value: 6)!
let observationOne = Observation(context: viewContext!)
observationOne.timestamp = firstObservationTime
observationOne.cd_Parameter = parameter!
observationOne.cd_Patient = patient!
observationOne.numericValue = 10
let observationTwo = Observation(context: viewContext!)
observationTwo.timestamp = secondObservationTime
observationTwo.cd_Parameter = parameter!
observationTwo.cd_Patient = patient!
observationTwo.numericValue = 100
}
// then
XCTAssertTrue(sut.lastObservation.isEmpty, "lastObservations should be empty")
XCTAssertTrue(sut.recentObservation.isEmpty, "recentObservation should be empty")
}
}
Helper function used to ensure synchronous mutation of Core Data stack:
extension XCTestCase {
/// Helper function to which attempts to mitigate test failures relating
/// to asynchronous Core Data operations leaving the MOC in an unpredictale
/// state.
/// Although saving the MOC is expensive in the production app and should only
/// occur when absolutely necessary, the associated notification can be used to
/// ensure the MOC in in the expected state before test execution proceeds
/// - Parameters:
/// - managedObjectContext: MOC to use for the operation
/// - block: code to be executed (typically creation, mutation or deletion of a MOM linked to the MOC)
func executeAndWaitForSave(managedObjectContext: NSManagedObjectContext, block: () -> Void) {
expectation(forNotification: .NSManagedObjectContextDidSave, object: managedObjectContext) { _ in
return true
}
block()
try! managedObjectContext.save()
waitForExpectations(timeout: 2.0) { error in
XCTAssertNil(error, "Save did not occur: \(error!.localizedDescription)")
}
}
}