use cascade_core::{CascadeError, CascadeResult};
use serde::{Deserialize, Serialize};
use crate::{EnvironmentKind, ExecutionMode, ToolReadiness, ToolReport, ToolRequirement};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DetectionRequest {
pub environment: EnvironmentKind,
pub execution_mode: ExecutionMode,
pub requirements: Vec<ToolRequirement>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum EnvironmentIssueSeverity {
Warning,
Error,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnvironmentIssue {
pub code: String,
pub severity: EnvironmentIssueSeverity,
pub message: String,
pub command: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnvironmentReport {
pub environment: EnvironmentKind,
pub execution_mode: ExecutionMode,
pub tools: Vec<ToolReport>,
pub issues: Vec<EnvironmentIssue>,
}
impl EnvironmentReport {
pub fn is_ready(&self) -> bool {
self.tools
.iter()
.all(|tool| tool.readiness == ToolReadiness::Ready)
&& self
.issues
.iter()
.all(|issue| issue.severity != EnvironmentIssueSeverity::Error)
}
}
pub trait EnvironmentDetector {
fn detect(&self, request: &DetectionRequest) -> CascadeResult<EnvironmentReport>;
}
#[derive(Debug, Clone)]
pub struct StaticEnvironmentDetector {
report: EnvironmentReport,
}
impl StaticEnvironmentDetector {
pub fn new(report: EnvironmentReport) -> Self {
Self { report }
}
}
impl EnvironmentDetector for StaticEnvironmentDetector {
fn detect(&self, request: &DetectionRequest) -> CascadeResult<EnvironmentReport> {
if self.report.environment != request.environment
|| self.report.execution_mode != request.execution_mode
{
return Err(CascadeError::new(
"static environment report does not match detection request",
));
}
Ok(self.report.clone())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{RequiredOrigin, ToolRole};
fn request() -> DetectionRequest {
DetectionRequest {
environment: EnvironmentKind::wsl("Ubuntu").unwrap(),
execution_mode: ExecutionMode::Native,
requirements: vec![ToolRequirement {
command: "git".to_owned(),
role: ToolRole::Git,
required_origin: RequiredOrigin::Native,
}],
}
}
#[test]
fn static_detector_returns_matching_report() {
let request = request();
let report = EnvironmentReport {
environment: request.environment.clone(),
execution_mode: request.execution_mode,
tools: Vec::new(),
issues: Vec::new(),
};
assert_eq!(
StaticEnvironmentDetector::new(report.clone())
.detect(&request)
.unwrap(),
report
);
}
#[test]
fn static_detector_rejects_wrong_environment() {
let request = request();
let report = EnvironmentReport {
environment: EnvironmentKind::Host,
execution_mode: ExecutionMode::Native,
tools: Vec::new(),
issues: Vec::new(),
};
assert!(
StaticEnvironmentDetector::new(report)
.detect(&request)
.is_err()
);
}
#[test]
fn report_readiness_includes_partial_detection_errors() {
let report = EnvironmentReport {
environment: EnvironmentKind::Host,
execution_mode: ExecutionMode::Native,
tools: Vec::new(),
issues: vec![EnvironmentIssue {
code: "probe-failed".to_owned(),
severity: EnvironmentIssueSeverity::Error,
message: "Git probe failed".to_owned(),
command: Some("git".to_owned()),
}],
};
assert!(!report.is_ready());
}
}