@DisplayName for readable names in JUnit - Framework Patterns

Framework Mode - @DisplayName for readable names

Folder Structure

project-root/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/example/app/
│   │           └── App.java
│   └── test/
│       └── java/
│           └── com/example/app/
│               ├── tests/
│               │   └── LoginTests.java
│               ├── pages/
│               │   └── LoginPage.java
│               └── utils/
│                   └── TestUtils.java
└── pom.xml
    

Test Framework Layers

• Test Classes: Contain test methods annotated with @Test and @DisplayName for readable test names.
• Page Objects: Represent UI pages with methods to interact with page elements.
• Utilities: Helper classes for common functions like waits, data setup, or assertions.
• Configuration: Manage environment settings, browser setup, and test parameters.
• Test Runner: JUnit platform runs tests and uses @DisplayName to show readable names in reports.

Configuration Patterns

• Use src/test/resources for config files like application.properties or test.properties.
• Use Maven profiles or system properties to switch environments (dev, test, prod).
• Configure browser and other settings in a central config class or via dependency injection.
• Keep credentials secure and load them from environment variables or encrypted files.
• JUnit 5 supports @BeforeAll and @BeforeEach to set up test context.

Test Reporting and CI/CD Integration

• JUnit 5 generates XML reports compatible with CI tools like Jenkins, GitHub Actions, or GitLab.
• @DisplayName annotations improve report readability by showing descriptive test names instead of method names.
• Integrate with build tools (Maven/Gradle) to run tests automatically on code commits.
• Use plugins like Surefire or Failsafe to generate detailed test reports.
• CI pipelines can fail builds on test failures and notify teams with clear test names from @DisplayName.

Best Practices

1. Use @DisplayName to write clear, human-readable test names that describe the test purpose.
2. Keep test method names concise but use @DisplayName for detailed explanations.
3. Consistently apply @DisplayName across all test methods for uniform reports.
4. Use natural language in @DisplayName to help non-technical stakeholders understand test results.
5. Combine @DisplayName with nested tests or parameterized tests for better structure and clarity.

Self Check

Where in this folder structure would you add a new test method with a @DisplayName annotation for a feature called "User Registration"?

Key Result

Use @DisplayName in JUnit tests to provide clear, readable test names for better reports and understanding.

Practice

1. What is the main purpose of using @DisplayName in JUnit tests?

easy

A. To skip a test during execution

B. To change the test execution order

C. To give tests clear, readable names for better understanding

D. To add tags for filtering tests

Solution

1. Step 1: Understand the role of @DisplayName

   @DisplayName is used to provide a human-friendly name to a test method instead of the method name.

2. Step 2: Identify the benefit of readable names

   This helps both technical and non-technical people quickly understand what the test checks when reading reports.

3. Final Answer:

   To give tests clear, readable names for better understanding -> Option C

4. Quick Check:

   @DisplayName = readable test names [OK]

Hint: Remember: @DisplayName makes test names easy to read [OK]

Common Mistakes:

• Thinking @DisplayName changes test order
• Confusing @DisplayName with @Tag
• Assuming @DisplayName skips tests

2. Which of the following is the correct syntax to use @DisplayName in a JUnit 5 test method?

easy

A. @DisplayName = "Test addition method"
void testAdd() {}

B. @DisplayName("Test addition method")
void testAdd() {}

C. @DisplayName: "Test addition method"
void testAdd() {}

D. @DisplayName testAdd("Test addition method") {}

Solution

1. Step 1: Recall correct annotation syntax

   Annotations in Java use @AnnotationName("string") before the method signature.

2. Step 2: Match syntax with options

   @DisplayName("Test addition method") void testAdd() {} correctly uses @DisplayName with parentheses and a string argument before the method.

3. Final Answer:

   @DisplayName("Test addition method") void testAdd() {} -> Option B

4. Quick Check:

   @DisplayName("...") syntax is correct [OK]

Hint: Annotations need @ and parentheses with strings [OK]

Common Mistakes:

• Using = or : instead of parentheses
• Placing @DisplayName after method signature
• Omitting quotes around the display name

3. Given the following test code, what will be the display name shown in the test report?

@Test
@DisplayName("Check if number is positive")
void isPositiveTest() {
    assertTrue(5 > 0);
}

medium

A. isPositiveTest

B. assertTrue(5 > 0)

C. void isPositiveTest()

D. Check if number is positive

Solution

1. Step 1: Identify the effect of @DisplayName

   The @DisplayName annotation overrides the default method name shown in reports with the given string.

2. Step 2: Check the string provided

   The string "Check if number is positive" will be shown instead of the method name.

3. Final Answer:

   Check if number is positive -> Option D

4. Quick Check:

   @DisplayName string replaces method name [OK]

Hint: Display name shows the annotation string, not method name [OK]

Common Mistakes:

• Expecting method name instead of display name
• Confusing method signature with display name
• Thinking assertion text appears as name

4. Identify the error in the following JUnit 5 test code using @DisplayName:

@Test
@DisplayName(Test addition)
void testAdd() {
    assertEquals(4, 2 + 2);
}

medium

A. Missing quotes around the display name string

B. Missing @Test annotation

C. assertEquals arguments are reversed

D. Method name should be public

Solution

1. Step 1: Check @DisplayName syntax

   The display name must be a string literal enclosed in double quotes.

2. Step 2: Identify missing quotes

   Here, Test addition is not in quotes, causing a syntax error.

3. Final Answer:

   Missing quotes around the display name string -> Option A

4. Quick Check:

   @DisplayName needs quotes around text [OK]

Hint: Always put display names inside double quotes [OK]

Common Mistakes:

• Omitting quotes around display name
• Confusing @DisplayName with @Test
• Thinking method must be public in JUnit 5

5. You want to write a JUnit 5 test method with a display name that includes quotes, like: Test "add" method works. Which is the correct way to write the @DisplayName annotation?

hard

A. @DisplayName("Test \"add\" method works")

B. @DisplayName('Test "add" method works')

C. @DisplayName("Test 'add' method works")

D. @DisplayName(Test "add" method works)

Solution

1. Step 1: Understand string escaping in Java annotations

   Double quotes inside a Java string must be escaped with a backslash (\") to be valid.

2. Step 2: Check each option for correct escaping

   @DisplayName("Test \"add\" method works") correctly escapes the inner quotes with \". @DisplayName('Test "add" method works') uses single quotes which are invalid for Java strings. @DisplayName("Test 'add' method works") uses single quotes inside double quotes which is valid but changes the quote style. @DisplayName(Test "add" method works) lacks quotes entirely, causing syntax error.

3. Final Answer:

   @DisplayName("Test \"add\" method works") -> Option A

4. Quick Check:

   Escape inner quotes with backslash in Java strings [OK]

Hint: Escape inner double quotes with \" inside @DisplayName [OK]

Common Mistakes:

• Using single quotes for Java strings
• Not escaping inner double quotes
• Omitting quotes around the display name