One of Swift's powerful feature features is reflection, which allows us to inspect and manipulate the properties and behaviors of an object at runtime.
Reflection can be useful for testing and debugging purposes, as it can help you verify the state and functionality of your code without relying on external tools or frameworks. In this blog post, we will explore how to use mirror objects in Swift to access type metadata and perform reflection operations.
What are mirror objects?
Mirror objects are instances of the Mirror struct that encapsulate type metadata in Swift. Type metadata is information about the structure, properties, methods, inheritance and protocols of a type. You can create a mirror object for any instance of any type using the Mirror(reflecting:) initializer.
Mirror objects provide read-only access to a subset of type metadata, such as:
The display style of the type (e.g., struct, enum, class)
The subject type of the instance (e.g., Person)
The children of the instance (e.g., name, age)
The superclass of the instance (if any)
The custom mirror of the instance (if any)
The custom leaf reflectable of the instance (if any)
Using mirror objects, you can inspect these aspects of an instance at runtime and use them for testing and debugging purposes.
Code examples
Let’s see some code examples of how to create and use mirror objects in Swift.
Creating a mirror object
To create a mirror object for an instance, you simply need to call the Mirror(reflecting:) initializer with the instance as an argument. For example:
struct Person {
let name: String
let age: Int
}
let alice = Person(name: "Alice", age: 25)
let mirror = Mirror(reflecting: alice)
Using a mirror object
Once you have created a mirror object for an instance, you can use its properties and methods to access its type metadata. For example:
print(mirror.displayStyle)
print(mirror.subjectType)
print(mirror.children.count)
for child in mirror.children {
print(child.label ?? "", child.value)
}
Practical use cases of mirror objects
Now that we have seen how to create and use mirror objects in Swift, let’s look at some practical use cases :
Testing and debugging private variables: You can use mirror objects to access and verify the values of private properties that are otherwise inaccessible from outside the type. For example, you can create a helper class that uses mirror objects to extract a property by name and type, and use it in your unit tests or debug console.
class ViewControllerToTest: UIViewController {
@IBOutlet private var titleLabel: UILabel!
@IBOutlet private var headerImageView: UIImageView!
private var secretAgentNames: [String]?
}
class MirrorObject {
let mirror: Mirror
init(reflecting: Any) {
mirror = Mirror(reflecting: reflecting)
}
func extract<T>(variableName: StaticString = #function) -> T? {
extract(variableName: variableName, mirror: mirror)
}
private func extract<T>(variableName: StaticString, mirror: Mirror?) -> T? {
guard let mirror = mirror else {
return nil
}
guard let descendant = mirror.descendant("\(variableName)") as? T else {
return extract(variableName: variableName, mirror: mirror.superclassMirror)
}
return descendant
}
}
Now, in our testing target:
final class ViewControllerToTestMirror: MirrorObject {
init(viewController: UIViewController) {
super.init(reflecting: viewController)
}
var headerImageView: UIImageView? {
extract()
}
var titleLabel: UILabel? {
extract()
}
var secretAgentNames: [String]? {
extract()
}
}
let viewControllerMirror = ViewControllerToTestMirror(viewController: ViewControllerToTest())
viewControllerMirror.headerImageView
viewControllerMirror.titleLabel
viewControllerMirror.secretAgentNames
Grouping errors by enum cases: You can use mirror objects to get the names of enum cases at runtime, and use them to group errors by their source or category. For example, you can create a custom error type that conforms to CustomStringConvertible and uses mirror objects to return a descriptive string based on its case name.
enum ArticleState {
case scheduled(Date)
case published
}
let scheduledState = ArticleState.scheduled(Date())
Mirror(reflecting: scheduledState).children.forEach { child in
print("Found child '\(child.label ?? "")' with value '\(child.value)'")
}
Preloading data from a database: You can use mirror objects to iterate over the properties of an object and preload them with data from a database. For example, you can create an extension for your model types that uses mirror objects to reset all their properties with default values or cached data.
extension UserSession {
func logOut() {
let mirror = Mirror(reflecting: self)
for child in mirror.children {
if let resettable = child.value as? Resettable {
resettable.reset()
}
}
}
}
I hope this blog post has given you some insights into how to use mirror objects in Swift for testing and debugging purposes. If you have any questions or feedback, please leave a comment below. Thank you for reading!
