Hey there! Let’s tackle your questions step by step—first designing an e-commerce load testing plan with JMeter, then sorting out your test cycle and Ultimate Thread Group configuration confusion.

E-commerce apps have unique user flows and critical bottlenecks, so your test plan needs to mirror real-world behavior closely. Here’s how to structure it:

Core User Scenarios to Model #

Start by mapping the most common (and critical) journeys your users take:

• Guest browsing: Homepage → Product catalogue → Product detail page → (optional) Add to cart (abandoned checkout)
• Registered user flow: Login → Browse products → Add to cart → Checkout (shipping/payment) → Order confirmation
• Peak event flows: Flash deal browsing, limited-time discount redemption (if your app supports these)
• Backend/admin operations: Inventory updates, order fulfillment (only relevant if you need to test backend scalability)

JMeter Setup Breakdown #

• Test Structure:
  1. Root Test Plan
  2. Use Ultimate Thread Group to segment users (e.g., 60% registered, 30% guests, 10% admins)
  3. Wrap each user journey in a Transaction Controller to measure end-to-end performance (e.g., "Registered User Checkout")
• Key Config Elements:
  • HTTP Cookie Manager: Critical for maintaining session state for logged-in users
  • CSV Data Set Config: Feed test data like usernames/passwords, product IDs, and payment details to avoid repetitive requests
  • Your existing Uniform Random Timer: Keep it! Set think time to 2-7 seconds (adjust based on actual user behavior data if you have it) to simulate real pauses between actions
• Assertions: Add response assertions to validate success at each step—e.g., check for 200 OK status, presence of "Welcome [Username]" after login, or correct product pricing in the catalogue
• Listeners: Use these to capture actionable metrics:
  • Summary Report: Aggregated response times, error rates, and throughput
  • Response Time Graph: Visualize how latency changes under load
  • Backend Listener: Send metrics to tools like Prometheus (if you have them) for long-term monitoring

Test Types to Execute #

• Baseline Test: 10-15 minutes with 10-20 users to validate script correctness and establish a performance benchmark
• Load Test: Gradually increase users to your expected peak (e.g., 100 → 200 → 500) and hold each level for 15-30 minutes to measure sustained performance
• Stress Test: Push beyond peak load (e.g., 1000+ users) to find the system’s breaking point (when errors spike or latency becomes unacceptable)
• Soak Test: Run at 80% peak load for 4-8 hours to detect memory leaks or slow performance degradation over time

Let’s demystify the settings you’re unsure about, with practical examples tied to real testing goals:

How Long Should Tests Run? #

• Baseline/Validation: 10-15 minutes—enough to confirm scripts work and capture stable baseline metrics
• Load/Stress: 15-30 minutes per load level. This gives the system time to stabilize (cache warm-up, database connection pool adjustment) and helps you spot consistent issues, not transient blips
• Soak: 4-8 hours (or longer for apps with 24/7 usage) to catch issues that only appear over extended periods (e.g., database index fragmentation)

How Many Users to Add? #

Start with real-world data if you have it:

• Check analytics tools (like your app’s internal monitoring or Google Analytics) for peak concurrent user counts
• If no data exists, use Little’s Law as a rough estimate: Concurrent Users = (Requests per Second) × Average Response Time. For example, if your app handles 100 RPS with a 2-second average response time, aim for ~200 concurrent users

Ultimate Thread Group Parameter Settings #

Here’s how to set each field based on your test goals:

• Ramp-Up Time: The time to reach your target user count.
  • Rule of thumb: Ramp-Up = Number of Users / Users Added per Second. Start with adding 2-5 users per second to avoid overwhelming the system. For 200 users, that’s 40-100 seconds of ramp-up
  • For sudden spike testing (e.g., flash sale launches), set a short ramp-up (e.g., 10 seconds for 200 users)
• Hold Time (Steady State): How long you maintain the target user load. 15-30 minutes per level is ideal—this lets you observe if performance stays consistent or degrades over time
• Shutting Time: Time to gracefully stop threads. Set to 5-10 seconds to avoid abrupt termination that could skew metrics or leave unfinished transactions

Example Load Test Configuration #

If your target is 200 concurrent users:

• Add a row in Ultimate Thread Group with:
  • Start Threads Count: 200
  • Initial Delay, sec: 0
  • Startup Time, sec: 40 (ramp-up: 5 users per second)
  • Hold Load For, sec: 1800 (30 minutes steady state)
  • Shutdown Time, sec: 10

When Do You Have Enough Data? #

You’re ready to make decisions when:

• Metrics stabilize: Response times, error rates, and resource usage (CPU, memory, database query times) don’t fluctuate wildly after the steady state starts
• You’ve tested 3+ load levels (below peak, peak, above peak) to understand scalability
• Results are replicable: Run the same test 2-3 times to ensure outcomes aren’t one-time anomalies

内容的提问来源于stack exchange，提问作者Rickshaw Tomtom