Skip to content

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

test: deduplicate browser config env var tests using pytest parametrization

Aneesh Sharma1e9ee3e64b57
diff --git a/tests/ci/test_extension_config.py b/tests/ci/test_extension_config.py
index 4eae8c724..2f8e17631 100644
--- a/tests/ci/test_extension_config.py
+++ b/tests/ci/test_extension_config.py
@@ -1,236 +1,118 @@
-"""Tests for extension configuration environment variables."""
-
-import os
+"""Tests for browser configuration environment variables."""
import pytest
+from browser_use.browser import BrowserSession
+from browser_use.browser.profile import (
+ BrowserProfile,
+ _get_enable_default_extensions_default,
+ _get_headless_default,
+)
+
+TRUTHY_STRINGS = ['true', 'True', 'TRUE', '1', 'yes', 'on']
+FALSY_STRINGS = ['false', 'False', 'FALSE', '0', 'no', 'off', '']
+
-class TestDisableExtensionsEnvVar:
- """Test BROWSER_USE_DISABLE_EXTENSIONS environment variable."""
+class TestConfigEnvVars:
+ """Tests for browser profile env var configuration."""
- def test_default_value_is_true(self):
- """Without env var set, enable_default_extensions should default to True."""
- # Clear the env var if it exists
- original = os.environ.pop('BROWSER_USE_DISABLE_EXTENSIONS', None)
- try:
- # Import fresh to get the default
- from browser_use.browser.profile import _get_enable_default_extensions_default
+ def test_default_values_without_env(self, monkeypatch: pytest.MonkeyPatch):
+ """Verify default values when environment variables are unset."""
+ monkeypatch.delenv('BROWSER_USE_DISABLE_EXTENSIONS', raising=False)
+ monkeypatch.delenv('BROWSER_USE_HEADLESS', raising=False)
- assert _get_enable_default_extensions_default() is True
- finally:
- if original is not None:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = original
+ assert _get_enable_default_extensions_default() is True
+ assert _get_headless_default() is None
@pytest.mark.parametrize(
- 'env_value,expected_enabled',
+ 'env_var,getter,truthy_expected,falsy_expected',
[
- # Truthy values for DISABLE = extensions disabled (False)
- ('true', False),
- ('True', False),
- ('TRUE', False),
- ('1', False),
- ('yes', False),
- ('on', False),
- # Falsy values for DISABLE = extensions enabled (True)
- ('false', True),
- ('False', True),
- ('FALSE', True),
- ('0', True),
- ('no', True),
- ('off', True),
- ('', True),
+ ('BROWSER_USE_DISABLE_EXTENSIONS', _get_enable_default_extensions_default, False, True),
+ ('BROWSER_USE_HEADLESS', _get_headless_default, True, False),
],
)
- def test_env_var_values(self, env_value: str, expected_enabled: bool):
- """Test various env var values are parsed correctly."""
- original = os.environ.get('BROWSER_USE_DISABLE_EXTENSIONS')
- try:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = env_value
- from browser_use.browser.profile import _get_enable_default_extensions_default
-
- result = _get_enable_default_extensions_default()
- assert result is expected_enabled, (
- f"Expected enable_default_extensions={expected_enabled} for DISABLE_EXTENSIONS='{env_value}', got {result}"
- )
- finally:
- if original is not None:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = original
- else:
- os.environ.pop('BROWSER_USE_DISABLE_EXTENSIONS', None)
-
- def test_browser_profile_uses_env_var(self):
- """Test that BrowserProfile picks up the env var."""
- original = os.environ.get('BROWSER_USE_DISABLE_EXTENSIONS')
- try:
- # Test with env var set to true (disable extensions)
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = 'true'
-
- from browser_use.browser.profile import BrowserProfile
-
- profile = BrowserProfile(headless=True)
- assert profile.enable_default_extensions is False, (
- 'BrowserProfile should disable extensions when BROWSER_USE_DISABLE_EXTENSIONS=true'
- )
-
- # Test with env var set to false (enable extensions)
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = 'false'
- profile2 = BrowserProfile(headless=True)
- assert profile2.enable_default_extensions is True, (
- 'BrowserProfile should enable extensions when BROWSER_USE_DISABLE_EXTENSIONS=false'
- )
-
- finally:
- if original is not None:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = original
- else:
- os.environ.pop('BROWSER_USE_DISABLE_EXTENSIONS', None)
-
- def test_explicit_param_overrides_env_var(self):
- """Test that explicit enable_default_extensions parameter overrides env var."""
- original = os.environ.get('BROWSER_USE_DISABLE_EXTENSIONS')
- try:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = 'true'
-
- from browser_use.browser.profile import BrowserProfile
-
- # Explicitly set to True should override env var
- profile = BrowserProfile(headless=True, enable_default_extensions=True)
- assert profile.enable_default_extensions is True, 'Explicit param should override env var'
-
- finally:
- if original is not None:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = original
- else:
- os.environ.pop('BROWSER_USE_DISABLE_EXTENSIONS', None)
-
- def test_browser_session_uses_env_var(self):
- """Test that BrowserSession picks up the env var via BrowserProfile."""
- original = os.environ.get('BROWSER_USE_DISABLE_EXTENSIONS')
- try:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = '1'
-
- from browser_use.browser import BrowserSession
-
- session = BrowserSession(headless=True)
- assert session.browser_profile.enable_default_extensions is False, (
- 'BrowserSession should disable extensions when BROWSER_USE_DISABLE_EXTENSIONS=1'
- )
-
- finally:
- if original is not None:
- os.environ['BROWSER_USE_DISABLE_EXTENSIONS'] = original
- else:
- os.environ.pop('BROWSER_USE_DISABLE_EXTENSIONS', None)
-
-
-class TestHeadlessEnvVar:
- """Test BROWSER_USE_HEADLESS environment variable."""
-
- def test_default_value_is_none(self):
- """Without env var set, headless default should be None."""
- original = os.environ.pop('BROWSER_USE_HEADLESS', None)
- try:
- from browser_use.browser.profile import _get_headless_default
-
- assert _get_headless_default() is None
- finally:
- if original is not None:
- os.environ['BROWSER_USE_HEADLESS'] = original
+ def test_env_var_truthy_values(
+ self,
+ monkeypatch: pytest.MonkeyPatch,
+ env_var: str,
+ getter,
+ truthy_expected: bool,
+ falsy_expected: bool,
+ ):
+ """Test truthy env var values are parsed correctly."""
+ for val in TRUTHY_STRINGS:
+ monkeypatch.setenv(env_var, val)
+ assert getter() is truthy_expected, f'Failed for {env_var}={val}'
@pytest.mark.parametrize(
- 'env_value,expected_headless',
+ 'env_var,getter,truthy_expected,falsy_expected',
[
- # Truthy values for HEADLESS = headless enabled (True)
- ('true', True),
- ('True', True),
- ('TRUE', True),
- ('1', True),
- ('yes', True),
- ('on', True),
- # Falsy values for HEADLESS = headless disabled (False)
- ('false', False),
- ('False', False),
- ('FALSE', False),
- ('0', False),
- ('no', False),
- ('off', False),
- ('', False),
+ ('BROWSER_USE_DISABLE_EXTENSIONS', _get_enable_default_extensions_default, False, True),
+ ('BROWSER_USE_HEADLESS', _get_headless_default, True, False),
],
)
- def test_env_var_values(self, env_value: str, expected_headless: bool):
- """Test various env var values are parsed correctly."""
- original = os.environ.get('BROWSER_USE_HEADLESS')
- try:
- os.environ['BROWSER_USE_HEADLESS'] = env_value
- from browser_use.browser.profile import _get_headless_default
-
- result = _get_headless_default()
- assert result is expected_headless, (
- f"Expected headless={expected_headless} for BROWSER_USE_HEADLESS='{env_value}', got {result}"
- )
- finally:
- if original is not None:
- os.environ['BROWSER_USE_HEADLESS'] = original
- else:
- os.environ.pop('BROWSER_USE_HEADLESS', None)
-
- def test_browser_profile_uses_env_var(self):
- """Test that BrowserProfile picks up the BROWSER_USE_HEADLESS env var."""
- original = os.environ.get('BROWSER_USE_HEADLESS')
- try:
- # Test with env var set to true
- os.environ['BROWSER_USE_HEADLESS'] = 'true'
-
- from browser_use.browser.profile import BrowserProfile
-
- profile = BrowserProfile()
- assert profile.headless is True, 'BrowserProfile should have headless=True when BROWSER_USE_HEADLESS=true'
-
- # Test with env var set to false
- os.environ['BROWSER_USE_HEADLESS'] = 'false'
- profile2 = BrowserProfile()
- assert profile2.headless is False, 'BrowserProfile should have headless=False when BROWSER_USE_HEADLESS=false'
- finally:
- if original is not None:
- os.environ['BROWSER_USE_HEADLESS'] = original
- else:
- os.environ.pop('BROWSER_USE_HEADLESS', None)
-
- def test_explicit_param_overrides_env_var(self):
- """Test that explicit headless parameter overrides env var."""
- original = os.environ.get('BROWSER_USE_HEADLESS')
- try:
- os.environ['BROWSER_USE_HEADLESS'] = 'true'
-
- from browser_use.browser.profile import BrowserProfile
-
- # Explicitly set to False should override env var
- profile = BrowserProfile(headless=False)
- assert profile.headless is False, 'Explicit param should override env var'
-
- os.environ['BROWSER_USE_HEADLESS'] = 'false'
- profile2 = BrowserProfile(headless=True)
- assert profile2.headless is True, 'Explicit param should override env var'
- finally:
- if original is not None:
- os.environ['BROWSER_USE_HEADLESS'] = original
- else:
- os.environ.pop('BROWSER_USE_HEADLESS', None)
+ def test_env_var_falsy_values(
+ self,
+ monkeypatch: pytest.MonkeyPatch,
+ env_var: str,
+ getter,
+ truthy_expected: bool,
+ falsy_expected: bool,
+ ):
+ """Test falsy env var values are parsed correctly."""
+ for val in FALSY_STRINGS:
+ monkeypatch.setenv(env_var, val)
+ assert getter() is falsy_expected, f'Failed for {env_var}={val}'
- def test_browser_session_uses_env_var(self):
- """Test that BrowserSession picks up the env var via BrowserProfile."""
- original = os.environ.get('BROWSER_USE_HEADLESS')
- try:
- os.environ['BROWSER_USE_HEADLESS'] = 'true'
-
- from browser_use.browser import BrowserSession
+ @pytest.mark.parametrize(
+ 'env_var,attr_name,truthy_val,falsy_val',
+ [
+ ('BROWSER_USE_DISABLE_EXTENSIONS', 'enable_default_extensions', False, True),
+ ('BROWSER_USE_HEADLESS', 'headless', True, False),
+ ],
+ )
+ def test_browser_profile_and_session_env_var(
+ self,
+ monkeypatch: pytest.MonkeyPatch,
+ env_var: str,
+ attr_name: str,
+ truthy_val: bool,
+ falsy_val: bool,
+ ):
+ """Test that BrowserProfile and BrowserSession pick up env vars."""
+ # Test truthy env value
+ monkeypatch.setenv(env_var, 'true')
+ profile = BrowserProfile()
+ assert getattr(profile, attr_name) is truthy_val
+ session = BrowserSession()
+ assert getattr(session.browser_profile, attr_name) is truthy_val
+
+ # Test falsy env value
+ monkeypatch.setenv(env_var, 'false')
+ profile_falsy = BrowserProfile()
+ assert getattr(profile_falsy, attr_name) is falsy_val
+ session_falsy = BrowserSession()
+ assert getattr(session_falsy.browser_profile, attr_name) is falsy_val
- session = BrowserSession()
- assert session.browser_profile.headless is True, (
- 'BrowserSession should have headless=True when BROWSER_USE_HEADLESS=true'
- )
- finally:
- if original is not None:
- os.environ['BROWSER_USE_HEADLESS'] = original
- else:
- os.environ.pop('BROWSER_USE_HEADLESS', None)
+ @pytest.mark.parametrize(
+ 'env_var,attr_name,env_val,explicit_arg,expected',
+ [
+ ('BROWSER_USE_DISABLE_EXTENSIONS', 'enable_default_extensions', 'true', {'enable_default_extensions': True}, True),
+ ('BROWSER_USE_DISABLE_EXTENSIONS', 'enable_default_extensions', 'false', {'enable_default_extensions': False}, False),
+ ('BROWSER_USE_HEADLESS', 'headless', 'true', {'headless': False}, False),
+ ('BROWSER_USE_HEADLESS', 'headless', 'false', {'headless': True}, True),
+ ],
+ )
+ def test_explicit_parameter_overrides_env_var(
+ self,
+ monkeypatch: pytest.MonkeyPatch,
+ env_var: str,
+ attr_name: str,
+ env_val: str,
+ explicit_arg: dict,
+ expected: bool,
+ ):
+ """Test that explicit constructor parameters override env vars."""
+ monkeypatch.setenv(env_var, env_val)
+ profile = BrowserProfile(**explicit_arg)
+ assert getattr(profile, attr_name) is expected