tor-browser

common.rs (6330B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use serde::ser::SerializeMap;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoolValue {
   value: bool,
}

impl BoolValue {
   pub fn new(val: bool) -> Self {
       BoolValue { value: val }
   }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Cookie {
   pub name: String,
   pub value: String,
   #[serde(skip_serializing_if = "Option::is_none")]
   pub path: Option<String>,
   #[serde(skip_serializing_if = "Option::is_none")]
   pub domain: Option<String>,
   #[serde(default)]
   pub secure: bool,
   #[serde(default, rename = "httpOnly")]
   pub http_only: bool,
   #[serde(skip_serializing_if = "Option::is_none")]
   pub expiry: Option<Date>,
   #[serde(skip_serializing_if = "Option::is_none", rename = "sameSite")]
   pub same_site: Option<String>,
}

pub fn to_cookie<T, S>(data: T, serializer: S) -> Result<S::Ok, S::Error>
where
   S: Serializer,
   T: Serialize,
{
   #[derive(Serialize)]
   struct Wrapper<T> {
       cookie: T,
   }

   Wrapper { cookie: data }.serialize(serializer)
}

pub fn from_cookie<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
   D: Deserializer<'de>,
   T: serde::de::DeserializeOwned,
   T: std::fmt::Debug,
{
   #[derive(Debug, Deserialize)]
   struct Wrapper<T> {
       cookie: T,
   }

   let w = Wrapper::deserialize(deserializer)?;
   Ok(w.cookie)
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Date(pub u64);

#[derive(Clone, Debug, PartialEq)]
pub enum Frame {
   Index(u16),
   Element(String),
   Top,
}

impl Serialize for Frame {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
       S: Serializer,
   {
       let mut map = serializer.serialize_map(Some(1))?;
       match self {
           Frame::Index(nth) => map.serialize_entry("id", nth)?,
           Frame::Element(el) => map.serialize_entry("element", el)?,
           Frame::Top => map.serialize_entry("id", &Value::Null)?,
       }
       map.end()
   }
}

impl<'de> Deserialize<'de> for Frame {
   fn deserialize<D>(deserializer: D) -> Result<Frame, D::Error>
   where
       D: Deserializer<'de>,
   {
       #[derive(Debug, Deserialize)]
       #[serde(rename_all = "lowercase")]
       struct JsonFrame {
           id: Option<u16>,
           element: Option<String>,
       }

       let json = JsonFrame::deserialize(deserializer)?;
       match (json.id, json.element) {
           (Some(_id), Some(_element)) => Err(de::Error::custom("conflicting frame identifiers")),
           (Some(id), None) => Ok(Frame::Index(id)),
           (None, Some(element)) => Ok(Frame::Element(element)),
           (None, None) => Ok(Frame::Top),
       }
   }
}

// TODO(nupur): Bug 1567165 - Make WebElement in Marionette a unit struct
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebElement {
   #[serde(rename = "element-6066-11e4-a52e-4f735466cecf")]
   pub element: String,
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Timeouts {
   #[serde(default, skip_serializing_if = "Option::is_none")]
   pub implicit: Option<u64>,
   #[serde(default, rename = "pageLoad", skip_serializing_if = "Option::is_none")]
   pub page_load: Option<u64>,
   #[serde(default, skip_serializing_if = "Option::is_none")]
   #[allow(clippy::option_option)]
   pub script: Option<Option<u64>>,
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Window {
   pub handle: String,
}

pub fn to_name<T, S>(data: T, serializer: S) -> Result<S::Ok, S::Error>
where
   S: Serializer,
   T: Serialize,
{
   #[derive(Serialize)]
   struct Wrapper<T> {
       name: T,
   }

   Wrapper { name: data }.serialize(serializer)
}

pub fn from_name<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
   D: Deserializer<'de>,
   T: serde::de::DeserializeOwned,
   T: std::fmt::Debug,
{
   #[derive(Debug, Deserialize)]
   struct Wrapper<T> {
       name: T,
   }

   let w = Wrapper::deserialize(deserializer)?;
   Ok(w.name)
}

#[cfg(test)]
mod tests {
   use super::*;
   use crate::test::{assert_de, assert_ser, assert_ser_de, ELEMENT_KEY};
   use serde_json::json;

   #[test]
   fn test_cookie_default_values() {
       let data = Cookie {
           name: "hello".into(),
           value: "world".into(),
           path: None,
           domain: None,
           secure: false,
           http_only: false,
           expiry: None,
           same_site: None,
       };
       assert_de(&data, json!({"name":"hello", "value":"world"}));
   }

   #[test]
   fn test_json_frame_index() {
       assert_ser_de(&Frame::Index(1234), json!({"id": 1234}));
   }

   #[test]
   fn test_json_frame_element() {
       assert_ser_de(&Frame::Element("elem".into()), json!({"element": "elem"}));
   }

   #[test]
   fn test_json_frame_parent() {
       assert_ser_de(&Frame::Top, json!({ "id": null }));
   }

   #[test]
   fn test_web_element() {
       let data = WebElement {
           element: "foo".into(),
       };
       assert_ser_de(&data, json!({ELEMENT_KEY: "foo"}));
   }

   #[test]
   fn test_timeouts_with_all_params() {
       let data = Timeouts {
           implicit: Some(1000),
           page_load: Some(200000),
           script: Some(Some(60000)),
       };
       assert_ser_de(
           &data,
           json!({"implicit":1000,"pageLoad":200000,"script":60000}),
       );
   }

   #[test]
   fn test_timeouts_with_missing_params() {
       let data = Timeouts {
           implicit: Some(1000),
           page_load: None,
           script: None,
       };
       assert_ser_de(&data, json!({"implicit":1000}));
   }

   #[test]
   fn test_timeouts_setting_script_none() {
       let data = Timeouts {
           implicit: Some(1000),
           page_load: None,
           script: Some(None),
       };
       assert_ser(&data, json!({"implicit":1000, "script":null}));
   }
}