test(coverage): cover 21 deterministic uncovered lines for --fail-under 100 gate

The CI coverage job reported 21 deterministic uncovered lines (identical
across runs once RUST_TEST_THREADS=1 stabilised attribution). Add focused
deterministic unit tests (NOT proptest-seed-dependent) driving each branch:
- lsp: locator missing-constraint fallback, network simple types, drift
  models-load-failure path, inlay-hint non-scalar ref_columns, percent-decode
  valid triplet, find_all URI/range sort, classify_yaml non-scalar type walk,
  symbols table emission + YAML quoted-range trim
- planner: check_expr_parser literal-start/keyword/eat_keyword arms,
  check_self_contradiction flatten_and leaf branch, schema PK-presence
- cli/core/query: erd dot relationship label, normalize idempotence (fixed
  fixture), MySQL FK ON DELETE/ON UPDATE 3-backend rstest

cargo test green across all 5 crates; fmt/clippy/line-budget clean.

Author: owjs3901

crates/vespertide-cli/src/commands/erd/dot.rs

@@ -86,3 +86,27 @@ fn escape_record_field(value: &str) -> String {
 
     escaped
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::commands::erd::Cardinality;
+
+    #[test]
+    fn relationship_label_formats_many_to_many_relation_columns() {
+        let relation = ForeignKeyRelation {
+            child_table: "user_tag".to_string(),
+            child_columns: vec!["user_id".to_string(), "tag_id".to_string()],
+            parent_table: "tag".to_string(),
+            parent_columns: vec!["id".to_string(), "tenant_id".to_string()],
+            on_delete: None,
+            on_update: None,
+            cardinality: Cardinality::ManyToMany,
+        };
+
+        assert_eq!(
+            relationship_label(&relation),
+            "M:N: user_id, tag_id -> id, tenant_id"
+        );
+    }
+}

crates/vespertide-core/src/schema/table/normalize_proptest.rs

@@ -3,6 +3,15 @@
 use proptest::prelude::*;
 
 use crate::arbitrary::arb_table_def;
+use crate::schema::primary_key::PrimaryKeySyntax;
+use crate::{ColumnDef, ColumnType, SimpleColumnType, StrOrBoolOrArray, TableDef};
+
+fn normalize_again(table: &TableDef) -> TableDef {
+    table
+        .clone()
+        .normalize()
+        .expect("normalize must not fail on already-normalized output")
+}
 
 proptest! {
     #![proptest_config(ProptestConfig {
@@ -15,12 +24,30 @@ proptest! {
     #[test]
     fn normalize_is_idempotent(table in arb_table_def()) {
         if let Ok(once) = table.normalize() {
-            let twice = once
-                .clone()
-                .normalize()
-                .expect("normalize must not fail on already-normalized output");
+            let twice = normalize_again(&once);
             prop_assert_eq!(once, twice);
         }
         // If normalize fails (e.g. duplicate index name), the property is vacuously true.
     }
 }
+
+#[test]
+fn normalize_is_idempotent_for_fixed_inline_constraints() {
+    let table = TableDef {
+        name: "account".into(),
+        description: None,
+        columns: vec![
+            ColumnDef::new("id", ColumnType::Simple(SimpleColumnType::Integer), false)
+                .primary_key(PrimaryKeySyntax::Bool(true)),
+            ColumnDef::new("email", ColumnType::Simple(SimpleColumnType::Text), false)
+                .unique(StrOrBoolOrArray::Bool(true))
+                .index(StrOrBoolOrArray::Bool(true)),
+        ],
+        constraints: Vec::new(),
+    };
+
+    let once = table.normalize().expect("fixed table should normalize");
+    let twice = normalize_again(&once);
+
+    assert_eq!(once, twice);
+}

crates/vespertide-lsp/src/diagnostics/locator.rs

@@ -468,6 +468,16 @@ mod tests {
         assert!(src[range].contains("user"));
     }
 
+    #[test]
+    fn locate_constraint_fallback_to_top_name_when_constraint_missing() {
+        let pool = ParserPool::new();
+        let src = r#"{"name":"user","constraints":[]}"#;
+        let tree = pool.parse(src, DocumentFormat::Json).unwrap();
+        let range = locate_constraint(Some(&tree), src, "missing_constraint");
+
+        assert!(src[range].contains("user"));
+    }
+
     #[test]
     fn locate_column_field_nullable_finds_target() {
         let pool = ParserPool::new();

crates/vespertide-lsp/src/diagnostics/validation/types.rs

@@ -237,6 +237,13 @@ mod tests {
         }
     }
 
+    #[test]
+    fn known_simple_types_include_network_scalars() {
+        assert!(KNOWN_SIMPLE_TYPES.contains(&"inet"));
+        assert!(KNOWN_SIMPLE_TYPES.contains(&"cidr"));
+        assert!(KNOWN_SIMPLE_TYPES.contains(&"macaddr"));
+    }
+
     #[test]
     fn enum_descriptor_skips_objects_missing_name_or_value_fields() {
         let src = r#"{"values":[{"value":1},{"name":"low"},{"name":"high","value":2}]}"#;

crates/vespertide-lsp/src/drift/compute.rs

@@ -261,6 +261,22 @@ mod tests {
         assert!(out.is_empty());
     }
 
+    #[test]
+    fn compute_returns_empty_when_models_directory_load_fails() {
+        let tmp = tempdir().unwrap();
+        fs::create_dir_all(tmp.path().join("migrations")).unwrap();
+        fs::write(tmp.path().join("vespertide.json"), r#"{"modelsDir":"models","migrationsDir":"migrations","tableNamingCase":"snake","columnNamingCase":"snake","modelFormat":"json"}"#).unwrap();
+
+        let out = compute_with_cache(
+            tmp.path(),
+            &WorkspaceIndex::new(),
+            &DocumentStore::new(),
+            &DriftCache::new(),
+        );
+
+        assert!(out.is_empty());
+    }
+
     #[test]
     fn compute_returns_empty_when_diff_validation_fails() {
         let tmp = tempdir().unwrap();

crates/vespertide-lsp/src/inlay_hints.rs

@@ -621,6 +621,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn yaml_block_sequence_ref_columns_skips_non_scalar_items() {
+        let src = "name: post\ncolumns:\n  - name: author_id\n    type: integer\n    foreign_key:\n      ref_table: user\n      ref_columns:\n        - name: id\n";
+        let tree = parse_yaml(src);
+        let hints = compute(src, Some(&tree), 0..src.len());
+
+        assert!(
+            hints.is_empty(),
+            "mapping-valued ref_columns item must not produce FK hint: {hints:?}"
+        );
+    }
+
     #[test]
     fn columns_value_that_is_not_sequence_yields_no_hints() {
         let src = r#"{"name":"u","columns":"not an array"}"#;

crates/vespertide-lsp/src/position.rs

@@ -261,6 +261,11 @@ mod tests {
         );
     }
 
+    #[test]
+    fn percent_decode_consumes_valid_triplets_and_continues_after_them() {
+        assert_eq!(percent_decode("/tmp/%41%2fname.json"), "/tmp/A/name.json");
+    }
+
     #[rstest]
     #[case::unencoded("file:///plain/path/file.json", &["plain", "file.json"])]
     #[case::lowercase_hex_drive("file:///c%3a/Users/test", &["Users"])]

crates/vespertide-lsp/src/references/search.rs

@@ -580,6 +580,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn find_all_sorts_references_by_uri_then_byte_range() {
+        let docs = DocumentStore::new();
+        let current_uri = uri("z_post.json");
+        let other_uri = uri("a_post.json");
+        let src = r#"{"name":"post","columns":[{"name":"user_id","type":"integer","foreign_key":{"ref_table":"user","ref_columns":["id"]}}]}"#;
+        let current_tree = parse_json(src);
+        docs.open(other_uri.clone(), "json".to_string(), 1, src.to_string());
+
+        let refs = find_all(
+            &ReferenceSymbol::Table {
+                name: "user".to_string(),
+            },
+            &current_uri,
+            src,
+            Some(&current_tree),
+            &WorkspaceIndex::new(),
+            &docs,
+            None,
+            false,
+        );
+
+        assert_eq!(refs.len(), 2);
+        assert_eq!(refs[0].uri, other_uri);
+        assert_eq!(refs[1].uri, current_uri);
+    }
+
     #[test]
     fn helper_false_paths_handle_missing_siblings_and_non_mapping_nodes() {
         let src = r#"{"name":"user","columns":[{"name":"id","type":"integer","foreign_key":{"ref_columns":["id"]}}],"constraints":[{"name":"c","expr":"id > 0"}]}"#;

crates/vespertide-lsp/src/semantic_tokens/classify_yaml.rs

@@ -644,6 +644,49 @@ mod tests {
         let _ = classify_yaml(malformed);
     }
 
+    #[test]
+    fn classify_type_value_walks_non_scalar_non_mapping_values() {
+        let pool = ParserPool::new();
+        let src = "name: u\ncolumns:\n  - name: x\n    type:\n      - integer\n";
+        let tree = pool.parse(src, DocumentFormat::Yaml).unwrap();
+        let type_pair = first_node(tree.root_node(), "block_mapping_pair")
+            .and_then(|_| find_type_pair(tree.root_node(), src.as_bytes()))
+            .expect("type pair");
+        let value = type_pair.named_child(1).expect("type value");
+        let mut out = Vec::new();
+
+        classify_type_value(value, src.as_bytes(), Ctx::default(), &mut out);
+
+        assert!(
+            out.is_empty(),
+            "sequence-valued type should be walked without type tokens: {out:?}"
+        );
+    }
+
+    fn find_type_pair<'tree>(
+        node: tree_sitter::Node<'tree>,
+        source: &[u8],
+    ) -> Option<tree_sitter::Node<'tree>> {
+        if matches!(node.kind(), "block_mapping_pair" | "flow_pair")
+            && node
+                .named_child(0)
+                .and_then(|key| source.get(key.byte_range()))
+                .and_then(|bytes| std::str::from_utf8(bytes).ok())
+                .map(|text| text.trim().trim_matches('"').trim_matches('\''))
+                == Some("type")
+        {
+            return Some(node);
+        }
+
+        let mut cursor = node.walk();
+        for child in node.children(&mut cursor) {
+            if let Some(found) = find_type_pair(child, source) {
+                return Some(found);
+            }
+        }
+        None
+    }
+
     #[test]
     fn check_expr_emitter_returns_for_non_scalar_empty_and_bad_sources() {
         let pool = ParserPool::new();

crates/vespertide-lsp/src/symbols.rs

@@ -448,6 +448,19 @@ mod tests {
         assert_eq!(email.container.as_deref(), Some("user"));
     }
 
+    #[test]
+    fn extract_raw_symbols_emits_table_symbol_with_identifier_range() {
+        let pool = ParserPool::new();
+        let src = r#"{"name":"user","columns":[]}"#;
+        let tree = pool.parse(src, DocumentFormat::Json).unwrap();
+        let symbols = extract_raw_symbols(&tree, src);
+
+        assert_eq!(symbols.len(), 1);
+        assert_eq!(symbols[0].name, "user");
+        assert_eq!(symbols[0].kind, SymbolKind::Table);
+        assert_eq!(&src[symbols[0].byte_range.clone()], "user");
+    }
+
     #[test]
     fn query_filters_case_insensitively() {
         let docs = DocumentStore::new();
@@ -843,6 +856,26 @@ mod tests {
         assert_eq!(symbols.len(), 1);
     }
 
+    #[test]
+    fn extract_raw_symbols_trims_yaml_quoted_identifier_ranges() {
+        let pool = ParserPool::new();
+        let src = "name: \"user\"\ncolumns:\n  - name: 'id'\n    type: integer\n";
+        let tree = pool.parse(src, DocumentFormat::Yaml).unwrap();
+        let symbols = extract_raw_symbols(&tree, src);
+
+        let table = symbols
+            .iter()
+            .find(|symbol| symbol.kind == SymbolKind::Table)
+            .expect("table symbol");
+        let column = symbols
+            .iter()
+            .find(|symbol| symbol.kind == SymbolKind::Column)
+            .expect("column symbol");
+
+        assert_eq!(&src[table.byte_range.clone()], "user");
+        assert_eq!(&src[column.byte_range.clone()], "id");
+    }
+
     #[test]
     fn unwrap_yaml_and_trim_one_byte_defensive_branches() {
         let pool = ParserPool::new();