use super::*;
#[test]
fn test_cypher_25_prefix_is_transparent() {
let stmt = parse("CYPHER 25 RETURN 1 AS n").unwrap();
assert_eq!(stmt.clauses.len(), 1);
assert!(matches!(stmt.clauses[0], Clause::Return(_)));
assert_eq!(stmt.cypher_version, Some(25));
}
#[test]
fn test_cypher_5_prefix_is_accepted_and_recorded() {
let stmt = parse("CYPHER 5 RETURN 1 AS n").unwrap();
assert_eq!(stmt.clauses.len(), 1);
assert_eq!(stmt.cypher_version, Some(5));
}
#[test]
fn test_cypher_no_prefix_leaves_version_unset() {
let stmt = parse("RETURN 1 AS n").unwrap();
assert_eq!(stmt.cypher_version, None);
}
#[test]
fn test_cypher_unknown_version_number_is_rejected() {
assert!(parse("CYPHER 99 RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_decimal_version_is_rejected() {
assert!(parse("CYPHER 5.0 RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_variable_named_cypher_is_unaffected() {
let stmt = parse("WITH 1 AS cypher RETURN cypher").unwrap();
assert_eq!(stmt.clauses.len(), 2);
}
#[test]
fn test_cypher_same_version_repeated_is_accepted() {
let stmt = parse("CYPHER 5 CYPHER 5 RETURN 1 AS n").unwrap();
assert_eq!(stmt.cypher_version, Some(5));
}
#[test]
fn test_cypher_conflicting_versions_are_rejected() {
assert!(parse("CYPHER 5 CYPHER 25 RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_versionless_options_clause_is_accepted() {
let stmt = parse("CYPHER planner=cost RETURN 1 AS n").unwrap();
assert_eq!(stmt.cypher_version, None);
}
#[test]
fn test_cypher_unrecognized_option_key_is_rejected() {
assert!(parse("CYPHER 5 foo=bar RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_conflicting_option_values_are_rejected() {
assert!(parse("CYPHER 5 runtime=slotted runtime=pipelined RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_explain_before_version_is_accepted() {
let stmt = parse("EXPLAIN CYPHER 5 runtime=slotted RETURN 1 AS n").unwrap();
assert!(stmt.explain);
assert_eq!(stmt.cypher_version, Some(5));
}
#[test]
fn test_cypher_version_before_explain_is_accepted() {
let stmt = parse("CYPHER 5 runtime=slotted EXPLAIN RETURN 1 AS n").unwrap();
assert!(stmt.explain);
assert_eq!(stmt.cypher_version, Some(5));
}
#[test]
fn test_cypher_explain_inside_options_clause_is_rejected() {
assert!(parse("CYPHER 5 EXPLAIN runtime=slotted RETURN 1 AS n").is_err());
}
#[test]
fn test_cypher_25_runtime_parallel_is_accepted_and_ignored() {
let stmt = parse("CYPHER 25 runtime=parallel RETURN 1 AS n").unwrap();
assert_eq!(stmt.cypher_version, Some(25));
assert!(matches!(stmt.clauses[0], Clause::Return(_)));
}
#[test]
fn test_cypher_25_runtime_unknown_value_is_rejected_naming_valid_values() {
let err = parse("CYPHER 25 runtime=bogus RETURN 1 AS n").expect_err("expected a value error");
assert!(
err.message
.starts_with("SyntaxError: 22N10 invalid pre-parser option value"),
"wrong error: {}",
err.message
);
assert!(
err.message.contains("parallel"),
"error must name the valid values: {}",
err.message
);
}
#[test]
fn test_cypher_runtime_option_accepts_the_runtime_vocabulary() {
for q in [
"CYPHER 25 runtime=slotted RETURN 1 AS n",
"CYPHER 25 runtime=pipelined RETURN 1 AS n",
"CYPHER 5 runtime=parallel RETURN 1 AS n",
"CYPHER 5 runtime=slotted RETURN 1 AS n",
"CYPHER 5 runtime=pipelined RETURN 1 AS n",
"CYPHER runtime=parallel RETURN 1 AS n",
] {
let stmt = parse(q).unwrap_or_else(|e| panic!("{q} must parse: {e}"));
assert!(matches!(stmt.clauses[0], Clause::Return(_)), "{q}");
}
}
#[test]
fn test_cypher_25_unrecognized_option_key_is_rejected() {
let err = parse("CYPHER 25 foo=bar RETURN 1 AS n").expect_err("expected a key error");
assert!(
err.message
.starts_with("SyntaxError: 22N07 invalid pre-parser option key"),
"wrong error: {}",
err.message
);
}