unki/integration/tests/helpers/panel.rs

use serde::de::DeserializeOwned;
use serde_json::{from_slice, Value};
use std::fmt::{Debug, Display};
use std::process::{Command, Output};
use u_lib::{
    datatypes::PanelResult,
    utils::{bytes_to_string, ProcOutput},
};

const PANEL_BINARY: &str = "/u_panel";

pub struct Panel;

impl Panel {
    fn run(args: &[&str]) -> Output {
        Command::new(PANEL_BINARY)
            .arg("--json")
            .args(args)
            .output()
            .unwrap()
    }

    pub fn output_argv<T: DeserializeOwned>(argv: &[&str]) -> PanelResult<T> {
        let result = Self::run(argv);
        let output = ProcOutput::from_output(&result).to_appropriate();
        from_slice(&output)
            .map_err(|e| {
                eprintln!(
                    "Failed to decode panel response: '{}'",
                    bytes_to_string(&output)
                );
                e.to_string()
            })
            .unwrap()
    }

    pub fn output<T: DeserializeOwned + Debug>(
        args: impl Into<String> + Display,
    ) -> PanelResult<T> {
        eprintln!("EXEC >>> {PANEL_BINARY} {}", &args);
        let splitted = shlex::split(args.into().as_ref()).unwrap();
        let result = Self::output_argv(
            splitted
                .iter()
                .map(|s| s.as_ref())
                .collect::<Vec<&str>>()
                .as_ref(),
        );
        match &result {
            PanelResult::Ok(r) => eprintln!("<<<+ {r:?}"),
            PanelResult::Err(e) => eprintln!("<<<! {e:?}"),
        }
        result
    }

    fn status_is_ok<T: DeserializeOwned + Debug>(data: PanelResult<T>) -> T {
        match data {
            PanelResult::Ok(r) => r,
            PanelResult::Err(e) => panic!("Panel failed: {}", e),
        }
    }

    pub fn check_status(args: impl Into<String> + Display) {
        let result: PanelResult<Value> = Self::output(args);
        Self::status_is_ok(result);
    }

    pub fn check_output<T: DeserializeOwned + Debug>(args: impl Into<String> + Display) -> T {
        let result = Self::output(args);
        Self::status_is_ok(result)
    }
}