Run unit tests with Fastlane
Introduction
In our latest post, we spoke about how to build your app with Fastlane. In this post, we’re going to talk about how to run your unit tests with Fastlane. But firstly, why would we even want to do this?
Reasoning
Unit tests are important, we all agree on that. Also, we all write unit tests (right?), but if we don’t run them - they’re meaningless. While manually running them is fine, it’s not the most efficient way to do it. We can automate this process with Fastlane, and have it run every time we push to our CI, or every time we want to run our tests.
Pre-requisites
I’m assuming you’ve already got Fastlane installed. If you don’t, you can follow this quick guide. Also, I’m going to assume you’ve got some unit tests in your project. If you don’t, you should probably write some.
Setting up
We’re going to be building off of the Fastlane file in the previous post, which at the moment looks like this:
#!/usr/bin/ruby
# frozen_string_literal: true
fastlane_version '2.225.0'
default_platform :ios
platform :ios do
desc "Build the app"
lane :build do
gym(scheme: "MyApp", configuration: "Release", export_method: "app-store", output_directory: "./build")
end
end
If you need a refresher about what’s going on, you can read the post here, but a quick summary is that we’re building our app with Fastlane and exporting it in a file that is ready to be shipped to the App Store.
Explaining the tool
We’re going to be using the scan tool that comes with Fastlane. This tool is used to run your tests, and it’s very easy to use. You can read more about it here. It’s a great tool to have in your belt, and it’s very easy to use. Let’s go over a few of the flags that we’re going to be using:
scheme
This is the scheme that you want to run your tests on. If you’ve got multiple schemes, you can specify which one you want to run your tests on. This is very useful if you’ve got different schemes for different environments, or if you’ve got different schemes for different parts of your app.
clean
This flag is used to clean the build folder before running the tests. This is useful if you want to make sure that you’re running your tests on a clean slate, and that there’s no leftover files from previous builds.
devices
This flag is used to specify which devices you want to run your tests on. This is useful if you’ve got different devices that you want to run your tests on, or if you want to run your tests on a specific device. This is useful if you’ve got snapshot tests that are per-device, for example.
Writing the lane
We’re going to add a new lane to our Fastfile, called test. This lane is going to run our tests, and it’s going to look like this:
#!/usr/bin/ruby
# frozen_string_literal: true
fastlane_version '2.225.0'
default_platform :ios
platform :ios do
desc "Build the app"
lane :build do
gym(scheme: "MyApp", configuration: "Release", export_method: "app-store", output_directory: "./build")
end
desc "Run the tests"
lane :test do
scan(scheme: "MyApp", clean: true, devices: ["iPhone 12 Pro Max"])
end
end
Explanation
In this lane, we’re running our tests on the scheme MyApp, cleaning the build folder before running the tests, and running the tests on the device iPhone 12 Pro Max. You can change the scheme, the devices, and any other flags that you want to use, to suit your needs. This will also produce a results file called report.junit in the ./fastlane/test_output directory, which you can use to visualize the test results.
Running the tests
Now that we’ve got our lane set up, we can run our tests by running bundle exec fastlane test in our project directory. This will run our tests on the specified scheme, clean the build folder before running the tests, and run the tests on the specified device.
Conclusion
And that’s it! You’ve now got your tests running with Fastlane. This is a great way to automate your testing and increase your confidence in your code. You can read more about the scan tool here. In the next post, we’re going to talk about how to run UI tests with Fastlane. Stay tuned! 🚀