refactor: move Rust tests to separate test files

Move all unit tests from inline #[cfg(test)] modules to separate files
in the rust/tests/ directory, keeping source files clean and focused.

Tests moved:
- link.rs tests -> tests/link_tests.rs
- lino_link.rs tests -> tests/lino_link_tests.rs
- parser.rs tests -> tests/parser_tests.rs
- changes_simplifier.rs tests -> tests/changes_simplifier_tests.rs
- link_storage.rs tests -> tests/link_storage_tests.rs
- query_processor.rs tests -> tests/query_processor_tests.rs

All 36 tests pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: konard

rust/src/changes_simplifier.rs

@@ -105,49 +105,3 @@ pub fn simplify_changes(changes: Vec<(Link, Link)>) -> Vec<(Link, Link)> {
 
     results
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_simplify_empty() {
-        let changes: Vec<(Link, Link)> = vec![];
-        let result = simplify_changes(changes);
-        assert!(result.is_empty());
-    }
-
-    #[test]
-    fn test_simplify_no_op() {
-        let link = Link::new(1, 2, 3);
-        let changes = vec![(link, link)];
-        let result = simplify_changes(changes);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0], (link, link));
-    }
-
-    #[test]
-    fn test_simplify_chain() {
-        let link1 = Link::new(1, 1, 1);
-        let link2 = Link::new(1, 2, 2);
-        let link3 = Link::new(1, 3, 3);
-
-        let changes = vec![(link1, link2), (link2, link3)];
-        let result = simplify_changes(changes);
-
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0], (link1, link3));
-    }
-
-    #[test]
-    fn test_simplify_with_unchanged() {
-        let unchanged = Link::new(2, 2, 2);
-        let link1 = Link::new(1, 1, 1);
-        let link2 = Link::new(1, 2, 2);
-
-        let changes = vec![(unchanged, unchanged), (link1, link2)];
-        let result = simplify_changes(changes);
-
-        assert_eq!(result.len(), 2);
-    }
-}

rust/src/link.rs

@@ -36,40 +36,3 @@ impl Link {
         format!("({} {} {})", self.index, self.source, self.target)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_link_creation() {
-        let link = Link::new(1, 2, 3);
-        assert_eq!(link.index, 1);
-        assert_eq!(link.source, 2);
-        assert_eq!(link.target, 3);
-    }
-
-    #[test]
-    fn test_link_is_null() {
-        let null_link = Link::default();
-        assert!(null_link.is_null());
-
-        let non_null_link = Link::new(1, 2, 3);
-        assert!(!non_null_link.is_null());
-    }
-
-    #[test]
-    fn test_link_is_full_point() {
-        let point = Link::new(1, 1, 1);
-        assert!(point.is_full_point());
-
-        let non_point = Link::new(1, 2, 3);
-        assert!(!non_point.is_full_point());
-    }
-
-    #[test]
-    fn test_link_format() {
-        let link = Link::new(1, 2, 3);
-        assert_eq!(link.format(), "(1 2 3)");
-    }
-}

rust/src/link_storage.rs

@@ -408,123 +408,3 @@ impl LinkStorage {
         self.trace
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tempfile::NamedTempFile;
-
-    #[test]
-    fn test_storage_create() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-        let id = storage.create(2, 3);
-
-        assert!(id > 0);
-        let link = storage.get(id).unwrap();
-        assert_eq!(link.source, 2);
-        assert_eq!(link.target, 3);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_update() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-        let id = storage.create(2, 3);
-        storage.update(id, 4, 5)?;
-
-        let link = storage.get(id).unwrap();
-        assert_eq!(link.source, 4);
-        assert_eq!(link.target, 5);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_delete() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-        let id = storage.create(2, 3);
-        storage.delete(id)?;
-
-        assert!(storage.get(id).is_none());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_persistence() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        // Create and save
-        {
-            let mut storage = LinkStorage::new(db_path, false)?;
-            storage.create(2, 3);
-            storage.save()?;
-        }
-
-        // Load and verify
-        {
-            let storage = LinkStorage::new(db_path, false)?;
-            let links = storage.all();
-            assert_eq!(links.len(), 1);
-            assert_eq!(links[0].source, 2);
-            assert_eq!(links[0].target, 3);
-        }
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_named_links() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-        let id = storage.get_or_create_named("test");
-
-        assert!(id > 0);
-        assert_eq!(storage.get_name(id), Some(&"test".to_string()));
-        assert_eq!(storage.get_by_name("test"), Some(id));
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_search() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-        let id = storage.create(2, 3);
-
-        assert_eq!(storage.search(2, 3), Some(id));
-        assert_eq!(storage.search(1, 1), None);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_get_or_create() -> Result<()> {
-        let temp_file = NamedTempFile::new()?;
-        let db_path = temp_file.path().to_str().unwrap();
-
-        let mut storage = LinkStorage::new(db_path, false)?;
-
-        let id1 = storage.get_or_create(2, 3);
-        let id2 = storage.get_or_create(2, 3);
-
-        assert_eq!(id1, id2);
-
-        Ok(())
-    }
-}

rust/src/lino_link.rs

@@ -57,51 +57,3 @@ impl LinoLink {
         self.id.as_ref().is_some_and(|id| id.parse::<u32>().is_ok())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_lino_link_new() {
-        let link = LinoLink::new(Some("test".to_string()));
-        assert_eq!(link.id, Some("test".to_string()));
-        assert!(link.values.is_none());
-    }
-
-    #[test]
-    fn test_lino_link_with_values() {
-        let child1 = LinoLink::new(Some("1".to_string()));
-        let child2 = LinoLink::new(Some("2".to_string()));
-        let link = LinoLink::with_values(Some("parent".to_string()), vec![child1, child2]);
-        assert_eq!(link.id, Some("parent".to_string()));
-        assert_eq!(link.values_count(), 2);
-    }
-
-    #[test]
-    fn test_lino_link_is_variable() {
-        let var = LinoLink::new(Some("$var".to_string()));
-        assert!(var.is_variable());
-
-        let non_var = LinoLink::new(Some("test".to_string()));
-        assert!(!non_var.is_variable());
-    }
-
-    #[test]
-    fn test_lino_link_is_wildcard() {
-        let wildcard = LinoLink::new(Some("*".to_string()));
-        assert!(wildcard.is_wildcard());
-
-        let non_wildcard = LinoLink::new(Some("test".to_string()));
-        assert!(!non_wildcard.is_wildcard());
-    }
-
-    #[test]
-    fn test_lino_link_is_numeric() {
-        let numeric = LinoLink::new(Some("123".to_string()));
-        assert!(numeric.is_numeric());
-
-        let non_numeric = LinoLink::new(Some("test".to_string()));
-        assert!(!non_numeric.is_numeric());
-    }
-}

rust/src/parser.rs

@@ -168,65 +168,3 @@ impl Default for Parser {
         Self::new()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_empty() {
-        let parser = Parser::new();
-        let result = parser.parse("").unwrap();
-        assert!(result.is_empty());
-    }
-
-    #[test]
-    fn test_parse_simple_link() {
-        let parser = Parser::new();
-        let result = parser.parse("(1 2)").unwrap();
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].values_count(), 2);
-    }
-
-    #[test]
-    fn test_parse_nested_link() {
-        let parser = Parser::new();
-        let result = parser.parse("((1 2) (3 4))").unwrap();
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].values_count(), 2);
-    }
-
-    #[test]
-    fn test_parse_link_with_id() {
-        let parser = Parser::new();
-        let result = parser.parse("(5: 1 2)").unwrap();
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].id, Some("5".to_string()));
-        assert_eq!(result[0].values_count(), 2);
-    }
-
-    #[test]
-    fn test_parse_variable() {
-        let parser = Parser::new();
-        let result = parser.parse("($var 1 2)").unwrap();
-        assert_eq!(result.len(), 1);
-        assert!(result[0].values.as_ref().unwrap()[0].is_variable());
-    }
-
-    #[test]
-    fn test_parse_wildcard() {
-        let parser = Parser::new();
-        let result = parser.parse("(* 1)").unwrap();
-        assert_eq!(result.len(), 1);
-        assert!(result[0].values.as_ref().unwrap()[0].is_wildcard());
-    }
-
-    #[test]
-    fn test_parse_query_format() {
-        let parser = Parser::new();
-        // Query format: (( restriction ) ( substitution ))
-        let result = parser.parse("(((1 2)) ((3 4)))").unwrap();
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].values_count(), 2);
-    }
-}