502 lines
16 KiB
Rust
502 lines
16 KiB
Rust
use proc_macro2::{Ident, Span, TokenStream};
|
|
use quote::quote;
|
|
|
|
use crate::parse::{ActionExpr, Fixtures, PiklTests, TestCase, TestKind, TestModule};
|
|
|
|
/// Generate all test modules from the parsed DSL.
|
|
pub fn generate(input: &PiklTests) -> syn::Result<TokenStream> {
|
|
let mut output = TokenStream::new();
|
|
for module in &input.modules {
|
|
output.extend(gen_module(module)?);
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
/// Generate a single `mod name { ... }` block with test
|
|
/// functions and the right imports for the test kind.
|
|
fn gen_module(module: &TestModule) -> syn::Result<TokenStream> {
|
|
let mod_name = &module.name;
|
|
let mut test_fns = Vec::new();
|
|
|
|
for case in &module.tests {
|
|
let tokens = match module.kind {
|
|
TestKind::Headless => gen_headless(case, &module.fixtures)?,
|
|
TestKind::Filter => gen_filter(case, &module.fixtures)?,
|
|
TestKind::Nav => gen_nav(case, &module.fixtures)?,
|
|
TestKind::Menu => gen_menu(case, &module.fixtures)?,
|
|
};
|
|
test_fns.push(tokens);
|
|
}
|
|
|
|
let imports = gen_imports(module.kind);
|
|
|
|
Ok(quote! {
|
|
mod #mod_name {
|
|
#imports
|
|
#(#test_fns)*
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Emit the `use` imports needed for a given test kind.
|
|
fn gen_imports(kind: TestKind) -> TokenStream {
|
|
match kind {
|
|
TestKind::Headless => {
|
|
quote! { use super::*; }
|
|
}
|
|
TestKind::Filter => {
|
|
quote! {
|
|
use pikl_core::item::Item;
|
|
use pikl_core::filter::{Filter, FuzzyFilter};
|
|
}
|
|
}
|
|
TestKind::Nav => {
|
|
quote! {
|
|
use pikl_core::navigation::Viewport;
|
|
}
|
|
}
|
|
TestKind::Menu => {
|
|
quote! {
|
|
use pikl_core::item::Item;
|
|
use pikl_core::event::{Action, MenuEvent, MenuResult};
|
|
use pikl_core::menu::MenuRunner;
|
|
use pikl_core::json_menu::JsonMenu;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Headless
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Generate a headless integration test that spawns the pikl
|
|
/// binary, feeds it items and a script, and asserts on
|
|
/// stdout/stderr/exit code.
|
|
fn gen_headless(case: &TestCase, fixtures: &Fixtures) -> syn::Result<TokenStream> {
|
|
let test_name = &case.name;
|
|
|
|
// Build items string: "item1\nitem2\n"
|
|
let items_str = match &fixtures.items {
|
|
Some(items) => {
|
|
let mut s = String::new();
|
|
for item in items {
|
|
s.push_str(item);
|
|
s.push('\n');
|
|
}
|
|
s
|
|
}
|
|
None => String::new(),
|
|
};
|
|
|
|
// Build script string from actions
|
|
let script = build_headless_script(&case.actions);
|
|
|
|
// Build extra CLI args (e.g. --label-key, --multi)
|
|
let mut extra_args: Vec<TokenStream> = Vec::new();
|
|
if let Some(ref key) = fixtures.label_key {
|
|
extra_args.push(quote! { "--label-key" });
|
|
extra_args.push(quote! { #key });
|
|
}
|
|
if fixtures.multi == Some(true) {
|
|
extra_args.push(quote! { "--multi" });
|
|
}
|
|
|
|
// Build assertions
|
|
let mut asserts = Vec::new();
|
|
|
|
if let Some(exit) = case.exit_code {
|
|
asserts.push(quote! {
|
|
assert_eq!(
|
|
code, #exit,
|
|
"expected exit {}, got {}, stderr: {}", #exit, code, stderr
|
|
);
|
|
});
|
|
}
|
|
|
|
if let Some(ref expected) = case.stdout {
|
|
if expected.is_empty() {
|
|
asserts.push(quote! {
|
|
assert!(
|
|
stdout.trim().is_empty(),
|
|
"expected empty stdout, got: {}", stdout
|
|
);
|
|
});
|
|
} else {
|
|
asserts.push(quote! {
|
|
assert!(
|
|
stdout.contains(#expected),
|
|
"expected stdout to contain {:?}, got: {}", #expected, stdout
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
if let Some(ref expected) = case.stderr_contains {
|
|
asserts.push(quote! {
|
|
assert!(
|
|
stderr.contains(#expected),
|
|
"expected stderr to contain {:?}, got: {}", #expected, stderr
|
|
);
|
|
});
|
|
}
|
|
|
|
Ok(quote! {
|
|
#[test]
|
|
fn #test_name() {
|
|
let (stdout, stderr, code) = run_pikl(#items_str, #script, &[#(#extra_args),*]);
|
|
#(#asserts)*
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Turn action expressions into the newline-delimited script
|
|
/// text that gets piped to `--action-fd`.
|
|
fn build_headless_script(actions: &[ActionExpr]) -> String {
|
|
let mut script = String::new();
|
|
for action in actions {
|
|
match action {
|
|
ActionExpr::Simple(name) => {
|
|
script.push_str(name);
|
|
script.push('\n');
|
|
}
|
|
ActionExpr::Filter(query) => {
|
|
script.push_str("filter ");
|
|
script.push_str(query);
|
|
script.push('\n');
|
|
}
|
|
ActionExpr::Raw(line) => {
|
|
script.push_str(line);
|
|
script.push('\n');
|
|
}
|
|
ActionExpr::AddItems(_) => {
|
|
// Not applicable for headless. Items come from stdin.
|
|
}
|
|
}
|
|
}
|
|
script
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Filter
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Generate a filter unit test: create items, push them
|
|
/// into a `FuzzyFilter`, set the query, and assert on
|
|
/// matched labels.
|
|
fn gen_filter(case: &TestCase, fixtures: &Fixtures) -> syn::Result<TokenStream> {
|
|
let test_name = &case.name;
|
|
|
|
let item_exprs = gen_item_constructors(fixtures);
|
|
|
|
let query = case.query.as_deref().unwrap_or("");
|
|
|
|
let mut asserts = Vec::new();
|
|
|
|
if let Some(ref expected) = case.match_labels {
|
|
asserts.push(quote! {
|
|
let labels: Vec<&str> = (0..f.matched_count())
|
|
.filter_map(|i| f.matched_index(i))
|
|
.map(|idx| items[idx].label())
|
|
.collect();
|
|
let expected: Vec<&str> = vec![#(#expected),*];
|
|
assert_eq!(
|
|
labels, expected,
|
|
"query {:?}: expected {:?}, got {:?}", #query, expected, labels
|
|
);
|
|
});
|
|
}
|
|
|
|
Ok(quote! {
|
|
#[test]
|
|
fn #test_name() {
|
|
let items: Vec<Item> = vec![#(#item_exprs),*];
|
|
let mut f = FuzzyFilter::new();
|
|
for (i, item) in items.iter().enumerate() {
|
|
f.push(i, item.label());
|
|
}
|
|
f.set_query(#query);
|
|
#(#asserts)*
|
|
}
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Nav
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Generate a navigation unit test: create a viewport, run
|
|
/// movement actions, and assert on cursor/offset.
|
|
fn gen_nav(case: &TestCase, fixtures: &Fixtures) -> syn::Result<TokenStream> {
|
|
let test_name = &case.name;
|
|
|
|
let (height, count) = fixtures.viewport.unwrap_or((10, 20));
|
|
let height_lit = height;
|
|
let count_lit = count;
|
|
|
|
let action_calls = gen_nav_actions(&case.actions)?;
|
|
|
|
let mut asserts = Vec::new();
|
|
|
|
if let Some(cursor) = case.cursor {
|
|
asserts.push(quote! {
|
|
assert_eq!(
|
|
v.cursor(), #cursor,
|
|
"expected cursor {}, got {}", #cursor, v.cursor()
|
|
);
|
|
});
|
|
}
|
|
|
|
if let Some(offset) = case.offset {
|
|
asserts.push(quote! {
|
|
assert_eq!(
|
|
v.scroll_offset(), #offset,
|
|
"expected offset {}, got {}", #offset, v.scroll_offset()
|
|
);
|
|
});
|
|
}
|
|
|
|
Ok(quote! {
|
|
#[test]
|
|
fn #test_name() {
|
|
let mut v = Viewport::new();
|
|
v.set_height(#height_lit);
|
|
v.set_filtered_count(#count_lit);
|
|
#(#action_calls)*
|
|
#(#asserts)*
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Convert DSL action names to `Viewport` method calls
|
|
/// (e.g. `move-down` becomes `v.move_down()`).
|
|
fn gen_nav_actions(actions: &[ActionExpr]) -> syn::Result<Vec<TokenStream>> {
|
|
let mut calls = Vec::new();
|
|
for action in actions {
|
|
match action {
|
|
ActionExpr::Simple(name) => {
|
|
let method = Ident::new(&name.replace('-', "_"), Span::call_site());
|
|
let needs_count = matches!(
|
|
name.as_str(),
|
|
"move-up"
|
|
| "move-down"
|
|
| "page-up"
|
|
| "page-down"
|
|
| "half-page-up"
|
|
| "half-page-down"
|
|
);
|
|
if needs_count {
|
|
calls.push(quote! { v.#method(1); });
|
|
} else {
|
|
calls.push(quote! { v.#method(); });
|
|
}
|
|
}
|
|
_ => {
|
|
return Err(syn::Error::new(
|
|
Span::call_site(),
|
|
format!(
|
|
"nav tests only support simple actions, got: {:?}",
|
|
action_debug(action)
|
|
),
|
|
));
|
|
}
|
|
}
|
|
}
|
|
Ok(calls)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Menu
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Generate an async menu state machine test: create a menu,
|
|
/// send actions, and assert on the final result (selected
|
|
/// item or cancellation).
|
|
fn gen_menu(case: &TestCase, fixtures: &Fixtures) -> syn::Result<TokenStream> {
|
|
let test_name = &case.name;
|
|
let item_exprs = gen_item_constructors(fixtures);
|
|
|
|
let label_key = fixtures.label_key.as_deref().unwrap_or("label");
|
|
|
|
let action_sends = gen_menu_actions(&case.actions)?;
|
|
|
|
let result_assert = if case.cancelled {
|
|
quote! {
|
|
assert!(
|
|
matches!(result, Ok(MenuResult::Cancelled)),
|
|
"expected Cancelled, got: {:?}", result.as_ref().map(|r| format!("{:?}", r))
|
|
);
|
|
}
|
|
} else if let Some(ref expected) = case.selected {
|
|
quote! {
|
|
match &result {
|
|
Ok(MenuResult::Selected { items, .. }) => {
|
|
assert!(!items.is_empty(), "expected Selected with items, got empty");
|
|
let value = &items[0].0;
|
|
let got = value.as_str()
|
|
.or_else(|| value.get(#label_key).and_then(|v| v.as_str()))
|
|
.unwrap_or("");
|
|
assert_eq!(
|
|
got, #expected,
|
|
"expected selected {:?}, got value: {:?}", #expected, value
|
|
);
|
|
}
|
|
other => panic!("expected Selected, got: {:?}", other),
|
|
}
|
|
}
|
|
} else if let Some(ref expected) = case.selected_items {
|
|
quote! {
|
|
match &result {
|
|
Ok(MenuResult::Selected { items, .. }) => {
|
|
let mut labels: Vec<&str> = items.iter()
|
|
.filter_map(|(v, _)| v.as_str()
|
|
.or_else(|| v.get(#label_key).and_then(|v| v.as_str())))
|
|
.collect();
|
|
labels.sort();
|
|
let mut expected = vec![#(#expected),*];
|
|
expected.sort();
|
|
assert_eq!(
|
|
labels, expected,
|
|
"expected selected_items {:?}, got {:?}", expected, labels
|
|
);
|
|
}
|
|
other => panic!("expected Selected, got: {:?}", other),
|
|
}
|
|
}
|
|
} else {
|
|
// No assertion on result. Probably an error, but let it compile.
|
|
quote! {}
|
|
};
|
|
|
|
// If test expects cancellation via sender drop (no cancel action, no confirm),
|
|
// we need to drop tx after sending actions.
|
|
let drop_sender = quote! { drop(tx); };
|
|
|
|
let multi_setup = if fixtures.multi == Some(true) {
|
|
quote! { menu.set_multi(true); }
|
|
} else {
|
|
quote! {}
|
|
};
|
|
|
|
Ok(quote! {
|
|
#[tokio::test]
|
|
async fn #test_name() {
|
|
let items = vec![#(#item_exprs),*];
|
|
let (mut menu, tx) = MenuRunner::new(JsonMenu::new(items, #label_key.to_string()));
|
|
#multi_setup
|
|
let mut rx = menu.subscribe();
|
|
let handle = tokio::spawn(async move { menu.run().await });
|
|
|
|
// Wait for initial state broadcast.
|
|
let _ = rx.recv().await;
|
|
|
|
// Give the viewport some height so confirms work.
|
|
let _ = tx.send(Action::Resize { height: 50 }).await;
|
|
let _ = rx.recv().await;
|
|
|
|
// Send all actions.
|
|
#(#action_sends)*
|
|
|
|
// Drop sender so menu loop can exit.
|
|
#drop_sender
|
|
|
|
let result = handle.await.unwrap_or(Ok(MenuResult::Cancelled));
|
|
#result_assert
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Convert DSL actions to `tx.send(Action::...)` calls for
|
|
/// menu tests.
|
|
fn gen_menu_actions(actions: &[ActionExpr]) -> syn::Result<Vec<TokenStream>> {
|
|
let mut sends = Vec::new();
|
|
for action in actions {
|
|
let expr = match action {
|
|
ActionExpr::Simple(name) => {
|
|
let variant = menu_action_variant(name)?;
|
|
quote! { let _ = tx.send(#variant).await; }
|
|
}
|
|
ActionExpr::Filter(query) => {
|
|
quote! {
|
|
let _ = tx.send(Action::UpdateFilter(#query.to_string())).await;
|
|
}
|
|
}
|
|
ActionExpr::AddItems(items) => {
|
|
let item_exprs: Vec<TokenStream> = items
|
|
.iter()
|
|
.map(|s| quote! { serde_json::Value::String(#s.to_string()) })
|
|
.collect();
|
|
quote! {
|
|
let _ = tx.send(Action::AddItems(vec![#(#item_exprs),*])).await;
|
|
}
|
|
}
|
|
ActionExpr::Raw(_) => {
|
|
return Err(syn::Error::new(
|
|
Span::call_site(),
|
|
"raw actions are only supported in headless tests",
|
|
));
|
|
}
|
|
};
|
|
sends.push(expr);
|
|
}
|
|
Ok(sends)
|
|
}
|
|
|
|
/// Map a DSL action name like `"move-down"` to the
|
|
/// corresponding `Action::MoveDown` token stream.
|
|
fn menu_action_variant(name: &str) -> syn::Result<TokenStream> {
|
|
let tokens = match name {
|
|
"confirm" => quote! { Action::Confirm },
|
|
"cancel" => quote! { Action::Cancel },
|
|
"move-down" => quote! { Action::MoveDown(1) },
|
|
"move-up" => quote! { Action::MoveUp(1) },
|
|
"move-to-top" => quote! { Action::MoveToTop },
|
|
"move-to-bottom" => quote! { Action::MoveToBottom },
|
|
"page-up" => quote! { Action::PageUp(1) },
|
|
"page-down" => quote! { Action::PageDown(1) },
|
|
"half-page-up" => quote! { Action::HalfPageUp(1) },
|
|
"half-page-down" => quote! { Action::HalfPageDown(1) },
|
|
"set-mode-insert" => quote! { Action::SetMode(pikl_core::event::Mode::Insert) },
|
|
"set-mode-normal" => quote! { Action::SetMode(pikl_core::event::Mode::Normal) },
|
|
"set-mode-visual" => quote! { Action::SetMode(pikl_core::event::Mode::Visual) },
|
|
"toggle-select" => quote! { Action::ToggleSelect },
|
|
"select-all" => quote! { Action::SelectAll },
|
|
"clear-selections" => quote! { Action::ClearSelections },
|
|
"undo-selection" => quote! { Action::UndoSelection },
|
|
"redo-selection" => quote! { Action::RedoSelection },
|
|
_ => {
|
|
return Err(syn::Error::new(
|
|
Span::call_site(),
|
|
format!("unknown menu action: '{name}'"),
|
|
));
|
|
}
|
|
};
|
|
Ok(tokens)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Shared helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Generate `Item::from_plain_text("...")` expressions for
|
|
/// each item in the fixtures.
|
|
fn gen_item_constructors(fixtures: &Fixtures) -> Vec<TokenStream> {
|
|
match &fixtures.items {
|
|
Some(items) => items
|
|
.iter()
|
|
.map(|s| quote! { Item::from_plain_text(#s) })
|
|
.collect(),
|
|
None => Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Format an action expression for use in error messages.
|
|
fn action_debug(action: &ActionExpr) -> String {
|
|
match action {
|
|
ActionExpr::Simple(name) => name.clone(),
|
|
ActionExpr::Filter(q) => format!("filter \"{q}\""),
|
|
ActionExpr::Raw(r) => format!("raw \"{r}\""),
|
|
ActionExpr::AddItems(items) => format!("add-items {:?}", items),
|
|
}
|
|
}
|