tawasuyu/brahman

1//! Smoke tests del CLI: init → ingest → status, todo persistido.
2
3use std::fs;
4
5use minga_cli::{cmd_ingest, cmd_init, cmd_status, CliError};
6use tempfile::TempDir;
7
8#[test]
9fn init_creates_keypair_and_repo() {
10    let dir = TempDir::new().unwrap();
11    let repo = dir.path().join("repo");
12    let did = cmd_init(&repo, "passphrase-secreta").unwrap();
13
14    // El keypair existe en disco.
15    assert!(repo.join("keypair").exists());
16    // El repo sled existe (es un directorio).
17    assert!(repo.join("repo").is_dir());
18    // El DID retornado es no-trivial.
19    assert_ne!(did, minga_core::Did([0u8; 32]));
20}
21
22#[test]
23fn init_refuses_existing_non_empty_directory() {
24    let dir = TempDir::new().unwrap();
25    let repo = dir.path().join("repo");
26    fs::create_dir(&repo).unwrap();
27    fs::write(repo.join("garbage"), b"hello").unwrap();
28    let r = cmd_init(&repo, "p");
29    assert!(matches!(r, Err(CliError::AlreadyExists(_))));
30}
31
32#[test]
33fn status_shows_empty_state_after_init() {
34    let dir = TempDir::new().unwrap();
35    let repo = dir.path().join("repo");
36    cmd_init(&repo, "p").unwrap();
37    let s = cmd_status(&repo, "p").unwrap();
38    assert_eq!(s.mst_len, 0);
39    assert_eq!(s.nodes_len, 0);
40    assert_eq!(s.attestations_len, 0);
41}
42
43#[test]
44fn status_with_wrong_passphrase_errors() {
45    let dir = TempDir::new().unwrap();
46    let repo = dir.path().join("repo");
47    cmd_init(&repo, "correcta").unwrap();
48    let r = cmd_status(&repo, "incorrecta");
49    assert!(r.is_err());
50}
51
52#[test]
53fn ingest_persists_function_with_self_attestation() {
54    let dir = TempDir::new().unwrap();
55    let repo = dir.path().join("repo");
56    let did = cmd_init(&repo, "p").unwrap();
57
58    // Escribir un archivo Rust de ejemplo.
59    let src = dir.path().join("ejemplo.rs");
60    fs::write(&src, "fn add(x: i32, y: i32) -> i32 { x + y }").unwrap();
61
62    let r = cmd_ingest(&repo, "p", &src).unwrap();
63    assert_eq!(r.did, did, "la firma debe ser del repo, no de otro");
64
65    let s = cmd_status(&repo, "p").unwrap();
66    assert_eq!(s.mst_len, 1);
67    assert!(s.nodes_len > 1, "el AST tiene más de un nodo");
68    assert_eq!(s.attestations_len, 1, "una autoatestación");
69}
70
71#[test]
72fn ingest_persists_across_runs() {
73    // Simulamos "reiniciar el proceso": cmd_init en una llamada,
74    // cmd_ingest en otra (que reabre el repo).
75    let dir = TempDir::new().unwrap();
76    let repo = dir.path().join("repo");
77    cmd_init(&repo, "p").unwrap();
78
79    let src1 = dir.path().join("uno.rs");
80    fs::write(&src1, "fn one() -> i32 { 1 }").unwrap();
81    cmd_ingest(&repo, "p", &src1).unwrap();
82
83    let src2 = dir.path().join("dos.rs");
84    fs::write(&src2, "fn two() -> i32 { 2 }").unwrap();
85    cmd_ingest(&repo, "p", &src2).unwrap();
86
87    let s = cmd_status(&repo, "p").unwrap();
88    assert_eq!(s.mst_len, 2);
89    assert_eq!(s.attestations_len, 2);
90}
91
92#[test]
93fn ingest_same_file_twice_is_idempotent() {
94    let dir = TempDir::new().unwrap();
95    let repo = dir.path().join("repo");
96    cmd_init(&repo, "p").unwrap();
97
98    let src = dir.path().join("f.rs");
99    fs::write(&src, "fn f() -> i32 { 42 }").unwrap();
100
101    let r1 = cmd_ingest(&repo, "p", &src).unwrap();
102    let r2 = cmd_ingest(&repo, "p", &src).unwrap();
103    assert_eq!(r1.hash, r2.hash);
104
105    let s = cmd_status(&repo, "p").unwrap();
106    // El MST tiene 1 entrada (mismo hash). Atestaciones también: 1
107    // por (autor, contenido) — idempotente.
108    assert_eq!(s.mst_len, 1);
109    assert_eq!(s.attestations_len, 1);
110}