swift-concurrency-extras
Reliably testable Swift concurrency.
Learn more
This library was designed to support libraries and episodes produced for Point-Free, a video series exploring the Swift programming language hosted by Brandon Williams and Stephen Celis.
You can watch all of the episodes here.
Motivation
This library comes with a number of tools that make working with Swift concurrency easier and more testable.
ActorIsolated
and LockIsolated
The ActorIsolated
and LockIsolated
types help wrap other values in an isolated context.
ActorIsolated
wraps the value in an actor so that the only way to access and mutate the value is
through an async/await interface. LockIsolated
wraps the value in a class with a lock, which
allows you to read and write the value with a synchronous interface. You should prefer to use
ActorIsolated
when you have access to an asynchronous context.
Streams
The library comes with numerous helper APIs spread across the two Swift stream types:
-
There are helpers that erase any
AsyncSequence
conformance to either concrete stream type. This allows you to treat the stream type as a kind of "type erased"AsyncSequence
.For example, suppose you have a dependency client like this:
struct ScreenshotsClient { var screenshots: () -> AsyncStream<Void> }
Then you can construct a live implementation that "erases" the
NotificationCenter.Notifications
async sequence to a stream:extension ScreenshotsClient { static let live = Self( screenshots: { NotificationCenter.default .notifications(named: UIApplication.userDidTakeScreenshotNotification) .map { _ in } .eraseToStream() // โฌ ๏ธ } ) }
Use
eraseToThrowingStream()
to propagate failures from throwing async sequences. -
Swift 5.9's
makeStream(of:)
functions have been back-ported. It can handy in tests that need to override a dependency endpoint that returns a stream:let screenshots = AsyncStream.makeStream(of: Void.self) let model = FeatureModel(screenshots: { screenshots.stream }) XCTAssertEqual(model.screenshotCount, 0) screenshots.continuation.yield() // Simulate a screenshot being taken. XCTAssertEqual(model.screenshotCount, 1)
-
Static
AsyncStream.never
andAsyncThrowingStream.never
helpers are provided that represent streams that live forever and never emit. They can be handy in tests that need to override a dependency endpoint with a stream that should suspend and never emit for the duration of the test.let model = FeatureModel(screenshots: { .never })
-
Static
AsyncStream.finished
andAsyncThrowingStream.finished(throwing:)
helpers are provided that represents streams that complete immediately without emitting. They can be handy in tests that need to override a dependency endpoint with a stream that completes/fails immediately.
Tasks
The library enhances the Task
type with new functionality.
-
The static function
Task.never()
can asynchronously return a value of any type, but does so by suspending forever. This can be useful for satisfying a dependency requirement in a way that does not require you to actually return data from that endpoint.For example, suppose you have a dependency client like this:
struct SettingsClient { var fetchSettings: () async throws -> Settings }
You can override the client's
fetchSettings
endpoint in tests to suspend forever by awaitingTask.never()
:SettingsClient( fetchSettings: { try await Task.never() } )
-
Task.cancellableValue
is a property that awaits the unstructured task'svalue
property while propagating cancellation from the current async context. -
Task.megaYield()
is a blunt tool that can make flakey async tests a little less flakey by suspending the current task a number of times and improve the odds that other async work has enough time to start. Prefer the reliability of serial execution instead where possible.
UncheckedSendable
A wrapper type that can make any type Sendable
, but in an unsafe and unchecked way. This type
should only be used as an alternative to @preconcurrency import
, which turns off concurrency
checks for everything in the library. Whereas UncheckedSendable
allows you to turn off concurrency
warnings for just one single usage of a particular type.
While SE-0302 mentions future work of "Adaptor Types for Legacy
Codebases", including an UnsafeTransfer
type that serves the same
purpose, it has not landed in Swift.
Serial execution
Some asynchronous code is notoriously difficult to test in
Swift due to how suspension points are processed by the runtime. The library comes with a static
function, withMainSerialExecutor
, that attempts to run all tasks spawned in an operation serially
and deterministically. This function can be used to make asynchronous tests faster and less flakey.
Warning: This API is only intended to be used from tests to make them more reliable. Please do not use it from application code.
We say that it "attempts to run all tasks spawned in an operation serially and deterministically" because under the hood it relies on a global, mutable variable in the Swift runtime to do its job, and there are no scoping guarantees should this mutable variable change during the operation.
For example, consider the following seemingly simple model that makes a network request and manages
some isLoading
state while the request is inflight:
@Observable
class NumberFactModel {
var fact: String?
var isLoading = false
var number = 0
// Inject the request dependency explicitly to make it testable, but can also
// be provided via a dependency management library.
let getFact: (Int) async throws -> String
func getFactButtonTapped() async {
self.isLoading = true
defer { self.isLoading = false }
do {
self.fact = try await self.getFact(self.number)
} catch {
// TODO: Handle error
}
}
}
We would love to be able to write a test that allows us to confirm that the isLoading
state
flips to true
and then false
. You might hope that it is as easy as this:
func testIsLoading() async {
let model = NumberFactModel(getFact: {
"\($0) is a good number."
})
let task = Task { await model.getFactButtonTapped() }
XCTAssertEqual(model.isLoading, true)
XCTAssertEqual(model.fact, nil)
await task.value
XCTAssertEqual(model.isLoading, false)
XCTAssertEqual(model.fact, "0 is a good number.")
}
However this fails almost 100% of the time. The problem is that the line immediately after creating
the unstructured Task
executes before the line inside the unstructured task, and so we never
detect the moment the isLoading
state flips to true
.
You might hope you can wiggle yourself in between the moment the getFactButtonTapped
method is
called and the moment the request finishes by using a Task.yield
:
func testIsLoading() async {
let model = NumberFactModel(getFact: {
"\($0) is a good number."
})
let task = Task { await model.getFactButtonTapped() }
+ await Task.yield()
XCTAssertEqual(model.isLoading, true)
XCTAssertEqual(model.fact, nil)
await task.value
XCTAssertEqual(model.isLoading, false)
XCTAssertEqual(model.fact, "0 is a good number.")
}
But that still fails the vast majority of times.
These problems, and more, can be fixed by running this entire test on the main serial executor.
You will also have insert a small yield in the getFact
endpoint due to Swift's ability to
inline async closures that do not actually perform async work:
func testIsLoading() async {
+ await withMainSerialExecutor {
let model = NumberFactModel(getFact: {
+ await Task.yield()
return "\($0) is a good number."
})
let task = Task { await model.getFactButtonTapped() }
await Task.yield()
XCTAssertEqual(model.isLoading, true)
XCTAssertEqual(model.fact, nil)
await task.value
XCTAssertEqual(model.isLoading, false)
XCTAssertEqual(model.fact, "0 is a good number.")
+ }
}
That small change makes this test pass deterministically, 100% of the time.
Documentation
The latest documentation for this library is available here.
Credits and thanks
Thanks to Pat Brown and Thomas Grapperon for providing feedback on the library before its release. Special thanks to Kabir Oberai who helped us work around an Xcode bug and ship serial execution tools with the library.
Other libraries
Concurrency Extras is just one library that makes it easier to write testable code in Swift.
-
Case Paths: Tools for working with and testing enums.
-
Clocks: A few clocks that make working with Swift concurrency more testable and more versatile.
-
Combine Schedulers: A few schedulers that make working with Combine more testable and more versatile.
-
Composable Architecture: A library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind.
-
Custom Dump: A collection of tools for debugging, diffing, and testing your application's data structures.
-
Dependencies: A dependency management library inspired by SwiftUI's "environment."
-
Snapshot Testing: Assert on your application by recording and and asserting against artifacts.
-
XCTest Dynamic Overlay: Call
XCTFail
and other typically test-only helpers from application code.
License
This library is released under the MIT license. See LICENSE for details.