Pyramid, Diamond, Honeycomb, or Trophy? Find A Testing Strategy That Fits

There’s no doubt that testing is an integral part of website and mobile application development in Kuwait. While writing test codes is a key component of testing, it can only be done correctly when a suitable testing plan is first created. This plan should cover both,

1. How you want to conduct the tests, and
2. What parts of the application you need tested

Last week, we talked a little about the first point. We covered the two main testing modes and the basic types of test automation. This week too, we will focus on the “how” of conducting tests, but with a more functional and detailed angle. Now that you are acquainted with the different types of automation tests, it’s time to start thinking about how to combine and execute them. And it’s not as straightforward as it seems. Different combinations of testing types fall into different testing strategies and provide different results. Just like all aspects of web and app development in Kuwait, you need to pick your strategy based on your objectives and resources.

With this article, we aim to provide a brief overview on how you can combine these testing types into effective strategies and pick one that suits your project. These strategies are generally compared to common shapes in order to better grasp their meaning. Let’s take a closer look!

1. Test Pyramid

   

   This is one of the most popular testing strategies. As depicted above, unit tests fall right at the base of the pyramid. This is because they allow for fast execution and easy maintenance. Just like we discussed in the earlier article, unit tests focus on isolating and verifying individual code units and provide fast and reliable feedback, making them an effective and efficient testing type, and qualifying them to form the foundation of the pyramid. In the middle layer, we have integration tests that are conducted between several app components and which ensure errorless collaboration. Integration tests provide overall system stability. At the very top of the pyramid, we have tests that simulate user interactions and validate the entire system from beginning to end. These UI/End-to-End tests, although slower and more resource-heavy, help in identifying issues in the user workflow and ensure that the app will work in the real world. The test pyramid strikes a perfect balance between all three testing levels, resulting in high-quality software.

   The layering of these three tests in the shape of a pyramid has significance. While the order of the layer tells you which tests to prioritize first, the surface area of each layer gives you an idea of how many tests you should write for that particular area. Finally, the higher you go up the pyramid the tests become costlier while providing higher degrees of confidence. For instance, the pyramid makes you focus on writing more unit tests, which lies at the bottom of the pyramid. And since E2E tests (at the peak) simulate users, they will give you the most confidence that your application is working as per the requirements, also making it the costliest.

   Since the pyramid no longer fits all types of real-world Kuwait mobile apps, several adaptations have been proposed over the last few years. Let’s list a few below.

2. Inverted Test Pyramid

   

   Also called the Ice Cream Cone Pyramid, this testing strategy places heavy focus on E2E testing, and is barely concerned with unit tests. Since this highly increases testing cost and reduces efficiency and agility, it should only be used when developing application prototypes/proof of concept, wherein emphasis is more on developing a functionality rather than maintaining a test suite.

3. Test Diamond

   

   An adaptation of the pyramid, test diamond replaces the overemphasis on unit tests with integration tests. According to this strategy, even if you reach 100% coverage on unit tests, refactoring can be a burden, since you will have to update almost all of the unit tests again. Consequently, a lot of unit test updates may be skipped, causing them to erode. With the test diamond, you are using both unit tests and E2E tests to only cover the most critical test cases, leaving a relatively higher emphasis on integration testing. Test diamond is mostly suitable in a domain service in microservice architecture. In comparison, while test pyramid is more about fast and easy-to-write tests, test diamond is all about covering business-critical functionalities. And although test diamond may take a little longer to execute for app developers in Kuwait, it has high predictability, reliability, and user simulation capabilities.

4. Test Honeycomb

   

   Similar to the test diamond, test honeycomb is further specialized for a microservice architecture. Since microservices are small in size, greater complexities do not lie within the services, but in their interaction with others. Thus, microservices software owners should primarily focus on integration tests.

   Integration tests in test honeycomb make up the middle layer, which is the biggest layer, representing most number of required tests. It’s important to reemphasize that integration tests test your services in combination with other services, yet in a more isolated fashion. So tests include other systems as well, and focus on their interaction points. On the other hand, integrated tests, which represents the topmost layer, have a pass/fail criteria based on the correctness of another system. In other words, integrated tests see whether a particular service malfunctions due to external dependencies, or whether the service being tested might cause other services to malfunction. The final layer specifies tests on implementation details. Similar to unit tests, these tests focus on sections of the code that are naturally isolated and consequently have their own internal complexity. Just like E2E tests in the previous models, integrated and implementation detail tests should be used carefully, and only for the most essential test cases, whether it be iOS, Android, or Windows mobile application development.

5. Test Trophy

   

   So far, we’ve seen testing strategies maintain a heavy focus on integration tests. However, static analysis is missing from the previously shown modifications. Test trophy keeps its focus on both integration tests and static analysis. Static analysis is important for catching typos, style mistakes, and other bugs. In fact, it is an effective method of debugging that is achieved without executing the program and by simply examining the code. Unit tests here are not as emphasized as the test pyramid. However, the placement of static and unit tests as the foundation of the trophy signifies that they are fast, easy to run, and can catch bugs more easily. Integration tests are again the main focus since they provide higher confidence in the code, and enhance software quality and stability without breaking the bank. End-to-end tests make up the top of the trophy, and play a similar role in this strategy as they do in test pyramid.

   Test trophy’s higher rate of bug detection produces a more reliable and robust software. Moreover, its balanced focus on different types of tests helps uncover potential issues at various levels, and leads to a higher-quality software. Ultimately, test trophy’s comprehensive nature reduces costs and enhances productvity.