Validating Response Time in RestAssured - Notes By ShariqSP

Validating Response Time in RestAssured

Response time is a critical performance metric for APIs. Validating response time ensures that the server processes requests efficiently and meets the expected performance standards. Below is a guide on how to validate response times using RestAssured.

Why Validate Response Time?

• Performance Benchmarking: Ensures the API responds within acceptable time limits.
• Improves User Experience: Faster responses lead to a better user experience.
• Detects Performance Bottlenecks: Identifies APIs that take longer than expected.

Example Code for Response Time Validation

            import io.restassured.RestAssured;
            import static io.restassured.RestAssured.*;
            import static org.hamcrest.Matchers.*;

            public class ResponseTimeValidation {

                public static void main(String[] args) {
                    // Base URL
                    String baseURL = "http://apitesting.shariqsp.com:8080/api/companies";

                    // Validate response time is less than 2 seconds (2000 milliseconds)
                    given()
                        .get(baseURL)
                        .then()
                        .assertThat()
                        .time(lessThan(2000L)); // Validate response time is under 2000 ms

                    // Validate response time is greater than 500 ms (Example: testing minimal threshold)
                    given()
                        .get(baseURL)
                        .then()
                        .assertThat()
                        .time(greaterThan(500L)); // Validate response time is above 500 ms

                    // Log response time for debugging
                    long responseTime = given()
                                            .get(baseURL)
                                            .time();
                    System.out.println("Response Time: " + responseTime + " ms");
                }
            }
                

Explanation of Response Time Assertions

• lessThan(2000L): Ensures the response time is within 2 seconds. Replace 2000L with your desired threshold.
• greaterThan(500L): Validates that the API does not respond too quickly, potentially missing processing steps.
• Logging Response Time: Helps monitor performance trends and debug slow API responses.

Best Practices for Response Time Validation

• Set Realistic Thresholds: Base the thresholds on SLA (Service Level Agreement) requirements or average response times.
• Run Tests Under Load: Validate response times during peak traffic scenarios to simulate real-world conditions.
• Log Results: Keep a record of response times to identify performance degradation over time.

Conclusion

Response time validation is a crucial aspect of API testing. By setting appropriate thresholds and logging performance data, you can ensure your APIs remain responsive and efficient under various conditions.

Validating Response Time Using Matchers.lessThan and Matchers.greaterThan

When working with APIs, it's important to validate response times to ensure they meet performance benchmarks. The `Matchers.lessThan` and `Matchers.greaterThan` methods allow precise response time validation.

Example Code Using Matchers

            import io.restassured.RestAssured;
            import static io.restassured.RestAssured.*;
            import org.hamcrest.Matchers;

            public class ResponseTimeValidation {

                public static void main(String[] args) {
                    // Base URL for API
                    String baseURL = "http://apitesting.shariqsp.com:8080/api/companies";

                    // Validate response time is less than 2000 ms
                    given()
                        .get(baseURL)
                        .then()
                        .assertThat()
                        .time(Matchers.lessThan(2000L)); // Ensures response time is less than 2000 ms

                    // Validate response time is greater than 500 ms
                    given()
                        .get(baseURL)
                        .then()
                        .assertThat()
                        .time(Matchers.greaterThan(500L)); // Ensures response time is greater than 500 ms

                    // Validate response time is between 500 ms and 2000 ms
                    given()
                        .get(baseURL)
                        .then()
                        .assertThat()
                        .time(Matchers.allOf(Matchers.greaterThan(500L), Matchers.lessThan(2000L)));
                    // Ensures 500 ms < response time < 2000 ms
                }
            }
                

Explanation

• Matchers.lessThan(2000L): Validates that the response time is below the threshold of 2000 ms.
• Matchers.greaterThan(500L): Ensures that the response time exceeds 500 ms.
• Matchers.allOf: Combines multiple conditions, such as ensuring the response time is within a specific range.

Best Practices

• Set Realistic Thresholds: Use benchmarks derived from actual user expectations and SLA agreements.
• Combine Matchers: Use `allOf` or `anyOf` to handle more complex scenarios.
• Use Logs: Log response times to track performance trends over time.
• Include Tolerances: Allow some flexibility to accommodate slight variations in network or server load.

Output

If the API response time meets the conditions, the test will pass silently. If not, RestAssured will throw an assertion error, specifying the mismatch in expected and actual response times.

Conclusion

Using `Matchers.lessThan` and `Matchers.greaterThan` provides precise validation of API response times, helping to enforce performance expectations effectively.