refactor(bare): enhance security and performance optimizations

- Remove unnecessary sorting in advertise_refs for deterministic output
- Add path traversal detection and validation in bare_dir construction
- Implement symlink resolution checks to prevent security vulnerabilities
- Refactor cache system with CRC validation and improved metrics
- Integrate repo-specific cache invalidation using indexed keys
- Add comprehensive unit tests for commit operations and diff functionality
- Move configuration constants to centralized config module
- Optimize string operations in disk cache random value generation
- Enhance license detection algorithm with cleaner matching logic
- Streamline argument processing in various git operations
- Update dependencies including crc32fast and flate2 for performance
- Add signal handling capability to tokio runtime configuration

tests/repository_test.rs

@@ -326,3 +326,193 @@ async fn test_exists_nonexistent_repo() {
         .into_inner();
     assert!(!result.exists);
 }
+
+
+#[test]
+fn test_find_merge_base() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let main_oid = common::get_main_oid(&gb);
+    let feature_oid = common::get_feature_oid(&gb);
+    let resp = gb.find_merge_base(FindMergeBaseRequest {
+        repository: Some(header(&gb)),
+        revisions: vec![
+            main_oid.as_bytes().to_vec(),
+            feature_oid.as_bytes().to_vec(),
+        ],
+    }).unwrap();
+    assert!(!resp.base_oid.is_empty());
+}
+
+#[test]
+fn test_find_merge_base_empty() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.find_merge_base(FindMergeBaseRequest {
+        repository: Some(header(&gb)),
+        revisions: vec![],
+    }).unwrap();
+    assert!(resp.base_oid.is_empty());
+}
+
+#[test]
+fn test_find_merge_base_single() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let oid = common::get_main_oid(&gb);
+    let resp = gb.find_merge_base(FindMergeBaseRequest {
+        repository: Some(header(&gb)),
+        revisions: vec![oid.as_bytes().to_vec()],
+    }).unwrap();
+    assert!(!resp.base_oid.is_empty());
+}
+
+#[test]
+fn test_commit_is_ancestor() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let feature_oid = common::get_feature_oid(&gb);
+    let main_oid = common::get_main_oid(&gb);
+    let resp = gb.commit_is_ancestor(CommitIsAncestorRequest {
+        repository: Some(header(&gb)),
+        ancestor_oid: feature_oid,
+        descendant_oid: main_oid,
+    }).unwrap();
+    assert!(resp.is_ancestor);
+}
+
+#[test]
+fn test_commit_is_ancestor_false() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let main_oid = common::get_main_oid(&gb);
+    let feature_oid = common::get_feature_oid(&gb);
+    let resp = gb.commit_is_ancestor(CommitIsAncestorRequest {
+        repository: Some(header(&gb)),
+        ancestor_oid: main_oid,
+        descendant_oid: feature_oid,
+    }).unwrap();
+    assert!(!resp.is_ancestor);
+}
+
+
+#[test]
+fn test_objects_size() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let oid = common::get_main_oid(&gb);
+    let resp = gb.objects_size(ObjectsSizeRequest {
+        repository: Some(header(&gb)),
+        oids: vec![oid.clone(), "0000000000000000000000000000000000000000".into()],
+    }).unwrap();
+    assert_eq!(resp.sizes.len(), 2);
+    assert!(resp.sizes[0].found);
+    assert!(resp.sizes[0].size > 0);
+}
+
+#[test]
+fn test_objects_size_empty() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.objects_size(ObjectsSizeRequest {
+        repository: Some(header(&gb)),
+        oids: vec![],
+    }).unwrap();
+    assert!(resp.sizes.is_empty());
+}
+
+#[test]
+fn test_repository_size() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.repository_size().unwrap();
+    assert!(resp.size_bytes > 0);
+}
+
+
+#[test]
+fn test_find_license_no_license() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.find_license().unwrap();
+    assert!(resp.license_spdx.is_empty());
+}
+
+
+#[test]
+fn test_optimize_repository_heuristic() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.optimize_repository(OptimizeRepositoryRequest {
+        repository: Some(header(&gb)),
+        strategy: OptimizeStrategy::Heuristic as i32,
+    }).unwrap();
+    assert!(resp.ok);
+}
+
+#[test]
+fn test_optimize_repository_incremental() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.optimize_repository(OptimizeRepositoryRequest {
+        repository: Some(header(&gb)),
+        strategy: OptimizeStrategy::Incremental as i32,
+    }).unwrap();
+    assert!(resp.ok);
+}
+
+
+#[test]
+fn test_search_files_by_content() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.search_files_by_content(SearchFilesByContentRequest {
+        repository: Some(header(&gb)),
+        query: "Test".into(),
+        revision: "main".into(),
+        max_results: 10,
+        case_sensitive: true,
+    }).unwrap();
+    assert!(!resp.results.is_empty());
+}
+
+#[test]
+fn test_search_files_by_content_no_match() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.search_files_by_content(SearchFilesByContentRequest {
+        repository: Some(header(&gb)),
+        query: "zzzznonexistentzzzz".into(),
+        revision: "main".into(),
+        max_results: 10,
+        case_sensitive: true,
+    }).unwrap();
+    assert!(resp.results.is_empty());
+}
+
+#[test]
+fn test_search_files_by_content_empty_query() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.search_files_by_content(SearchFilesByContentRequest {
+        repository: Some(header(&gb)),
+        query: String::new(),
+        revision: "main".into(),
+        max_results: 10,
+        case_sensitive: true,
+    });
+    assert!(resp.is_err());
+}
+
+#[test]
+fn test_search_files_by_name() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.search_files_by_name(SearchFilesByNameRequest {
+        repository: Some(header(&gb)),
+        query: "README".into(),
+        revision: "main".into(),
+        max_results: 10,
+        recursive: true,
+    }).unwrap();
+    assert!(!resp.results.is_empty());
+    assert!(resp.results.iter().any(|r| r.path.contains("README")));
+}
+
+#[test]
+fn test_search_files_by_name_no_match() {
+    let (_dir, gb) = common::setup_bare_repo();
+    let resp = gb.search_files_by_name(SearchFilesByNameRequest {
+        repository: Some(header(&gb)),
+        query: "zzzznonexistentzzzz".into(),
+        revision: "main".into(),
+        max_results: 10,
+        recursive: true,
+    }).unwrap();
+    assert!(resp.results.is_empty());
+}