xUnit Test Patterns: Refactoring Test Code Flashcards

Question

Key Principles of Refactoring Test Code What is descriptive naming in test code?

Answer 1

test method names should clearly describe what is being tested and the expected behavior. Example: testGetCustomerNameReturnsCorrectValue()

Answer 2

Simplifies test execution and reporting. Catches regressions earlier.

Answer 3

To improve readability and make it clear what is being tested.

Answer 4

Each test should focus on one thing (one assertion).

Answer 5

It makes tests clearer, easier to debug, and faster to execute.

Answer 6

Move repetitive code into setup methods (e.g., @Before, setUp). Use data-driven tests to run the same test with multiple inputs.

Answer 7

A shared setup used across multiple tests (e.g., database connections, mock objects).

Answer 8

To reduce redundancy and make tests more efficient.

Answer 9

Signs that indicate poorly written test code, making it harder to maintain.

Answer 10

Duplicated Code – Repeated setup or logic across tests. Long Test Methods – Testing multiple things in one method. Setup Duplication – Repeating the same setup in each test. Hard-to-Understand Logic – Tests are too complex. Excessive Use of Mocks – Too many mocks make tests difficult to maintain.

Answer 11

It makes test maintenance harder and increases redundancy.

Answer 12

They test too many things at once, making them hard to debug.

Answer 13

Same test setup logic is repeated in multiple tests. Increases maintenance effort and code duplication.

Answer 14

It can make tests too complex and less reliable.

Answer 15

They make test code harder to update and debug.

Answer 16

Poor test design can lead to false positives/negatives and fragile tests.

Answer 17

To ensure test names clearly describe what is being tested and the expected outcome.

Answer 18

Rename testMethod1() to testWhenInputIsNullThenReturnEmptyList().

Answer 19

To move repetitive test code into reusable setup or helper methods.

Answer 20

Extracting list initialization into a helper method to be used in multiple tests.

Answer 21

When an extracted method is too simple and clutters the test code.

Answer 22

It splits large test classes into smaller, more focused classes.

Answer 23

Splitting CustomerTests into DatabaseTests and UITests.

Answer 24

To ensure the test class name clearly reflects its purpose.

Answer 25

Renaming TestClass1 to CustomerServiceTests.

Answer 26

Identify the Problem Isolate the Problem Refactor the Code Test the Refactor

Answer 27

Look for test smells like duplication, complexity, or fragility.

Answer 28

Unclear logic or unintentional dependencies.

Answer 29

Determine which test class or method needs refactoring.

Answer 30

It helps identify the underlying cause before refactoring.

Answer 31

Apply refactoring patterns like extract method, remove duplication, and simplify assertions.

Answer 32

Run tests to ensure they still pass and no functionality is broken.

Answer 33

To minimize errors and make debugging easier.

Answer 34

Objects that replace real components to isolate the unit under test.

Answer 35

To improve test isolation and remove dependencies on real components.

Answer 36

Stubs, Mocks, Spies, Fakes, and Dummies.

Answer 37

Predefined responses to method calls.

Answer 38

They verify interactions (assertions inside mocks).

Answer 39

Like mocks, but also record method calls for later verification.

Answer 40

Simplified implementations for testing (e.g., an in-memory database).

Answer 41

Used as placeholders but not actually used in the test.

Answer 42

A technique where dependencies are injected into tests instead of being created within the test.

Answer 43

It makes it easier to replace dependencies with stubs, mocks, or fakes.

Answer 44

Ensuring that tests do not rely on external systems like databases or file systems.

Answer 45

Use mocking or stubbing to simulate interactions with external systems.

Answer 46

It keeps the test suite lean and easy to maintain.

Answer 47

It encourages cleaner code and improves the development process.

Answer 48

Refactor tests after each new feature or bug fix to prevent test rot.

Answer 49

A group of related tests that are run together logically.

Answer 50

It ensures independent tests by using setup/teardown methods.

Answer 51

To clearly explain what the test does and what it verifies.

Answer 52

It makes tests easier to understand, maintain, and debug.

Answer 53

It describes expected behavior. Example: should_ReturnValidUser_WhenInputIsCorrect()

Answer 54

It describes the condition under which the test is run. Example: when_InputIsNull_then_ReturnEmptyList()

Answer 55

It describes the expected outcome of the test. Example: when_UserNotFound_then_ThrowException()

Answer 56

Stubs provide predefined behavior for a method during a test.

Answer 57

public class StubDatabaseConnection implements DatabaseConnection { public String fetchData() { return "Stubbed Data"; } }

Answer 58

Mocks check interactions between classes, ensuring methods are called.

Answer 59

@Test public void shouldCallServiceOnce() { Service serviceMock = mock(Service.class); serviceMock.doSomething(); verify(serviceMock, times(1)).doSomething(); }

Answer 60

Fakes are simplified implementations of a system, often used for performance.

Answer 61

public class FakeDatabase implements DatabaseConnection { private Map dataStore = new HashMap<>(); @Override public String fetchData(int id) { return dataStore.get(id); } }

Answer 62

To initialize and clean up resources before and after each test.

Answer 63

@Before and @After.

Answer 64

@Before public void setUp() { // Setup code for shared resources like DB connections } @After public void tearDown() { // Cleanup code after each test }

Answer 65

Shared setup for multiple tests using @BeforeClass and @AfterClass.

Answer 66

@BeforeClass public static void setupClass() { // Setup shared resources for all tests } @AfterClass public static void tearDownClass() { // Clean up shared resources }

xUnit Test Patterns: Refactoring Test Code Flashcards

(90 cards)