add unhandled_prompt_behavior param for create_user_context

Author: navin772

py/selenium/webdriver/common/bidi/browser.py

@@ -16,9 +16,10 @@
 # under the License.
 
 
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from selenium.webdriver.common.bidi.common import command_builder
+from selenium.webdriver.common.bidi.session import UserPromptHandler
 from selenium.webdriver.common.proxy import Proxy
 
 
@@ -185,26 +186,35 @@ class Browser:
     def __init__(self, conn):
         self.conn = conn
 
-    def create_user_context(self, accept_insecure_certs: Optional[bool] = None, proxy: Optional[Proxy] = None) -> str:
+    def create_user_context(
+        self,
+        accept_insecure_certs: Optional[bool] = None,
+        proxy: Optional[Proxy] = None,
+        unhandled_prompt_behavior: Optional[UserPromptHandler] = None,
+    ) -> str:
         """Creates a new user context.
 
         Parameters:
         -----------
             accept_insecure_certs: Optional flag to accept insecure TLS certificates
             proxy: Optional proxy configuration for the user context
+            unhandled_prompt_behavior: Optional configuration for handling user prompts
 
         Returns:
         -------
             str: The ID of the created user context.
         """
-        params = {}
+        params: Dict[str, Any] = {}
 
         if accept_insecure_certs is not None:
             params["acceptInsecureCerts"] = accept_insecure_certs
 
         if proxy is not None:
             params["proxy"] = proxy.to_bidi_dict()
 
+        if unhandled_prompt_behavior is not None:
+            params["unhandledPromptBehavior"] = unhandled_prompt_behavior.to_dict()
+
         result = self.conn.execute(command_builder("browser.createUserContext", params))
         return result["userContext"]
 

py/selenium/webdriver/common/bidi/session.py

@@ -15,9 +15,91 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from typing import Dict, Optional
+
 from selenium.webdriver.common.bidi.common import command_builder
 
 
+class UserPromptHandlerType:
+    """Represents the behavior of the user prompt handler."""
+
+    ACCEPT = "accept"
+    DISMISS = "dismiss"
+    IGNORE = "ignore"
+
+    VALID_TYPES = {ACCEPT, DISMISS, IGNORE}
+
+
+class UserPromptHandler:
+    """Represents the configuration of the user prompt handler."""
+
+    def __init__(
+        self,
+        alert: Optional[str] = None,
+        before_unload: Optional[str] = None,
+        confirm: Optional[str] = None,
+        default: Optional[str] = None,
+        file: Optional[str] = None,
+        prompt: Optional[str] = None,
+    ):
+        """Initialize UserPromptHandler.
+
+        Parameters:
+        -----------
+            alert: Handler type for alert prompts
+            before_unload: Handler type for beforeUnload prompts
+            confirm: Handler type for confirm prompts
+            default: Default handler type for all prompts
+            file: Handler type for file picker prompts
+            prompt: Handler type for prompt dialogs
+
+        Raises:
+        ------
+            ValueError: If any handler type is not valid
+        """
+        for field_name, value in [
+            ("alert", alert),
+            ("before_unload", before_unload),
+            ("confirm", confirm),
+            ("default", default),
+            ("file", file),
+            ("prompt", prompt),
+        ]:
+            if value is not None and value not in UserPromptHandlerType.VALID_TYPES:
+                raise ValueError(
+                    f"Invalid {field_name} handler type: {value}. Must be one of {UserPromptHandlerType.VALID_TYPES}"
+                )
+
+        self.alert = alert
+        self.before_unload = before_unload
+        self.confirm = confirm
+        self.default = default
+        self.file = file
+        self.prompt = prompt
+
+    def to_dict(self) -> Dict[str, str]:
+        """Convert the UserPromptHandler to a dictionary for BiDi protocol.
+
+        Returns:
+        -------
+            Dict[str, str]: Dictionary representation suitable for BiDi protocol
+        """
+        result = {}
+        if self.alert is not None:
+            result["alert"] = self.alert
+        if self.before_unload is not None:
+            result["beforeUnload"] = self.before_unload
+        if self.confirm is not None:
+            result["confirm"] = self.confirm
+        if self.default is not None:
+            result["default"] = self.default
+        if self.file is not None:
+            result["file"] = self.file
+        if self.prompt is not None:
+            result["prompt"] = self.prompt
+        return result
+
+
 class Session:
     def __init__(self, conn):
         self.conn = conn