TestNG annotations (@Test, @BeforeMethod, @AfterMethod) in Selenium Java - Framework Patterns

Framework Mode - TestNG annotations (@Test, @BeforeMethod, @AfterMethod)

Folder Structure

selenium-testng-project/
├── src/
│   └── test/
│       └── java/
│           ├── tests/
│           │   └── LoginTest.java
│           ├── pages/
│           │   └── LoginPage.java
│           ├── utils/
│           │   └── WebDriverFactory.java
│           └── config/
│               └── TestConfig.java
├── testng.xml
└── pom.xml
  

Test Framework Layers

• Test Layer: Contains test classes with @Test methods. Example: LoginTest.java where tests run and assertions happen.
• Setup/Teardown Layer: Uses @BeforeMethod and @AfterMethod annotations to prepare and clean up before and after each test method. For example, opening and closing browser sessions.
• Page Object Layer: Classes representing web pages with methods to interact with UI elements. Example: LoginPage.java encapsulates login form actions.
• Utility Layer: Helper classes like WebDriverFactory.java to create and manage WebDriver instances.
• Configuration Layer: Holds environment settings, browser types, and credentials in classes like TestConfig.java or external files.

Configuration Patterns

Use testng.xml to define test suites and parameters like browser type or environment.

Example snippet in testng.xml:

<suite name="RegressionSuite" parallel="tests" thread-count="2">
  <parameter name="browser" value="chrome" />
  <test name="LoginTests">
    <classes>
      <class name="tests.LoginTest" />
    </classes>
  </test>
</suite>
  

In test classes, use @Parameters to receive these values and configure WebDriver accordingly.

Store sensitive data like credentials securely, e.g., environment variables or encrypted files, and load them in TestConfig.java.

Test Reporting and CI/CD Integration

• TestNG generates HTML and XML reports automatically after test runs.
• Use listeners like ITestListener to customize reports or capture screenshots on failures.
• Integrate with CI/CD tools (Jenkins, GitHub Actions) to run tests on code commits and publish reports.
• Configure build tools (Maven/Gradle) to run TestNG tests and fail builds on test failures.

Best Practices

1. Use @BeforeMethod and @AfterMethod for clean setup and teardown: This ensures each test runs independently with a fresh browser state.
2. Keep tests atomic: Each @Test method should test one thing to make failures easy to diagnose.
3. Use Page Object Model: Encapsulate UI interactions to keep tests readable and maintainable.
4. Parameterize tests: Use @Parameters and testng.xml to run tests on different browsers or environments without code changes.
5. Handle waits explicitly: Avoid flaky tests by using explicit waits instead of fixed sleeps.

Self Check

Where in this folder structure would you add a new method to open the browser before each test?

Answer: In the test class under src/test/java/tests/, inside a method annotated with @BeforeMethod.

Key Result

Use TestNG annotations @Test, @BeforeMethod, and @AfterMethod to organize test execution with setup and cleanup steps.

Practice

1. What is the main purpose of the @BeforeMethod annotation in TestNG?

easy

A. To run a method before each test method to set up the test environment

B. To mark a method as a test case

C. To run a method after all test methods have finished

D. To skip a test method during execution

Solution

1. Step 1: Understand the role of @BeforeMethod

   This annotation is used to run a method before each test method to prepare or set up the environment.

2. Step 2: Differentiate from other annotations

   @Test marks test methods, @AfterMethod runs after each test, and skipping tests uses other annotations.

3. Final Answer:

   To run a method before each test method to set up the test environment -> Option A

4. Quick Check:

   @BeforeMethod = setup before each test [OK]

Hint: BeforeMethod always runs before each test method [OK]

Common Mistakes:

• Confusing @BeforeMethod with @BeforeClass
• Thinking @BeforeMethod runs only once
• Mixing @BeforeMethod with @AfterMethod

2. Which of the following is the correct syntax to mark a method as a test case in TestNG?

easy

A. @BeforeMethod void testMethod() {}

B. @Test void testMethod() {}

C. @AfterMethod void testMethod() {}

D. test void testMethod() {}

Solution

1. Step 1: Identify the annotation for test methods

   @Test is the correct annotation to mark a method as a test case in TestNG.

2. Step 2: Check syntax correctness

   The method signature with @Test void testMethod() {} is valid Java and TestNG syntax.

3. Final Answer:

   @Test void testMethod() {} -> Option B

4. Quick Check:

   @Test marks test methods [OK]

Hint: Use @Test to mark test methods in TestNG [OK]

Common Mistakes:

• Using @BeforeMethod or @AfterMethod instead of @Test
• Missing parentheses in method declaration
• Writing 'test' instead of '@Test'

3. Consider the following TestNG class:

public class SampleTest {
  @BeforeMethod
  public void setup() {
    System.out.println("Setup");
  }

  @Test
  public void test1() {
    System.out.println("Test1");
  }

  @Test
  public void test2() {
    System.out.println("Test2");
  }

  @AfterMethod
  public void cleanup() {
    System.out.println("Cleanup");
  }
}

What will be the order of printed lines when this test class runs?

medium

A. Test1
Test2
Setup
Cleanup

B. Setup
Cleanup
Test1
Setup
Cleanup
Test2

C. Setup
Test1
Test2
Cleanup

D. Setup
Test1
Cleanup
Setup
Test2
Cleanup

Solution

1. Step 1: Understand TestNG execution flow

   For each @Test method, @BeforeMethod runs before it and @AfterMethod runs after it.

2. Step 2: Trace the print statements

   First test: Setup -> Test1 -> Cleanup. Second test: Setup -> Test2 -> Cleanup.

3. Final Answer:

   Setup Test1 Cleanup Setup Test2 Cleanup -> Option D

4. Quick Check:

   BeforeMethod and AfterMethod wrap each test [OK]

Hint: BeforeMethod and AfterMethod run around each test [OK]

Common Mistakes:

• Assuming BeforeMethod runs once before all tests
• Assuming AfterMethod runs once after all tests
• Mixing order of print statements

4. Identify the error in the following TestNG code snippet:

public class TestExample {
  @BeforeMethod
  public void setup() {
    System.out.println("Setup");
  }

  @Test
  public void testMethod() {
    System.out.println("Test");
  }

  @AfterMethod
  public void cleanup() {
    System.out.println("Cleanup")
  }
}

medium

A. Missing semicolon after System.out.println("Cleanup")

B. Incorrect annotation @AfterMethod should be @AfterTest

C. setup() method should be static

D. testMethod() must return boolean

Solution

1. Step 1: Check syntax in cleanup() method

   The line System.out.println("Cleanup") is missing a semicolon at the end.

2. Step 2: Verify other parts

   Annotations are correct, methods do not need to be static, and test methods can be void.

3. Final Answer:

   Missing semicolon after System.out.println("Cleanup") -> Option A

4. Quick Check:

   Java statements must end with semicolon [OK]

Hint: Check for missing semicolons in Java code [OK]

Common Mistakes:

• Confusing @AfterMethod with @AfterTest
• Thinking test methods must return boolean
• Assuming setup() must be static

5. You want to run a setup method once before all tests in a TestNG class and a cleanup method after each test method. Which annotations should you use for these methods?

hard

A. @BeforeMethod for setup, @AfterMethod for cleanup

B. @BeforeMethod for setup, @AfterClass for cleanup

C. @BeforeClass for setup, @AfterMethod for cleanup

D. @BeforeTest for setup, @AfterTest for cleanup

Solution

1. Step 1: Identify annotation to run once before all tests

   @BeforeClass runs once before any test methods in the class.

2. Step 2: Identify annotation to run after each test method

   @AfterMethod runs after each test method to clean up.

3. Final Answer:

   @BeforeClass for setup, @AfterMethod for cleanup -> Option C

4. Quick Check:

   BeforeClass = once before all, AfterMethod = after each test [OK]

Hint: Use BeforeClass once, AfterMethod after each test [OK]

Common Mistakes:

• Using BeforeMethod for setup once only
• Using AfterClass for cleanup after each test
• Confusing BeforeTest with BeforeClass