Retry mechanism for flaky tests in Selenium Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this retry decorator on flaky test?

Consider this Python code using Selenium and a retry decorator for flaky tests. What will be printed when the test function is run?

Selenium Python

import random

def retry(times):
    def decorator(func):
        def wrapper():
            for attempt in range(1, times + 1):
                try:
                    func()
                    print(f"Test passed on attempt {attempt}")
                    break
                except Exception as e:
                    print(f"Attempt {attempt} failed: {e}")
                    if attempt == times:
                        print("Test failed after retries")
        return wrapper
    return decorator

@retry(3)
def flaky_test():
    if random.choice([True, False]):
        raise Exception("Random failure")

flaky_test()

A Test passed on attempt 3

B Attempt 1 failed: Random failure\nTest passed on attempt 2

C Test passed on attempt 1

D Attempt 1 failed: Random failure\nAttempt 2 failed: Random failure\nAttempt 3 failed: Random failure\nTest failed after retries

💡 Hint

The test stops retrying once it passes.

The retry decorator runs the test up to 3 times. If the test passes on the first try, it prints 'Test passed on attempt 1' and stops retrying.

❓ assertion

intermediate

Which assertion correctly verifies retry count in flaky test?

You want to assert that a flaky Selenium test retried exactly 3 times before failing. Which assertion code snippet correctly checks this?

Selenium Python

retry_attempts = []

def flaky_test():
    retry_attempts.append(1)
    raise Exception("Fail")

# Retry decorator calls flaky_test 3 times

# Which assertion below is correct?

A assert retry_attempts == 3

B assert len(retry_attempts) == 3

C assert retry_attempts.count == 3

D assert retry_attempts.length == 3

💡 Hint

retry_attempts is a list, check its length.

len(retry_attempts) returns the number of times the test was retried. The other options use invalid syntax or methods.

🔧 Debug

advanced

Why does this retry decorator not retry on failure?

This retry decorator is supposed to retry a flaky Selenium test 3 times, but it only runs once. What is the bug?

Selenium Python

def retry(times):
    def decorator(func):
        def wrapper():
            for attempt in range(times):
                try:
                    func()
                    print(f"Passed on attempt {attempt}")
                    return
                except Exception:
                    print(f"Failed on attempt {attempt}")
        return wrapper
    return decorator

@retry(3)
def flaky_test():
    raise Exception("Fail")

flaky_test()

A The decorator is missing @functools.wraps

B The range(times) should start at 1, not 0

C The exception is not caught properly

D The 'return' inside try block stops retries after first attempt

💡 Hint

Check what happens when the test passes or fails inside the loop.

The 'return' inside the try block exits the wrapper function immediately after first attempt, so no retries happen.

❓ framework

advanced

Which pytest feature best supports retrying flaky Selenium tests?

You want to automatically retry flaky Selenium tests in pytest without writing custom decorators. Which pytest feature or plugin should you use?

A pytest-rerunfailures plugin

B pytest-mock plugin

C pytest-cov plugin

D pytest-xdist plugin

💡 Hint

Look for a plugin that reruns failed tests.

pytest-rerunfailures reruns failed tests automatically. The others serve different purposes.

🧠 Conceptual

expert

What is the main risk of using retry mechanisms for flaky Selenium tests?

Retrying flaky Selenium tests can hide underlying problems. What is the biggest risk of relying heavily on retries?

A Masking real issues and reducing test suite reliability

B Increasing test execution speed significantly

C Making tests easier to maintain and debug

D Guaranteeing 100% test pass rate

💡 Hint

Think about what happens if flaky tests are ignored by retries.

Retries can hide real bugs or environment issues, making the test suite less trustworthy.