Adding Testing to Your iOS Project - You Need Testing

“Writing software is like building a cathedral - when we finish, we start praying.”

Software and cathedrals are much the same – first we build them, then we pray. - Sam Redwine

Adding Testing to Your iOS Project - You Need Testing

Do you think unit testing is troublesome, time-consuming, and unnecessary? If so, you’re mistaken! Unit testing brings numerous benefits to iOS projects.

Firstly, unit testing enhances the quality and readability of your code. You can verify whether your program logic is correct, meets requirements, and is free of bugs or errors through unit testing. It also allows you to refactor your code to make it cleaner, clearer, and easier to maintain. You don’t have to worry about refactoring affecting other functionalities because unit testing ensures that your programs still function properly.

Secondly, unit testing saves you time and costs. You might think writing unit tests is time-consuming, but consider the time you would spend debugging and fixing bugs without them. Furthermore, if bugs are only discovered after deployment, the consequences can be severe, affecting user experience and trust, and increasing your maintenance costs and risks. In contrast, with unit testing, you can identify and resolve issues during the development phase, thus enhancing your development efficiency and product quality.

Lastly, unit testing boosts your confidence and professionalism. When you have unit tests backing your code, you can confidently address feedback and requirements. You’ll also feel more confident collaborating with other developers and sharing your code. Moreover, unit testing is a way to demonstrate your professional attitude and skills. When others see that your code is well-tested, they’ll have a higher regard for your level of responsibility and skill.

In conclusion, the benefits of unit testing for iOS projects are numerous. If you haven’t started writing unit tests, now is the time to act! Trust me, unit testing will make your development life better!

The Testing Pyramid

This is a common diagram of the testing pyramid found online. It categorizes different types of tests into three levels: unit tests, integration tests, and UI tests.

• Unit Tests: Located at the base of the pyramid, these are the most fundamental and quickest tests, aimed at verifying the smallest testable units of software (like functions, methods, or classes) to ensure code logic correctness and robustness. Unit tests are typically written and executed by developers themselves using various tools and frameworks to automate and simplify the testing process. They should occupy the largest proportion of the pyramid, as they can promptly detect and fix errors in the code, enhancing quality and maintainability.
• Integration Tests: Positioned in the middle of the pyramid, these tests follow unit tests and are aimed at verifying the interaction and collaboration between different modules or components of the software, ensuring the integrated system functions correctly. Integration tests are usually handled by developers or testers and use techniques like Mocks or Stubs to isolate external dependencies and impacts. They should occupy a medium proportion of the pyramid, as they check whether the system’s internal structure and logic meet design specifications and requirements.
• UI Tests: At the top of the pyramid, these are tests that are closest to real usage scenarios and user experiences, aimed at verifying the complete functionality and process of the software to ensure the system provides services as expected. End-to-end tests are usually managed by testers or user representatives and employ automated or manual methods to simulate user operations and behaviors. They should occupy the smallest proportion of the pyramid, as they are generally time-consuming and costly, and challenging to cover all possible situations and variables.

The F.I.R.S.T Principles of Unit Testing

• Fast: Unit tests should execute quickly without taking up too much time or resources.
• Independent: Unit tests should be independent of other tests, not affecting or relying on each other.
• Repeatable: Unit tests should be repeatable in any environment or under any circumstances, providing consistent results.
• Self-validating: Unit tests should have clear standards for passing or failing without the need for manual checks or validation.
• Timely: Unit tests should be written in a timely manner, ideally before or concurrently with code development, to drive design and refactoring.