Bug 1854996 - Implement Permissions API extension for geckodriver. r=webdriver-reviewers,whimboo

Differential Revision: https://phabricator.services.mozilla.com/D212406

testing/geckodriver/marionette/src/webdriver.rs

@@ -131,6 +131,25 @@ impl Default for PrintMargins {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetPermissionParameters {
+    pub descriptor: SetPermissionDescriptor,
+    pub state: SetPermissionState,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetPermissionDescriptor {
+    pub name: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SetPermissionState {
+    Denied,
+    Granted,
+    Prompt,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum WebAuthnProtocol {
     #[serde(rename = "ctap1/u2f")]
@@ -328,6 +347,8 @@ pub enum Command {
     ReleaseActions,
     #[serde(rename = "WebDriver:SendAlertText")]
     SendAlertText(Keys),
+    #[serde(rename = "WebDriver:SetPermission")]
+    SetPermission(SetPermissionParameters),
     #[serde(rename = "WebDriver:SetTimeouts")]
     SetTimeouts(Timeouts),
     #[serde(rename = "WebDriver:SetWindowRect")]

testing/geckodriver/src/marionette.rs

@@ -24,7 +24,9 @@ use marionette_rs::webdriver::{
     PrintMargins as MarionettePrintMargins, PrintOrientation as MarionettePrintOrientation,
     PrintPage as MarionettePrintPage, PrintPageRange as MarionettePrintPageRange,
     PrintParameters as MarionettePrintParameters, ScreenshotOptions, Script as MarionetteScript,
-    Selector as MarionetteSelector, Url as MarionetteUrl,
+    Selector as MarionetteSelector, SetPermissionDescriptor as MarionetteSetPermissionDescriptor,
+    SetPermissionParameters as MarionetteSetPermissionParameters,
+    SetPermissionState as MarionetteSetPermissionState, Url as MarionetteUrl,
     UserVerificationParameters as MarionetteUserVerificationParameters,
     WebAuthnProtocol as MarionetteWebAuthnProtocol, WindowRect as MarionetteWindowRect,
 };
@@ -53,18 +55,19 @@ use webdriver::command::WebDriverCommand::{
     GetPageSource, GetShadowRoot, GetTimeouts, GetTitle, GetWindowHandle, GetWindowHandles,
     GetWindowRect, GoBack, GoForward, IsDisplayed, IsEnabled, IsSelected, MaximizeWindow,
     MinimizeWindow, NewSession, NewWindow, PerformActions, Print, Refresh, ReleaseActions,
-    SendAlertText, SetTimeouts, SetWindowRect, Status, SwitchToFrame, SwitchToParentFrame,
+    SendAlertText, SetPermission, SetTimeouts, SetWindowRect, Status, SwitchToFrame,
-    SwitchToWindow, TakeElementScreenshot, TakeScreenshot, WebAuthnAddCredential,
+    SwitchToParentFrame, SwitchToWindow, TakeElementScreenshot, TakeScreenshot,
-    WebAuthnAddVirtualAuthenticator, WebAuthnGetCredentials, WebAuthnRemoveAllCredentials,
+    WebAuthnAddCredential, WebAuthnAddVirtualAuthenticator, WebAuthnGetCredentials,
-    WebAuthnRemoveCredential, WebAuthnRemoveVirtualAuthenticator, WebAuthnSetUserVerified,
+    WebAuthnRemoveAllCredentials, WebAuthnRemoveCredential, WebAuthnRemoveVirtualAuthenticator,
+    WebAuthnSetUserVerified,
 };
 use webdriver::command::{
     ActionsParameters, AddCookieParameters, AuthenticatorParameters, AuthenticatorTransport,
     GetNamedCookieParameters, GetParameters, JavascriptCommandParameters, LocatorParameters,
     NewSessionParameters, NewWindowParameters, PrintMargins, PrintOrientation, PrintPage,
-    PrintPageRange, PrintParameters, SendKeysParameters, SwitchToFrameParameters,
+    PrintPageRange, PrintParameters, SendKeysParameters, SetPermissionDescriptor,
-    SwitchToWindowParameters, TimeoutsParameters, UserVerificationParameters, WebAuthnProtocol,
+    SetPermissionParameters, SetPermissionState, SwitchToFrameParameters, SwitchToWindowParameters,
-    WindowRectParameters,
+    TimeoutsParameters, UserVerificationParameters, WebAuthnProtocol, WindowRectParameters,
 };
 use webdriver::command::{WebDriverCommand, WebDriverMessage};
 use webdriver::common::{
@@ -459,6 +462,7 @@ impl MarionetteSession {
             | GetAlertText
             | TakeScreenshot
             | Print(_)
+            | SetPermission(_)
             | TakeElementScreenshot(_)
             | WebAuthnAddVirtualAuthenticator(_)
             | WebAuthnRemoveVirtualAuthenticator
@@ -996,6 +1000,9 @@ fn try_convert_to_marionette_message(
         SendAlertText(ref x) => Some(Command::WebDriver(
             MarionetteWebDriverCommand::SendAlertText(x.to_marionette()?),
         )),
+        SetPermission(ref x) => Some(Command::WebDriver(
+            MarionetteWebDriverCommand::SetPermission(x.to_marionette()?),
+        )),
         SetTimeouts(ref x) => Some(Command::WebDriver(MarionetteWebDriverCommand::SetTimeouts(
             x.to_marionette()?,
         ))),
@@ -1520,6 +1527,33 @@ impl ToMarionette<MarionettePrintMargins> for PrintMargins {
     }
 }
 
+impl ToMarionette<MarionetteSetPermissionParameters> for SetPermissionParameters {
+    fn to_marionette(&self) -> WebDriverResult<MarionetteSetPermissionParameters> {
+        Ok(MarionetteSetPermissionParameters {
+            descriptor: self.descriptor.to_marionette()?,
+            state: self.state.to_marionette()?,
+        })
+    }
+}
+
+impl ToMarionette<MarionetteSetPermissionDescriptor> for SetPermissionDescriptor {
+    fn to_marionette(&self) -> WebDriverResult<MarionetteSetPermissionDescriptor> {
+        Ok(MarionetteSetPermissionDescriptor {
+            name: self.name.clone(),
+        })
+    }
+}
+
+impl ToMarionette<MarionetteSetPermissionState> for SetPermissionState {
+    fn to_marionette(&self) -> WebDriverResult<MarionetteSetPermissionState> {
+        Ok(match self {
+            SetPermissionState::Denied => MarionetteSetPermissionState::Denied,
+            SetPermissionState::Granted => MarionetteSetPermissionState::Granted,
+            SetPermissionState::Prompt => MarionetteSetPermissionState::Prompt,
+        })
+    }
+}
+
 impl ToMarionette<MarionetteAuthenticatorParameters> for AuthenticatorParameters {
     fn to_marionette(&self) -> WebDriverResult<MarionetteAuthenticatorParameters> {
         Ok(MarionetteAuthenticatorParameters {

testing/web-platform/meta/webdriver/tests/classic/permissions/set.py.ini

@@ -2,38 +2,8 @@
   [test_non_secure_context[granted\]]
     expected: FAIL
 
-  [test_invalid_parameters[parameters2\]]
-    expected: FAIL
-
-  [test_invalid_parameters[parameters5\]]
-    expected: FAIL
-
   [test_non_secure_context[prompt\]]
     expected: FAIL
 
-  [test_invalid_parameters[parameters6\]]
-    expected: FAIL
-
-  [test_invalid_parameters[parameters1\]]
-    expected: FAIL
-
-  [test_invalid_parameters[parameters4\]]
-    expected: FAIL
-
-  [test_invalid_parameters[parameters3\]]
-    expected: FAIL
-
-  [test_invalid_parameters[parameters0\]]
-    expected: FAIL
-
   [test_non_secure_context[denied\]]
     expected: FAIL
-
-  [test_set_to_state[granted\]]
-    expected: FAIL
-
-  [test_set_to_state[denied\]]
-    expected: FAIL
-
-  [test_set_to_state[prompt\]]
-    expected: FAIL

testing/webdriver/src/command.rs

@@ -79,6 +79,7 @@ pub enum WebDriverCommand<T: WebDriverExtensionCommand> {
     TakeScreenshot,
     TakeElementScreenshot(WebElement),
     Print(PrintParameters),
+    SetPermission(SetPermissionParameters),
     Status,
     Extension(T),
     WebAuthnAddVirtualAuthenticator(AuthenticatorParameters),
@@ -408,6 +409,9 @@ impl<U: WebDriverExtensionRoute> WebDriverMessage<U> {
                 WebDriverCommand::TakeElementScreenshot(element)
             }
             Route::Print => WebDriverCommand::Print(serde_json::from_str(raw_body)?),
+            Route::SetPermission => {
+                WebDriverCommand::SetPermission(serde_json::from_str(raw_body)?)
+            }
             Route::Status => WebDriverCommand::Status,
             Route::Extension(ref extension) => extension.command(params, &body_data)?,
             Route::WebAuthnAddVirtualAuthenticator => {
@@ -656,6 +660,25 @@ impl Default for PrintMargins {
     }
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetPermissionParameters {
+    pub descriptor: SetPermissionDescriptor,
+    pub state: SetPermissionState,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetPermissionDescriptor {
+    pub name: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SetPermissionState {
+    Denied,
+    Granted,
+    Prompt,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum WebAuthnProtocol {
     #[serde(rename = "ctap1/u2f")]
@@ -1382,6 +1405,49 @@ mod tests {
         assert!(serde_json::from_value::<PrintParameters>(json!({"scale": 3})).is_err());
     }
 
+    #[test]
+    fn test_json_permission() {
+        let params: SetPermissionParameters = SetPermissionParameters {
+            descriptor: SetPermissionDescriptor {
+                name: "push".into(),
+            },
+            state: SetPermissionState::Granted,
+        };
+        assert_de(
+            &params,
+            json!({"descriptor": {"name": "push"}, "state": "granted"}),
+        );
+    }
+
+    #[test]
+    fn test_json_permission_parameters_invalid() {
+        assert!(serde_json::from_value::<SetPermissionParameters>(json!({"test": 3})).is_err());
+    }
+
+    #[test]
+    fn test_json_permission_descriptor_invalid_type() {
+        assert!(serde_json::from_value::<SetPermissionParameters>(
+            json!({"descriptor": "test", "state": "granted"})
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn test_json_permission_state_invalid_type() {
+        assert!(serde_json::from_value::<SetPermissionParameters>(
+            json!({"descriptor": {"name": "push"}, "state": 3})
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn test_json_permission_state_invalid_value() {
+        assert!(serde_json::from_value::<SetPermissionParameters>(
+            json!({"descriptor": {"name": "push"}, "state": "invalid"})
+        )
+        .is_err());
+    }
+
     #[test]
     fn test_json_authenticator() {
         let params = AuthenticatorParameters {

testing/webdriver/src/httpapi.rs

@@ -307,6 +307,7 @@ pub fn standard_routes<U: WebDriverExtensionRoute>() -> Vec<(Method, &'static st
             "/session/{sessionId}/actions",
             Route::ReleaseActions,
         ),
+        (Method::POST, "/session/{sessionId}/permissions", Route::SetPermission),
         (Method::POST, "/session/{sessionId}/print", Route::Print),
         (
             Method::POST,
@@ -414,6 +415,7 @@ pub enum Route<U: WebDriverExtensionRoute> {
     TakeScreenshot,
     TakeElementScreenshot,
     Print,
+    SetPermission,
     Status,
     Extension(U),
     WebAuthnAddVirtualAuthenticator,