Maximize and minimize window in Selenium Python - Build an Automation Script

Maximize and Minimize Browser Window

Preconditions (3)

Step 1: Open the browser using Selenium WebDriver

Step 2: Maximize the browser window

Step 3: Verify the browser window is maximized

Step 4: Minimize the browser window

Step 5: Verify the browser window is minimized

Step 6: Close the browser

✅ Expected Result: The browser window should maximize and minimize successfully, and the verifications should confirm these states.

Automation Requirements - Selenium with Python

Assertions Needed:

Verify window is maximized after maximize command

Verify window is minimized after minimize command

Best Practices:

Use explicit waits if needed

Use WebDriver's window management methods

Close the browser at the end of the test

Use try-finally to ensure browser closes even if test fails

Automated Solution

Selenium Python

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
import time

# Setup Chrome options
options = Options()
options.add_argument('--disable-infobars')

# Setup WebDriver service
service = Service()
driver = webdriver.Chrome(service=service, options=options)

try:
    # Open browser
    driver.get('https://www.example.com')

    # Maximize window
    driver.maximize_window()
    time.sleep(1)  # Wait a moment for the window to maximize

    # Verify maximize by checking window size is close to screen size
    window_size = driver.get_window_size()
    screen_width = driver.execute_script('return screen.width')
    screen_height = driver.execute_script('return screen.height')

    assert window_size['width'] >= screen_width * 0.9, f"Window width {window_size['width']} is less than 90% of screen width {screen_width}"
    assert window_size['height'] >= screen_height * 0.9, f"Window height {window_size['height']} is less than 90% of screen height {screen_height}"

    # Minimize window
    driver.minimize_window()
    time.sleep(1)  # Wait a moment for the window to minimize

    # Verify minimize by checking window is not visible or size is very small
    # Selenium does not provide direct API to check minimized state,
    # so we check window size is very small or zero
    minimized_size = driver.get_window_size()
    assert minimized_size['width'] < 100, f"Window width {minimized_size['width']} is not small after minimize"
    assert minimized_size['height'] < 100, f"Window height {minimized_size['height']} is not small after minimize"

finally:
    # Close browser
    driver.quit()

This script uses Selenium WebDriver with Python to automate maximizing and minimizing the browser window.

First, it opens the browser and navigates to a website.

Then it maximizes the window using driver.maximize_window() and verifies the window size is close to the screen size by comparing widths and heights.

Next, it minimizes the window using driver.minimize_window(). Since Selenium does not provide a direct way to check if the window is minimized, it verifies by checking the window size is very small.

Finally, it closes the browser in a finally block to ensure cleanup even if assertions fail.

Short time.sleep() calls are used to allow the window state to update before verification.

Common Mistakes - 4 Pitfalls

Not closing the browser after the test

Using hardcoded window sizes to verify maximize/minimize

Not waiting briefly after maximize or minimize before checking size

Trying to verify minimize state by checking window visibility

Bonus Challenge

Now add data-driven testing with 3 different URLs to open before maximizing and minimizing

Show Hint

Practice

1. What does the maximize_window() method do in Selenium WebDriver?

easy

A. It minimizes the browser window to the taskbar.

B. It closes the browser window.

C. It refreshes the current page.

D. It makes the browser window full screen.

Solution

1. Step 1: Understand the purpose of maximize_window()

   The method is designed to enlarge the browser window to fill the screen.

2. Step 2: Compare with other window methods

   Unlike minimize_window() which hides the window, maximize_window() expands it fully.

3. Final Answer:

   It makes the browser window full screen. -> Option D

4. Quick Check:

   maximize_window() = full screen [OK]

Hint: Maximize means full screen, minimize means hide [OK]

Common Mistakes:

• Confusing maximize with minimize
• Thinking maximize closes the window
• Assuming maximize refreshes the page

2. Which of the following is the correct syntax to minimize the browser window using Selenium in Python?

easy

A. driver.minimizeWindow()

B. driver.minimize()

C. driver.minimize_window()

D. driver.window.minimize()

Solution

1. Step 1: Recall Selenium WebDriver method names

   The correct method to minimize the window is minimize_window() called on the driver object.

2. Step 2: Check syntax correctness

   Options A, B, and C use incorrect method names or wrong casing.

3. Final Answer:

   driver.minimize_window() -> Option C

4. Quick Check:

   Correct method name = minimize_window() [OK]

Hint: Use exact method names with underscores in Selenium [OK]

Common Mistakes:

• Using camelCase instead of snake_case
• Calling minimize() without _window
• Trying to access window as a property

3. What will be the output of the following code snippet?

from selenium import webdriver

driver = webdriver.Chrome()
driver.maximize_window()
size = driver.get_window_size()
print(size)

medium

A. {'width': 0, 'height': 0}

B. A dictionary with the current window width and height after maximizing

C. An error because get_window_size() is not a valid method

D. None

Solution

1. Step 1: Understand maximize_window() effect

   This method makes the browser window full screen, so the size will reflect the screen dimensions.

2. Step 2: Check get_window_size() output

   This method returns a dictionary with keys 'width' and 'height' showing current window size.

3. Final Answer:

   A dictionary with the current window width and height after maximizing -> Option B

4. Quick Check:

   maximize_window() + get_window_size() = size dict [OK]

Hint: get_window_size() returns dict with width and height [OK]

Common Mistakes:

• Expecting get_window_size() to return None or error
• Thinking maximize_window() does not affect size
• Confusing method names

4. Identify the error in the following Selenium Python code that tries to minimize the browser window:

from selenium import webdriver

driver = webdriver.Firefox()
driver.minimize()

medium

A. The method minimize() does not exist; should use minimize_window()

B. Firefox driver does not support window operations

C. Missing parentheses after webdriver.Firefox

D. minimize() should be called before creating the driver

Solution

1. Step 1: Check method name correctness

   The method to minimize the window is minimize_window(), not minimize().

2. Step 2: Verify driver and method compatibility

   Firefox driver supports window operations, so the error is due to wrong method name.

3. Final Answer:

   The method minimize() does not exist; should use minimize_window() -> Option A

4. Quick Check:

   Correct method = minimize_window() [OK]

Hint: Use full method names exactly as in docs [OK]

Common Mistakes:

• Using minimize() instead of minimize_window()
• Assuming Firefox driver lacks window methods
• Forgetting parentheses on driver creation

5. You want to test how your website behaves when the browser window is minimized and then maximized again. Which sequence of Selenium Python commands correctly achieves this?

hard

A. driver.minimize_window()
driver.maximize_window()

B. driver.maximize_window()
driver.minimize_window()

C. driver.set_window_size(0, 0)
driver.maximize_window()

D. driver.minimize()
driver.maximize()

Solution

1. Step 1: Minimize the window first

   Use minimize_window() to hide the browser window.

2. Step 2: Maximize the window after minimizing

   Use maximize_window() to restore it to full screen.

3. Step 3: Verify method correctness

   Options A, C, and D use incorrect methods or order; A reverses the intended test flow.

4. Final Answer:

   driver.minimize_window() driver.maximize_window() -> Option A

5. Quick Check:

   Minimize then maximize = B [OK]

Hint: Minimize first, then maximize to test window state changes [OK]

Common Mistakes:

• Reversing the order of minimize and maximize
• Using incorrect method names like minimize()
• Trying to set size to zero instead of minimizing