use std::path::Path;
use std::sync::{Arc, Mutex};
use xert::{
scaffold::{create_project, ProgressHandler},
Template,
};
struct TestProgressHandler {
phases: Arc<Mutex<Vec<String>>>,
}
impl TestProgressHandler {
fn new() -> Self {
Self {
phases: Arc::new(Mutex::new(Vec::new())),
}
}
fn get_phases(&self) -> Vec<String> {
self.phases.lock().unwrap().clone()
}
}
impl ProgressHandler for TestProgressHandler {
fn start_phase(&self, phase: &str) {
self.phases
.lock()
.unwrap()
.push(format!("START: {}", phase));
}
fn finish_phase(&self, phase: &str) {
self.phases
.lock()
.unwrap()
.push(format!("FINISH: {}", phase));
}
}
struct SilentHandler;
impl ProgressHandler for SilentHandler {
fn start_phase(&self, _phase: &str) {}
fn finish_phase(&self, _phase: &str) {}
}
#[tokio::test]
async fn test_create_cli_project() {
let handler = TestProgressHandler::new();
let project_name = "test_cli_project";
if Path::new(project_name).exists() {
std::fs::remove_dir_all(project_name).ok();
}
let result = create_project(&Template::Cli, project_name, &handler).await;
assert!(
result.is_ok(),
"Project creation failed: {:?}",
result.err()
);
assert!(
Path::new(project_name).exists(),
"Project directory not created"
);
assert!(
Path::new(project_name).join("Cargo.toml").exists(),
"Cargo.toml not created"
);
assert!(
Path::new(project_name).join("src").join("main.rs").exists(),
"main.rs not created"
);
let phases = handler.get_phases();
assert!(
phases.len() >= 4,
"Progress handler should have been called at least 4 times"
);
assert!(
phases
.iter()
.any(|p| p.contains("Dependencies") || p.contains("dependencies")),
"Should track dependency resolution"
);
assert!(
phases.iter().any(|p| p.to_lowercase().contains("scaffold")),
"Should track scaffolding"
);
std::fs::remove_dir_all(project_name).ok();
}
#[tokio::test]
async fn test_create_web_project() {
let handler = SilentHandler;
let project_name = "test_web_project";
if Path::new(project_name).exists() {
std::fs::remove_dir_all(project_name).ok();
}
let result = create_project(&Template::Web, project_name, &handler).await;
assert!(
result.is_ok(),
"Web project creation failed: {:?}",
result.err()
);
assert!(
Path::new(project_name).exists(),
"Project directory not created"
);
let cargo_toml = std::fs::read_to_string(Path::new(project_name).join("Cargo.toml")).unwrap();
assert!(
cargo_toml.contains("axum"),
"Cargo.toml should contain axum dependency"
);
assert!(
cargo_toml.contains("tokio"),
"Cargo.toml should contain tokio dependency"
);
std::fs::remove_dir_all(project_name).ok();
}
#[tokio::test]
async fn test_create_embedded_project() {
let handler = SilentHandler;
let project_name = "test_embedded_project";
if Path::new(project_name).exists() {
std::fs::remove_dir_all(project_name).ok();
}
let result = create_project(&Template::Embedded, project_name, &handler).await;
assert!(
result.is_ok(),
"Embedded project creation failed: {:?}",
result.err()
);
assert!(
Path::new(project_name).exists(),
"Project directory not created"
);
let cargo_toml = std::fs::read_to_string(Path::new(project_name).join("Cargo.toml")).unwrap();
assert!(
cargo_toml.contains("cortex-m"),
"Cargo.toml should contain cortex-m dependency"
);
std::fs::remove_dir_all(project_name).ok();
}
#[tokio::test]
async fn test_duplicate_project_error() {
let handler = SilentHandler;
let project_name = "test_duplicate_project";
if Path::new(project_name).exists() {
std::fs::remove_dir_all(project_name).ok();
}
let result1 = create_project(&Template::Cli, project_name, &handler).await;
assert!(result1.is_ok(), "First project creation should succeed");
let result2 = create_project(&Template::Cli, project_name, &handler).await;
assert!(result2.is_err(), "Creating duplicate project should fail");
assert!(
result2.unwrap_err().to_string().contains("already exists"),
"Error should mention that directory already exists"
);
std::fs::remove_dir_all(project_name).ok();
}
#[tokio::test]
async fn test_dependency_resolution() {
use xert::deps::resolve_dependencies;
let crates = vec!["serde", "tokio", "anyhow"];
let versions = resolve_dependencies(&crates).await;
assert!(
!versions.is_empty(),
"Should resolve at least some dependencies"
);
if let Some(version) = versions.get("serde") {
assert!(!version.is_empty(), "Version should not be empty");
assert!(
version.contains('.'),
"Version should contain dots (e.g., 1.0.0)"
);
}
}
#[tokio::test]
async fn test_template_equality() {
assert_eq!(Template::Web, Template::Web);
assert_eq!(Template::Cli, Template::Cli);
assert_eq!(Template::Embedded, Template::Embedded);
assert_ne!(Template::Web, Template::Cli);
}
#[tokio::test]
async fn test_all_templates_create_projects() {
let handler = SilentHandler;
let templates = vec![
(Template::Web, "test_all_web"),
(Template::Cli, "test_all_cli"),
(Template::Embedded, "test_all_embedded"),
];
for (template, name) in templates {
if Path::new(name).exists() {
std::fs::remove_dir_all(name).ok();
}
let result = create_project(&template, name, &handler).await;
assert!(result.is_ok(), "Failed to create {:?} project", template);
assert!(Path::new(name).exists());
assert!(Path::new(name).join("Cargo.toml").exists());
std::fs::remove_dir_all(name).ok();
}
}
#[tokio::test]
async fn test_security_audit_file_created() {
let handler = SilentHandler;
let project_name = "test_security_audit";
if Path::new(project_name).exists() {
std::fs::remove_dir_all(project_name).ok();
}
create_project(&Template::Cli, project_name, &handler)
.await
.unwrap();
let audit_path = Path::new(project_name)
.join(".github")
.join("workflows")
.join("audit.yml");
assert!(
audit_path.exists(),
"Security audit workflow should be created"
);
let audit_content = std::fs::read_to_string(&audit_path).unwrap();
assert!(
audit_content.contains("Security Audit"),
"Audit file should contain workflow name"
);
std::fs::remove_dir_all(project_name).ok();
}
#[tokio::test]
async fn test_concurrent_project_creation() {
use tokio::task::JoinSet;
let mut set = JoinSet::new();
for i in 0..3 {
set.spawn(async move {
let handler = SilentHandler;
let name = format!("test_concurrent_{}", i);
if Path::new(&name).exists() {
std::fs::remove_dir_all(&name).ok();
}
let result = create_project(&Template::Cli, &name, &handler).await;
if Path::new(&name).exists() {
std::fs::remove_dir_all(&name).ok();
}
result.is_ok()
});
}
while let Some(res) = set.join_next().await {
assert!(res.unwrap(), "Concurrent project creation should succeed");
}
}
#[test]
fn test_template_debug_format() {
let web = Template::Web;
let debug_str = format!("{:?}", web);
assert_eq!(debug_str, "Web");
}