Stress testing concepts in Testing Fundamentals - Build an Automation Script

Stress Test Login Functionality Under High Load

Preconditions (3)

Step 1: Open the login page URL

Step 2: Simulate 1000 users attempting to login simultaneously using valid credentials

Step 3: Monitor the response time and server behavior during the login attempts

Step 4: Record any errors or failures during the login process

✅ Expected Result: The system should handle 1000 simultaneous login requests without crashing, with acceptable response times and no data loss or errors.

Automation Requirements - JMeter

Assertions Needed:

Verify that all login requests return HTTP status 200

Check that average response time is below 5 seconds

Ensure no error responses are returned during the test

Best Practices:

Use thread groups to simulate concurrent users

Add timers to mimic real user think time

Use assertions to validate server responses

Monitor server resource usage during the test

Automated Solution

Testing Fundamentals

import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.engine.StandardJMeterEngine;
import org.apache.jmeter.protocol.http.control.HeaderManager;
import org.apache.jmeter.protocol.http.control.gui.HttpTestSampleGui;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy;
import org.apache.jmeter.reporters.ResultCollector;
import org.apache.jmeter.samplers.SampleSaveConfiguration;
import org.apache.jmeter.testelement.TestPlan;
import org.apache.jmeter.threads.ThreadGroup;
import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.collections.HashTree;

public class StressTestLogin {
    public static void main(String[] args) throws Exception {
        // Set JMeter home for JMeter utils
        String jmeterHome = System.getenv("JMETER_HOME");
        JMeterUtils.setJMeterHome(jmeterHome);
        JMeterUtils.loadJMeterProperties(jmeterHome + "/bin/jmeter.properties");
        JMeterUtils.initLocale();

        StandardJMeterEngine jmeter = new StandardJMeterEngine();

        // Test Plan
        TestPlan testPlan = new TestPlan("Stress Test Login Functionality");

        // HTTP Sampler for login
        HTTPSamplerProxy loginSampler = new HTTPSamplerProxy();
        loginSampler.setDomain("example.com");
        loginSampler.setPort(80);
        loginSampler.setPath("/login");
        loginSampler.setMethod("POST");
        loginSampler.addArgument("username", "testuser");
        loginSampler.addArgument("password", "password123");
        loginSampler.setName("Login Request");
        loginSampler.setProperty(TestElement.TEST_CLASS, HTTPSamplerProxy.class.getName());
        loginSampler.setProperty(TestElement.GUI_CLASS, HttpTestSampleGui.class.getName());

        // Thread Group to simulate 1000 users
        ThreadGroup threadGroup = new ThreadGroup();
        threadGroup.setName("User Threads");
        threadGroup.setNumThreads(1000);
        threadGroup.setRampUp(10); // 10 seconds ramp-up
        threadGroup.setSamplerController(new LoopController() {{
            setLoops(1);
            setFirst(true);
        }});

        // Test Plan tree
        HashTree testPlanTree = new HashTree();
        HashTree threadGroupHashTree = testPlanTree.add(testPlan, threadGroup);
        threadGroupHashTree.add(loginSampler);

        // Result collector
        ResultCollector logger = new ResultCollector();
        SampleSaveConfiguration saveConfig = new SampleSaveConfiguration();
        saveConfig.setTime(true);
        saveConfig.setLatency(true);
        saveConfig.setSuccess(true);
        saveConfig.setResponseCode(true);
        saveConfig.setResponseMessage(true);
        saveConfig.setThreadName(true);
        logger.setSaveConfig(saveConfig);
        testPlanTree.add(testPlanTree.getArray()[0], logger);

        // Run Test Plan
        jmeter.configure(testPlanTree);
        jmeter.run();
    }
}

This script uses Apache JMeter's Java API to create a stress test for the login functionality.

First, it sets up JMeter environment and properties.

Then, it creates a Test Plan and an HTTP Sampler that sends a POST request to the login URL with valid credentials.

A Thread Group simulates 1000 users logging in simultaneously with a 10-second ramp-up to avoid all hitting at once.

The test plan tree organizes these elements, and a Result Collector is added to capture results.

Finally, the test plan is run, which will simulate the load and allow monitoring of response times and errors.

Common Mistakes - 3 Pitfalls

{'mistake': 'Using Thread.sleep() to simulate user wait times instead of JMeter timers', 'why_bad': 'Thread.sleep() pauses the entire test thread and does not simulate real user think time properly, leading to inaccurate load simulation.', 'correct_approach': "Use JMeter's built-in timers like Constant Timer or Uniform Random Timer to simulate realistic user delays."}

Hardcoding user credentials inside the script without parameterization

Not setting ramp-up time, causing all users to hit the server at once

Bonus Challenge

Now add data-driven testing with 3 different user credentials to simulate varied login attempts.

Show Hint

Practice

1. What is the main goal of stress testing in software testing?

easy

A. To verify the system's installation process

B. To check if the system meets all functional requirements

C. To test the system's user interface for usability

D. To push the system beyond its normal limits to find breaking points

Solution

1. Step 1: Understand the purpose of stress testing

   Stress testing is designed to push a system beyond normal operational capacity to see how it behaves under extreme conditions.

2. Step 2: Compare options with stress testing goal

   Only To push the system beyond its normal limits to find breaking points describes pushing the system beyond normal limits to find breaking points, which matches stress testing's main goal.

3. Final Answer:

   To push the system beyond its normal limits to find breaking points -> Option D

4. Quick Check:

   Stress testing = pushing limits [OK]

Hint: Stress testing means pushing beyond normal use [OK]

Common Mistakes:

• Confusing stress testing with functional testing
• Thinking stress testing checks UI or installation
• Assuming stress testing is about normal load only

2. Which of the following is the correct way to describe a stress test scenario?

easy

A. Testing the system with a load that exceeds its maximum capacity

B. Testing the system with normal expected user load

C. Testing only the system's database queries

D. Testing the system's response to a single user action

Solution

1. Step 1: Define stress test scenario

   A stress test scenario involves applying a load that is higher than the system's maximum expected capacity to observe failure points.

2. Step 2: Match options to definition

   Testing the system with a load that exceeds its maximum capacity correctly states testing with load exceeding maximum capacity, which fits stress testing. Other options describe normal load or unrelated tests.

3. Final Answer:

   Testing the system with a load that exceeds its maximum capacity -> Option A

4. Quick Check:

   Stress test = load beyond max [OK]

Hint: Stress test means load beyond max capacity [OK]

Common Mistakes:

• Choosing normal load as stress test
• Confusing stress test with functional or unit tests
• Ignoring the 'exceeds capacity' part

3. Consider this pseudo-code for a stress test:

for users in range(1000, 1100):
    simulate_login(users)
    simulate_data_request(users)
    check_response_time(users)

What is the main purpose of increasing users from 1000 to 1099 in this test?

medium

A. To check if the system crashes at 1000 users

B. To verify system functionality for exactly 1000 users

C. To test system behavior under gradually increasing load

D. To test only the login feature repeatedly

Solution

1. Step 1: Analyze the loop range and actions

   The loop increases user count from 1000 to 1099, simulating login and data requests for each user count, then checking response time.

2. Step 2: Understand the test goal

   This gradual increase tests how the system handles increasing load, which is typical in stress testing to find breaking points or performance degradation.

3. Final Answer:

   To test system behavior under gradually increasing load -> Option C

4. Quick Check:

   Increasing users = increasing load [OK]

Hint: Increasing users means testing load growth [OK]

Common Mistakes:

• Thinking test is only for exactly 1000 users
• Assuming test checks only login feature
• Ignoring the gradual increase aspect

4. A tester wrote this stress test code snippet:

for i in range(1000, 1100):
    simulate_login(i)
    simulate_data_request(i)
    check_response_time()

What is the main issue in this code?

medium

A. The check_response_time function is missing the user parameter

B. The loop range is incorrect for stress testing

C. The simulate_login function should be outside the loop

D. There is no issue; the code is correct

Solution

1. Step 1: Review function calls inside the loop

   The loop calls simulate_login(i) and simulate_data_request(i) with the user parameter i. However, check_response_time() is called without any parameter.

2. Step 2: Identify inconsistency

   Since response time likely depends on the user or request, missing the user parameter in check_response_time() is an error causing incorrect or failed measurement.

3. Final Answer:

   The check_response_time function is missing the user parameter -> Option A

4. Quick Check:

   Missing parameter in function call = bug [OK]

Hint: Check all function calls have needed parameters [OK]

Common Mistakes:

• Ignoring missing parameters in function calls
• Thinking loop range is wrong for stress testing
• Assuming functions should be outside the loop

5. You want to design a stress test for a web application that must handle up to 5000 users simultaneously. Which approach best fits stress testing principles?

hard

A. Test the system with 3000 users and assume it works for 5000

B. Gradually increase users from 1000 to 6000 while monitoring system response and failures

C. Run functional tests for 100 users repeatedly

D. Test only 5000 users once and check if the system crashes

Solution

1. Step 1: Understand stress testing for capacity limits

   Stress testing involves pushing the system beyond expected limits to find breaking points and observe behavior under extreme load.

2. Step 2: Evaluate options for best stress test design

   Gradually increase users from 1000 to 6000 while monitoring system response and failures gradually increases users beyond 5000 to 6000, monitoring response and failures, which aligns with stress testing goals. Other options either test only once, test fewer users, or do unrelated functional tests.

3. Final Answer:

   Gradually increase users from 1000 to 6000 while monitoring system response and failures -> Option B

4. Quick Check:

   Gradual increase beyond max = proper stress test [OK]

Hint: Increase load beyond max users gradually [OK]

Common Mistakes:

• Testing only once at max users
• Confusing stress test with functional test
• Assuming fewer users prove max capacity