[#222] test: 파싱 성공·실패 계약을 단언하는 property 추가

CodeRabbit 리뷰 반영. 기존 property는 전부 '패닉하지 않는다'와
'결정적이다'만 확인하고 결과를 버렸습니다. 지적대로 유효 SQL이 실제로
파싱되는지는 아무도 검증하지 않고 있었습니다.

이게 왜 문제인지 실제로 확인했습니다. parse()가 무조건 빈 결과를
돌려주도록 바꿔봤더니:

  parser_never_panics_on_arbitrary_text     ok
  parser_never_panics_on_sql_like_input     ok
  parser_never_panics_on_mutated_statement  ok
  parsing_is_deterministic                  ok

'아무것도 파싱하지 않는 파서'가 기존 property를 전부 만족합니다.

두 가지를 추가했습니다.

- valid_statement() 생성기 + valid_statements_parse_into_exactly_one_statement
  구성상 유효한 SQL(SELECT/INSERT/UPDATE/DELETE/DROP 7형태, 세미콜론
  유무 포함)이 파싱되고 정확히 한 문장을 만드는지 확인합니다.
- a_bare_statement_keyword_is_an_error
  실패 쪽 계약입니다. 키워드만 있고 뒤가 없는 입력은 조용히 빈 결과가
  아니라 에러여야 합니다.

bite-test: 위의 '빈 결과만 돌려주는 파서'를 넣으면 신규 2건만 FAILED로
뒤집히고 기존 패닉 property는 전부 통과합니다.

cargo test 687 passed / 0 failed (직전 683 + 4).
clippy --all-targets 73건으로 master와 동일.

Author: DPS0340

src/engine/parser/test/property.rs

@@ -84,6 +84,33 @@ fn mutated_statement() -> impl Strategy<Value = String> {
     })
 }
 
+/// Statements that are valid by construction. Needed because every other
+/// generator here explores *malformed* input: they prove the parser does not
+/// panic, but nothing so far asserts that well-formed SQL actually parses. A
+/// parser that rejected everything would satisfy all the panic and determinism
+/// properties below.
+fn valid_statement() -> impl Strategy<Value = String> {
+    let table = prop::sample::select(vec!["foo", "bar", "baz_1"]);
+    let column = prop::sample::select(vec!["a", "b", "id"]);
+    let literal = prop::sample::select(vec!["1", "42", "'x'"]);
+    let terminator = prop::sample::select(vec!["", ";"]);
+
+    (table, column, literal, terminator).prop_flat_map(
+        |(table, column, literal, terminator)| {
+            let shapes = vec![
+                format!("SELECT {} FROM {}", column, table),
+                format!("SELECT * FROM {}", table),
+                format!("SELECT {} FROM {} WHERE {} = {}", column, table, column, literal),
+                format!("INSERT INTO {} ({}) VALUES ({})", table, column, literal),
+                format!("UPDATE {} SET {} = {}", table, column, literal),
+                format!("DELETE FROM {} WHERE {} = {}", table, column, literal),
+                format!("DROP TABLE {}", table),
+            ];
+            prop::sample::select(shapes).prop_map(move |shape| format!("{}{}", shape, terminator))
+        },
+    )
+}
+
 proptest! {
     #![proptest_config(ProptestConfig::with_cases(1024))]
 
@@ -150,6 +177,42 @@ proptest! {
 
     /// The tokenizer must terminate and must not invent trailing tokens for
     /// input that is only whitespace.
+    /// The success half of the contract: well-formed SQL must parse, and must
+    /// produce exactly one statement. Without this, "the parser never panics"
+    /// would also hold for a parser that rejected every input.
+    #[test]
+    fn valid_statements_parse_into_exactly_one_statement(sql in valid_statement()) {
+        let parsed = try_parse(&sql);
+        prop_assert!(
+            parsed.is_ok(),
+            "valid SQL should parse: {:?} -> {:?}",
+            sql,
+            parsed.as_ref().err()
+        );
+        prop_assert_eq!(
+            parsed.unwrap().len(),
+            1,
+            "valid SQL should yield one statement: {:?}",
+            sql
+        );
+    }
+
+    /// The failure half: input that cannot be a statement must come back as an
+    /// error, not as a silently empty parse. A statement keyword with nothing
+    /// after it is unambiguously incomplete.
+    #[test]
+    fn a_bare_statement_keyword_is_an_error(
+        keyword in prop::sample::select(vec!["SELECT", "INSERT", "UPDATE", "DELETE", "DROP"])
+    ) {
+        let parsed = try_parse(keyword);
+        prop_assert!(
+            parsed.is_err(),
+            "{:?} alone is incomplete and must be rejected, got {:?}",
+            keyword,
+            parsed.ok()
+        );
+    }
+
     #[test]
     fn whitespace_only_input_yields_no_statements(
         spaces in proptest::string::string_regex(r"[ \t\r\n]{0,40}").expect("valid regex")