aft/
lib.rs

1// ## Note on `.unwrap()` / `.expect()` usage
2//
3// The remaining `.unwrap()` and `.expect()` calls in `src/` are in:
4// - **Tree-sitter query operations** (parser.rs, zoom.rs, extract.rs, inline.rs,
5//   outline.rs): These operate on AFT's own compiled grammars and query patterns, which
6//   are compile-time constants. Pattern captures and node kinds are guaranteed to exist.
7// - **Checkpoint serialization** (checkpoint.rs): serde_json::to_value on known-good
8//   HashMap<PathBuf, String> types cannot fail.
9// - **lib.rs main loop**: JSON parsing of stdin lines — a malformed line is logged and
10//   skipped, not unwrapped.
11//
12// All production command handlers that process user/agent input return Result or
13// Response::error instead of panicking. Confirmed zero .unwrap()/.expect() in
14// production error paths as of v0.6.3 audit.
15
16pub mod ast_grep_lang;
17pub mod backup;
18pub mod callgraph;
19pub mod calls;
20pub mod checkpoint;
21pub mod commands;
22pub mod config;
23pub mod context;
24pub mod edit;
25pub mod error;
26pub mod extract;
27pub mod format;
28pub mod fuzzy_match;
29pub mod imports;
30pub mod indent;
31pub mod language;
32pub mod lsp;
33pub mod lsp_hints;
34pub mod parser;
35pub mod protocol;
36pub mod search_index;
37pub mod semantic_index;
38pub mod symbols;
39
40#[cfg(test)]
41mod tests {
42    use super::*;
43    use config::Config;
44    use error::AftError;
45    use protocol::{RawRequest, Response};
46
47    // --- Protocol serialization ---
48
49    #[test]
50    fn raw_request_deserializes_ping() {
51        let json = r#"{"id":"1","command":"ping"}"#;
52        let req: RawRequest = serde_json::from_str(json).unwrap();
53        assert_eq!(req.id, "1");
54        assert_eq!(req.command, "ping");
55        assert!(req.lsp_hints.is_none());
56    }
57
58    #[test]
59    fn raw_request_deserializes_echo_with_params() {
60        let json = r#"{"id":"2","command":"echo","message":"hello"}"#;
61        let req: RawRequest = serde_json::from_str(json).unwrap();
62        assert_eq!(req.id, "2");
63        assert_eq!(req.command, "echo");
64        // "message" is captured in the flattened params
65        assert_eq!(req.params["message"], "hello");
66    }
67
68    #[test]
69    fn raw_request_preserves_unknown_fields() {
70        let json = r#"{"id":"3","command":"ping","future_field":"abc","nested":{"x":1}}"#;
71        let req: RawRequest = serde_json::from_str(json).unwrap();
72        assert_eq!(req.params["future_field"], "abc");
73        assert_eq!(req.params["nested"]["x"], 1);
74    }
75
76    #[test]
77    fn raw_request_with_lsp_hints() {
78        let json = r#"{"id":"4","command":"ping","lsp_hints":{"completions":["foo","bar"]}}"#;
79        let req: RawRequest = serde_json::from_str(json).unwrap();
80        assert!(req.lsp_hints.is_some());
81        let hints = req.lsp_hints.unwrap();
82        assert_eq!(hints["completions"][0], "foo");
83    }
84
85    #[test]
86    fn response_success_round_trip() {
87        let resp = Response::success("42", serde_json::json!({"command": "pong"}));
88        let json_str = serde_json::to_string(&resp).unwrap();
89        let v: serde_json::Value = serde_json::from_str(&json_str).unwrap();
90        assert_eq!(v["id"], "42");
91        assert_eq!(v["success"], true);
92        assert_eq!(v["command"], "pong");
93    }
94
95    #[test]
96    fn response_error_round_trip() {
97        let resp = Response::error("99", "unknown_command", "unknown command: foo");
98        let json_str = serde_json::to_string(&resp).unwrap();
99        let v: serde_json::Value = serde_json::from_str(&json_str).unwrap();
100        assert_eq!(v["id"], "99");
101        assert_eq!(v["success"], false);
102        assert_eq!(v["code"], "unknown_command");
103        assert_eq!(v["message"], "unknown command: foo");
104    }
105
106    // --- Error formatting ---
107
108    #[test]
109    fn error_display_symbol_not_found() {
110        let err = AftError::SymbolNotFound {
111            name: "foo".into(),
112            file: "bar.rs".into(),
113        };
114        assert_eq!(err.to_string(), "symbol 'foo' not found in bar.rs");
115        assert_eq!(err.code(), "symbol_not_found");
116    }
117
118    #[test]
119    fn error_display_ambiguous_symbol() {
120        let err = AftError::AmbiguousSymbol {
121            name: "Foo".into(),
122            candidates: vec!["a.rs:10".into(), "b.rs:20".into()],
123        };
124        let s = err.to_string();
125        assert!(s.contains("Foo"));
126        assert!(s.contains("a.rs:10, b.rs:20"));
127    }
128
129    #[test]
130    fn error_display_parse_error() {
131        let err = AftError::ParseError {
132            message: "unexpected token".into(),
133        };
134        assert_eq!(err.to_string(), "parse error: unexpected token");
135    }
136
137    #[test]
138    fn error_display_file_not_found() {
139        let err = AftError::FileNotFound {
140            path: "/tmp/missing.rs".into(),
141        };
142        assert_eq!(err.to_string(), "file not found: /tmp/missing.rs");
143    }
144
145    #[test]
146    fn error_display_invalid_request() {
147        let err = AftError::InvalidRequest {
148            message: "missing field".into(),
149        };
150        assert_eq!(err.to_string(), "invalid request: missing field");
151    }
152
153    #[test]
154    fn error_display_checkpoint_not_found() {
155        let err = AftError::CheckpointNotFound {
156            name: "pre-refactor".into(),
157        };
158        assert_eq!(err.to_string(), "checkpoint not found: pre-refactor");
159        assert_eq!(err.code(), "checkpoint_not_found");
160    }
161
162    #[test]
163    fn error_display_no_undo_history() {
164        let err = AftError::NoUndoHistory {
165            path: "src/main.rs".into(),
166        };
167        assert_eq!(err.to_string(), "no undo history for: src/main.rs");
168        assert_eq!(err.code(), "no_undo_history");
169    }
170
171    #[test]
172    fn error_display_ambiguous_match() {
173        let err = AftError::AmbiguousMatch {
174            pattern: "TODO".into(),
175            count: 5,
176        };
177        assert_eq!(
178            err.to_string(),
179            "pattern 'TODO' matches 5 occurrences, expected exactly 1"
180        );
181        assert_eq!(err.code(), "ambiguous_match");
182    }
183
184    #[test]
185    fn error_to_json_has_code_and_message() {
186        let err = AftError::FileNotFound { path: "/x".into() };
187        let j = err.to_error_json();
188        assert_eq!(j["code"], "file_not_found");
189        assert!(j["message"].as_str().unwrap().contains("/x"));
190    }
191
192    // --- Config defaults ---
193
194    #[test]
195    fn config_default_values() {
196        let cfg = Config::default();
197        assert!(cfg.project_root.is_none());
198        assert_eq!(cfg.validation_depth, 1);
199        assert_eq!(cfg.checkpoint_ttl_hours, 24);
200        assert_eq!(cfg.max_symbol_depth, 10);
201        assert_eq!(cfg.formatter_timeout_secs, 10);
202        assert_eq!(cfg.type_checker_timeout_secs, 30);
203    }
204}
aft/lib.rs

aft/
lib.rs
