use std::fs;
use crate::common::{setup_test_project, run_rsconstruct, run_rsconstruct_with_env};
#[test]
fn cache_operations() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::write(
project_path.join("config/cache_test.py"),
"value = 'cached'"
).unwrap();
fs::write(
project_path.join("templates.tera/cached.txt.tera"),
"{% set c = load_python(path='config/cache_test.py') %}{{ c.value }}"
).unwrap();
let output = run_rsconstruct(project_path, &["build"]);
assert!(output.status.success());
assert!(project_path.join("cached.txt").exists());
assert!(project_path.join(".rsconstruct/db.redb").exists());
assert!(project_path.join(".rsconstruct/objects").exists());
let size_output = run_rsconstruct(project_path, &["cache", "size"]);
assert!(size_output.status.success());
let size_stdout = String::from_utf8_lossy(&size_output.stdout);
assert!(size_stdout.contains("Cache size:"));
assert!(size_stdout.contains("objects"));
assert!(!size_stdout.contains("0 objects"), "Cache should have objects after build");
fs::remove_file(project_path.join("cached.txt")).unwrap();
assert!(!project_path.join("cached.txt").exists());
let restore_output = run_rsconstruct_with_env(project_path, &["build", "--verbose"], &[("NO_COLOR", "1")]);
assert!(restore_output.status.success());
let restore_stdout = String::from_utf8_lossy(&restore_output.stdout);
assert!(restore_stdout.contains("Restored from cache:"));
assert!(project_path.join("cached.txt").exists());
let content = fs::read_to_string(project_path.join("cached.txt")).unwrap();
assert_eq!(content.trim(), "cached");
let trim_output = run_rsconstruct(project_path, &["cache", "trim"]);
assert!(trim_output.status.success());
let trim_stdout = String::from_utf8_lossy(&trim_output.stdout);
assert!(trim_stdout.contains("0 unreferenced objects"));
let clear_output = run_rsconstruct(project_path, &["cache", "clear"]);
assert!(clear_output.status.success());
assert!(!project_path.join(".rsconstruct").join("objects").exists());
let size_after = run_rsconstruct(project_path, &["cache", "size"]);
assert!(size_after.status.success());
let size_after_stdout = String::from_utf8_lossy(&size_after.stdout);
assert!(size_after_stdout.contains("0 B"));
assert!(size_after_stdout.contains("0 objects"));
}
#[test]
fn cache_list_shows_entries() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::create_dir_all(project_path.join("sleep")).unwrap();
fs::write(project_path.join("sleep/list_test.sleep"), "0.01").unwrap();
fs::write(
project_path.join("rsconstruct.toml"),
"[processor]\nenabled = [\"sleep\"]\n"
).unwrap();
let build = run_rsconstruct(project_path, &["build"]);
assert!(build.status.success());
let output = run_rsconstruct_with_env(project_path, &["cache", "list"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let stdout = String::from_utf8_lossy(&output.stdout);
let entries: serde_json::Value = serde_json::from_str(&stdout)
.unwrap_or_else(|e| panic!("Cache list should be valid JSON: {}\nOutput: {}", e, stdout));
let arr = entries.as_array().expect("Cache list should be a JSON array");
assert!(!arr.is_empty(), "Cache list should have entries after build");
let first = &arr[0];
assert!(first["cache_key"].as_str().unwrap().contains("sleep"),
"Cache entry should contain processor name: {}", first);
let outputs = first["outputs"].as_array().expect("outputs should be an array");
assert!(outputs.is_empty(), "Checker cache entry should have empty outputs: {}", first);
}
#[test]
fn cache_list_empty() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::write(
project_path.join("rsconstruct.toml"),
"[processor]\nenabled = []\n"
).unwrap();
let output = run_rsconstruct_with_env(project_path, &["cache", "list"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let stdout = String::from_utf8_lossy(&output.stdout);
let entries: serde_json::Value = serde_json::from_str(&stdout)
.unwrap_or_else(|e| panic!("Cache list should be valid JSON: {}\nOutput: {}", e, stdout));
let arr = entries.as_array().expect("Cache list should be a JSON array");
assert!(arr.is_empty(), "Empty cache should produce an empty JSON array: {}", stdout);
}
#[test]
fn cache_stats_empty() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::write(
project_path.join("rsconstruct.toml"),
"[processor]\nenabled = []\n"
).unwrap();
let output = run_rsconstruct_with_env(project_path, &["cache", "stats"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("Cache is empty"), "Expected 'Cache is empty' message, got: {}", stdout);
}
#[test]
fn cache_stats_after_build() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::create_dir_all(project_path.join("sleep")).unwrap();
fs::write(project_path.join("sleep/stats_test.sleep"), "0.01").unwrap();
fs::write(
project_path.join("rsconstruct.toml"),
"[processor]\nenabled = [\"sleep\"]\n"
).unwrap();
let build = run_rsconstruct(project_path, &["build"]);
assert!(build.status.success());
let output = run_rsconstruct_with_env(project_path, &["cache", "stats"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("sleep"), "Expected processor name in stats, got: {}", stdout);
assert!(stdout.contains("entries"), "Expected 'entries' in stats, got: {}", stdout);
}
#[test]
fn cache_stats_json() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
fs::create_dir_all(project_path.join("sleep")).unwrap();
fs::write(project_path.join("sleep/json_test.sleep"), "0.01").unwrap();
fs::write(
project_path.join("rsconstruct.toml"),
"[processor]\nenabled = [\"sleep\"]\n"
).unwrap();
let build = run_rsconstruct(project_path, &["build"]);
assert!(build.status.success());
let output = run_rsconstruct_with_env(project_path, &["--json", "cache", "stats"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let stdout = String::from_utf8_lossy(&output.stdout);
let parsed: serde_json::Value = serde_json::from_str(&stdout)
.unwrap_or_else(|e| panic!("Cache stats JSON should be valid: {}\nOutput: {}", e, stdout));
assert!(parsed.is_object(), "Expected JSON object, got: {}", stdout);
assert!(parsed.get("sleep").is_some(), "Expected 'sleep' key in stats JSON, got: {}", stdout);
}