native-theme-gtk 0.1.1

Resolve the active GTK 4 theme into a serializable toolkit-neutral snapshot
Documentation
//! Subprocess integration tests for GTK theme resolution.

use std::path::Path;
use std::process::{Command, Output};

use native_theme_gtk::{Rgba, ThemeSnapshot};

fn command() -> Command {
    Command::new(env!("CARGO_BIN_EXE_native-theme-gtk"))
}

fn parse_success(output: Output) -> ThemeSnapshot {
    assert!(
        output.status.success(),
        "probe failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    serde_json::from_slice(&output.stdout).expect("probe emitted invalid JSON")
}

fn run_theme(theme: &str, config_home: Option<&Path>) -> ThemeSnapshot {
    let mut process = command();
    process.env("GTK_THEME", theme);
    if let Some(config_home) = config_home {
        process.env("XDG_CONFIG_HOME", config_home);
    }
    parse_success(process.output().expect("failed to run GTK probe"))
}

fn live_tests_enabled() -> bool {
    std::env::var_os("NATIVE_THEME_RUN_LIVE_TESTS").is_some()
}

fn approximately_equal(actual: Rgba, expected: Rgba) -> bool {
    const TOLERANCE: f32 = 1.0 / 255.0;
    (actual.red - expected.red).abs() <= TOLERANCE
        && (actual.green - expected.green).abs() <= TOLERANCE
        && (actual.blue - expected.blue).abs() <= TOLERANCE
        && (actual.alpha - expected.alpha).abs() <= TOLERANCE
}

#[test]
fn unavailable_display_backend_fails_cleanly() {
    let output = command()
        .env("GDK_BACKEND", "native-theme-no-such-backend")
        .output()
        .expect("failed to run GTK probe");

    assert!(!output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("failed to initialize GTK"), "{stderr}");
}

#[test]
fn adwaita_light_and_dark_are_distinct() {
    if !live_tests_enabled() {
        return;
    }

    let light = run_theme("Adwaita", None);
    let dark = run_theme("Adwaita:dark", None);
    let light_background = light.semantic_palette.window_background.unwrap();
    let dark_background = dark.semantic_palette.window_background.unwrap();
    let light_bridge = light.resolve_native_theme().unwrap();
    let dark_bridge = dark.resolve_native_theme().unwrap();

    assert!(light_background.red > dark_background.red);
    assert!(light_background.green > dark_background.green);
    assert!(!light_bridge.mode.is_dark());
    assert!(dark_bridge.mode.is_dark());
    assert_eq!(
        light_bridge
            .resolved
            .defaults
            .background_color
            .to_f32_array(),
        [
            light_background.red,
            light_background.green,
            light_background.blue,
            light_background.alpha,
        ]
    );
    assert_eq!(
        light_bridge.resolved.scrollbar.overlay_mode,
        light.settings.overlay_scrolling.unwrap()
    );
    assert_eq!(light.backend, "gtk4");
    assert_eq!(light.widgets.len(), 8);

    #[cfg(feature = "gpui")]
    {
        let light_gpui = light.to_gpui_theme().unwrap();
        let dark_gpui = dark.to_gpui_theme().unwrap();
        assert!(!light_gpui.is_dark());
        assert!(dark_gpui.is_dark());
    }

    let minor = light
        .identity
        .toolkit_version
        .split('.')
        .nth(1)
        .unwrap()
        .parse::<u32>()
        .unwrap();
    if minor >= 20 {
        assert!(light.settings.interface_color_scheme.is_some());
        assert!(light.settings.interface_contrast.is_some());
    }
    if minor >= 22 {
        assert!(light.settings.interface_reduced_motion.is_some());
    }
}

#[test]
fn user_css_overrides_are_resolved() {
    if !live_tests_enabled() {
        return;
    }

    let config = tempfile::tempdir().unwrap();
    let gtk_config = config.path().join("gtk-4.0");
    std::fs::create_dir(&gtk_config).unwrap();
    std::fs::write(
        gtk_config.join("gtk.css"),
        "@define-color window_bg_color #123456;\n@define-color window_fg_color #fedcba;\n",
    )
    .unwrap();

    let snapshot = run_theme("Adwaita", Some(config.path()));
    let expected_background = Rgba {
        red: 0x12 as f32 / 255.0,
        green: 0x34 as f32 / 255.0,
        blue: 0x56 as f32 / 255.0,
        alpha: 1.0,
    };
    let expected_text = Rgba {
        red: 0xfe as f32 / 255.0,
        green: 0xdc as f32 / 255.0,
        blue: 0xba as f32 / 255.0,
        alpha: 1.0,
    };

    assert!(approximately_equal(
        snapshot.semantic_palette.window_background.unwrap(),
        expected_background
    ));
    assert!(approximately_equal(
        snapshot.semantic_palette.window_text.unwrap(),
        expected_text
    ));
    let bridge = snapshot.resolve_native_theme().unwrap();
    assert_eq!(
        bridge.resolved.defaults.background_color.to_f32_array(),
        [
            expected_background.red,
            expected_background.green,
            expected_background.blue,
            expected_background.alpha,
        ]
    );

    #[cfg(feature = "gpui")]
    assert_eq!(
        snapshot.to_gpui_theme().unwrap().is_dark(),
        bridge.mode.is_dark()
    );
}

#[test]
fn repeated_probes_are_deterministic() {
    if !live_tests_enabled() {
        return;
    }

    let first = run_theme("Adwaita", None);
    let second = run_theme("Adwaita", None);
    assert_eq!(first, second);
}

#[test]
fn desktop_color_scheme_matches_the_effective_theme_mode() {
    if !live_tests_enabled() {
        return;
    }

    let snapshot = parse_success(
        command()
            .env_remove("GTK_THEME")
            .output()
            .expect("failed to run GTK probe"),
    );
    let Some(color_scheme) = snapshot.settings.interface_color_scheme.as_ref() else {
        return;
    };
    let expected_dark = match color_scheme.nick.as_str() {
        "dark" => true,
        "light" => false,
        _ => return,
    };

    let bridge = snapshot.resolve_native_theme().unwrap();
    assert_eq!(
        bridge.mode.is_dark(),
        expected_dark,
        "GTK sampled colors did not honor the desktop's explicit {} preference",
        color_scheme.nick
    );
    assert_eq!(snapshot.settings.prefer_dark, Some(expected_dark));
}