Time.sleep vs proper waits in Selenium Python - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why avoid using time.sleep() in Selenium tests?

Which of the following is the best reason to avoid using time.sleep() in Selenium tests?

A It automatically retries failed actions until success, making tests flaky.

B It waits only for specific elements to appear, improving test speed.

C It causes tests to wait a fixed time even if the page is ready earlier, slowing down tests.

D It dynamically adjusts wait time based on network speed.

💡 Hint

Think about what happens if the page loads faster than the sleep time.

time.sleep() pauses the test for a fixed time regardless of page state, which can slow tests unnecessarily. Proper waits wait only as long as needed.

❓ Predict Output

intermediate

Output of Selenium wait code snippet

What will be the output of this Selenium Python code snippet?

Selenium Python

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class DummyDriver:
    def find_element(self, by, value):
        raise Exception('Element not found')

try:
    driver = DummyDriver()
    wait = WebDriverWait(driver, 3)
    wait.until(EC.presence_of_element_located((By.ID, 'myid')))
    print('Element found')
except Exception as e:
    print(f'Error: {e}')

A Element found

B TimeoutException

C SyntaxError

D Error: Element not found

💡 Hint

Consider what happens when find_element always raises an exception.

The dummy driver always raises an exception when searching for the element, so the wait fails immediately and prints the error message.

❓ assertion

advanced

Correct assertion for element visibility after wait

Which assertion correctly verifies that an element is visible after using an explicit wait in Selenium?

Selenium Python

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

wait = WebDriverWait(driver, 10)
wait.until(EC.visibility_of_element_located((By.CSS_SELECTOR, '.my-class')))

# Which assertion is correct here?

A assert driver.find_element(By.CSS_SELECTOR, '.my-class').is_enabled()

B assert driver.find_element(By.CSS_SELECTOR, '.my-class').is_displayed()

C assert driver.find_element(By.CSS_SELECTOR, '.my-class').text == ''

D assert driver.find_element(By.CSS_SELECTOR, '.my-class') is None

💡 Hint

Visibility means the element is shown on the page.

The is_displayed() method returns True if the element is visible. Other options check different properties or are invalid.

🔧 Debug

advanced

Identify the problem with this wait usage

What is the main problem with this Selenium Python code snippet?

Selenium Python

import time
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

wait = WebDriverWait(driver, 5)
wait.until(EC.presence_of_element_located((By.ID, 'submit-btn')))
time.sleep(3)
driver.find_element(By.ID, 'submit-btn').click()

A Using time.sleep() after the explicit wait causes unnecessary delay.

B The wait timeout is too long and causes a timeout error.

C The locator By.ID is invalid and causes NoSuchElementException.

D The click() method is called before the element is present.

💡 Hint

Think about the purpose of explicit waits and fixed sleeps.

The explicit wait already waits for the element presence. Adding time.sleep(3) after causes a fixed delay that slows the test without benefit.

❓ framework

expert

Best practice for waiting in Selenium test framework

In a Selenium test framework, which approach best improves test reliability and speed when waiting for elements?

A Use explicit waits with Expected Conditions targeting specific elements and avoid fixed sleeps.

B Use only time.sleep() with long fixed delays to ensure all elements load.

C Use implicit waits set once globally and never use explicit waits.

D Avoid any waits and rely on retrying failed tests manually.

💡 Hint

Consider how to wait efficiently and reliably for elements.

Explicit waits with Expected Conditions wait only as long as needed for specific elements, improving speed and reliability. Fixed sleeps waste time, implicit waits can cause unpredictable delays, and manual retries are inefficient.

Practice

1. What is the main difference between time.sleep() and proper waits in Selenium?

easy

A. Proper waits always wait longer than time.sleep().

B. time.sleep() pauses for a fixed time; proper waits wait only as long as needed.

C. time.sleep() is faster than proper waits in all cases.

D. time.sleep() waits until an element is clickable; proper waits pause for a fixed time.

Solution

1. Step 1: Understand time.sleep() behavior

   time.sleep() pauses the test for a fixed number of seconds regardless of page state.

2. Step 2: Understand proper waits behavior

   Proper waits wait only until a condition is met or a timeout occurs, making tests faster and more reliable.

3. Final Answer:

   time.sleep() pauses for a fixed time; proper waits wait only as long as needed. -> Option B

4. Quick Check:

   Fixed pause vs conditional wait = D [OK]

Hint: Remember: sleep waits fixed time; proper waits wait smartly [OK]

Common Mistakes:

• Thinking time.sleep() waits for conditions
• Assuming proper waits always wait full timeout
• Believing time.sleep() is faster

2. Which of the following is the correct syntax to wait until an element is visible using Selenium's WebDriverWait in Python?

easy

A. driver.wait(10).until(EC.visibility_of_element_located('myId'))

B. time.sleep(10).until(EC.visibility_of_element_located((By.ID, 'myId')))

C. WebDriverWait(driver, 10).until(EC.visibility_of_element_located((By.ID, 'myId')))

D. WebDriverWait(driver, 10).wait_for_element('myId')

Solution

1. Step 1: Recall correct WebDriverWait syntax

   The correct syntax uses WebDriverWait(driver, timeout).until(condition) with a locator tuple.

2. Step 2: Check locator format and method

   WebDriverWait(driver, 10).until(EC.visibility_of_element_located((By.ID, 'myId'))) uses EC.visibility_of_element_located with (By.ID, 'myId') tuple, which is correct.

3. Final Answer:

   WebDriverWait(driver, 10).until(EC.visibility_of_element_located((By.ID, 'myId'))) -> Option C

4. Quick Check:

   Correct WebDriverWait syntax = C [OK]

Hint: Use WebDriverWait with until and locator tuple [OK]

Common Mistakes:

• Using time.sleep instead of WebDriverWait
• Passing locator as string instead of tuple
• Calling non-existent wait_for_element method

3. What will happen when the following code runs if the element with ID 'submit' appears after 3 seconds?

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

WebDriverWait(driver, 5).until(EC.element_to_be_clickable((By.ID, 'submit')))
print('Element is clickable')

medium

A. Prints 'Element is clickable' after about 3 seconds

B. Raises TimeoutException immediately

C. Prints 'Element is clickable' after 5 seconds fixed

D. Code syntax error, will not run

Solution

1. Step 1: Understand WebDriverWait behavior

   It waits up to 5 seconds for the element to be clickable, checking repeatedly.

2. Step 2: Element appears after 3 seconds

   Since element appears before timeout, wait ends early and prints message.

3. Final Answer:

   Prints 'Element is clickable' after about 3 seconds -> Option A

4. Quick Check:

   Wait ends early if condition met = A [OK]

Hint: Wait ends as soon as element is ready, not full timeout [OK]

Common Mistakes:

• Thinking it waits full 5 seconds always
• Expecting immediate TimeoutException
• Confusing syntax causing errors

4. Identify the problem in this code snippet that uses time.sleep() instead of proper waits:

driver.find_element(By.ID, 'start').click()
time.sleep(10)
driver.find_element(By.ID, 'finish').click()

medium

A. No problem; this is best practice

B. The click() method is used incorrectly

C. The locator By.ID is invalid

D. time.sleep(10) may cause unnecessary delay or fail if element appears late

Solution

1. Step 1: Analyze use of time.sleep(10)

   It pauses test for 10 seconds regardless of whether the 'finish' element is ready.

2. Step 2: Understand impact on test reliability

   If element appears earlier, test wastes time; if later, test may fail after sleep ends.

3. Final Answer:

   time.sleep(10) may cause unnecessary delay or fail if element appears late -> Option D

4. Quick Check:

   Fixed sleep causes delay or flakiness = A [OK]

Hint: Avoid fixed sleeps; use waits that check conditions [OK]

Common Mistakes:

• Assuming fixed sleep is always safe
• Ignoring element readiness timing
• Thinking locator or click usage is wrong

5. You want to wait for a dynamic element that may appear anytime within 15 seconds after clicking a button. Which approach is best to make your Selenium test fast and reliable?

hard

A. Use WebDriverWait(driver, 15).until(EC.presence_of_element_located(locator))

B. Use time.sleep(15) after clicking the button

C. Use a loop with time.sleep(1) checking element presence manually

D. Do not wait; try to interact immediately after clicking

Solution

1. Step 1: Evaluate fixed sleep approach

   time.sleep(15) always waits full 15 seconds, slowing tests unnecessarily.

2. Step 2: Evaluate proper wait approach

   WebDriverWait waits up to 15 seconds but continues as soon as element appears, making tests faster and stable.

3. Step 3: Consider manual loop and no wait

   Manual loops are error-prone and less efficient; no wait risks failures.

4. Final Answer:

   Use WebDriverWait(driver, 15).until(EC.presence_of_element_located(locator)) -> Option A

5. Quick Check:

   Proper wait with timeout = B [OK]

Hint: Use WebDriverWait with condition, avoid fixed sleep [OK]

Common Mistakes:

• Using fixed sleep wasting time
• Writing manual loops instead of waits
• Skipping waits causing flaky tests