Perform Overbooking Testing to Simulate More Booking Request

Overbooking testing in JMeter helps ensure that a system can gracefully handle situations where booking requests exceed the available resources, such as hotel rooms or flight seats. This type of testing simulates real-world scenarios of high demand and is essential for identifying potential bottlenecks, failures, or performance issues. Using JMeter, you can create and execute a test plan to simulate overbooking scenarios, analyze system behavior, and validate responses under stress conditions.

What are the Steps to Perform Overbooking Testing in JMeter?

1. Prepare Your Test Plan
   • Install JMeter: Ensure you have JMeter set up.
   • Identify the Booking Endpoint: Know the API or URL where booking requests are processed.
   • Define Test Data: Create a CSV file with user details, booking dates, etc., to simulate multiple bookings.
2. Create the JMeter Test Plan
   

   Step-by-Step Configuration:

   • Create a Thread Group
     • Right-click on Test Plan → Add → Threads (Users) → Thread Group.
     • Configure:
       • Number of Threads (Users): Set this to a number higher than the available resources (e.g., 150 users for 100 available resources).
       • Ramp-Up Period: Gradually increase load to simulate real-world behavior (e.g., 30 seconds).
       • Loop Count: Set to 1 (or more if simulating retries).
   • Add an HTTP Request Sampler
     • Right-click on Thread Group → Add → Sampler → HTTP Request.
     • Configure the request:
       • Server Name or IP: Your booking server.
       • Method: POST (if creating a booking).
       • Path: Endpoint (e.g., /api/book).
       • Parameters: Add booking details like userId, resourceId, and bookingDate.
   • Add a CSV Data Set Config (For Dynamic Data)
     • Right-click on Thread Group → Add → Config Element → CSV Data Set Config.
     • Load your test data file.
   • Add Assertions (Optional but Recommended)
     • To verify responses:
       • Response Assertion: Right-click on HTTP Request → Add → Assertions → Response Assertion.
       • Validate successful or failed bookings based on expected responses (e.g., status codes or messages).
   • Add Listeners
     • For reporting:
       • View Results Tree and Summary Report help monitor and analyze performance.
3. Analyze Results
   • View Results Tree: Check for failed requests and response times.
   • Summary Report: Identify the percentage of failed bookings.
   • Check Logs: Validate how the system handled overbooked requests (e.g., error codes, rollback processes).
4. JMX Script Example: [xml file]

   <ThreadGroup testname="OverbookingTest" enabled="true">
     <stringProp name="ThreadGroup.num_threads">150</stringProp>
     <stringProp name="ThreadGroup.ramp_time">30</stringProp>
     <elementProp name="ThreadGroup.main_controller" elementType="LoopController"/>
   </ThreadGroup>
   <HTTPSamplerProxy testname="BookRequest" enabled="true">
     <stringProp name="HTTPSampler.domain">booking.example.com</stringProp>
     <stringProp name="HTTPSampler.path">/api/book</stringProp>
     <stringProp name="HTTPSampler.method">POST</stringProp>
     <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
       <collectionProp name="Arguments.arguments">
         <elementProp name="resourceId" elementType="HTTPArgument">
           <stringProp name="Argument.value">123</stringProp>
         </elementProp>
       </collectionProp>
     </elementProp>
   </HTTPSamplerProxy>

   This script creates a load of 150 users sending booking requests, simulating overbooking effectively.

   • num_threads: Number of concurrent users (simulated load)—set to 150.
   • ramp_time: Time (in seconds) to start all threads gradually—set to 30.
   • domain: Server address where booking requests are sent—booking.example.com.
   • path: API endpoint for booking — /api/book.
   • method: HTTP method used for the request—POST.
   • resourceId: Booking parameter value—123.

Conclusion

Overbooking testing is critical for systems that manage limited resources, ensuring they remain reliable and efficient under high-demand conditions. With JMeter's powerful tools, such as Thread Groups, HTTP Samplers, and CSV data configuration, you can simulate realistic overbooking scenarios and identify areas for improvement. Proper test results analysis ensures that your system is prepared to handle peak loads effectively, maintaining customer satisfaction and operational stability.