Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
A variant of XCTKVOExpectation that works with native Swift key paths. To try it out, paste the code into an Xcode playground and observe the unit test output in the console. Based on Ole's blog post at https://oleb.net/blog/2018/02/xctkvoexpectation-swift-keypaths/, with a fix in the case that the condition on the expectation is already fulfilled.
import XCTest
/// An expectation that is fulfilled when a Key Value Observing (KVO) condition
/// is met. It's variant of `XCTKVOExpectation` with support for native Swift
/// key paths.
final class KVOExpectation: XCTestExpectation {
private var kvoToken: NSKeyValueObservation?
/// Creates an expectation that is fulfilled when a KVO change causes the
/// specified key path of the observed object to have an expected value.
///
/// - Parameter objectToObserve: The object to observe.
/// - Parameter keyPath: The key path to observe.
/// - Parameter expectedValue: The expected value for the observed key path.
///
/// This initializer sets up KVO observation for keyPath with the
/// `NSKeyValueObservingOptions.initial` option set. This means that the
/// observed key path will be checked immediately after initialization.
convenience init<Object: NSObject, Value: Equatable>(
object objectToObserve: Object, keyPath: KeyPath<Object, Value>,
expectedValue: Value, file: StaticString = #file, line: Int = #line)
{
self.init(object: objectToObserve, keyPath: keyPath, options: .initial) { (obj, change) -> Bool in
return obj[keyPath: keyPath] == expectedValue
}
}
/// Creates an expectation that is fulfilled by a KVO change for which the
/// provided handler returns `true`.
///
/// - Parameter objectToObserve: The object to observe.
/// - Parameter keyPath: The key path to observe.
/// - Parameter options: KVO options to be used for the observation.
/// The default value is `[]`.
/// - Parameter handler: An optional handler block that will be invoked for
/// every KVO event. Return `true` to signal that the expectation should
/// be fulfilled. If you pass `nil` (the default value), the expectation
/// will be fulfilled by the first KVO event.
///
/// When changes to the value are detected, the handler block is called to
/// assess the new value to see if the expectation has been fulfilled. Every
/// KVO event will run the handler block until it either returns `true` (to
/// fulfill the expectation), or the wait times out.
init<Object: NSObject, Value>(
object objectToObserve: Object, keyPath: KeyPath<Object, Value>,
options: NSKeyValueObservingOptions = [],
file: StaticString = #file, line: Int = #line,
handler: ((Object, NSKeyValueObservedChange<Value>) -> Bool)? = nil)
{
super.init(description: KVOExpectation.description(forObject: objectToObserve, keyPath: keyPath, file: file, line: line))
var observedImmediately = false
kvoToken = objectToObserve.observe(keyPath, options: options) { (object, change) in
let isFulfilled = handler == nil || handler?(object, change) == true
if isFulfilled {
if self.kvoToken != nil {
self.clearToken()
} else {
observedImmediately = true
}
}
}
if observedImmediately {
self.clearToken()
}
}
func clearToken() {
self.kvoToken = nil
self.fulfill()
}
fileprivate static func description<Object: NSObject, Value>(forObject object: Object, keyPath: KeyPath<Object, Value>, file: StaticString, line: Int) -> String {
return "\(file):\(line) – KVO expectation – object: \(object) – keyPath: \(keyPath)"
}
}
extension XCTestCase {
/// Creates an expectation that is fulfilled when a KVO change causes the
/// specified key path of the observed object to have an expected value.
///
/// - Parameter objectToObserve: The object to observe.
/// - Parameter keyPath: The key path to observe.
/// - Parameter expectedValue: The expected value for the observed key path.
///
/// This initializer sets up KVO observation for keyPath with the
/// `NSKeyValueObservingOptions.initial` option set. This means that the
/// observed key path will be checked immediately after initialization.
@discardableResult
func keyValueObservingExpectation<Object: NSObject, Value: Equatable>(
for objectToObserve: Object, keyPath: KeyPath<Object, Value>,
expectedValue: Value, file: StaticString = #file, line: Int = #line)
-> XCTestExpectation
{
return keyValueObservingExpectation(for: objectToObserve, keyPath: keyPath, options: [.initial]) { (obj, change) -> Bool in
return obj[keyPath: keyPath] == expectedValue
}
}
/// Creates an expectation that is fulfilled by a KVO change for which the
/// provided handler returns `true`.
///
/// - Parameter objectToObserve: The object to observe.
/// - Parameter keyPath: The key path to observe.
/// - Parameter options: KVO options to be used for the observation.
/// The default value is `[]`.
/// - Parameter handler: An optional handler block that will be invoked for
/// every KVO event. Return `true` to signal that the expectation should
/// be fulfilled. If you pass `nil` (the default value), the expectation
/// will be fulfilled by the first KVO event.
///
/// When changes to the value are detected, the handler block is called to
/// assess the new value to see if the expectation has been fulfilled. Every
/// KVO event will run the handler block until it either returns `true` (to
/// fulfill the expectation), or the wait times out.
@discardableResult
func keyValueObservingExpectation<Object: NSObject, Value>(
for objectToObserve: Object, keyPath: KeyPath<Object, Value>,
options: NSKeyValueObservingOptions = [],
file: StaticString = #file, line: Int = #line,
handler: ((Object, NSKeyValueObservedChange<Value>) -> Bool)? = nil)
-> XCTestExpectation
{
let wrapper = expectation(description: KVOExpectation.description(forObject: objectToObserve, keyPath: keyPath, file: file, line: line))
// Following XCTest precedent, which sets `assertForOverFulfill` to true by default
// for expectations created with `XCTestCase` convenience methods.
wrapper.assertForOverFulfill = true
// The KVO handler inside KVOExpectation retains its parent object while the observation is active.
// That's why we can get away with not retaining the KVOExpectation here.
_ = KVOExpectation(object: objectToObserve, keyPath: keyPath, options: options) { (object, change) in
let isFulfilled = handler == nil || handler?(object, change) == true
if isFulfilled {
wrapper.fulfill()
return true
} else {
return false
}
}
return wrapper
}
}
class KVOExpectationTests: XCTestCase {
func test_settingProperty_fulfillsExpectation() {
let kvoObject = KVOAbleNSObject()
let sut = KVOExpectation(object: kvoObject, keyPath: \.intValue) { (obj, change) -> Bool in
return obj.intValue == 10
}
kvoObject.intValue = 10
wait(for: [sut], timeout: 1)
}
func test_doesNotFulfill_unlessPredicateIsTrue() {
let kvoObject = KVOAbleNSObject()
let first = KVOExpectation(object: kvoObject, keyPath: \.intValue) { (obj, change) -> Bool in
return obj.intValue == 20
}
first.isInverted = true
let second = KVOExpectation(object: kvoObject, keyPath: \.intValue) { (obj, change) -> Bool in
return obj.intValue == 20
}
kvoObject.intValue = 10
wait(for: [first], timeout: 1)
kvoObject.intValue = 20
wait(for: [second], timeout: 1)
}
func test_fulfillingWithInitialValue_requiresInitialKVOOption() {
let kvoTarget = KVOAbleNSObject()
kvoTarget.intValue = 10
let expectWithoutInitial = KVOExpectation(object: kvoTarget, keyPath: \.intValue, options: []) { (obj, change) -> Bool in
return obj.intValue == 10
}
expectWithoutInitial.isInverted = true
let expectWithInitial = KVOExpectation(object: kvoTarget, keyPath: \.intValue, options: .initial) { (obj, change) -> Bool in
return obj.intValue == 10
}
wait(for: [expectWithoutInitial, expectWithInitial], timeout: 1)
}
func test_nilHandler_fulfillsOnFirstKVOEvent() {
let kvoObject = KVOAbleNSObject()
let sut = KVOExpectation(object: kvoObject, keyPath: \.intValue)
kvoObject.intValue = 30
wait(for: [sut], timeout: 1)
}
func test_comparesAgainstExpectedValue() {
let kvoObject = KVOAbleNSObject()
let first = KVOExpectation(object: kvoObject, keyPath: \.intValue, expectedValue: 20)
first.isInverted = true
let second = KVOExpectation(object: kvoObject, keyPath: \.intValue, expectedValue: 20)
kvoObject.intValue = 10
wait(for: [first], timeout: 1)
kvoObject.intValue = 20
wait(for: [second], timeout: 1)
}
func test_expectedValueIsComparedImmediatelyOnInit() {
let kvoObject = KVOAbleNSObject()
kvoObject.intValue = 10
let sut = KVOExpectation(object: kvoObject, keyPath: \.intValue, expectedValue: 10)
wait(for: [sut], timeout: 1)
}
func test_fulfillsExpectationJustOnce() {
let kvoObject = KVOAbleNSObject()
let sut = KVOExpectation(object: kvoObject, keyPath: \.intValue)
sut.expectedFulfillmentCount = 1
sut.assertForOverFulfill = true
kvoObject.intValue = 10
kvoObject.intValue = 20
kvoObject.intValue = 30
wait(for: [sut], timeout: 1)
}
func test_supportsXCTestCaseConvenienceAPI() {
let kvoObject = KVOAbleNSObject()
keyValueObservingExpectation(for: kvoObject, keyPath: \.intValue) { (obj, change) in
return obj.intValue == 10
}
kvoObject.intValue = 10
waitForExpectations(timeout: 1)
}
func test_XCTestCaseConvenienceAPI_onlyFiresWhenPredicateIsTrue() {
let kvoObject = KVOAbleNSObject()
let sut = keyValueObservingExpectation(for: kvoObject, keyPath: \.intValue) { (obj, change) in
return obj.intValue == 20
}
sut.isInverted = true
kvoObject.intValue = 10
waitForExpectations(timeout: 1)
}
func test_supportsXCTestCaseConvenienceAPIWithExpectedValue() {
let kvoObject = KVOAbleNSObject()
let first = keyValueObservingExpectation(for: kvoObject, keyPath: \.intValue, expectedValue: 20)
first.isInverted = true
kvoObject.intValue = 10
waitForExpectations(timeout: 1)
keyValueObservingExpectation(for: kvoObject, keyPath: \.intValue, expectedValue: 20)
kvoObject.intValue = 20
waitForExpectations(timeout: 1)
}
}
private final class KVOAbleNSObject: NSObject {
@objc dynamic var intValue: Int = 0
}
KVOExpectationTests.defaultTestSuite.run()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.