use super::*;
#[test]
fn test_next_chains_two_stages() {
let stmt = parse("RETURN 1 AS a NEXT RETURN a + 1 AS b").unwrap();
assert_eq!(stmt.clauses.len(), 1);
let next = stmt.next.as_deref().expect("expected a .next stage");
assert_eq!(next.clauses.len(), 1);
assert!(next.next.is_none());
}
#[test]
fn test_next_chains_three_stages() {
let stmt = parse("RETURN 1 AS a NEXT RETURN a AS b NEXT RETURN b AS c").unwrap();
let stage1 = stmt.next.as_deref().expect("stage 1");
let stage2 = stage1.next.as_deref().expect("stage 2");
assert!(stage2.next.is_none());
}
#[test]
fn test_next_is_a_non_reserved_word_usable_as_a_variable() {
let stmt = parse("MATCH (next) RETURN next").unwrap();
assert_eq!(stmt.clauses.len(), 2);
}
#[test]
fn test_next_bare_next_alone_is_a_syntax_error() {
assert!(parse("NEXT").is_err());
}
#[test]
fn test_next_leading_next_before_first_statement_is_a_syntax_error() {
assert!(parse("NEXT LET a = 1 RETURN a").is_err());
}
#[test]
fn test_next_trailing_dangling_next_is_a_syntax_error() {
assert!(parse("LET a = 1 RETURN a NEXT").is_err());
}
#[test]
fn test_next_double_next_is_a_syntax_error() {
assert!(parse("RETURN 1 AS a NEXT NEXT RETURN a AS b").is_err());
}
#[test]
fn test_next_bare_when_chain_after_next_no_braces() {
let stmt =
parse("RETURN 1 AS a NEXT WHEN a = 1 THEN RETURN 2 AS a ELSE RETURN 3 AS a").unwrap();
let next = stmt.next.as_deref().expect("expected a .next stage");
match &next.clauses[0] {
Clause::Conditional(cc) => {
assert_eq!(cc.branches.len(), 1);
assert!(cc.else_body.is_some());
}
other => panic!("expected Conditional clause, got {other:?}"),
}
}
#[test]
fn test_next_bare_multi_when_chain_after_next_no_braces() {
let stmt = parse(
"RETURN 1 AS a NEXT WHEN a > 2 THEN RETURN 1 AS m WHEN a > 1 THEN RETURN 2 AS m ELSE RETURN 3 AS m",
)
.unwrap();
let next = stmt.next.as_deref().expect("expected a .next stage");
match &next.clauses[0] {
Clause::Conditional(cc) => assert_eq!(cc.branches.len(), 2),
other => panic!("expected Conditional clause, got {other:?}"),
}
}
#[test]
fn test_bare_mid_clause_when_after_match_is_still_a_hard_error() {
assert!(parse("MATCH (n) WHEN true THEN { RETURN 1 AS s } RETURN n").is_err());
}
#[test]
fn test_next_call_scope_body_parses_as_next_chain() {
let stmt = parse("CALL (a) { RETURN a + 1 AS b NEXT RETURN a + b AS c } RETURN c").unwrap();
match &stmt.clauses[0] {
Clause::CallSubquery(csq) => {
assert!(csq.statement.next.is_some());
}
other => panic!("expected CallSubquery clause, got {other:?}"),
}
}
#[test]
fn test_next_forbidden_inside_naked_importing_with_call() {
assert!(
parse("WITH 1 AS x CALL { WITH x RETURN x AS y NEXT RETURN y + 1 AS z } RETURN z").is_err()
);
}
#[test]
fn test_next_allowed_inside_naked_call_without_importing_with() {
assert!(parse("CALL { RETURN 1 AS a NEXT RETURN a + 1 AS b } RETURN b").is_ok());
}
#[test]
fn test_next_top_level_brace_block_own_chain_splices_into_outer_next() {
let stmt = parse("{ RETURN 1 AS a NEXT RETURN a + 1 AS b } NEXT RETURN b + 1 AS c").unwrap();
let stage1 = stmt.next.as_deref().expect("stage 1 (brace's own NEXT)");
let stage2 = stage1.next.as_deref().expect("stage 2 (outer NEXT)");
assert!(stage2.next.is_none());
}