darkwing/server/services/browser_profile_services/config/

screen.rs

/// Configuration module for screen-related settings in browser profiles.
/// Handles screen dimensions, pixel density, and color depth based on
/// platform and mode settings.
use crate::{
  database::browser_profile::Platform,
  server::{
    dtos::{
      browser_profile_dto::{BrowserProfileFullData, Mode},
      start_dto::StartRequest,
    },
    error::Error,
  },
};
use serde::{Deserialize, Serialize};

use super::{FromStartRequest, Navigator};

/// Represents screen configuration settings for a browser profile.
///
/// Contains information about:
/// - Whether real screen dimensions should be used
/// - Screen width and height
/// - Device pixel ratio (DPR)
/// - Color depth
#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq)]
pub struct Screen {
  /// Whether to use real screen dimensions from the user's device
  pub is_real: bool,
  /// Screen width in pixels
  pub width: i16,
  /// Screen height in pixels
  pub height: i16,
  /// Device pixel ratio (physical pixels per CSS pixel)
  pub dpr: f32,
  /// Color depth in bits per pixel
  pub depth: i16,
}

/// Implementation of screen configuration generation from start request data
impl FromStartRequest<Screen> for Screen {
  /// Creates a new Screen configuration from browser profile and start request
  /// data.
  ///
  /// # Arguments
  /// * `bp` - Full browser profile data containing screen preferences
  /// * `request` - Start request containing user's actual screen dimensions
  /// * `_navigator` - Navigator configuration (unused)
  /// * `_screen` - Base screen configuration (unused)
  /// * `_token` - Authentication token (unused)
  ///
  /// # Returns
  /// * `Result<Screen, Error>` - New screen configuration or error
  fn from_start_request(
    bp: &BrowserProfileFullData,
    request: &StartRequest,
    _navigator: &Navigator,
    _screen: &Screen,
    _token: &str,
  ) -> Result<Self, Error> {
    let is_real = bp.screen.mode == Mode::Real;
    let mut width = bp.screen.width.unwrap_or(1366) as i16;
    let mut height = bp.screen.height.unwrap_or(768) as i16;
    let mut dpr = 1.0;
    let mut depth = 24;

    if is_real {
      width = request.user_screen_width as i16;
      height = request.user_screen_height as i16;
    }

    if bp.platform == Platform::Macos {
      dpr = 2.0;
      depth = 30;
    }

    Ok(Self {
      is_real,
      width,
      height,
      dpr,
      depth,
    })
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::server::services::browser_profile_services::config::consts::LINUX_MOCK_PROFILE;

  /// Creates a base browser profile for testing with default screen settings
  fn create_base_profile() -> BrowserProfileFullData {
    BrowserProfileFullData {
      screen: crate::server::dtos::browser_profile_dto::Screen {
        mode: Mode::Manual,
        width: Some(1920),
        height: Some(1080),
      },
      ..LINUX_MOCK_PROFILE.clone()
    }
  }

  /// Creates a base start request for testing with mock screen dimensions
  fn create_base_request() -> StartRequest {
    StartRequest {
      user_screen_width: 1440,
      user_screen_height: 900,
      ..StartRequest::get_mock()
    }
  }

  /// Tests screen configuration generation in manual mode
  #[test]
  fn test_manual_mode() -> Result<(), Error> {
    let profile = create_base_profile();
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = Screen::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert!(!result.is_real);
    assert_eq!(result.width, 1920);
    assert_eq!(result.height, 1080);
    assert_eq!(result.dpr, 1.0);
    assert_eq!(result.depth, 24);
    Ok(())
  }

  /// Tests screen configuration generation in real mode
  #[test]
  fn test_real_mode() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.screen.mode = Mode::Real;
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = Screen::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert!(result.is_real);
    assert_eq!(result.width, 1440);
    assert_eq!(result.height, 900);
    assert_eq!(result.dpr, 1.0);
    assert_eq!(result.depth, 24);
    Ok(())
  }

  /// Tests screen configuration with default resolution values
  #[test]
  fn test_default_resolution() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.screen.width = None;
    profile.screen.height = None;
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = Screen::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert!(!result.is_real);
    assert_eq!(result.width, 1366);
    assert_eq!(result.height, 768);
    assert_eq!(result.dpr, 1.0);
    assert_eq!(result.depth, 24);
    Ok(())
  }

  /// Tests screen configuration for macOS platform
  #[test]
  fn test_macos_platform() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Macos;
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = Screen::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert!(!result.is_real);
    assert_eq!(result.width, 1920);
    assert_eq!(result.height, 1080);
    assert_eq!(result.dpr, 2.0);
    assert_eq!(result.depth, 30);
    Ok(())
  }

  /// Tests screen configuration for Windows platform
  #[test]
  fn test_windows_platform() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Windows;
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = Screen::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert!(!result.is_real);
    assert_eq!(result.width, 1920);
    assert_eq!(result.height, 1080);
    assert_eq!(result.dpr, 1.0);
    assert_eq!(result.depth, 24);
    Ok(())
  }
}