In the past, I’ve talked about ways to easily write unit tests for Cocoa applications, including [tests for user interfaces using target-action][1] and [tests for interfaces using Cocoa bindings][2]. There are some strategies you can apply to make writing tests for Cocoa code even easier, though. They’re just straightforward object-oriented programming, but sometimes we can forget that all the techniques you might use in your main code base can also be applied to our test code.<\/p>\n
So here’s one trick that you can use in writing tests for Cocoa user interfaces, especially in ways that will make test-driven development easier.<\/p>\n
### Use a Common Base Class with Check Methods<\/p>\n
The first, probably most important thing to do is *use your own common base class* for your tests. Don’t derive your tests directly from `SenTestCase`; instead, derive them from your own `MyTestCase` class that in turn derives from `SenTestCase`. This gives you a place to put all of the customization that’s appropriate for your project.<\/p>\n
Sometimes you might need a series of assertions to verify some particular state. However, that series of assertions will be the same every time you need to verify that state. Or the assertions themselves aren’t very *intention revealing* so you always wind up putting a comment above them describing what they’re really doing.<\/p>\n
### Checking Target-Action<\/p>\n
A simple example of this is checking a target-action connection in a user interface. Say you have a view controller that presents a collection of objects managed by an array controller. Its view has an Add button that should send `-addObject:` to the array controller. You might write a test for it like this:<\/p>\n
– (void)testAddButtonSendsAddObjectToArrayController {
\n STAssertEquals([viewController.addButton target], viewController.arrayController,
\n @”The Add button should target the array controller.”);
\n STAssertEquals([viewController.addButton action], @selector(addObject:),
\n @”The Add button should send the -addObject: action.”);
\n }<\/p>\n
That’s not too difficult to understand, but it could be made simpler \u00e2\u20ac\u201d it could be done in a single assertion. You’d just write a method to check both the target and action at once and then use that method from your test, like this:<\/p>\n
\/\/ in your test base class…<\/p>\n
\/*! Tells whether the control sends the action to the target. *\/
\n – (BOOL)checkControl:(NSControl *)control
\n sendsAction:(SEL)action
\n toTarget:(id)target
\n {
\n return ([control action] == action)
\n && ([control target] == target);
\n }<\/p>\n
\/\/ in the tests specifying the view controller’s behavior…<\/p>\n
– (void)testAddButtonSendsAddObjectToArrayController {
\n STAssertTrue([self checkControl:viewController.addButton
\n sendsAction:@selector(addObject:)
\n toTarget:viewController.arrayController],
\n @”The Add button’s action should send -addObject: to the array controller.”);
\n }<\/p>\n
That makes the intention behind the entire test a lot clearer, and it makes writing the test easier & safer since you can’t (say) forget to check either the target or the action.<\/p>\n
It *does* lose a tiny bit of information: If the test fails, you’ll have to look at your xib file instead of the failure message to determine whether it’s because the target or the action isn’t set as you’ve specified. However, the trade-off in making the test easier to read and write is worth it here.<\/p>\n
### Checking Outlets<\/p>\n
This is even worthwhile for single assertions, such as those you’d use to test that your outlets are connected in the first place. For example, you might initially write a test that your view controller is your table view’s delegate like this:<\/p>\n
– (void)testViewControllerIsTableViewDelegate {
\n STAssertEquals([viewController.tableView delegate], viewController,
\n @”The table view’s delegate should be the view controller.”);
\n }<\/p>\n
Rewriting it to be more intention-revealing with a simple check method would make it look like this:<\/p>\n
\/\/ in your test base class…<\/p>\n
\/*! Tells whether the outlet is connected to the given destination. *\/
\n – (BOOL)checkOutlet:(id)outlet connectsTo:(id)destination {
\n return outlet == destination;
\n }<\/p>\n
\/\/ in the tests specifying the view controller’s behavior…<\/p>\n
– (void)testViewControllerIsTableViewDelegate {
\n STAssertTrue([self checkOutlet:[viewController.tableView delegate]
\n connectsTo:viewController],
\n @”The table view’s delegate should be the view controller.”);
\n }<\/p>\n
You’re not saving any code by writing your test this way \u00e2\u20ac\u201d you’re actually writing more \u00e2\u20ac\u201d but its *complexity* has gone down because it requires less effort to see what it’s actually trying to do.<\/p>\n
### Checking Bindings<\/p>\n
This is even worthwhile in situations where you may still need a few extra assertions. For example, Cocoa bindings are specified using a lot more information than just outlets and target-acton connections; you won’t always want to check (and specify the value of) all of it, but you can easily make the common parts clearer.<\/p>\n
Going back to our Add button example, as is typical its enabled state should be bound to the array controller’s `canAdd` property. Writing a test to specify this involves using `-infoForBinding:` and interpreting the results, which takes a couple lines of code and a couple of assertions:<\/p>\n
– (void)testAddButtonEnabledStateIsBoundToArrayControllerCanAdd {
\n NSDictionary *bindingInfo = [viewController.addButton infoForBinding:NSEnabledBinding];
\n STAssertNotNil(bindingInfo,
\n @”The Add button’s enabled state should be bound.”);<\/p>\n
id observedObject = [bindingInfo objectForKey:NSObservedObjectKey];
\n STAssertEquals(observedObject, viewController.arrayController,
\n @”The Add button’s enabled state should be bound to the array controller.”);<\/p>\n
NSString *observedKeyPath = [bindingInfo objectForKey:NSObservedKeyPathKey];
\n STAssertEqualObjects(observedKeyPath, @”canAdd”,
\n @”The Add button’s enabled state should be bound through the ‘canAdd’ key path.”);
\n }<\/p>\n
This isn’t too complicated, but it does start to get tedious, especially given that you have to remember to distinguish between `STAssertEquals` (pointer equality) and `STAssertEqualObjects` (object equivalence). Let’s put the tedium in one place:<\/p>\n
\/*! Tells whether the object’s binding is connected through the given key path. *\/
\n – (BOOL)checkObject:(id)source
\n hasBinding:(NSString *)binding
\n toObject:(id)destination
\n through:(NSString *)keyPath
\n {
\n NSDictionary *bindingInfo = ;
\n id observedObject = [bindingInfo objectForKey:NSObservedObjectKey];
\n NSString *observedKeyPath = [bindingInfo objectForKey:NSObservedKeyPathKey];<\/p>\n
return (bindingInfo != nil)
\n && (observedObject == destination)
\n && [keyPath isEqualToString:observedKeyPath];
\n }<\/p>\n
\/\/ in the tests specifying the view controller’s behavior…<\/p>\n
– (void)testAddButtonEnabledStateIsBoundToArrayControllerCanAdd {
\n STAssertTrue([self checkObject:viewController.addButton
\n hasBinding:NSEnabledBinding
\n toObject:viewController.arrayController
\n through:@”canAdd”],
\n @”The Add button’s enabled state should be bound to the array controller’s ‘canAdd’ property.”);
\n }<\/p>\n
Much clearer!<\/p>\n
[1]: https:\/\/eschatologist.net\/blog\/?p=10 “Unit testing Cocoa user interfaces: Target-Action”
\n[2]: https:\/\/eschatologist.net\/blog\/?p=12 “Unit testing Cocoa user interfaces: Cocoa Bindings”<\/p>\n","protected":false},"excerpt":{"rendered":"
In the past, I’ve talked about ways to easily write unit tests for Cocoa applications, including [tests for user interfaces using target-action][1] and [tests for interfaces using Cocoa bindings][2]. There are some strategies you can apply to make writing tests for Cocoa code even easier, though. They’re just straightforward object-oriented programming, but sometimes we can…<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[3],"tags":[12,9,13,10,11,18,15,16,7,14,17],"class_list":["post-205","post","type-post","status-publish","format-standard","hentry","category-technology","tag-agile-development","tag-cocoa","tag-cocoa-bindings","tag-human-interface-design","tag-interface-builder","tag-objective-c","tag-patterns","tag-test-driven-development","tag-unit-testing","tag-user-interface-testing","tag-xcode"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p74loH-3j","_links":{"self":[{"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/posts\/205","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=205"}],"version-history":[{"count":14,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/posts\/205\/revisions"}],"predecessor-version":[{"id":219,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=\/wp\/v2\/posts\/205\/revisions\/219"}],"wp:attachment":[{"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=205"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=205"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/eschatologist.net\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=205"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}