🚣🏽 🐺 🌤️ Single source of truth (SSOT) on MVVM with RxSwift & CoreData 👩🏽‍🤝‍👨🏼 🍑 👩🏽‍🏫

Often the following functionality needs to be implemented in a mobile application:

Make an asynchronous request
Bind the result in the main thread to different views
If necessary, update the database on the device asynchronously in a background thread
If errors occur while performing these operations, then show a notification
Comply with the SSOT principle for data relevance
Test it all

Solving this problem is greatly simplified by the architectural approach of MVVM and the RxSwift and CoreData frameworks .

The approach described below uses reactive programming principles and is not exclusively tied to RxSwift and CoreData . And, if desired, can be implemented using other tools.

As an example, I will take a snippet of an application that displays seller data. The controller has two UILabel outlets for the phone number and address, and one UIButton for calling this phone number. ContactsViewController .

Let me explain the implementation from model to view.

Model

Fragment of auto-generated file SellerContacts + CoreDataProperties from DerivedSources

with attributes:

extension SellerContacts {

    @nonobjc public class func fetchRequest() -> NSFetchRequest<SellerContacts> {
        return NSFetchRequest<SellerContacts>(entityName: "SellerContacts")
    }

    @NSManaged public var address: String?
    @NSManaged public var order: Int16
    @NSManaged public var phone: String?

}

Repository .

Method providing seller data:

func sellerContacts() -> Observable<Event<[SellerContacts]>> {
        // 1
        Observable.merge([
            // 2
            context.rx.entities(fetchRequest: SellerContacts.fetchRequestWithSort()).materialize(),
            // 3
            updater.sync()
        ])
    }

This is where SSOT is implemented . A request is made to CoreData , and CoreData is updated as needed. All data is received ONLY from the database, and updater.sync () can only generate an Event with an error, but NOT with data.

Using the merge operator allows us to achieve asynchronous execution of a query to the database and its updating.
For the convenience of building a query to the database, RxCoreData is used
Updating the database

Because an asynchronous approach of receiving and updating data is used, you must use Observable <Event <... >> . This is necessary so that the subscriber does not receive an Error when receiving an error while receiving remote data, but only shows this error and continues to respond to changes in CoreData . More on this later.

DatabaseUpdater

In the sample application, remote data is retrieved from Firebase Remote Config . CoreData is only updated if fetchAndActivate () exits with a .successFetchedFromRemote status .

But you can use any other update restrictions, for example, by time.

Sync () method to update the database:

func sync<T>() -> Observable<Event<T>> {
        // 1
        // Check can fetch
        if fetchLimiter.fetchInProcess {
            return Observable.empty()
        }
        // 2
        // Block fetch for other requests
        fetchLimiter.fetchInProcess = true
        // 3
        // Fetch & activate remote config
        return remoteConfig.rx.fetchAndActivate().flatMap { [weak self] status, error -> Observable<Event<T>> in
            // 4
            // Default result
            var result = Observable<Event<T>>.empty()
            // Update database only when config wethed from remote
            switch status {
            // 5
            case .error:
                let error = error ?? AppError.unknown
                print("Remote config fetch error: \(error.localizedDescription)")
                // Set error to result
                result = Observable.just(Event.error(error))
            // 6
            case .successFetchedFromRemote:
                print("Remote config fetched data from remote")
                // Update database from remote config
                try self?.update()
            case .successUsingPreFetchedData:
                print("Remote config using prefetched data")
            @unknown default:
                print("Remote config unknown status")
            }
            // 7
            // Unblock fetch for other requests
            self?.fetchLimiter.fetchInProcess = false
            return result
        }
    }

, . , sync(). fetchLimiter . , fetchInProcess .
Event

ViewModel

In this example, the ViewModel simply calls the sellerContacts () methodfrom the Repository and returns the result.

func contacts() -> Observable<Event<[SellerContacts]>> {
        repository.sellerContacts()
    }

ViewController

In the controller, you need to bind the query result to the fields. To do this, the bindContacts () method is called in viewDidLoad () :

private func bindContacts() {
        // 1
        viewModel?.contacts()
            .subscribeOn(SerialDispatchQueueScheduler.init(qos: .userInteractive))
            .observeOn(MainScheduler.instance)
             // 2
            .flatMapError { [weak self] in
                self?.rx.showMessage($0.localizedDescription) ?? Observable.empty()
            }
             // 3
            .compactMap { $0.first }
             // 4
            .subscribe(onNext: { [weak self] in
                self?.phone.text = $0.phone
                self?.address.text = $0.address
            }).disposed(by: disposeBag)
    }

We execute a request for contacts in the background thread, and with the resulting result we work in the main
If an element containing an Event arrives with an error, then an error message is shown and an empty sequence is returned. More details about flatMapError and showMessage operator below
Using the compactMap operator to get contacts from an array
Setting data to outlets

Operator .flatMapError ()

To convert the result of a sequence from Event to an element it contains or to display an error, use the operator:

func flatMapError<T>(_ handler: ((_ error: Error) -> Observable<T>)? = nil) -> Observable<Element.Element> {
        // 1
        flatMap { element -> Observable<Element.Element> in
            switch element.event {
            // 2
            case .error(let error):
                return handler?(error).flatMap { _ in Observable<Element.Element>.empty() } ?? Observable.empty()
            // 3
            case .next(let element):
                return Observable.just(element)
            // 4
            default:
                return Observable.empty()
            }
        }
    }

Convert a sequence from Event.Element to Element
If the Event contains an error, then we return the handler converted to an empty sequence
If Event contains a result, then return a sequence with one element containing this result.
An empty sequence is returned by default

This approach allows you to handle query execution errors without sending an Error Event to the subscriber. And monitoring the change in the database remains active.

Operator .showMessage ()

To show messages to the user, use the operator:

public func showMessage(_ text: String, withEvent: Bool = false) -> Observable<Void> {
        // 1
        let _alert = alert(title: nil,
              message: text,
              actions: [AlertAction(title: "OK", style: .default)]
        // 2
        ).map { _ in () }
        // 3
        return withEvent ? _alert : _alert.flatMap { Observable.empty() }
    }

With RxAlert window is created with a message and a single button
The result is converted to Void
If an event is needed after showing the message, then we return the result. Otherwise, we first convert it to an empty sequence and then return

Because .showMessage () can be used not only to show error notifications, it is useful to be able to adjust whether the sequence is empty or with an event.

Tests

Everything described above is not difficult to test. Let's start in order of presentation.

RepositoryTests DatabaseUpdaterMock is

used to test the repository . There it is possible to track whether the sync () method was called and set the result of its execution:

func testSellerContacts() throws {
        // 1
        // Success
        // Check sequence contains only one element
        XCTAssertThrowsError(try repository.sellerContacts().take(2).toBlocking(timeout: 1).toArray())
        updater.isSync = false
        // Check that element
        var result = try repository.sellerContacts().toBlocking().first()?.element
        XCTAssertTrue(updater.isSync)
        XCTAssertEqual(result?.count, sellerContacts.count)

        // 2
        // Sync error
        updater.isSync = false
        updater.error = AppError.unknown
        let resultArray = try repository.sellerContacts().take(2).toBlocking().toArray()
        XCTAssertTrue(resultArray.contains { $0.error?.localizedDescription == AppError.unknown.localizedDescription })
        XCTAssertTrue(updater.isSync)
        result = resultArray.first { $0.error == nil }?.element
        XCTAssertEqual(result?.count, sellerContacts.count)
    }

We check that the sequence contains only one element, the sync () method is called
We check that the sequence contains two elements. One contains an Event with an error, the other the result of a query from the database, the sync () method is called

DatabaseUpdaterTests

testSync ()

func testSync() throws {
        let remoteConfig = RemoteConfigMock()
        let fetchLimiter = FetchLimiter(serialQueue: DispatchQueue(label: "test"))
        let databaseUpdater = DatabaseUpdaterImpl(remoteConfig: remoteConfig, decoder: JSONDecoderMock(), context: context, fetchLimiter: fetchLimiter)
        // 1
        // Not update. Fetch in process
        fetchLimiter.fetchInProcess = true
        XCTAssertFalse(remoteConfig.isFetchAndActivate)
        XCTAssertFalse(remoteConfig.isSubscript)
        
        expectation(forNotification: .NSManagedObjectContextDidSave, object: context)
            .isInverted = true
    
        var sync: Observable<Event<Void>> = databaseUpdater.sync()
        XCTAssertNil(try sync.toBlocking().first())
        XCTAssertFalse(remoteConfig.isFetchAndActivate)
        XCTAssertFalse(remoteConfig.isSubscript)
        XCTAssertTrue(fetchLimiter.fetchInProcess)
        
        waitForExpectations(timeout: 1)
        // 2
        // Not update. successUsingPreFetchedData
        fetchLimiter.fetchInProcess = false
        
        expectation(forNotification: .NSManagedObjectContextDidSave, object: context)
            .isInverted = true
        
        sync = databaseUpdater.sync()
        var result: Event<Void>?
        sync.subscribe(onNext: { result = $0 }).disposed(by: disposeBag)
        XCTAssertTrue(fetchLimiter.fetchInProcess)
        remoteConfig.completionHandler?(RemoteConfigFetchAndActivateStatus.successUsingPreFetchedData, nil)
        
        waitForExpectations(timeout: 1)
        XCTAssertNil(result)
        XCTAssertTrue(remoteConfig.isFetchAndActivate)
        XCTAssertFalse(remoteConfig.isSubscript)
        XCTAssertFalse(fetchLimiter.fetchInProcess)
        // 3
        // Not update. Error
        fetchLimiter.fetchInProcess = false
        remoteConfig.isFetchAndActivate = false
        
        expectation(forNotification: .NSManagedObjectContextDidSave, object: context)
            .isInverted = true
        sync = databaseUpdater.sync()
        sync.subscribe(onNext: { result = $0 }).disposed(by: disposeBag)
        XCTAssertTrue(fetchLimiter.fetchInProcess)
        remoteConfig.completionHandler?(RemoteConfigFetchAndActivateStatus.error, AppError.unknown)
        
        waitForExpectations(timeout: 1)
        
        XCTAssertEqual(result?.error?.localizedDescription, AppError.unknown.localizedDescription)
        XCTAssertTrue(remoteConfig.isFetchAndActivate)
        XCTAssertFalse(remoteConfig.isSubscript)
        XCTAssertFalse(fetchLimiter.fetchInProcess)
        // 4
        // Update
        fetchLimiter.fetchInProcess = false
        remoteConfig.isFetchAndActivate = false
        result = nil
        
        expectation(forNotification: .NSManagedObjectContextDidSave, object: context)
        
        sync = databaseUpdater.sync()
        sync.subscribe(onNext: { result = $0 }).disposed(by: disposeBag)
        XCTAssertTrue(fetchLimiter.fetchInProcess)
        remoteConfig.completionHandler?(RemoteConfigFetchAndActivateStatus.successFetchedFromRemote, nil)
        
        waitForExpectations(timeout: 1)
        
        XCTAssertNil(result)
        XCTAssertTrue(remoteConfig.isFetchAndActivate)
        XCTAssertTrue(remoteConfig.isSubscript)
        XCTAssertFalse(fetchLimiter.fetchInProcess)
    }

An empty sequence is returned if an update is in progress
An empty sequence is returned if no data has been received
An Event is returned with an error
An empty sequence is returned if the data has been updated

ViewModelTests

ViewControllerTests

testBindContacts ()

func testBindContacts() {
        // 1
        // Error. Show message
        XCTAssertNotEqual(controller.phone.text, contacts.phone)
        XCTAssertNotEqual(controller.address.text, contacts.address)
        viewModel.contactsResult.accept(Event.error(AppError.unknown))
        
        expectation(description: "wait 1 second").isInverted = true
        waitForExpectations(timeout: 1)
        // 2
        XCTAssertNotNil(controller.presentedViewController)
        let alertController = controller.presentedViewController as! UIAlertController
        XCTAssertEqual(alertController.actions.count, 1)
        XCTAssertEqual(alertController.actions.first?.style, .default)
        XCTAssertEqual(alertController.actions.first?.title, "OK")
        XCTAssertNotEqual(controller.phone.text, contacts.phone)
        XCTAssertNotEqual(controller.address.text, contacts.address)
        // 3
        // Trigger action OK
        let action = alertController.actions.first!
        typealias AlertHandler = @convention(block) (UIAlertAction) -> Void
        let block = action.value(forKey: "handler")
        let blockPtr = UnsafeRawPointer(Unmanaged<AnyObject>.passUnretained(block as AnyObject).toOpaque())
        let handler = unsafeBitCast(blockPtr, to: AlertHandler.self)
        handler(action)
        
        expectation(description: "wait 1 second").isInverted = true
        waitForExpectations(timeout: 1)
        // 4
        XCTAssertNil(controller.presentedViewController)
        XCTAssertNotEqual(controller.phone.text, contacts.phone)
        XCTAssertNotEqual(controller.address.text, contacts.address)
        // 5
        // Empty array of contats
        viewModel.contactsResult.accept(Event.next([]))
        
        expectation(description: "wait 1 second").isInverted = true
        waitForExpectations(timeout: 1)
        
        XCTAssertNil(controller.presentedViewController)
        XCTAssertNotEqual(controller.phone.text, contacts.phone)
        XCTAssertNotEqual(controller.address.text, contacts.address)
        // 6
        // Success
        viewModel.contactsResult.accept(Event.next([contacts]))
        
        expectation(description: "wait 1 second").isInverted = true
        waitForExpectations(timeout: 1)
        
        XCTAssertNil(controller.presentedViewController)
        XCTAssertEqual(controller.phone.text, contacts.phone)
        XCTAssertEqual(controller.address.text, contacts.address)
    }

Show error message
Check that controller.presentedViewController has an error message
Run a handler for the Ok button and make sure that the message box is hidden
For an empty result, no error is shown and no fields are filled
For a successful request, no error is shown and the fields are filled

Operator tests

.flatMapError ()

.showMessage ()

Using a similar design approach, we implement asynchronous data fetch, update, and error notification without losing the ability to respond to data changes, following the SSOT principle .

Single source of truth (SSOT) on MVVM with RxSwift & CoreData

Model

Tests

Operator tests

More articles: