How to mock NSUbiquitousKeyValueStore for unit testing?

Question

So I have a class I'm trying to unit test that uses both UserDefaults and NSUbiquitousKeyValueStore. I can easily mock UserDefaults using UserDefaults(suiteName: #file) (for example), but I can't figure out how to mock NSUbiquitousKeyValueStore. I can't seem to find any thread about it here on SO, and my google-fu is lacking.

Here's the beginning of my test class just for reference:

class ReviewTests: XCTestCase {

    private var userDefaults: UserDefaults = UserDefaults(suiteName: #file)!
    private var ubiquitousKeyValueStore: NSUbiquitousKeyValueStore = // How do I mock this?
    private var reviewPromptController: ReviewPromptController!

Answer 1

What I did to unit test my interactions with NSUbiquitousKeyValueStore was to create a protocol that my custom cloud-storage wrapper around NSUbiquitousKeyValueStore and NSUbiquitousKeyValueStore conform to. Those implementations are below:

protocol KeyValueStore: class {

    // MARK: Properties
    static var didChangeExternallyNotification: Notification.Name { get }

    // MARK: Reading
    func object(forKey aKey: String) -> Any?
    func string(forKey aKey: String) -> String?
    func array(forKey aKey: String) -> [Any]?
    func dictionary(forKey aKey: String) -> [String : Any]?
    func data(forKey aKey: String) -> Data?
    func longLong(forKey aKey: String) -> Int64
    func double(forKey aKey: String) -> Double
    func bool(forKey aKey: String) -> Bool

    // MARK: Writing

    func set(_ anObject: Any?, forKey aKey: String)
    func set(_ aString: String?, forKey aKey: String)
    func set(_ aData: Data?, forKey aKey: String)
    func set(_ anArray: [Any]?, forKey aKey: String)
    func set(_ aDictionary: [String : Any]?, forKey aKey: String)
    func set(_ value: Int64, forKey aKey: String)
    func set(_ value: Double, forKey aKey: String)
    func set(_ value: Bool, forKey aKey: String)
    func removeObject(forKey aKey: String)

}

KeyValueStore is a protocol, which contains method signatures that NSUbiquitousKeyValueStore has. By doing so, I can create a type that can be used in tests where an instance of NSUbiquitousKeyValueStore could be used.

Next, I conformed NSUbiquitousKeyValueStore to KeyValueStore. Nothing else needed to be done for NSUbiquitousKeyValueStore since it already implements the methods defined in KeyValueStore .

extension NSUbiquitousKeyValueStore: KeyValueStore { }

Then, I created a type that is a wrapper around NSUbiquitousKeyValueStore. UserSettingsStorage accepts any type that conforms to KeyValueStore. Since NSUbiquitousKeyValueStore and MockCloudKeyValueStore both conform to KeyValueStore, I can pass an instance of NSUbiquitousKeyValueStore in production and an instance of MockCloudKeyValueStore in tests.

class MockCloudKeyValueStore: KeyValueStore {

    // MARK: Properties

    // KeyValueStore
    static var didChangeExternallyNotification: Notification.Name = Notification.Name(NSUbiquitousKeyValueStore.didChangeExternallyNotification.rawValue)

    // Helpers
    private var arrays: [String: [Any]] = [:]
    private var bools: [String: Bool] = [:]
    private var datas: [String: Data] = [:]
    private var dictionaries: [String: [String: Any]] = [:]
    private var doubles: [String: Double] = [:]
    private var longLongs: [String: Int64] = [:]
    private var objects: [String: Any] = [:]
    private var strings: [String: String] = [:]

    // MARK: Reading
    func object(forKey aKey: String) -> Any? {
        objects[aKey]
    }

    func string(forKey aKey: String) -> String? {
        strings[aKey]
    }

    func array(forKey aKey: String) -> [Any]? {
        arrays[aKey]
    }

    func dictionary(forKey aKey: String) -> [String : Any]? {
        dictionaries[aKey]
    }

    func data(forKey aKey: String) -> Data? {
        datas[aKey]
    }

    func longLong(forKey aKey: String) -> Int64 {
        longLongs[aKey] ?? 0
    }

    func double(forKey aKey: String) -> Double {
        doubles[aKey] ?? 0
    }

    func bool(forKey aKey: String) -> Bool {
        bools[aKey] ?? false
    }

    // MARK: Writing

    func set(_ anObject: Any?, forKey aKey: String) {
        objects[aKey] = anObject
        postServerDidChangeNotification()
    }

    func set(_ aString: String?, forKey aKey: String) {
        strings[aKey] = aString
        postServerDidChangeNotification()
    }

    func set(_ aData: Data?, forKey aKey: String) {
        datas[aKey] = aData
        postServerDidChangeNotification()
    }

    func set(_ anArray: [Any]?, forKey aKey: String) {
        arrays[aKey] = anArray
        postServerDidChangeNotification()
    }

    func set(_ aDictionary: [String : Any]?, forKey aKey: String) {
        dictionaries[aKey] = aDictionary
        postServerDidChangeNotification()
    }

    func set(_ value: Int64, forKey aKey: String) {
        longLongs[aKey] = value
        postServerDidChangeNotification()
    }

    func set(_ value: Double, forKey aKey: String) {
        doubles[aKey] = value
        postServerDidChangeNotification()
    }

    func set(_ value: Bool, forKey aKey: String) {
        bools[aKey] = value
        postServerDidChangeNotification()
    }

    func removeObject(forKey aKey: String) {
        arrays[aKey] = nil
        bools[aKey] = nil
        datas[aKey] = nil
        dictionaries[aKey] = nil
        doubles[aKey] = nil
        longLongs[aKey] = nil
        objects[aKey] = nil
        strings[aKey] = nil
        postServerDidChangeNotification()
    }

    // MARK: Helpers

    private func postServerDidChangeNotification() {
        var userInfo = [AnyHashable : Any]()
        let changeReason = NSUbiquitousKeyValueStoreServerChange
        userInfo[NSUbiquitousKeyValueStoreChangeReasonKey] = changeReason
        NotificationCenter.default.post(name: Self.didChangeExternallyNotification, object: nil, userInfo: userInfo)
    }

}

class UserSettingsStorage: ObservableObject {

    // MARK: Properties

    private let cloudKeyValueStore: KeyValueStore

    private let notificationCenter: NotificationCenter

    @Published var selectedListName = ""

    // MARK: Initialization

    init(cloudKeyValueStore: KeyValueStore,
         notificationCenter: NotificationCenter = .default) {
        self.cloudKeyValueStore = cloudKeyValueStore
        self.notificationCenter = notificationCenter
        observeUbiquitousKeyValueStoreDidChangeExternallyNotification()
    }

    // MARK: Reading

    private func getSelectedListIndex() {
        selectedListName = cloudKeyValueStore.string(forKey: "selectedListIndexKey") ?? ""
    }

    // MARK: Writing

    // Cloud Key-Value Store

    func setSelectedList(name: String) {
        selectedListName = name
        cloudKeyValueStore.set(name, forKey: "selectedListIndexKey")
    }

    // MARK: Notification Observation

    private func observeUbiquitousKeyValueStoreDidChangeExternallyNotification(in center: NotificationCenter = .default) {
        center.addObserver(self,
                       selector: #selector(handleUbiquitousKeyValueStoreDidChangeExternallyNotification(notification:)),
                       name: NSUbiquitousKeyValueStore.didChangeExternallyNotification,
                       object: nil)
    }

    // MARK: Notification Selectors

    @objc private func handleUbiquitousKeyValueStoreDidChangeExternallyNotification(notification: Notification) {
        // Check for the reasons listed at https://developer.apple.com/documentation/foundation/nsubiquitouskeyvaluestore/1433687-change_reason_values to handle errors/blockers
        if let userInfo = notification.userInfo, let changeReason = userInfo[NSUbiquitousKeyValueStoreChangeReasonKey] as? NSNumber {
            switch changeReason.intValue {
            case NSUbiquitousKeyValueStoreServerChange:
                getSelectedListIndex()
            case NSUbiquitousKeyValueStoreInitialSyncChange:
                print("initial sync change")
            case NSUbiquitousKeyValueStoreQuotaViolationChange:
                print("quota violation change")
            case NSUbiquitousKeyValueStoreAccountChange:
                print("account change")
            default:
                print("unknown change")
            }
        } else {
            print("userInfo not available for Notification", notification)
        }
    }

}

Finally, I can use my mock in my unit tests, ensure that NSUbiquiousKeyValueStore.didChangeExternallyNotification is called from my mock, and then verify that my wrapper around NSUbiquitousKeyValueStore responds as expected to the notification.

class UnitTests: XCTestCase {

    // MARK: Properties

    var storage: UserSettingsStorage!

    // MARK: Lifecycle

    override func setUp() {
        super.setUp()
        storage = UserSettingsStorage(cloudKeyValueStore: MockCloudKeyValueStore())
    }

    override func tearDown() {
        storage = nil
        super.tearDown()
    }

    // MARK: Selected List Name

    func test_UserSettingsStorage_PublishesSelectedListName_WhenListNameIsSet() {
        let listName = "list name"
        let publishedExpectation = expectation(forNotification: NSUbiquitousKeyValueStore.didChangeExternallyNotification, object: nil) { notification in
            return self.storage.selectedListName == listName
        }
        storage.setSelectedList(name: listName)
        wait(for: [publishedExpectation], timeout: 2)
    }

}