Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

Replace _browser_context with _cdp_client_root

Magnus Müllerb2bb0d69d5c9
diff --git a/tests/ci/test_browser_session_recent_events.py b/tests/ci/test_browser_session_recent_events.py
index d9d331d8b..47853ffa3 100644
--- a/tests/ci/test_browser_session_recent_events.py
+++ b/tests/ci/test_browser_session_recent_events.py
@@ -7,9 +7,6 @@ import json
import time
import pytest
-
-pytest.skip('TODO: fix - uses removed navigate method', allow_module_level=True)
-
from pytest_httpserver import HTTPServer
from werkzeug.wrappers import Response
@@ -57,10 +54,10 @@ class TestBrowserRecentEvents:
browser_session = BrowserSession(
browser_profile=BrowserProfile(
headless=True,
- user_data_dir=None,
- keep_alive=False,
- wait_for_network_idle_page_load_time=0.1, # 100ms idle time
- minimum_wait_page_load_time=0.1, # Don't wait extra
+ user_data_dir=None,
+ keep_alive=False,
+ wait_for_network_idle_page_load_time=0.1, # 100ms idle time
+ minimum_wait_page_load_time=0.1, # Don't wait extra
)
)
@@ -133,8 +130,8 @@ class TestBrowserRecentEvents:
browser_session = BrowserSession(
browser_profile=BrowserProfile(
headless=True,
- user_data_dir=None,
- keep_alive=False,
+ user_data_dir=None,
+ keep_alive=False,
)
)
@@ -197,8 +194,8 @@ class TestBrowserRecentEvents:
browser_session = BrowserSession(
browser_profile=BrowserProfile(
headless=True,
- user_data_dir=None,
- keep_alive=False,
+ user_data_dir=None,
+ keep_alive=False,
)
)
@@ -263,8 +260,8 @@ class TestBrowserRecentEvents:
browser_session = BrowserSession(
browser_profile=BrowserProfile(
headless=True,
- user_data_dir=None,
- keep_alive=False,
+ user_data_dir=None,
+ keep_alive=False,
)
)
@@ -313,10 +310,10 @@ class TestBrowserRecentEvents:
browser_session = BrowserSession(
browser_profile=BrowserProfile(
headless=True,
- user_data_dir=None,
- keep_alive=False,
- wait_for_network_idle_page_load_time=0.1,
- minimum_wait_page_load_time=0.1,
+ user_data_dir=None,
+ keep_alive=False,
+ wait_for_network_idle_page_load_time=0.1,
+ minimum_wait_page_load_time=0.1,
)
)
diff --git a/tests/ci/test_browser_session_start.py b/tests/ci/test_browser_session_start.py
index 4b39c2fce..0b4b88acc 100644
--- a/tests/ci/test_browser_session_start.py
+++ b/tests/ci/test_browser_session_start.py
@@ -17,8 +17,6 @@ from pathlib import Path
import pytest
-pytest.skip('TODO: fix - uses removed _browser_context attribute', allow_module_level=True)
-
from browser_use.browser.profile import (
BROWSERUSE_DEFAULT_CHANNEL,
BrowserChannel,
@@ -54,13 +52,13 @@ class TestBrowserSessionStart:
# Start the session for the first time
result1 = await browser_session.start()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
assert result1 is browser_session
# Start the session again - should return immediately without re-initialization
result2 = await browser_session.start()
assert result2 is browser_session
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Both results should be the same instance
assert result1 is result2
@@ -81,7 +79,7 @@ class TestBrowserSessionStart:
assert len(successful_results) == 2, f'Expected both starts to succeed, got results: {results}'
# The session should be initialized after concurrent calls
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Should have a single browser PID
final_pid = browser_session.browser_pid
@@ -97,7 +95,7 @@ class TestBrowserSessionStart:
# Start the session normally
await browser_session.start()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Simulate a closed browser connection by closing the browser
if browser_session.browser:
@@ -106,7 +104,7 @@ class TestBrowserSessionStart:
# The session should detect the closed connection and reinitialize
result = await browser_session.start()
assert result is browser_session
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
async def test_start_after_browser_crash(self, browser_session):
"""Test calling .start() after browser has crashed."""
@@ -114,7 +112,7 @@ class TestBrowserSessionStart:
# Start the session normally
await browser_session.start()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
original_pid = browser_session.browser_pid
# Force close the browser to simulate a crash
@@ -122,12 +120,12 @@ class TestBrowserSessionStart:
await browser_session.browser.close()
# Check that initialized reflects the disconnected state
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
# Start should recover and create a new browser
result = await browser_session.start()
assert result is browser_session
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Should have a new PID (or same if reusing process)
new_pid = browser_session.browser_pid
@@ -149,7 +147,7 @@ class TestBrowserSessionStart:
await browser_session.start()
# Session should not be initialized
- assert browser_session._browser_context is None
+ assert browser_session.cdp_client is None
finally:
await browser_session.kill()
@@ -158,117 +156,13 @@ class TestBrowserSessionStart:
# logger.info('Testing close on unstarted session')
# Ensure session is not started
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
# Close should not raise an exception
await browser_session.stop()
# State should remain unchanged
- assert browser_session._browser_context is None
-
- async def test_close_alias_method(self, browser_session):
- """Test the deprecated .close() alias method."""
- # logger.info('Testing deprecated close alias method')
-
- # Start the session
- await browser_session.start()
- assert browser_session._browser_context is not None
-
- # Use the deprecated close method
- await browser_session.close()
-
- # Session should be stopped
- assert browser_session._browser_context is None
-
- async def test_context_manager_usage(self, browser_session):
- """Test using BrowserSession as an async context manager."""
- # logger.info('Testing context manager usage')
-
- # Use as context manager
- async with browser_session as session:
- assert session is browser_session
- assert session._browser_context is not None
-
- # Should be stopped after exiting context
- assert browser_session._browser_context is None
-
- async def test_multiple_concurrent_operations_after_start(self, browser_session):
- """Test that multiple operations can run concurrently after start() completes."""
- # logger.info('Testing multiple concurrent operations after start')
-
- # Start the session
- await browser_session.start()
-
- # Run multiple operations concurrently that require initialization
- async def get_tabs():
- return await browser_session.get_tabs_info()
-
- async def get_current_page():
- return await browser_session.get_current_page()
-
- async def take_screenshot():
- return await browser_session.take_screenshot()
-
- # All operations should succeed concurrently
- results = await asyncio.gather(get_tabs(), get_current_page(), take_screenshot(), return_exceptions=True)
-
- # Check that all operations completed successfully
- assert len(results) == 3
- assert all(not isinstance(r, Exception) for r in results)
-
- async def test_operations_on_started_session(self, browser_session):
- """Test various operations work correctly on already started session."""
- # logger.info('Testing operations on already started session')
-
- # Start the session first
- await browser_session.start()
- assert browser_session._browser_context is not None
- initial_pid = browser_session.browser_pid
-
- # Various operations should work without restarting
- tabs_info = await browser_session.get_tabs_info()
- assert isinstance(tabs_info, list)
-
- current_page = await browser_session.get_current_page()
- assert current_page is not None
-
- # Create a new tab
- new_page = await browser_session.create_new_tab()
- assert new_page is not None
-
- # Get tabs info again - should show more tabs
- updated_tabs = await browser_session.get_tabs_info()
- assert len(updated_tabs) > len(tabs_info)
-
- # Browser PID should remain the same
- assert browser_session.browser_pid == initial_pid
- assert browser_session._browser_context is not None
-
- async def test_lazy_initialization_behavior(self, browser_session):
- """Test that operations trigger initialization when needed."""
- # logger.info('Testing lazy initialization behavior')
-
- # Ensure session is not started
- assert browser_session._browser_context is None
- assert browser_session.browser_pid is None
-
- # Calling an operation that needs browser should work
- # (implementation may auto-start or return empty/error)
- try:
- # Try to get current page on unstarted session
- page = await browser_session.get_current_page()
- # If it returns a page, session must have auto-started
- if page is not None:
- assert browser_session._browser_context is not None
- assert browser_session.browser_pid is not None
- except Exception:
- # If it fails, that's also valid behavior
- pass
-
- # Explicitly start and verify it works
- await browser_session.start()
- assert browser_session._browser_context is not None
- assert browser_session.browser_pid is not None
+ assert browser_session._cdp_client_root is None
async def test_page_lifecycle_management(self, browser_session):
"""Test session handles page lifecycle correctly."""
@@ -309,7 +203,7 @@ class TestBrowserSessionStart:
# Create a single session for this test
browser_session = BrowserSession(browser_profile=browser_profile)
await browser_session.start()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Create a lock to ensure only one stop actually executes
stop_lock = asyncio.Lock()
@@ -318,7 +212,7 @@ class TestBrowserSessionStart:
async def safe_stop():
nonlocal stop_execution_count
async with stop_lock:
- if browser_session._browser_context is not None:
+ if browser_session._cdp_client_root is not None:
stop_execution_count += 1
await browser_session.stop()
return 'stopped'
@@ -333,16 +227,16 @@ class TestBrowserSessionStart:
assert stop_execution_count == 1
# Session should be stopped
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
- async def test_stop_with_closed_browser_context(self, browser_session):
+ async def test_stop_with_closed_cdp_client_root(self, browser_session):
"""Test calling stop() when browser context is already closed."""
# logger.info('Testing stop with closed browser context')
# Start the session
await browser_session.start()
- assert browser_session._browser_context is not None
- browser_ctx = browser_session._browser_context
+ assert browser_session._cdp_client_root is not None
+ browser_ctx = browser_session._cdp_client_root
assert browser_ctx is not None
# Manually close the browser context
@@ -352,7 +246,7 @@ class TestBrowserSessionStart:
await browser_session.stop()
# Session should be properly cleaned up
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
async def test_access_after_stop(self, browser_profile):
"""Test accessing browser context after stop() to ensure proper cleanup."""
@@ -366,11 +260,11 @@ class TestBrowserSessionStart:
await browser_session.stop()
# Verify session is stopped
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
# calling a method wrapped in @require_initialization should auto-restart the session
await browser_session.get_tabs()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
async def test_race_condition_between_stop_and_operation(self, browser_session):
"""Test race condition between stop() and other operations."""
@@ -411,8 +305,8 @@ class TestBrowserSessionStart:
for i in range(3):
# Start
await browser_session.start()
- assert browser_session._browser_context is not None
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
+ assert browser_session._cdp_client_root is not None
# Perform an operation
tabs = await browser_session.get_tabs_info()
@@ -420,7 +314,7 @@ class TestBrowserSessionStart:
# Stop
await browser_session.stop()
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
async def test_context_manager_with_exception(self, browser_session):
"""Test context manager properly closes even when exception occurs."""
@@ -432,11 +326,11 @@ class TestBrowserSessionStart:
# Use context manager and raise exception inside
with pytest.raises(TestException):
async with browser_session as session:
- assert session._browser_context is not None
+ assert session._cdp_client_root is not None
raise TestException('Test exception')
# Session should still be stopped despite the exception
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
async def test_session_without_fixture(self):
"""Test creating a session without using fixture."""
@@ -446,9 +340,9 @@ class TestBrowserSessionStart:
try:
await session.start()
- assert session._browser_context is not None
+ assert session._cdp_client_root is not None
await session.stop()
- assert session._browser_context is None
+ assert session._cdp_client_root is None
finally:
pass
@@ -461,7 +355,7 @@ class TestBrowserSessionStart:
try:
# Start the session
await session.start()
- assert session._browser_context is not None
+ assert session._cdp_client_root is not None
# Now test keep_alive behavior
session.browser_profile.keep_alive = True
@@ -469,7 +363,7 @@ class TestBrowserSessionStart:
# Stop should not actually close the browser with keep_alive=True
await session.stop()
# Browser should still be connected
- assert session._browser_context and session._browser_context.pages[0]
+ assert session._cdp_client_root and session._cdp_client_root.pages[0]
finally:
await session.kill()
@@ -488,7 +382,7 @@ class TestBrowserSessionStart:
try:
await session.start()
- assert session._browser_context is not None
+ assert session._cdp_client_root is not None
# Verify the user_data_dir wasn't changed
assert session.browser_profile.user_data_dir == CONFIG.BROWSER_USE_DEFAULT_USER_DATA_DIR
finally:
@@ -542,7 +436,7 @@ class TestBrowserSessionReusePatterns:
# Verify first agent's session is closed
assert agent1.browser_session is not None
- assert not agent1.browser_session._browser_context is not None
+ assert not agent1.browser_session._cdp_client_root is not None
# Second agent with same profile
agent2 = Agent(
@@ -556,7 +450,7 @@ class TestBrowserSessionReusePatterns:
# Verify second agent created a new session
assert agent2.browser_session is not None
assert agent1.browser_session is not agent2.browser_session
- assert not agent2.browser_session._browser_context is not None
+ assert not agent2.browser_session._cdp_client_root is not None
async def test_sequential_agents_same_profile_same_browser(self, mock_llm):
"""Test Sequential Agents, Same Profile, Same Browser pattern"""
@@ -585,7 +479,7 @@ class TestBrowserSessionReusePatterns:
await agent1.run()
# Verify session is still alive
- assert reused_session._browser_context is not None
+ assert reused_session._cdp_client_root is not None
# Second agent reusing the same session
agent2 = Agent(
@@ -599,359 +493,11 @@ class TestBrowserSessionReusePatterns:
# Verify same browser was used (using __eq__ to check browser_pid, cdp_url)
assert agent1.browser_session == agent2.browser_session
assert agent1.browser_session == reused_session
- assert reused_session._browser_context is not None
+ assert reused_session._cdp_client_root is not None
finally:
await reused_session.kill()
- # async def test_parallel_agents_same_browser_multiple_tabs(self, httpserver):
- # """Test Parallel Agents, Same Browser, Multiple Tabs pattern"""
-
- # from browser_use import Agent, BrowserSession
-
- # # Create a shared browser session
- # with tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as f:
- # # Write minimal valid storage state
- # f.write('{"cookies": [], "origins": []}')
- # storage_state_path = f.name
-
- # # Convert to Path object to fix storage state type error
- # from pathlib import Path
-
- # storage_state_path = Path(storage_state_path)
-
- # shared_browser = BrowserSession(
- # browser_profile=BrowserProfile(
- # storage_state=storage_state_path,
- # user_data_dir=None,
- # keep_alive=True,
- # headless=True,
- # ),
- # )
-
- # try:
- # # Set up httpserver
- # httpserver.expect_request('/').respond_with_data('<html><body>Test page</body></html>')
- # test_url = httpserver.url_for('/')
-
- # # Start the session before passing it to agents
- # await shared_browser.start()
-
- # # Create action sequences for each agent
- # # Each agent creates a new tab then completes
- # tab_creation_action = (
- # """
- # {
- # "thinking": "null",
- # "evaluation_previous_goal": "Starting the task",
- # "memory": "Need to create a new tab",
- # "next_goal": "Create a new tab to work in",
- # "action": [
- # {
- # "go_to_url": {
- # "url": "%s",
- # "new_tab": true
- # }
- # }
- # ]
- # }
- # """
- # % test_url
- # )
-
- # done_action = """
- # {
- # "thinking": "null",
- # "evaluation_previous_goal": "Tab created",
- # "memory": "Task completed in new tab",
- # "next_goal": "Complete the task",
- # "action": [
- # {
- # "done": {
- # "text": "Task completed successfully",
- # "success": true
- # }
- # }
- # ]
- # }
- # """
-
- # # Create 3 agents sharing the same browser session
- # # Each gets its own mock LLM with the same action sequence
- # mock_llm1 = create_mock_llm([tab_creation_action, done_action])
- # mock_llm2 = create_mock_llm([tab_creation_action, done_action])
- # mock_llm3 = create_mock_llm([tab_creation_action, done_action])
-
- # agent1 = Agent(
- # task='First parallel task...',
- # llm=mock_llm1,
- # browser_session=shared_browser,
- # # Disable memory for tests
- # )
- # agent2 = Agent(
- # task='Second parallel task...',
- # llm=mock_llm2,
- # browser_session=shared_browser,
- # # Disable memory for tests
- # )
- # agent3 = Agent(
- # task='Third parallel task...',
- # llm=mock_llm3,
- # browser_session=shared_browser,
- # # Disable memory for tests
- # )
-
- # # Run all agents in parallel
- # results = await asyncio.gather(agent1.run(), agent2.run(), agent3.run(), return_exceptions=True)
-
- # # Check if any agents failed
- # for i, result in enumerate(results):
- # if isinstance(result, Exception):
- # raise AssertionError(f'Agent {i + 1} failed with error: {result}')
-
- # # Verify all agents used the same browser session (using __eq__ to check browser_pid, cdp_url)
- # # Debug: print the browser sessions to see what's different
- # print(f'Agent1 session: {agent1.browser_session}')
- # print(f'Agent2 session: {agent2.browser_session}')
- # print(f'Agent3 session: {agent3.browser_session}')
- # print(f'Shared session: {shared_browser}')
-
- # # Check each pair individually
- # assert agent1.browser_session == agent2.browser_session, (
- # f'agent1 != agent2: {agent1.browser_session} != {agent2.browser_session}'
- # )
- # assert agent2.browser_session == agent3.browser_session, (
- # f'agent2 != agent3: {agent2.browser_session} != {agent3.browser_session}'
- # )
- # assert agent1.browser_session == shared_browser, f'agent1 != shared: {agent1.browser_session} != {shared_browser}'
- # assert shared_browser._browser_context is not None
-
- # # Give a small delay to ensure all tabs are fully created
- # await asyncio.sleep(0.5)
-
- # # Verify multiple tabs were created
- # tabs_info = await shared_browser.get_tabs_info()
- # print(f'Number of tabs: {len(tabs_info)}')
- # for i, tab in enumerate(tabs_info):
- # print(f'Tab {i}: {tab}')
-
- # # Should have at least 3 tabs (one per agent)
- # # In some cases, there might be more tabs if the initial about:blank tab is still open
- # assert len(tabs_info) >= 3, f'Expected at least 3 tabs, but found {len(tabs_info)}: {tabs_info}'
-
- # finally:
- # await shared_browser.kill()
- # storage_state_path.unlink(missing_ok=True)
-
- # async def test_parallel_agents_same_browser_same_tab(self, mock_llm, httpserver):
- # """Test Parallel Agents, Same Browser, Same Tab pattern (not recommended)"""
- # from browser_use import Agent, BrowserSession
-
- # # Create a browser session and start it first
- # shared_browser = BrowserSession(
- # browser_profile=BrowserProfile(
- # user_data_dir=None,
- # headless=True,
- # keep_alive=True, # Keep the browser alive for reuse
- # ),
- # )
-
- # try:
- # await shared_browser.start()
-
- # # Create agents sharing the same browser session
- # # They will share the same tab since we're not creating new tabs
- # agent1 = Agent(
- # task='Fill out the form in section A...',
- # llm=mock_llm,
- # browser_session=shared_browser,
- # # Disable memory for tests
- # )
- # agent2 = Agent(
- # task='Fill out the form in section B...',
- # llm=mock_llm,
- # browser_session=shared_browser,
- # # Disable memory for tests
- # )
-
- # # Set up httpserver and navigate to a page before running agents
- # httpserver.expect_request('/').respond_with_data('<html><body>Test page</body></html>')
- # page = await shared_browser.get_current_page()
- # await page.goto(httpserver.url_for('/'), wait_until='domcontentloaded', timeout=3000)
-
- # # Run agents in parallel (may interfere with each other)
- # _results = await asyncio.gather(agent1.run(), agent2.run(), return_exceptions=True)
-
- # # Verify both agents used the same browser session
- # assert agent1.browser_session == agent2.browser_session
- # assert agent1.browser_session == shared_browser
-
- # finally:
- # # Clean up
- # await shared_browser.kill()
-
- async def test_parallel_agents_same_profile_different_browsers(self, mock_llm, httpserver):
- """Test Parallel Agents, Same Profile, Different Browsers pattern (recommended)"""
-
- from browser_use import Agent
- from browser_use.browser import BrowserProfile, BrowserSession
-
- # Set up HTTP server with cookie-setting endpoint using HTTP headers
- httpserver.expect_request('/set-cookies').respond_with_data(
- '<html><body>Cookies set via HTTP headers!</body></html>',
- headers={
- 'Content-Type': 'text/html',
- 'Set-Cookie': ['session_id=test123; Path=/', 'auth_token=abc456; Path=/'],
- },
- )
-
- httpserver.expect_request('/page2').respond_with_data(
- '<html><body>Page 2 with preferences!</body></html>',
- headers={
- 'Content-Type': 'text/html',
- 'Set-Cookie': ['user_pref=dark_mode; Path=/', 'theme=night; Path=/'],
- },
- )
-
- # Create a shared profile with storage state
- with tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as f:
- # Write minimal valid storage state
- f.write('{"cookies": [], "origins": []}')
- auth_json_path = f.name
-
- # Convert to Path object
- from pathlib import Path
-
- auth_json_path = Path(auth_json_path)
-
- shared_profile = BrowserProfile(
- headless=True,
- user_data_dir=None, # Use dedicated tmp user_data_dir per session
- storage_state=str(auth_json_path), # Load/save cookies to/from json file
- keep_alive=True,
- )
- print(f'Profile storage_state: {shared_profile.storage_state}')
-
- try:
- # Create separate browser sessions from the same profile
- window1 = BrowserSession(browser_profile=shared_profile)
- await window1.start()
- agent1 = Agent(task='First agent task...', llm=mock_llm, browser_session=window1, enable_memory=False)
-
- window2 = BrowserSession(browser_profile=shared_profile)
- await window2.start()
- agent2 = Agent(task='Second agent task...', llm=mock_llm, browser_session=window2, enable_memory=False)
-
- # Navigate to pages that set cookies
- # Use 127.0.0.1 instead of localhost for cookie persistence
- base_url = httpserver.url_for('/')
- if 'localhost' in base_url:
- base_url = base_url.replace('localhost', '127.0.0.1')
-
- await window1.navigate_to(base_url.rstrip('/') + '/set-cookies')
- await window2.navigate_to(base_url.rstrip('/') + '/page2')
-
- # Wait for pages to load
- page1 = await window1.get_current_page()
- page2 = await window2.get_current_page()
- await page1.wait_for_load_state('networkidle')
- await page2.wait_for_load_state('networkidle')
-
- # Inject cookies directly via CDP to ensure they're set
- await page1.context.add_cookies(
- [
- {'name': 'session_id', 'value': 'test123', 'domain': '127.0.0.1', 'path': '/'},
- {'name': 'auth_token', 'value': 'abc456', 'domain': '127.0.0.1', 'path': '/'},
- ]
- )
- await page2.context.add_cookies(
- [
- {'name': 'user_pref', 'value': 'dark_mode', 'domain': '127.0.0.1', 'path': '/'},
- {'name': 'theme', 'value': 'night', 'domain': '127.0.0.1', 'path': '/'},
- ]
- )
-
- # Run agents in parallel
- _results = await asyncio.gather(agent1.run(), agent2.run())
-
- # Verify different browser sessions were used
- assert agent1.browser_session is not agent2.browser_session
- assert window1 is not window2
-
- # Both sessions should be initialized
- assert window1._browser_context is not None
- assert window2._browser_context is not None
-
- # Check cookies in each context - they should be separate
- context1_cookies = await page1.context.cookies()
- context2_cookies = await page2.context.cookies()
- print(f'Context1 cookies: {[c.get("name", "unknown") for c in context1_cookies]}')
- print(f'Context2 cookies: {[c.get("name", "unknown") for c in context2_cookies]}')
-
- # Since these are separate browser contexts, they won't share cookies
- # But let's verify the cookies exist in their respective contexts
- # We need to get cookies for the specific domain
- domain_cookies1 = await page1.context.cookies(base_url)
- domain_cookies2 = await page2.context.cookies(base_url)
- print(f'Domain cookies window1: {[c.get("name", "unknown") for c in domain_cookies1]}')
- print(f'Domain cookies window2: {[c.get("name", "unknown") for c in domain_cookies2]}')
-
- # Save storage state from window1
- await window1.save_storage_state()
- storage_state_1 = json.loads(auth_json_path.read_text())
- cookies_1 = {c.get('name', 'unknown') for c in storage_state_1['cookies']}
- print(f'Cookies saved from window1: {cookies_1}')
-
- # Save storage state from window2 (this overwrites the file)
- await window2.save_storage_state()
- storage_state_2 = json.loads(auth_json_path.read_text())
- cookies_2 = {c.get('name', 'unknown') for c in storage_state_2['cookies']}
- print(f'Cookies saved from window2: {cookies_2}')
-
- # Verify each window saved its own cookies
- assert len(cookies_1) >= 2, f'Window1 should have saved at least 2 cookies, got {cookies_1}'
- assert len(cookies_2) >= 2, f'Window2 should have saved at least 2 cookies, got {cookies_2}'
-
- # Now test that a new session can load the saved cookies
- print('\nTesting cookie persistence with new session...')
- await window1.kill()
- await window2.kill()
-
- # Create a new session with the same profile
- window3 = BrowserSession(browser_profile=shared_profile)
- await window3.start()
-
- # Check if cookies were loaded
- page3 = await window3.get_current_page()
- await page3.goto(base_url) # Navigate to the domain
- loaded_cookies = await page3.context.cookies()
- loaded_cookie_names = {c.get('name', 'unknown') for c in loaded_cookies}
- print(f'Cookies loaded in new session: {loaded_cookie_names}')
-
- # Should have the cookies from window2 (last save)
- assert len(loaded_cookie_names) >= 2, f'Expected loaded cookies, got {loaded_cookie_names}'
-
- await window3.kill()
-
- finally:
- # Clean up any remaining sessions
- try:
- if 'window1' in locals():
- await window1.kill()
- except Exception:
- pass
- try:
- if 'window2' in locals():
- await window2.kill()
- except Exception:
- pass
- try:
- if 'window3' in locals():
- await window3.kill()
- except Exception:
- pass
- auth_json_path.unlink(missing_ok=True)
-
async def test_browser_shutdown_isolated(self):
"""Test that browser shutdown doesnt affect other browser_sessions"""
from browser_use import BrowserSession
@@ -1050,7 +596,7 @@ class TestBrowserSessionEventSystem:
await start_event
# Check if BrowserConnectedEvent was dispatched
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Check event history
event_history = list(browser_session.event_bus.event_history.values())
@@ -1072,7 +618,6 @@ class TestBrowserSessionEventSystem:
assert recent_events_json != '[]'
# Parse and validate the JSON
- import json
recent_events = json.loads(recent_events_json)
assert isinstance(recent_events, list)
@@ -1101,7 +646,7 @@ class TestBrowserSessionEventSystem:
await start_event
# The session should not be initialized due to the error
- assert error_session._browser_context is None, 'Session should not be initialized after connection error'
+ assert error_session._cdp_client_root is None, 'Session should not be initialized after connection error'
# Verify the error was logged in the event history (good enough for error handling test)
assert len(error_session.event_bus.event_history) > 0, 'Event should be tracked even with errors'
@@ -1181,7 +726,7 @@ class TestBrowserSessionEventSystem:
new_tab_tasks = []
for browser_session in browser_sessions:
assert await browser_session.is_connected()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
new_tab_tasks.append(browser_session.create_new_tab('chrome://version'))
await asyncio.gather(*new_tab_tasks)
@@ -1201,7 +746,7 @@ class TestBrowserSessionEventSystem:
screenshot_tasks = []
for browser_session in filter(bool, browser_sessions):
assert await browser_session.is_connected()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
new_tab_tasks.append(browser_session.create_new_tab('chrome://version'))
screenshot_tasks.append(browser_session.take_screenshot())
await asyncio.gather(*new_tab_tasks)
diff --git a/tests/ci/test_browser_session_tab_management.py b/tests/ci/test_browser_session_tab_management.py
index 5fef02050..9ed64cba2 100644
--- a/tests/ci/test_browser_session_tab_management.py
+++ b/tests/ci/test_browser_session_tab_management.py
@@ -133,7 +133,7 @@ class TestTabManagement:
assert browser_session.page == initial_tab
# Test that get_current_page works even after closing all tabs
- for page in browser_session._browser_context.pages:
+ for page in browser_session._cdp_client_root.pages:
await page.close()
# Give time for watchdogs to process tab closure events
@@ -166,7 +166,7 @@ class TestTabManagement:
# test opening a new tab
new_tab = await browser_session.create_new_tab(f'{base_url}/page2')
- new_tab_count = len(browser_session._browser_context.pages)
+ new_tab_count = len(browser_session._cdp_client_root.pages)
# Debug: Check tab count after new tab creation
print(f'DEBUG: new_tab_count = {new_tab_count}')
@@ -271,7 +271,7 @@ class TestTabManagement:
# close_tab should have called get_current_page, which creates a new about:blank tab if none are left
assert browser_session.page.url == 'about:blank'
- async def test_browser_context_state_after_error(self, browser_session):
+ async def test_cdp_client_root_state_after_error(self, browser_session):
"""Test browser context state remains consistent after errors"""
# logger.info('Testing browser context state after error')
@@ -279,7 +279,7 @@ class TestTabManagement:
# Force an error by killing the session (stop() with keep_alive=True doesn't close context)
# This properly cleans up connections
- original_context = browser_session._browser_context
+ original_context = browser_session._cdp_client_root
# Use stop with force=True to actually close the browser context
from browser_use.browser.events import BrowserStopEvent
@@ -288,7 +288,7 @@ class TestTabManagement:
await event
# Verify session is properly killed
- assert browser_session._browser_context is None
+ assert browser_session._cdp_client_root is None
# This should trigger reinitialization
# Verify by getting URL
@@ -296,8 +296,8 @@ class TestTabManagement:
# Verify state is consistent with a new context
assert current_url is not None
- assert browser_session._browser_context is not None
- assert browser_session._browser_context != original_context
+ assert browser_session._cdp_client_root is not None
+ assert browser_session._cdp_client_root != original_context
assert (await browser_session.is_connected()) is True
async def test_concurrent_context_access_during_closure(self, browser_session):
diff --git a/tests/ci/test_browser_watchdog_screenshots.py b/tests/ci/test_browser_watchdog_screenshots.py
index e7e413117..d6e12a957 100644
--- a/tests/ci/test_browser_watchdog_screenshots.py
+++ b/tests/ci/test_browser_watchdog_screenshots.py
@@ -29,7 +29,7 @@ class TestHeadlessScreenshots:
try:
# Start the session
await browser_session.start()
- assert browser_session._browser_context is not None
+ assert browser_session._cdp_client_root is not None
# Set up test page with visible content
httpserver.expect_request('/').respond_with_data(