test: improve test coverage from 55% to 60%

Add 35 new tests focusing on critical logic:

- inlay_hints.rs: version normalization, hint creation for Cargo/npm/PyPI,
  PyPI version comparison edge cases, PEP 440 extraction
- completion.rs: context detection for versions, package names, features,
  edge cases with whitespace, multiline, table syntax
- code_actions.rs: range overlap logic (same, adjacent, contained, multiline)
- parser.rs (PyPI): comments, platform markers, git URLs, complex version
  specifiers, Poetry path deps, PEP 735 includes, empty sections

Coverage improvements:
- completion.rs: 29% → 54%
- code_actions.rs: 8% → 29%
- inlay_hints.rs: 27% → 48%
- parser.rs (PyPI): 78% → 83%

Author: bug-ops

crates/deps-lsp/src/handlers/code_actions.rs

@@ -359,4 +359,60 @@ mod tests {
         let range3 = Range::new(Position::new(1, 0), Position::new(1, 4));
         assert!(!ranges_overlap(range1, range3));
     }
+
+    #[test]
+    fn test_ranges_overlap_same_range() {
+        let range = Range::new(Position::new(1, 5), Position::new(1, 10));
+        assert!(ranges_overlap(range, range));
+    }
+
+    #[test]
+    fn test_ranges_overlap_adjacent() {
+        let range1 = Range::new(Position::new(1, 5), Position::new(1, 10));
+        let range2 = Range::new(Position::new(1, 10), Position::new(1, 15));
+        assert!(ranges_overlap(range1, range2));
+    }
+
+    #[test]
+    fn test_ranges_overlap_different_lines() {
+        let range1 = Range::new(Position::new(1, 5), Position::new(1, 10));
+        let range2 = Range::new(Position::new(2, 0), Position::new(2, 5));
+        assert!(!ranges_overlap(range1, range2));
+    }
+
+    #[test]
+    fn test_ranges_overlap_multiline() {
+        let range1 = Range::new(Position::new(1, 5), Position::new(3, 10));
+        let range2 = Range::new(Position::new(2, 0), Position::new(4, 5));
+        assert!(ranges_overlap(range1, range2));
+    }
+
+    #[test]
+    fn test_ranges_overlap_contained() {
+        let outer = Range::new(Position::new(1, 0), Position::new(1, 20));
+        let inner = Range::new(Position::new(1, 5), Position::new(1, 10));
+        assert!(ranges_overlap(outer, inner));
+        assert!(ranges_overlap(inner, outer));
+    }
+
+    #[test]
+    fn test_ranges_overlap_edge_case_same_position() {
+        let range1 = Range::new(Position::new(1, 5), Position::new(1, 10));
+        let range2 = Range::new(Position::new(1, 5), Position::new(1, 5));
+        assert!(ranges_overlap(range1, range2));
+    }
+
+    #[test]
+    fn test_ranges_overlap_before() {
+        let range1 = Range::new(Position::new(2, 0), Position::new(2, 10));
+        let range2 = Range::new(Position::new(1, 0), Position::new(1, 10));
+        assert!(!ranges_overlap(range1, range2));
+    }
+
+    #[test]
+    fn test_ranges_overlap_after() {
+        let range1 = Range::new(Position::new(1, 0), Position::new(1, 10));
+        let range2 = Range::new(Position::new(2, 0), Position::new(2, 10));
+        assert!(!ranges_overlap(range1, range2));
+    }
 }

crates/deps-lsp/src/handlers/completion.rs

@@ -174,4 +174,79 @@ mod tests {
             Some(CompletionContext::PackageName { .. })
         ));
     }
+
+    #[test]
+    fn test_determine_completion_context_feature() {
+        let content = r#"serde = { version = "1.0", features = [""#;
+        let position = Position::new(0, 40);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(context, Some(CompletionContext::Feature { .. })));
+    }
+
+    #[test]
+    fn test_determine_completion_context_no_match() {
+        let content = r#"# comment"#;
+        let position = Position::new(0, 5);
+        let context = determine_completion_context(content, position);
+        assert!(context.is_none());
+    }
+
+    #[test]
+    fn test_determine_completion_context_version_with_spaces() {
+        let content = r#"  serde  =  ""#;
+        let position = Position::new(0, 13);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(context, Some(CompletionContext::Version { .. })));
+    }
+
+    #[test]
+    fn test_determine_completion_context_short_prefix() {
+        let content = "s";
+        let position = Position::new(0, 1);
+        let context = determine_completion_context(content, position);
+        if let Some(CompletionContext::PackageName { prefix }) = context {
+            assert_eq!(prefix, "s");
+        } else {
+            panic!("Expected PackageName context");
+        }
+    }
+
+    #[test]
+    fn test_determine_completion_context_hyphenated_name() {
+        let content = "tokio-util";
+        let position = Position::new(0, 10);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(
+            context,
+            Some(CompletionContext::PackageName { .. })
+        ));
+    }
+
+    #[test]
+    fn test_determine_completion_context_underscored_name() {
+        let content = "tower_lsp";
+        let position = Position::new(0, 9);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(
+            context,
+            Some(CompletionContext::PackageName { .. })
+        ));
+    }
+
+    #[test]
+    fn test_determine_completion_context_multiline_version() {
+        let content = "[dependencies]\nserde = \"";
+        let position = Position::new(1, 9);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(context, Some(CompletionContext::Version { .. })));
+    }
+
+    #[test]
+    fn test_determine_completion_context_table_syntax() {
+        let content = r#"[dependencies.serde]
+version = ""#;
+        let position = Position::new(1, 11);
+        let context = determine_completion_context(content, position);
+        assert!(matches!(context, Some(CompletionContext::Version { .. })));
+    }
 }

crates/deps-lsp/src/handlers/inlay_hints.rs

@@ -740,4 +740,134 @@ mod tests {
         );
         assert_eq!(extract_pypi_min_version("^1.0"), Some("1.0".to_string())); // Poetry style
     }
+
+    #[test]
+    fn test_normalize_and_parse_version() {
+        assert_eq!(
+            normalize_and_parse_version("1.0.0").unwrap().to_string(),
+            "1.0.0"
+        );
+        assert_eq!(
+            normalize_and_parse_version("1.0").unwrap().to_string(),
+            "1.0.0"
+        );
+        assert_eq!(
+            normalize_and_parse_version("8").unwrap().to_string(),
+            "8.0.0"
+        );
+        assert!(normalize_and_parse_version("invalid").is_none());
+    }
+
+    #[test]
+    fn test_create_cargo_hint_up_to_date() {
+        let config = InlayHintsConfig::default();
+        let range = tower_lsp::lsp_types::Range {
+            start: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 10,
+            },
+            end: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 15,
+            },
+        };
+
+        let hint = create_cargo_hint("serde", "1.0.0", range, "1.0.0", true, &config);
+
+        assert_eq!(hint.position, range.end);
+        assert!(matches!(hint.kind, Some(InlayHintKind::TYPE)));
+        assert_eq!(hint.padding_left, Some(true));
+    }
+
+    #[test]
+    fn test_create_cargo_hint_needs_update() {
+        let config = InlayHintsConfig::default();
+        let range = tower_lsp::lsp_types::Range {
+            start: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 10,
+            },
+            end: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 15,
+            },
+        };
+
+        let hint = create_cargo_hint("serde", "1.0.0", range, "1.0.214", false, &config);
+
+        assert_eq!(hint.position, range.end);
+        if let InlayHintLabel::LabelParts(parts) = hint.label {
+            assert!(parts[0].value.contains("1.0.214"));
+        } else {
+            panic!("Expected LabelParts");
+        }
+    }
+
+    #[test]
+    fn test_create_npm_hint_up_to_date() {
+        let config = InlayHintsConfig::default();
+        let range = tower_lsp::lsp_types::Range {
+            start: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 10,
+            },
+            end: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 15,
+            },
+        };
+
+        let hint = create_npm_hint("express", "^4.18.0", range, "4.18.2", true, &config);
+
+        assert_eq!(hint.position, range.end);
+        assert!(matches!(hint.kind, Some(InlayHintKind::TYPE)));
+    }
+
+    #[test]
+    fn test_create_pypi_hint_needs_update() {
+        let config = InlayHintsConfig::default();
+        let range = tower_lsp::lsp_types::Range {
+            start: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 10,
+            },
+            end: tower_lsp::lsp_types::Position {
+                line: 0,
+                character: 15,
+            },
+        };
+
+        let hint = create_pypi_hint("django", ">=4.0", range, "5.0.0", false, &config);
+
+        assert_eq!(hint.position, range.end);
+        if let InlayHintLabel::LabelParts(parts) = hint.label {
+            assert!(parts[0].value.contains("5.0.0"));
+        } else {
+            panic!("Expected LabelParts");
+        }
+    }
+
+    #[test]
+    fn test_extract_pypi_min_version_edge_cases() {
+        assert_eq!(extract_pypi_min_version(">1.0"), Some("1.0".to_string()));
+        assert_eq!(extract_pypi_min_version("~1.0"), Some("1.0".to_string()));
+        assert_eq!(
+            extract_pypi_min_version(">=1.0, !=1.5"),
+            Some("1.0".to_string())
+        );
+        assert!(extract_pypi_min_version("<2.0").is_none());
+        assert!(extract_pypi_min_version("").is_none());
+    }
+
+    #[test]
+    fn test_is_pypi_version_latest_edge_cases() {
+        assert!(is_pypi_version_latest(">=0.1.0", "0.1.5"));
+        assert!(!is_pypi_version_latest(">=0.1.0", "0.2.0"));
+        assert!(is_pypi_version_latest("==1.0.0", "1.0.0"));
+        // ==1.0.0 means pinned to 1.0.0, but the function checks major version match
+        // So with latest 1.1.0 (same major), it returns true (within major version family)
+        assert!(is_pypi_version_latest("==1.0.0", "1.1.0"));
+        // Different major version should return false
+        assert!(!is_pypi_version_latest("==1.0.0", "2.0.0"));
+    }
 }