Identifying performance bottlenecks in Testing Fundamentals - Test Execution Trace

Test Overview

This test checks if the application responds within an acceptable time limit when loading the homepage. It verifies that the page load time is under 2 seconds to identify any performance bottlenecks.

Test Code - unittest

Testing Fundamentals

import time
import unittest

class PerformanceTest(unittest.TestCase):
    def test_homepage_load_time(self):
        start_time = time.time()
        # Simulate loading homepage
        load_homepage()  # Assume this function loads the homepage
        end_time = time.time()
        load_duration = end_time - start_time
        self.assertLess(load_duration, 2.0, f"Homepage load took too long: {load_duration} seconds")

def load_homepage():
    # Simulated delay representing page load
    time.sleep(1.5)  # 1.5 seconds load time

if __name__ == '__main__':
    unittest.main()

Execution Trace - 6 Steps

Step	Action	System State	Assertion	Result
1	Test starts	Test runner initialized, ready to execute test_homepage_load_time	—	PASS
2	Records start time	Current time noted before homepage load	—	PASS
3	Calls load_homepage function to simulate page loading	Simulated homepage loading with 1.5 seconds delay	—	PASS
4	Records end time after homepage load	Current time noted after homepage load	—	PASS
5	Calculates load duration and asserts it is less than 2 seconds	Load duration calculated as approximately 1.5 seconds	Assert load_duration < 2.0 seconds	PASS
6	Test ends with PASS	Homepage load time is within acceptable limit	—	PASS

Failure Scenario

Failing Condition: Homepage load time exceeds 2 seconds

Execution Trace Quiz - 3 Questions

What does the test measure to identify performance bottlenecks?

A The color scheme of the homepage

B The time taken to load the homepage

C The number of clicks on the homepage

D The size of images on the homepage

Key Result

Measuring response times with assertions helps catch slow parts early, so you can fix performance bottlenecks before users notice.

Practice

1. What is a performance bottleneck in software testing?

easy

A. A part of the software that slows down the whole system

B. A feature that adds new functionality

C. A test case that always passes

D. A tool used to write code faster

Solution

1. Step 1: Understand the meaning of bottleneck

   A bottleneck is something that limits or slows down a process.

2. Step 2: Apply this to software performance

   In software, a bottleneck is the slow part that affects the whole system's speed.

3. Final Answer:

   A part of the software that slows down the whole system -> Option A

4. Quick Check:

   Performance bottleneck = slow part [OK]

Hint: Bottleneck means slowest part slowing everything [OK]

Common Mistakes:

• Confusing bottleneck with new features
• Thinking bottleneck is a test case
• Mixing bottleneck with coding tools

2. Which of the following is the correct way to measure execution time in Python for identifying bottlenecks?

easy

A. import time; start = time.time(); # code; end = time.time(); print(end - start)

B. import datetime; print(datetime.now())

C. print('Execution time')

D. time.sleep(5)

Solution

1. Step 1: Identify timing method for measuring code duration

   Using time.time() before and after code gives elapsed seconds.

2. Step 2: Check options for correct timing usage

   import time; start = time.time(); # code; end = time.time(); print(end - start) correctly measures start and end time and calculates difference.

3. Final Answer:

   import time; start = time.time(); # code; end = time.time(); print(end - start) -> Option A

4. Quick Check:

   Use time.time() to measure duration [OK]

Hint: Use time.time() before and after code [OK]

Common Mistakes:

• Using print statements without timing
• Using datetime.now() without calculating difference
• Using sleep to measure time

3. Consider this Python code snippet measuring a function's execution time:

import time
def slow_function():
    total = 0
    for i in range(1000000):
        total += i
start = time.time()
slow_function()
end = time.time()
print(round(end - start, 2))

What is the expected output type?

medium

A. The sum of numbers from 0 to 999999

B. An error because of missing return

C. A float number showing seconds taken

D. A string 'round' printed

Solution

1. Step 1: Understand what the code measures

   The code measures time before and after running slow_function and prints the difference rounded to 2 decimals.

2. Step 2: Analyze output type

   round(end - start, 2) returns a float number representing seconds elapsed.

3. Final Answer:

   A float number showing seconds taken -> Option C

4. Quick Check:

   Timing code prints float seconds [OK]

Hint: Timing code prints float seconds elapsed [OK]

Common Mistakes:

• Thinking it prints sum instead of time
• Expecting an error due to no return
• Confusing round function output

4. You have this code snippet to find a bottleneck:

import time
start = time.time()
for i in range(1000000):
    pass
print(end - start)

What is the error and how to fix it?

medium

A. Range should be 1000 instead of 1000000

B. Missing import statement for time module

C. Use print(start - end) instead

D. Variable 'end' is not defined; define end = time.time() before print

Solution

1. Step 1: Identify the error in variable usage

   The variable 'end' is used in print but never assigned, causing a NameError.

2. Step 2: Fix by assigning end before print

   Assign end = time.time() after the loop and before print to measure elapsed time.

3. Final Answer:

   Variable 'end' is not defined; define end = time.time() before print -> Option D

4. Quick Check:

   Define end = time.time() before print [OK]

Hint: Always assign end time before printing elapsed [OK]

Common Mistakes:

• Forgetting to assign end time
• Changing range unnecessarily
• Subtracting times in wrong order

5. You run a profiler on your web app and find that database queries take 80% of the total time. What is the best next step to improve performance?

hard

A. Add more logging to the application

B. Optimize or reduce the number of database queries

C. Increase the size of the frontend assets

D. Rewrite the UI in a different framework

Solution

1. Step 1: Analyze profiler results

   Profiler shows database queries consume most time, indicating a bottleneck there.

2. Step 2: Choose action targeting bottleneck

   Optimizing or reducing queries directly addresses the slowest part to improve speed.

3. Final Answer:

   Optimize or reduce the number of database queries -> Option B

4. Quick Check:

   Fix bottleneck by optimizing slowest part [OK]

Hint: Fix bottleneck by improving slowest part first [OK]

Common Mistakes:

• Changing unrelated parts like UI or logging
• Ignoring profiler data
• Adding features instead of fixing speed