Why synchronization prevents flaky tests in Selenium Python - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to wait for an element to be visible before clicking it.

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)
element = wait.until(EC.[1]((By.ID, 'submit-button')))
element.click()

Drag options to blanks, or click blank then click option'

Apresence_of_element_located

Belement_to_be_clickable

Calert_is_present

Dvisibility_of_element_located

Attempts:

3 left

💡 Hint

Common Mistakes

Using presence_of_element_located which only checks if element is in DOM but not visible.

Using alert_is_present which waits for alerts, not elements.

The visibility_of_element_located condition waits until the element is visible on the page, ensuring it can be clicked without errors.

2fill in blank

medium

Complete the code to wait until a button is clickable before clicking it.

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, 15)
button = wait.until(EC.[1]((By.CSS_SELECTOR, '.btn-primary')))
button.click()

Drag options to blanks, or click blank then click option'

Avisibility_of_element_located

Bpresence_of_element_located

Celement_to_be_clickable

Dframe_to_be_available_and_switch_to_it

Attempts:

3 left

💡 Hint

Common Mistakes

Using presence_of_element_located which does not guarantee clickability.

Using frame_to_be_available_and_switch_to_it which is for frames, not buttons.

The element_to_be_clickable condition waits until the element is visible and enabled, so it can be clicked safely.

3fill in blank

hard

Fix the error in the code to properly wait for an element's text to be 'Loaded'.

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, 20)
wait.until(EC.text_to_be_present_in_element((By.CLASS_NAME, 'status'), [1]))

Drag options to blanks, or click blank then click option'

A'Loaded'

BLoaded

C['Loaded']

DLoaded()

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Loaded without quotes causes a NameError.

Passing a list or function call instead of a string.

The text to check must be a string, so it needs quotes around it like 'Loaded'.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that waits for elements with text length greater than 5.

Selenium Python

elements = driver.find_elements(By.TAG_NAME, 'p')
lengths = {el.text: len(el.text) for el in elements if len(el.text) [1] [2]

Drag options to blanks, or click blank then click option'

A>

B5

C<

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' reverses the condition.

Using 10 instead of 5 changes the filter threshold.

The condition len(el.text) > 5 filters elements whose text length is more than 5 characters.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase texts to their lengths if length is less than 8.

Selenium Python

elements = driver.find_elements(By.CLASS_NAME, 'item')
result = { [1]: [2] for el in elements if len(el.text) [3] 8 }

Drag options to blanks, or click blank then click option'

Ael.text.upper()

Blen(el.text)

C<

Del.text.lower()

Attempts:

3 left

💡 Hint

Common Mistakes

Using lower() instead of upper() changes the key format.

Using '>' instead of '<' reverses the filter condition.

The comprehension maps the uppercase text to its length only if the length is less than 8.

Practice

1. Why is synchronization important in Selenium tests?

easy

A. It changes the website's code to make testing easier.

B. It waits for elements to be ready before interacting, preventing timing issues.

C. It speeds up the test execution by skipping waits.

D. It automatically fixes bugs in the application.

Solution

1. Step 1: Understand synchronization role

   Synchronization ensures the test waits until the page or elements are ready before performing actions.

2. Step 2: Identify why this matters

   This prevents random failures caused by elements not being ready, which are common timing issues in tests.

3. Final Answer:

   It waits for elements to be ready before interacting, preventing timing issues. -> Option B

4. Quick Check:

   Synchronization = waits for readiness [OK]

Hint: Synchronization means waiting for elements before action [OK]

Common Mistakes:

• Thinking synchronization speeds up tests
• Believing synchronization changes app code
• Assuming synchronization fixes bugs automatically

2. Which of the following is the correct way to use an explicit wait in Selenium Python?

easy

A. wait = WebDriverWait(driver, 10)
wait.until(EC.element_to_be_clickable((By.ID, 'submit')))

B. wait = WebDriverWait(driver, '10')
wait.until(EC.element_to_be_clickable('submit'))

C. wait = WebDriverWait(driver)
wait.until(EC.element_to_be_clickable((By.ID, 'submit')))

D. wait = WebDriverWait(driver, 10)
wait.until(EC.element_to_be_clickable('submit'))

Solution

1. Step 1: Check WebDriverWait syntax

   WebDriverWait requires driver and timeout as integer seconds, so 10 is correct.

2. Step 2: Verify locator usage

   Locator must be a tuple like (By.ID, 'submit'), not just a string.

3. Final Answer:

   wait = WebDriverWait(driver, 10)\nwait.until(EC.element_to_be_clickable((By.ID, 'submit'))) -> Option A

4. Quick Check:

   Correct wait syntax = wait = WebDriverWait(driver, 10) wait.until(EC.element_to_be_clickable((By.ID, 'submit'))) [OK]

Hint: Use integer timeout and tuple locator in explicit wait [OK]

Common Mistakes:

• Passing timeout as string instead of integer
• Using string locator instead of tuple
• Omitting timeout parameter

3. What will happen if you run this Selenium Python code without synchronization?

driver.get('https://example.com')
element = driver.find_element(By.ID, 'dynamic-button')
element.click()

medium

A. The test will always pass because the element is found immediately.

B. The test will throw a syntax error.

C. The test will wait automatically until the element is clickable.

D. The test may fail sometimes if the element is not yet loaded when searched.

Solution

1. Step 1: Understand element loading timing

   Without synchronization, Selenium tries to find the element immediately after page load.

2. Step 2: Identify possible failure cause

   If the element loads slowly, find_element may fail because the element is not present yet, causing flaky failures.

3. Final Answer:

   The test may fail sometimes if the element is not yet loaded when searched. -> Option D

4. Quick Check:

   No wait = possible failure [OK]

Hint: No wait means element might not be ready, causing failure [OK]

Common Mistakes:

• Assuming element is always ready immediately
• Thinking Selenium waits automatically without explicit code
• Confusing syntax error with runtime failure

4. You wrote this code but sometimes it fails with NoSuchElementException:

driver.get('https://example.com')
button = driver.find_element(By.ID, 'submit')
button.click()

How can you fix it?

medium

A. Add an explicit wait to wait until the button is clickable before clicking.

B. Remove the click() method to avoid errors.

C. Change the locator to By.CLASS_NAME without checking the element.

D. Add a sleep(10) before driver.get() call.

Solution

1. Step 1: Identify cause of NoSuchElementException

   The element may not be present immediately after page load, causing the exception.

2. Step 2: Apply explicit wait for element readiness

   Using explicit wait waits until the button is clickable, preventing the error.

3. Final Answer:

   Add an explicit wait to wait until the button is clickable before clicking. -> Option A

4. Quick Check:

   Use explicit wait to fix element not found [OK]

Hint: Use explicit wait before clicking to avoid element not found [OK]

Common Mistakes:

• Removing click() disables test action
• Changing locator blindly may not fix timing
• Using sleep before page load is ineffective

5. You have a test that clicks a button which appears only after a loading spinner disappears. Which synchronization approach best prevents flaky failures?

hard

A. Click the button immediately after page load without waiting.

B. Use time.sleep(5) to wait a fixed time before clicking the button.

C. Use an explicit wait to wait until the spinner element is invisible before clicking the button.

D. Use an implicit wait to wait for the button to be present.

Solution

1. Step 1: Understand the problem with spinner

   The button appears only after the spinner disappears, so waiting for spinner invisibility is key.

2. Step 2: Choose best synchronization method

   Explicit wait for spinner to be invisible is precise and reliable, preventing flaky tests.

3. Step 3: Compare other options

   Fixed sleep is unreliable; implicit wait waits for presence but not invisibility; clicking immediately causes failure.

4. Final Answer:

   Use an explicit wait to wait until the spinner element is invisible before clicking the button. -> Option C

5. Quick Check:

   Wait for spinner invisibility = stable test [OK]

Hint: Wait explicitly for spinner to disappear before clicking [OK]

Common Mistakes:

• Using fixed sleep causes flaky timing
• Relying on implicit wait for invisibility
• Clicking without waiting causes failure