feat: add playwright proxy formatter

Author: davidteather

proxyproviders/models/proxy.py

@@ -112,7 +112,7 @@ def format(
             ProxyFormat.CURL: lambda: ["-x", self.to_url("http")],
             ProxyFormat.HTTPX: lambda: self._format_httpx(),
             ProxyFormat.AIOHTTP: lambda: self.to_url("http"),
-            ProxyFormat.PLAYWRIGHT: lambda: self._format_playwright(),
+            ProxyFormat.PLAYWRIGHT: lambda: self._format_playwright(**kwargs),
         }
 
         handler = format_handlers.get(format_type)
@@ -132,9 +132,18 @@ def _format_httpx(self):
         proxy_url = self.to_url("http")
         return {"http://": proxy_url, "https://": proxy_url}
 
-    def _format_playwright(self):
+    def _format_playwright(self, **kwargs):
         """Format proxy for Playwright."""
-        playwright_proxy = {"server": f"{self.proxy_address}:{self.port}"}
+        # Playwright expects server with protocol (e.g., 'http://ip:port', 'socks5://ip:port')
+        # Allow protocol selection via kwargs, default to http
+        protocol = kwargs.get("protocol", "http")
+
+        # Validate protocol is supported by the proxy
+        if self.protocols and protocol not in self.protocols:
+            # If proxy has specific protocols, use the first available one
+            protocol = self.protocols[0]
+
+        playwright_proxy = {"server": f"{protocol}://{self.proxy_address}:{self.port}"}
 
         if self.username and self.password:
             playwright_proxy["username"] = self.username

tests/integration/test_algorithms_integration.py

@@ -96,6 +96,119 @@ def test_webshare_proxy_conversion_methods():
     assert "https" in requests_dict
     print(f"Requests dict: {requests_dict}")
 
+    # Test Playwright format (default protocol)
+    playwright_dict = proxy.format(ProxyFormat.PLAYWRIGHT)
+    assert isinstance(playwright_dict, dict)
+    assert "server" in playwright_dict
+    assert playwright_dict["server"].startswith("http://")
+    assert f"{proxy.proxy_address}:{proxy.port}" in playwright_dict["server"]
+    assert "username" in playwright_dict
+    assert "password" in playwright_dict
+    assert playwright_dict["username"] == proxy.username
+    assert playwright_dict["password"] == proxy.password
+
+    # Test Playwright format with different protocols
+    for protocol in ["http", "https"]:
+        playwright_protocol = proxy.format(ProxyFormat.PLAYWRIGHT, protocol=protocol)
+        assert playwright_protocol["server"].startswith(f"{protocol}://")
+
+
+@skip_integration
+def test_webshare_playwright_format_comprehensive():
+    """Comprehensive test of Playwright format with real Webshare API."""
+    api_key = os.getenv("WEBSHARE_API_KEY")
+    provider = Webshare(api_key=api_key)
+
+    proxy = provider.get_proxy()
+
+    # Test 1: Default Playwright format
+    default_format = proxy.format(ProxyFormat.PLAYWRIGHT)
+    assert isinstance(default_format, dict)
+    assert "server" in default_format
+    assert "username" in default_format
+    assert "password" in default_format
+    assert default_format["server"].startswith("http://")
+
+    # Test 2: Protocol variations
+    protocols_to_test = ["http", "https"]
+
+    for protocol in protocols_to_test:
+        result = proxy.format(ProxyFormat.PLAYWRIGHT, protocol=protocol)
+        assert result["server"].startswith(f"{protocol}://")
+        assert result["username"] == proxy.username
+        assert result["password"] == proxy.password
+
+    # Test 3: String format
+    string_format = proxy.format("playwright")
+    assert string_format == default_format
+
+    # Test 4: Format consistency
+    enum_format = proxy.format(ProxyFormat.PLAYWRIGHT)
+    string_format = proxy.format("playwright")
+    assert enum_format == string_format
+
+    # Test 5: Playwright documentation compliance
+    playwright_config = proxy.format(ProxyFormat.PLAYWRIGHT)
+
+    # Verify structure matches Playwright docs
+    required_fields = ["server"]
+    optional_fields = ["username", "password"]
+
+    for field in required_fields:
+        assert field in playwright_config, f"Missing required field: {field}"
+
+    for field in optional_fields:
+        if field in playwright_config:
+            assert True  # Field is present
+        else:
+            assert False, f"Missing optional field: {field}"
+
+    # Verify server format
+    server = playwright_config["server"]
+    assert "://" in server, "Server should include protocol"
+    assert (
+        f"{proxy.proxy_address}:{proxy.port}" in server
+    ), "Server should include address and port"
+
+
+@skip_integration
+def test_webshare_playwright_e2e_simulation():
+    """End-to-end simulation of Playwright usage with real Webshare proxy."""
+    api_key = os.getenv("WEBSHARE_API_KEY")
+    provider = Webshare(api_key=api_key)
+
+    proxy = provider.get_proxy()
+
+    # Convert to Playwright format
+    playwright_config = proxy.format(ProxyFormat.PLAYWRIGHT)
+
+    # Verify the format is exactly what Playwright expects
+    # Check server format
+    server = playwright_config["server"]
+    assert "://" in server, "Server must include protocol"
+    assert (
+        f"{proxy.proxy_address}:{proxy.port}" in server
+    ), "Server must include address and port"
+
+    # Check authentication
+    assert "username" in playwright_config, "Username field is required"
+    assert "password" in playwright_config, "Password field is required"
+
+    # Check required fields
+    assert "server" in playwright_config, "Server field is required"
+
+    # Check optional fields
+    optional_fields = ["username", "password"]
+    for field in optional_fields:
+        assert field in playwright_config, f"Missing optional field: {field}"
+
+    # Test different protocols
+    protocols = ["http", "https"]
+    for protocol in protocols:
+        config = proxy.format(ProxyFormat.PLAYWRIGHT, protocol=protocol)
+        server = config["server"]
+        assert server.startswith(f"{protocol}://")
+
 
 @skip_integration
 def test_webshare_e2e_with_requests():

tests/integration/test_brightdata_algorithms_integration.py

@@ -94,6 +94,86 @@ def test_brightdata_proxy_conversion_methods():
     assert "https" in requests_dict
     print(f"BrightData Requests dict: {requests_dict}")
 
+    # Test Playwright format (default protocol)
+    playwright_dict = proxy.format(ProxyFormat.PLAYWRIGHT)
+    assert isinstance(playwright_dict, dict)
+    assert "server" in playwright_dict
+    assert playwright_dict["server"].startswith("http://")
+    assert f"{proxy.proxy_address}:{proxy.port}" in playwright_dict["server"]
+    assert "username" in playwright_dict
+    assert "password" in playwright_dict
+    assert playwright_dict["username"] == proxy.username
+    assert playwright_dict["password"] == proxy.password
+
+    # Test Playwright format with different protocols
+    for protocol in ["http", "https"]:
+        playwright_protocol = proxy.format(ProxyFormat.PLAYWRIGHT, protocol=protocol)
+        assert playwright_protocol["server"].startswith(f"{protocol}://")
+
+
+@skip_integration
+def test_brightdata_playwright_format_comprehensive():
+    """Comprehensive test of Playwright format with real BrightData API."""
+    api_key = os.getenv("BRIGHTDATA_API_KEY")
+    provider = BrightData(api_key=api_key, zone="static")
+
+    proxy = provider.get_proxy()
+
+    # Test 1: Default Playwright format
+    default_format = proxy.format(ProxyFormat.PLAYWRIGHT)
+    assert isinstance(default_format, dict)
+    assert "server" in default_format
+    assert "username" in default_format
+    assert "password" in default_format
+    assert default_format["server"].startswith("http://")
+
+    # Test 2: Protocol variations
+    protocols_to_test = ["http", "https"]
+
+    for protocol in protocols_to_test:
+        result = proxy.format(ProxyFormat.PLAYWRIGHT, protocol=protocol)
+        assert result["server"].startswith(f"{protocol}://")
+        assert result["username"] == proxy.username
+        assert result["password"] == proxy.password
+
+    # Test 3: String format
+    string_format = proxy.format("playwright")
+    assert string_format == default_format
+
+    # Test 4: Format consistency
+    enum_format = proxy.format(ProxyFormat.PLAYWRIGHT)
+    string_format = proxy.format("playwright")
+    assert enum_format == string_format
+
+    # Test 5: Playwright documentation compliance
+    playwright_config = proxy.format(ProxyFormat.PLAYWRIGHT)
+
+    # Verify structure matches Playwright docs
+    required_fields = ["server"]
+    optional_fields = ["username", "password"]
+
+    for field in required_fields:
+        assert field in playwright_config, f"Missing required field: {field}"
+
+    for field in optional_fields:
+        if field in playwright_config:
+            assert True  # Field is present
+        else:
+            assert False, f"Missing optional field: {field}"
+
+    # Verify server format
+    server = playwright_config["server"]
+    assert "://" in server, "Server should include protocol"
+    assert (
+        f"{proxy.proxy_address}:{proxy.port}" in server
+    ), "Server should include address and port"
+
+    # Test 6: Protocol fallback behavior
+    # Try to use an unsupported protocol - should fallback gracefully
+    fallback_result = proxy.format(ProxyFormat.PLAYWRIGHT, protocol="socks5")
+    assert "server" in fallback_result
+    assert fallback_result["server"].startswith("http://")  # Should fallback to http
+
 
 @skip_integration
 def test_brightdata_e2e_with_requests():

tests/test_proxy_model.py

@@ -145,7 +145,7 @@ def test_format_playwright_with_auth(self, sample_proxy):
         """Test format for Playwright with authentication."""
         result = sample_proxy.format(ProxyFormat.PLAYWRIGHT)
         expected = {
-            "server": "192.168.1.100:8080",
+            "server": "http://192.168.1.100:8080",
             "username": "testuser",
             "password": "testpass",
         }
@@ -155,7 +155,7 @@ def test_format_playwright_without_auth(self, sample_proxy_no_protocols):
         """Test format for Playwright with authentication (sample_proxy_no_protocols has auth)."""
         result = sample_proxy_no_protocols.format(ProxyFormat.PLAYWRIGHT)
         expected = {
-            "server": "10.0.0.1:3128",
+            "server": "http://10.0.0.1:3128",
             "username": "user2",
             "password": "pass2",
         }
@@ -171,7 +171,7 @@ def test_format_playwright_empty_credentials(self):
             port=8080,
         )
         result = proxy.format(ProxyFormat.PLAYWRIGHT)
-        expected = {"server": "192.168.1.1:8080"}
+        expected = {"server": "http://192.168.1.1:8080"}
         assert result == expected
 
     def test_format_playwright_none_credentials(self):
@@ -184,19 +184,71 @@ def test_format_playwright_none_credentials(self):
             port=8080,
         )
         result = proxy.format(ProxyFormat.PLAYWRIGHT)
-        expected = {"server": "192.168.1.1:8080"}
+        expected = {"server": "http://192.168.1.1:8080"}
         assert result == expected
 
     def test_format_playwright_string_format(self, sample_proxy):
         """Test format for Playwright using string format."""
         result = sample_proxy.format("playwright")
         expected = {
-            "server": "192.168.1.100:8080",
+            "server": "http://192.168.1.100:8080",
             "username": "testuser",
             "password": "testpass",
         }
         assert result == expected
 
+    def test_format_playwright_with_protocol(self, sample_proxy):
+        """Test format for Playwright with specific protocol."""
+        # Test with https protocol
+        result = sample_proxy.format(ProxyFormat.PLAYWRIGHT, protocol="https")
+        expected = {
+            "server": "https://192.168.1.100:8080",
+            "username": "testuser",
+            "password": "testpass",
+        }
+        assert result == expected
+
+    def test_format_playwright_with_socks5(self):
+        """Test format for Playwright with SOCKS5 protocol."""
+        # Create a proxy that supports SOCKS5
+        proxy = Proxy(
+            id="socks5-test",
+            username="testuser",
+            password="testpass",
+            proxy_address="192.168.1.100",
+            port=8080,
+            protocols=["http", "https", "socks5"],  # Include socks5 support
+        )
+
+        result = proxy.format(ProxyFormat.PLAYWRIGHT, protocol="socks5")
+        expected = {
+            "server": "socks5://192.168.1.100:8080",
+            "username": "testuser",
+            "password": "testpass",
+        }
+        assert result == expected
+
+    def test_format_playwright_protocol_fallback(self):
+        """Test format for Playwright with protocol fallback."""
+        # Create proxy with limited protocols
+        proxy = Proxy(
+            id="limited-protocol",
+            username="user",
+            password="pass",
+            proxy_address="192.168.1.1",
+            port=8080,
+            protocols=["http"],  # Only supports HTTP
+        )
+
+        # Request unsupported protocol, should fallback to http
+        result = proxy.format(ProxyFormat.PLAYWRIGHT, protocol="socks5")
+        expected = {
+            "server": "http://192.168.1.1:8080",
+            "username": "user",
+            "password": "pass",
+        }
+        assert result == expected
+
     def test_format_string_enum(self, sample_proxy):
         """Test format with string instead of enum."""
         result = sample_proxy.format("requests")