gitks/tests/tree_test.rs

mod common;

use gitks::pb::*;

#[test]
fn test_list_tree_recursive() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .list_tree(ListTreeRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: String::new(),
            recursive: true,
            pagination: None,
        })
        .expect("list_tree recursive");

    let paths: Vec<String> = result.entries.iter().map(|e| e.path.clone()).collect();
    assert!(
        paths.iter().any(|p| p.contains("src/lib/mod.rs")),
        "should include nested files, got: {:?}",
        paths
    );
}

#[test]
fn test_get_tree_subpath() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .get_tree(GetTreeRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: "src".into(),
        })
        .expect("get_tree subpath");

    assert!(result.oid.is_some());
    let root_tree = gb
        .get_tree(GetTreeRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: String::new(),
        })
        .expect("get_tree root");
    assert_ne!(
        result.oid.unwrap().hex,
        root_tree.oid.unwrap().hex,
        "subtree OID should differ from root"
    );
}

#[test]
fn test_find_files() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .find_files(FindFilesRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            pattern: "mod.rs".into(),
            pathspec: vec![],
            pagination: None,
        })
        .expect("find_files");

    assert!(!result.files.is_empty());
    assert!(result.files.iter().all(|f| f.path.contains("mod.rs")));
}

#[test]
fn test_get_blob() {
    let (_dir, gb) = common::setup_bare_repo();
    let blob = gb
        .get_blob(GetBlobRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: "README.md".into(),
            oid: None,
            max_bytes: 0,
        })
        .expect("get_blob");

    let content = String::from_utf8_lossy(&blob.data);
    assert!(content.contains("# Test"));
    assert!(blob.size > 0);
    assert!(!blob.binary);
}

#[test]
fn test_get_blob_with_truncation() {
    let (_dir, gb) = common::setup_bare_repo();
    let blob = gb
        .get_blob(GetBlobRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: "README.md".into(),
            oid: None,
            max_bytes: 5,
        })
        .expect("get_blob truncated");

    assert_eq!(blob.data.len(), 5);
    assert!(blob.truncated);
    assert!(
        blob.size > 5,
        "size should be original size, not truncated size"
    );
}

#[test]
fn test_get_file_metadata() {
    let (_dir, gb) = common::setup_bare_repo();
    let meta = gb
        .get_file_metadata(GetFileMetadataRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: "README.md".into(),
        })
        .expect("get_file_metadata");

    assert_eq!(meta.path, "README.md");
    assert!(meta.oid.is_some());
    assert_eq!(meta.r#type, ObjectType::Blob as i32);
}

#[test]
fn test_list_tree_with_pagination() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .list_tree(ListTreeRequest {
            repository: None,
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            path: String::new(),
            recursive: false,
            pagination: Some(Pagination {
                page_size: 1,
                page_token: String::new(),
            }),
        })
        .expect("list_tree paginated");

    assert_eq!(result.entries.len(), 1);
    let pi = result.page_info.unwrap();
    assert!(pi.has_next_page);
}