TestNG, a robust testing framework for Java, empowers testers to create custom annotations with parameters, revolutionizing how test configurations are managed. In this blog, we will delve into the process of crafting custom annotations in TestNG, explore the art of passing parameters to these annotations, and showcase their practical application through illustrative examples. This feature enhances test modularity, readability, and maintainability and serves as a game-changer for intermediate TestNG users.
Creating Custom Annotations with Parameters
To create custom annotations in TestNG, one must define the annotation interface with the desired parameters. These parameters can be used to pass values to test methods, enabling dynamic test configurations. By incorporating parameters into custom annotations, testers can tailor test behavior based on specific requirements, enhancing the flexibility and adaptability of their test suites.
Example:
Let’s consider a scenario where we have test methods for different payment methods (e.g., credit card, PayPal), and we want to parameterize them with the respective account details using the @TestData annotation.
package Practice;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface TestData {
String method(); // Payment method: creditCard or paypal
String account(); // Account details: credit card number, PayPal email, etc.
String cvv() default ""; // CVV for credit card (optional)
String expiry() default ""; // Expiry date for credit card (optional)
String password() default ""; // Password for PayPal (optional)
}
Let’s understand the code:
-
@Retention(RetentionPolicy.RUNTIME):
- This line defines the retention policy for the @TestData annotation. RetentionPolicy.RUNTIME indicates that the annotation should be retained at runtime and can be accessed via reflection.
-
@Target(ElementType.METHOD):
- This line specifies that the @TestData annotation can only be applied to methods.
-
public @interface TestData:
- This declares the TestData annotation. Annotations in Java are declared using the @interface keyword.
package Practice;
import org.testng.annotations.Test;
import java.lang.reflect.Method;
public class PaymentTest {
@Test
@TestData(method = "creditCard", account = "1234567890123456", cvv = "123", expiry = "12/25")
public void testCreditCardPayment() throws NoSuchMethodException {
printTestData("testCreditCardPayment");
}
@Test
@TestData(method = "paypal", account = "example@example.com", password = "password")
public void testPayPalPayment() throws NoSuchMethodException {
printTestData("testPayPalPayment");
}
private void printTestData(String methodName) throws NoSuchMethodException {
Method method = getClass().getMethod(methodName);
TestData testDataAnnotation = method.getAnnotation(TestData.class);
if (testDataAnnotation != null) {
System.out.println("Test Method: " + methodName);
System.out.println("Payment Method: " + testDataAnnotation.method());
if (testDataAnnotation.method().equals("creditCard")) {
System.out.println("Credit Card Number: " + testDataAnnotation.account());
System.out.println("CVV: " + testDataAnnotation.cvv());
System.out.println("Expiry Date: " + testDataAnnotation.expiry());
} else if (testDataAnnotation.method().equals("paypal")) {
System.out.println("PayPal Account: " + testDataAnnotation.account());
System.out.println("PayPal Password: " + testDataAnnotation.password());
}
} else {
System.out.println("No TestData annotation found for method: " + methodName);
}
}
}
Let’s understand the code:
-
@Test:
- This annotation marks a method as a test method.
-
@TestData(method = “creditCard”, account = “1234567890123456”, cvv = “123”, expiry = “12/25”):
- This line applies the @TestData annotation to the testCreditCardPayment method and specifies the payment method as “creditCard” along with the associated account details, such as credit card number, CVV, and expiry date.
-
Method method = getClass().getMethod(methodName);:
- This line retrieves the Method object corresponding to the test method with the given name (methodName) using reflection.
-
TestData testDataAnnotation = method.getAnnotation(TestData.class);:
- This line retrieves the @TestData annotation associated with the test method.
-
if (testDataAnnotation != null):
- This line checks if the @TestData annotation is present for the test method.
-
System.out.println(“Test Method: ” + methodName);:
- This line prints the name of the test method.
-
System.out.println(“Payment Method: ” + testDataAnnotation.method());:
- This line prints the payment method specified in the @TestData annotation.
-
if (testDataAnnotation.method().equals(“CreditCard”)) { … }
- This conditional block checks if the payment method is “creditCard” and prints additional details such as credit card number, CVV, and expiry date.
Advantages of Custom Annotations with Parameters
- Enhanced Modularity: Custom annotations allow testers to encapsulate common testing behaviors or conditions, promoting code reusability and reducing duplication.
- Improved Readability: By abstracting complex configurations into custom annotations, test methods become more concise and easier to understand.
- Dynamic Test Configuration: Parameters in custom annotations enable dynamic test configuration, allowing testers to customize test behavior based on specific criteria.
Custom annotations with parameters in TestNG offer a powerful way to enhance test configurations, promote reusability, and improve maintainability in test automation. By creating annotations like @TestData with specific parameters, testers can dynamically provide input values to test methods, making tests more adaptable and flexible.
