Browser State Management

Browser State Management in Selenium

The Memory Keeper of Your Browser

Imagine you’re playing your favorite video game. Every time you play, the game remembers your high score, your unlocked levels, and your favorite character. How does it do that? It saves your state!

Your web browser does the same thing. When you log into a website, shop online, or watch videos, the browser remembers things about you. Selenium can control all of this!

Think of Browser State Management like being a magical librarian who can:

• 📚 Store books (cookies) on shelves
• ⏰ Set timers for how long to wait
• 📋 Choose how fast to load pages
• 🔍 Read secret notes the browser writes

Let’s explore each of these superpowers!

🍪 Cookie Operations

What Are Cookies?

No, not the delicious chocolate chip kind! Browser cookies are tiny text files that websites save on your computer.

Simple Example:

• You visit a toy store website
• You put toys in your shopping cart
• You close the browser
• When you come back, your toys are still in the cart!
• How? A cookie remembered them!

Why Do We Need Cookies in Selenium?

Sometimes when testing websites, you need to:

• ✅ Log in without typing username/password every time
• ✅ Test what happens with different user settings
• ✅ Check if the website remembers things correctly

Cookie Operations in Code

Adding a Cookie

# Create a cookie like putting a
# book on a shelf
cookie = {
    'name': 'user_login',
    'value': 'johnny123',
    'domain': 'example.com'
}
driver.add_cookie(cookie)

Getting All Cookies

# See all books on the shelf
all_cookies = driver.get_cookies()
for cookie in all_cookies:
    print(cookie['name'])

Getting One Cookie

# Find a specific book
my_cookie = driver.get_cookie('user_login')
print(my_cookie['value'])

Deleting Cookies

# Remove one book
driver.delete_cookie('user_login')

# Clear the whole shelf!
driver.delete_all_cookies()

Cookie Diagram

graph TD
    A["🍪 Cookie Operations"] --> B["Add Cookie"]
    A --> C["Get Cookies"]
    A --> D["Delete Cookie"]
    B --> E["Store login info"]
    B --> F["Save preferences"]
    C --> G["Read all cookies"]
    C --> H["Find one cookie"]
    D --> I["Remove one"]
    D --> J["Clear all"]

Real-Life Use

Before: You test login 100 times, typing password each time. 😫

After: You add a login cookie, skip the login page! 🎉

🚀 Page Load Strategies

The Waiting Game

When you open a webpage, lots of things happen:

1. The address is found (like finding a house)
2. Basic page loads (walls and roof appear)
3. Pictures and styles load (furniture arrives)
4. Scripts run (lights turn on)

Question: How long should Selenium wait?

Three Ways to Wait

Selenium gives you three strategies - like choosing how patient you want to be:

1. NORMAL (Default) - The Patient One 🐢

from selenium.webdriver.chrome.options import Options

options = Options()
options.page_load_strategy = 'normal'
driver = webdriver.Chrome(options=options)

What it does: Waits for EVERYTHING to load completely.

Like: Waiting until the whole pizza is baked, sliced, and boxed.

2. EAGER - The Balanced One 🚶

options = Options()
options.page_load_strategy = 'eager'
driver = webdriver.Chrome(options=options)

What it does: Waits until the page is ready to interact with, but doesn’t wait for all images.

Like: Getting your pizza as soon as it’s baked, even if they’re still cutting it.

3. NONE - The Impatient One 🏃

options = Options()
options.page_load_strategy = 'none'
driver = webdriver.Chrome(options=options)

What it does: Doesn’t wait at all! Just fires the request.

Like: Ordering pizza and leaving immediately. You handle when it’s ready!

Strategy Comparison

graph TD
    A["Page Load Strategies"] --> B["NORMAL"]
    A --> C["EAGER"]
    A --> D["NONE"]
    B --> E["✅ Everything loads"]
    B --> F["⏱️ Slowest"]
    C --> G["✅ DOM ready"]
    C --> H["⏱️ Medium speed"]
    D --> I["✅ Fastest start"]
    D --> J["⚠️ You manage waits"]

When to Use Each?

⏰ Timeout Configuration

What Are Timeouts?

A timeout is like setting an alarm. You’re telling Selenium: “Wait this long, then give up!”

Without timeouts, your test might wait forever for a page that never loads. That’s bad!

Three Types of Timeouts

1. Implicit Wait - The Background Timer

# Wait up to 10 seconds when
# finding any element
driver.implicitly_wait(10)

What it does: Whenever Selenium looks for something, it waits this long before saying “I can’t find it!”

Like: “I’ll search for my toy for 10 seconds before giving up.”

2. Explicit Wait - The Specific Timer

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.presence_of_element_located(
        (By.ID, "my-button")
    )
)

What it does: Waits for a specific thing to happen.

Like: “I’ll wait for the ice cream truck music, up to 10 minutes.”

3. Page Load Timeout

# Give up if page takes more
# than 30 seconds
driver.set_page_load_timeout(30)

What it does: Sets maximum time for a page to load.

Like: “If my food doesn’t arrive in 30 minutes, I’m ordering elsewhere!”

4. Script Timeout

# For JavaScript execution
driver.set_script_timeout(15)

What it does: Maximum time for JavaScript to finish running.

Timeout Decision Tree

graph TD
    A["Need to Wait?"] --> B{What for?}
    B --> C["Any element?"]
    B --> D["Specific condition?"]
    B --> E["Page to load?"]
    C --> F["Use implicit_wait"]
    D --> G["Use WebDriverWait"]
    E --> H["Use page_load_timeout"]

Pro Tips

• 🎯 Don’t mix implicit and explicit waits
• ⚡ Keep timeouts reasonable (5-30 seconds)
• 🧪 Shorter timeouts = faster test failures (good for debugging!)

📋 Browser Console Logs

The Browser’s Diary

Every browser keeps a secret diary called the Console Log. It writes down:

• ❌ Errors (something broke!)
• ⚠️ Warnings (something might be wrong)
• ℹ️ Info (just letting you know)
• 🐛 Debug (for detectives)

Why Read Console Logs?

Scenario: Your test passes, but something’s wrong on the page.

The console might say: “Error: Image failed to load!”

Without logs: You’d never know! ❌ With logs: You catch the problem! ✅

How to Get Console Logs

Step 1: Enable Logging

from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities

options = Options()
options.set_capability(
    'goog:loggingPrefs',
    {'browser': 'ALL'}
)
driver = webdriver.Chrome(options=options)

Step 2: Read the Logs

# Get all browser logs
logs = driver.get_log('browser')

# Print each log entry
for log in logs:
    print(f"Level: {log['level']}")
    print(f"Message: {log['message']}")
    print("---")

Log Levels Explained

graph TD
    A["Console Log Levels"] --> B["SEVERE 🔴"]
    A --> C["WARNING 🟡"]
    A --> D["INFO 🔵"]
    A --> E["DEBUG ⚪"]
    B --> F["Errors - Must fix!"]
    C --> G["Warnings - Should check"]
    D --> H["Information - Good to know"]
    E --> I["Details - For debugging"]

Filter Only Errors

logs = driver.get_log('browser')

errors = [
    log for log in logs
    if log['level'] == 'SEVERE'
]

if errors:
    print("Found errors!")
    for error in errors:
        print(error['message'])

Real Example

# Visit a page
driver.get("https://example.com")

# Do your test actions...

# Check for any JavaScript errors
logs = driver.get_log('browser')
js_errors = [
    log for log in logs
    if 'error' in log['message'].lower()
]

if js_errors:
    print("Page has JavaScript errors!")

🎯 Putting It All Together

Here’s how all four concepts work together:

graph TD
    A["Browser State Management"] --> B["🍪 Cookies"]
    A --> C["🚀 Page Load"]
    A --> D["⏰ Timeouts"]
    A --> E["📋 Console Logs"]
    B --> F["Remember user data"]
    C --> G["Control when ready"]
    D --> H[Don't wait forever]
    E --> I["Catch hidden errors"]

Complete Example

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

# Setup with all our powers!
options = Options()
options.page_load_strategy = 'eager'
options.set_capability(
    'goog:loggingPrefs',
    {'browser': 'ALL'}
)

driver = webdriver.Chrome(options=options)
driver.implicitly_wait(10)
driver.set_page_load_timeout(30)

# Add a cookie
driver.get("https://example.com")
driver.add_cookie({
    'name': 'session',
    'value': 'abc123'
})

# Refresh to use cookie
driver.refresh()

# Wait for specific element
wait = WebDriverWait(driver, 15)
element = wait.until(
    EC.element_to_be_clickable(
        (By.ID, "dashboard")
    )
)

# Check for errors
logs = driver.get_log('browser')
errors = [l for l in logs if l['level'] == 'SEVERE']
if errors:
    print("Warning: Page has errors!")

driver.quit()

🏆 Key Takeaways

🌟 You Did It!

You now understand how to be the master librarian of your browser! You can:

• 🍪 Store and retrieve cookies like a pro
• 🚀 Choose how fast pages should load
• ⏰ Set smart timeouts so tests don’t hang
• 📋 Read the browser’s secret diary for hidden bugs

Remember: Great testers don’t just click buttons. They control the browser’s memory and behavior like a wizard! 🧙‍♂️

Keep practicing, and these tools will become second nature!