CODEWITHSUNDEEP
iosswiftuiviewuiviewcontrollertdd
Ivan S Ivanov
Ivan S Ivanov

Reputation: 542

Should I write tests first (following TDD) for the view layer or only do only manual testing and add snapshot tests when finished?

As expected, I normally have difficulties when following TDD (i.e. writing the tests first) with the view layer.

Namely, in order to observe or trigger certain visible changes (layout or styling) I would need to make the view's internals public. This breaks encapsulation and allows for client code do some thing like myView.label.text = "User".

To avoid this, I either add getter methods to UIView class:

var userName: String{ return label.text }

Or do some extensions that are added only to the test framework:

extension MyView{

//avoids making a getter just for the sake of testing, while keeping it private and interchangeable
var userName : String{
   return (viewWithTag(someLabelTage) as! UILabel).text
}

A different approach is to skip the TDD work flow (i.e. test manually after the feature is done) and add snapshot testing (see https://github.com/pointfreeco/swift-snapshot-testing) to the increase coverage and have a safety net when refactoring.

Considering all this, I was wondering if there are any other patterns or approaches, that I can use to be more efficient while keeping my confidence in the code.

Upvotes: 2

Views: 608

Answers (2)

mokagio
mokagio

Reputation: 17481

I don't have much to add to Spock's answer. Tests should be written to help development and maintenance of the code in the future. If they get in the way then either the code is not architected properly or it's code for which the ROI is low.

A pattern that is worth mentioning is the humble view. There are a few ways to approach it, each with different trade offs, but the gist is to have data structures defining how the view should look like, and then let the view read these data structure and set its properties from them.

This allows you to test that the data structure driving the view is generated properly, without having to test the view itself, because it's nothing but an humble object that reads and sets values.

Upvotes: 1

Spock
Spock

Reputation: 6992

Not an expert in Swift, but regardless of the language/framework, something tells me you're actually making your task harder.

I normally have difficulties when following TDD with the view layer.

This is expected. The View support to be simple and have no behavior (i.e domain logic) at all. It should be simple user interaction, and binding data to the controls in the view. So you don't need TDD or to be more precise Unit Tests around the View in my opinion. You're not going to get much value out of trying to write Unit tests for the View.

You View can be tested more effectively using a UI test framework, such as Selenium, or your own UI test framework, which tests User interactions. This way you more return in investment (ROI) than attempting to TDD the View layer.

Upvotes: 5

Related Questions