When writing unit tests in Swift for complex objects, you may need to write a lot of setup boilerplate code in the arrange phase. Scenario Builders are a pattern that extracts and encapsulated all that logic in a single component with an English-like API. This tutorial shows how to build a Scenario Builder in Swift and looks at its pros and cons.
You can get the Swift compiler to generate an initializer with default values for your structs, if you're willing to put up with a bit of mutability.
The XCTest Swift testing framework has a limited offer of assertions. There's only so much you can do with XCTAssertTrue and XCTAssertEqual. This XCTest tutorial shows how to create custom assertions to make your unit tests and UI tests shorter and clearer.
Result is one of the most useful types in the Swift language. Learn how to write better unit tests using Result in this XCTest tutorial.
How to make the unit tests of your SwiftUI app safer and faster by preventing them from running the program startup flow. This will avoid all of the launch operations like network requests or reads from the local storage that would affect the global state.
Using Swift's nested types helps making it clear that a view model belongs to a view.
With his famous pipe wrench lecture, Vannevar Bush taught young MIT engineers the value of precision. The same teaching holds true for software developers.
Triple-state Booleans can be ambiguous to work with. Replace them with an enum to make the code clearer.
When the output value of a function changes often but the logic to pick it doesn't, adding a separation layer will make unit tests easier to maintain.
An explanation of what referential transparency means with examples in Swift
The answer to "How can I test that a view controller presents another view controller when something happens?" is as simple as defining a delegate.
When testing delegates, we are asserting rigid implementation details. Here's a way to make those tests more flexible.
With test driven development you can write high quality software in small shippable steps. Here's how to get started.
An overview of the different kind of doubles we can use in our tests, and how to write them in Swift.
There is a subtle way to overload software components, by making them both take decision and act on them. We can simplify these bloated components by separating the responsibility of taking decisions from the one action on them. This will result in leaner and easier to maintain software, and is made simple by the Swift type system.
Some code ends up requiring a lot of duplication to be tested. You can remove it by using helper functions encapsulating the shared assertion logic.
Keeping tests short and focused is important for the health of the test suite. A fixture method to generate instances with default values in the tests helps keeping the setup code short, focused, and readable
Using protocols describing a single capability or action that can be performed is a way to enhance local reasoning and facilitate testability
The Nimble matchers framework provides two ways assert expectations on asynchronous code, this post explores when to use one or the other.
Porting Ruby's unless operator into Swift via a function.
Testing async code is not simple, but XCTest provides us with all the required tool. This post shows how to wait for an expectation to be fulfilled based on a Swift closure.
In Swift it is possible to pass a reference to a type itself, not just to an instance of it. This post shows how to use this capability to test legacy code.
A look at what implicitly unwrapping and force unwrap a Swift Optional mean, and how they differ from each other.
A look at what implicitly unwrapping an Optional value means and why it should be avoided.
This post introduces the Either type and shows a practical application of it in Swift, injecting extra cells in a table view.
An exercise to understand Swift's optional type: reimplementing the if let functionality
This post looks into one of Swift's most powerful feature: optionals
A quick post showing how to use the Swift availability attribute to mark objects and functions as unavailable.
This is a blogpost version of the content of my talk "Functional Core, Reactive Shell"
How to configure NSDateFormatter to work with JSON API dates.
Third party code can be hard to test, but you can use Swift's protocols to abstract its details and improve testability
A look at how to write tests for async code when using the Quick and Nimble Swift frameworks. This post is part of the Practical Testing in Swift series.
In this second post of the Practical Testing in Swift we a look at strategies to test how objects call their delegate methods or set property on them.
How to prevent the unit test target from loading the AppDelegate and have faster tests execution.
Unit and acceptance test are powerful tools that can be used to identify and fix bugs. Let's see how using a bugged Swift app as an example.
Swift allows us to natively iterate over arrays using map. Map could be used to replace every for loop in your code, but that's not a great idea. Map and for have different purposes and should be used appropriately
This is the post version of a talk I've been given in the past months. In this post we will demystify functional programming terms like monad and functor, and see how those concepts can be brought back to the every day Swift development, in particular how they can help to deal with optionals in a leaner way.
Nimble is a matchers framework built for Swift that provides powerful and versatile expectations. Writing test within the standard XCTest harness but using Nimble assertions is easier and productive, and a good combination of tools to introduce testing and TDD to colleagues and teams in a frictionless way.
A look at how to write classes and structs that expose their dependencies as initialization arguments in Swift.
How to get an array of single characters String from a multiple characters String. From foobar to [f, o, o, b, a, r].
If you are having problems with xcodebuild failing to export your apps with either Swift or Watch Kit support here's the solution, with a handy custom script.
In this port to Swift of the great of Haskell's "Functors, Applicatives, And Monads In Pictures" we are going to look at these functional programming concepts aided by some very helpful pictures.