Unit testing vs. integration testing

Flaky Tests

Sep 29, 2023

Ensuring the quality and reliability of an application is paramount. To achieve this, testing is an key practice that comes in various forms, each serving a specific purpose in the development lifecycle. Among these, unit testing and integration testing are fundamental types of testing strategies that help developers identify and fix issues at different stages. Let's delve into the key differences and benefits of unit testing and integration testing, and dive into what roles they play.

Unit Testing: Peering into the Smallest Units

Unit testing is a vital practice in the software testing arsenal, focusing on testing the smallest testable parts of an application—the individual units. A unit can be a function, method, or class, representing the building blocks of the codebase. Testers write unit tests to verify that each piece of code functions as expected and adheres to the provided specification.

Here's an exploration of the essential aspects of unit testing and how it fits into the larger picture of software testing:

Testing Individual Units of Code

Unit testing involves breaking up large pieces of code into smaller pieces to test in isolation. Testers create test cases for these units to validate their behavior and ensure they conform to the specified requirements.

White Box Testing

Unit testing is a form of white box testing, wherein testers have full knowledge of the internal workings of the units being tested. The goal is to control the inputs and validate outputs. This allows for a thorough evaluation of the code, including different paths and logical branches.

Rapid Feedback Loop

Unit tests are designed for fast execution, enabling a rapid feedback loop within the development process. Developers can quickly run these tests with each code change, facilitating early bug detection and prompt bug fixes.

Test-Driven Development (TDD)

Unit testing often aligns with the Test-Driven Development (TDD) approach, where developers write tests before writing the actual code. This encourages a structured and systematic development process, leading to a comprehensive test suite.

Integration Testing: Ensuring Harmony among Modules

On the other side of the spectrum, integration testing is a crucial practice that evaluates the interaction and harmony among different modules or components within an application. It ensures that these units, which have been validated through unit testing, integrate seamlessly to form a functioning system.

Let's dissect the key aspects of integration testing and understand its place in the software testing landscape:

Testing Interaction and Dependencies

Integration tests focus on evaluating how different modules or components interact and depend on each other. This includes testing data flow, communication, and integration points to detect any potential integration issues.

Black Box Testing

Integration testing often falls under the category of black box testing, wherein testers evaluate the software's functionality without having detailed knowledge of its internal workings. This helps simulate real-world scenarios and user interactions.

Top-Down and Bottom-Up Approaches

Integration testing can be conducted using both top-down and bottom-up approaches. The top-down approach starts with testing higher-level functionalities and gradually integrates lower-level modules, while the bottom-up approach begins with testing the foundational units and gradually combines them into integrated systems.

Verification of External Dependencies

Integration tests also involve verifying how the software interacts with external dependencies, such as databases, APIs, or third-party services. This ensures that the software functions correctly in real-world environments.

Striking a Balance: The Testing Pyramid and Comprehensive Testing Strategies

In the grand scheme, both unit testing and integration testing are essential pillars that uphold the quality assurance of a software application. The testing pyramid is a widely recognized model that emphasizes the importance of a balanced testing strategy. At the base of the pyramid lie unit tests, forming the largest portion, followed by integration tests in the middle, and finally, end-to-end or system tests at the top.

  • Unit Tests: These form the base of the testing pyramid, constituting the majority of the test suite. They validate individual units of code and contribute to a solid foundation of reliable code.

  • Integration Tests: Positioned in the middle of the pyramid, integration tests ensure that different units of code work cohesively when integrated, forming a functioning system.

  • End-to-End Tests: These reside at the top of the pyramid, focusing on testing the entire application's flow to ensure that all integrated components work harmoniously and deliver the expected functionality.

Making Informed Choices: Selecting the Right Testing Method

In software development methodologies, the choice of test depends on the project requirements, the development process, and the overall testing strategy. Agile and DevOps methodologies emphasize continuous integration and delivery, necessitating automated testing to ensure rapid and reliable deployments.

  • Automated Testing: Automated testing is a key component of both unit testing and integration testing. Tools like Selenium for web applications and various testing frameworks in languages like Java facilitate the automation of test cases, leading to more efficient and consistent testing.

  • Manual Testing and Acceptance Testing: While automated testing plays a crucial role, manual testing and acceptance testing are also essential in certain scenarios, especially for exploring real-world user experiences and ensuring software meets user expectations.

The Continuous Lifecycle of Quality Assurance

In the modern software development lifecycle, quality assurance is an ongoing process. Continuous integration and continuous testing are integral to maintaining high-quality codebases and ensuring that new features and bug fixes are thoroughly tested and validated before they are integrated into the codebase.

  • Continuous Integration: Developers integrate code changes into a shared repository frequently, followed by automated builds and tests to ensure early detection of integration issues and regressions.

  • Continuous Testing: This involves continuously running automated tests to verify the application's functionality, performance, and security throughout the development process.

Code Coverage

Additionally, code coverage tool can help you measure how much of your code is tested. Tests ensure correctness in the behavior of the application, but how do you know how well you've tested your application? You can't improve it till you measure it. BuildPulse Flaky Tests allows you to see exactly how much of your code is tested, as well as what isn’t tested. Check it out today here.

Balancing Act for a Resilient Software Application

Understanding the differences and benefits of unit testing and integration testing is crucial for developing a resilient and functional software application. Both testing techniques are indispensable, with unit testing validating individual units of code and integration testing ensuring their seamless integration and functionality within the system.

By implementing a well-structured testing strategy that embraces the testing pyramid and leverages automated testing tools, developers can achieve a high-quality codebase, reduce bug fixes, and enhance overall software reliability. The continuous integration and testing practices further solidify the software development lifecycle, contributing to the creation of robust and user-friendly software applications that stand the test of time.


What is the difference between a flaky test and a false positive?

A false positive is a test failure in your test suite due to an actual error in the code being executed, or a mismatch in what the test expects from the code.

A flaky test is when you have conflicting test results for the same code. For example, while running tests if you see that a test fails and passes, but the code hasn’t changed, then it’s a flaky test. There’s many causes of flakiness.

What is an example of a flaky test?

An example can be seen in growing test suites - when pull request builds fail for changes you haven’t made. Put differently, when you see a test pass and fail without any code change. These failed tests are flaky tests.

What are common causes of flakiness?

Broken assumptions in test automation and development process can introduce flaky tests - for example, if test data is shared between different tests whether asynchronous, high concurrency, or sequential, the results of one test can affect another. 

Poorly written test code can also be a factor. Improper polling, race conditions, improper event dependency handling, shared test data, or timeout handling for network requests or page loads. Any of these can lead to flaky test failures and test flakiness.

End-to-end tests that rely on internal API uptime can cause test flakiness and test failures.

What's the impact of flaky tests?

Flaky tests can wreck havoc on the development process - from wasted developer time from test retries, to creating bugs and product instability and missed releases, time-consuming flaky tests can grind your development process to a halt.

What is the best way to resolve or fix flaky tests?

Devops, software engineering, and software development teams will often need to compare code changes, logs, and other context across test environments from before the test instability started, and after - adding retries or reruns can also help with debugging. Test detection and test execution tooling can help automate this process as well. 

BuildPulse enables you to find, assess impact metrics, quarantine, and fix flaky tests.

What are some strategies for preventing flaky tests?

Paying attention and prioritizing flaky tests as they come up can be a good way to prevent them from becoming an issue. This is where a testing culture is important - if a flaky test case is spotted by an engineer, it should be logged right away. This, however, takes a certain level of hygiene - BuildPulse can provide monitoring so flaky tests are caught right away.

What type of tests have flaky tests?

Flaky tests can be seen across the testing process - unit tests, integration tests, end-to-end tests, UI tests, acceptance tests.

What if I don't have that many flaky tests?

Flaky tests can be stealthy - often ignored by engineers and test runs are retried, they build up until they can’t be ignored anymore. These automated tests slow down developer productivity, impact functionality, and reduce confidence in test results and test suites. Better to get ahead while it’s easy and invest in test management.

It’s also important to prevent regressions to catch flakiness early while it’s manageable.

What languages and continuous integration providers does BuildPulse work with?

BuildPulse integrates with all continuous integration providers (including GitHub Actions, BitBucket Pipelines, and more), test frameworks, and workflows.

Combat non-determinism, drive test confidence, and provide the best experience you can to your developers!

How long does implementation/integration with BuildPulse take?

Implementation/integration takes 5 minutes!

Ready for Takeoff?

Ready for Takeoff?

Ready for Takeoff?