Unit Testing Flashcards
What is unit testing in software development?
Unit testing is a software testing technique where individual components or functions of a software application are tested in isolation to ensure that they perform correctly as per their specifications.
What is the primary goal of unit testing?
The primary goal of unit testing is to verify that each unit of code (e.g., functions, methods, classes) works correctly in isolation, identifying and fixing bugs early in the development process.
What are the key characteristics of a good unit test?
Good unit tests are automated, isolated, repeatable, and provide clear pass/fail results. They should cover various scenarios, including edge cases, and be independent of external dependencies.
What is a test case in unit testing?
A test case is a specific scenario or condition that a unit test evaluates to check if the code behaves as expected. Test cases are designed to cover different aspects of the code’s functionality.
What is a test framework, and how does it relate to unit testing?
A test framework is a set of tools, libraries, and conventions used to organize, execute, and report on unit tests. It provides a structure for writing, organizing, and running tests efficiently.
What is the purpose of mock objects in unit testing?
Mock objects are used to simulate external dependencies or collaborators in unit tests. They allow developers to isolate the unit being tested and control the behavior of external components.
What is test-driven development (TDD), and how does it relate to unit testing?
Test-driven development (TDD) is a development approach where tests are written before writing the actual code. Developers follow a cycle of writing tests, implementing code to pass the tests, and then refactoring. TDD promotes unit testing as a core practice.
Why is regression testing important in the context of unit testing?
Regression testing ensures that new changes or features added to the codebase do not introduce new defects or break existing functionality. Unit tests play a significant role in regression testing by quickly identifying issues.
What are some popular unit testing frameworks for different programming languages?
Popular unit testing frameworks include JUnit for Java, NUnit for .NET, pytest for Python, RSpec for Ruby, and Jasmine for JavaScript, among others.
How can code coverage metrics help in unit testing?
Code coverage metrics measure the percentage of code that is executed by unit tests. They help identify areas of code that are not covered by tests, ensuring comprehensive test coverage.
What are flaky tests in the context of software testing?
Flaky tests, also known as unstable tests or nondeterministic tests, are automated tests that produce inconsistent results upon multiple test executions, even if the application code remains unchanged.
What are some common reasons for tests to become flaky?
Flaky tests can result from various factors, including:
Timing Issues: Tests relying on specific timing conditions can fail if the system’s performance varies.
Concurrency Problems: Tests involving multiple threads or processes can lead to race conditions.
External Dependencies: Tests interacting with external services, databases, or network resources may fail due to external changes or network issues.
Order Dependency: Tests that rely on the order of execution can become flaky if executed in a different order.
Test Data: Flaky tests may occur if test data changes or is not properly isolated.
Environment Variability: Differences in test environments (e.g., hardware, software, configurations) can lead to flakiness.
Why are flaky tests problematic in software development?
Flaky tests can be problematic for several reasons:
They erode trust in the testing process as developers may ignore or mistrust test failures.
They waste development time and resources in investigating and fixing non-existent issues.
They can lead to false bug reports and unnecessary code changes.
They may hide actual defects by masking them with random test failures.
How can flaky tests be identified and mitigated?
To identify and mitigate flaky tests:
Rerun Tests: Rerun failing tests multiple times to confirm flakiness. If a test fails intermittently, it’s likely flaky.
Isolate Tests: Ensure that tests are isolated from each other and don’t share state or dependencies.
Fix Timing Issues: Use explicit waits, timeouts, or mock time to handle timing-related issues.
Mock External Dependencies: Replace external services with mocks or stubs to eliminate external factors.
Randomize Test Order: Execute tests in random order to uncover order-dependent issues.
Reset State: Reset the application or test environment to a known state before each test.
Use Stable Environments: Ensure that test environments are stable and consistent.
Monitor and Investigate: Continuously monitor test results and investigate failures promptly.
Documentation: Document known flaky tests and their status to inform the development team.
Are there tools or frameworks to help identify and manage flaky tests?
Yes, there are tools and frameworks designed to help identify and manage flaky tests. Some of these include:
Test Retry Mechanisms: Some test runners allow you to automatically retry failed tests a certain number of times to identify flakiness.
Test Flakiness Detection Tools: There are tools like “Flaky Tests Detection” plugins for test frameworks that help identify flaky tests based on historical data.
Continuous Integration (CI) Pipelines: CI systems can be configured to rerun failed tests, and the number of retries can be adjusted based on historical data.
Custom Test Wrappers: Developers can create custom test wrappers that automatically rerun tests and report flaky ones.
Logging and Reporting: Comprehensive test logging and reporting can help identify patterns of flakiness over time.
How can a development team prevent flaky tests from being introduced in the first place?
To prevent flaky tests:
Follow best practices for writing stable and deterministic tests.
Isolate tests from external dependencies and shared state.
Use explicit synchronization mechanisms when dealing with timing-related operations.
Regularly review and refactor tests to maintain their stability.
Maintain a clean and consistent test environment.
Encourage communication within the team about test flakiness to address issues promptly.
What role does test automation play in managing flaky tests?
Test automation can both contribute to and help mitigate flaky tests. While poorly designed automated tests can introduce flakiness, well-designed automated tests can detect flakiness early and facilitate rapid retesting and debugging. Automation also allows for rerunning tests frequently, increasing the chances of identifying flaky tests.
What is the purpose of the @Mock annotation in Mockito?
The @Mock annotation is used to create a mock object of a class or interface in Mockito.
How is the @Spy annotation different from the @Mock annotation in Mockito?
The @Spy annotation is used to create a spy object, which retains the real behavior of the object while allowing you to stub or verify specific methods. The @Mock annotation creates a traditional mock object with no real behavior.
What does the @Captor annotation help you do in Mockito?
The @Captor annotation is used to create an ArgumentCaptor, which helps capture arguments passed to methods during method invocations on mock objects. It is often used for verification purposes.
How do you inject mock or spy dependencies into the class under test using Mockito?
You can use the @InjectMocks annotation to inject mock or spy dependencies into the class under test.
What is the purpose of the @RunWith(MockitoJUnitRunner.class) annotation in Mockito?
The @RunWith(MockitoJUnitRunner.class) annotation is used to run the test class with the MockitoJUnitRunner. It initializes mocks annotated with @Mock and manages the Mockito lifecycle.
How can you manually initialize mock objects when not using the MockitoJUnitRunner?
You can manually initialize mock objects using the @MockitoAnnotations.initMocks(this) annotation. It is typically used in the @Before setup method of the test class.
Mockit Annotations
@Mock:
Usage: @Mock
Description: This annotation is used to create a mock object of a class or interface. It initializes a mock object and makes it available for use in the test class.
@Spy:
Usage: @Spy
Description: The @Spy annotation is used to create a spy object, which is a partially mocked object. A spy retains the real behavior of the object but allows you to stub or verify specific methods.
@Captor:
Usage: @Captor
Description: The @Captor annotation is used to create an ArgumentCaptor, which is used to capture arguments passed to methods during method invocations on mock objects. It’s often used in conjunction with verification.
@InjectMocks:
Usage: @InjectMocks
Description: The @InjectMocks annotation is used to inject mock or spy dependencies into the class under test. It identifies the target class where mock dependencies should be injected.
@RunWith(MockitoJUnitRunner.class):
Usage: @RunWith(MockitoJUnitRunner.class)
Description: This annotation is used at the class level to run the test class with the MockitoJUnitRunner. It initializes mocks annotated with @Mock, and it manages the Mockito lifecycle.
@MockitoAnnotations.initMocks(this):
Usage: @MockitoAnnotations.initMocks(this)
Description: Instead of using the MockitoJUnitRunner, you can manually initialize mock objects using this annotation. It’s typically used in the @Before setup method of the test class.
