Setting Up Testing Development for iOS Apps in Startup Companies

When setting up new projects, I have evolved my tool set to meet the demands of high-quality iOS development. In this article, I will provide a comprehensive overview of my current setup for iOS app development, including dependency management, testing strategies, CI/CD pipelines, and other tools that have proven valuable in startup environments. My aim is to share insights that can help other developers and teams build robust, reliable apps efficiently.

Dependency Management with CocoaPods

The foundation of any iOS project is its dependencies. CocoaPods has become the standard for managing these dependencies, providing a simple and effective way to integrate third-party libraries into your project. CocoaPods allows you to define your project's required packages in a `Podfile`, and then use the `pod install` command to install and link these packages. This method ensures that your project remains organized and easy to manage. I often combine this with Carthage for even more flexibility, though CocoaPods remains my default choice for its broader ecosystem support.

Testing Strategies with Kiwi and CI

Effective testing is crucial for any app development, and I employ a combination of unit and integration testing to ensure high code quality. For testing, I use Kiwi, which integrates seamlessly with Xcode and offers a simpler target structure. Although OCMock can be used for more complex scenarios, Kiwi's behavior-driven development approach has proven highly effective and easy to maintain. Additionally, I use CI (Continuous Integration) tools like Jenkins or TeamCity to automate my build and test processes. These tools not only speed up the development cycle but also increase the reliability of my code.

Continuous Integration and Continuous Delivery

For my CI/CD pipelines, I rely on Jenkins or TeamCity. Shell scripts or rake tasks were my initial methods for performing builds, but these tools now provide plugins and web UIs, making configuration more user-friendly and accessible. My CI setup includes over-the-air (OTA) installs of the current development builds, either through external services like HockeyApp or TestFlight, or through an internal web server. This allows me to test and deploy multiple app versions, with each having its own backend configuration, enabling a comprehensive test environment that closely mirrors the production setup.

Functional Testing with Frank and Kiwi

While unit and integration tests provide excellent coverage in most cases, I sometimes use functional tests, such as those with Frank or UIAutomation, to complement my testing strategy. These tests verify that the UI behaves as expected, although they typically involve higher overhead. In many projects, unit and integration tests offer sufficient coverage, and the added complexity of setting up and maintaining functional tests may not be justified. However, for projects where UI behavior is complex or critical, these tests can be invaluable.

Other Tools and Best Practices

For additional tooling, I use Objection for dependency injection, which helps in managing dependencies and improving the modularity of the codebase. AppCode, while not a complete replacement for Xcode, offers significant improvements in refactoring, code generation, and code formatting. This helps in maintaining a high level of code quality and productivity.

When it comes to coupling iOS app builds with API server builds, I prefer to decouple them as much as possible by using versioned APIs and avoiding the need to run a server during testing. While coordination between client and server builds is sometimes necessary, this is usually manageable with the same set of developers working on both ends.

By following these best practices and using the right tools, I have been able to build and maintain high-quality iOS apps in a startup environment. These strategies not only improve the codebase but also contribute to a more efficient and enjoyable development process.