terraphim_middleware 1.16.33

Terraphim middleware for searching haystacks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use serial_test::serial;
use terraphim_config::{ConfigBuilder, Haystack, Role, ServiceType};
use terraphim_middleware::{indexer::IndexMiddleware, RipgrepIndexer};
use terraphim_types::{RelevanceFunction, RoleName};

fn create_test_role() -> Role {
    let mut role = Role::new("Test");
    role.shortname = Some("Test".to_string());
    role.relevance_function = RelevanceFunction::TitleScorer;
    role.theme = "default".to_string();
    role.haystacks = vec![Haystack {
        location: "test_data".to_string(),
        service: ServiceType::Ripgrep,
        read_only: true,
        fetch_content: false,
        atomic_server_secret: None,
        extra_parameters: std::collections::HashMap::new(),
    }];
    role
}

fn create_test_config() -> terraphim_config::Config {
    ConfigBuilder::new()
        .global_shortcut("Ctrl+T")
        .add_role("Test", create_test_role())
        .build()
        .unwrap()
}

#[tokio::test]
#[serial]
async fn test_indexer() {
    let _config = create_test_config();
    let haystack = Haystack {
        location: "fixtures/haystack".to_string(),
        service: ServiceType::Ripgrep,
        read_only: true,
        fetch_content: false,
        atomic_server_secret: None,
        extra_parameters: std::collections::HashMap::new(),
    };
    let indexer = RipgrepIndexer::default();
    let _index = indexer.index("test", &haystack).await.unwrap();
}

#[tokio::test]
#[serial]
async fn test_search_graph() {
    let _config = create_test_config();
    let haystack = Haystack {
        location: "fixtures/haystack".to_string(),
        service: ServiceType::Ripgrep,
        read_only: true,
        fetch_content: false,
        atomic_server_secret: None,
        extra_parameters: std::collections::HashMap::new(),
    };
    let indexer = RipgrepIndexer::default();
    let _index = indexer.index("graph", &haystack).await.unwrap();
}

#[tokio::test]
#[serial]
async fn test_search_machine_learning() {
    let _config = create_test_config();
    let haystack = Haystack {
        location: "fixtures/haystack".to_string(),
        service: ServiceType::Ripgrep,
        read_only: true,
        fetch_content: false,
        atomic_server_secret: None,
        extra_parameters: std::collections::HashMap::new(),
    };

    let indexer = RipgrepIndexer::default();
    let index = indexer.index("graph", &haystack).await.unwrap();
    println!("Indexed documents: {:#?}", index);
}

#[tokio::test]
#[serial]
async fn test_role_configuration() {
    let config = create_test_config();

    // Test that roles are configured correctly
    assert!(config.roles.contains_key(&RoleName::new("Test")));

    // Test haystack configuration
    let test_role = config.roles.get(&RoleName::new("Test")).unwrap();
    assert_eq!(test_role.haystacks.len(), 1);
    assert_eq!(test_role.haystacks[0].service, ServiceType::Ripgrep);
    assert_eq!(test_role.haystacks[0].atomic_server_secret, None);
}

#[cfg(test)]
mod nested_tests {
    use super::*;
    use terraphim_middleware::Result;

    #[tokio::test]
    async fn test_nested_search() -> Result<()> {
        let config = create_test_config();
        let _role = config.roles.get(&RoleName::new("Test")).unwrap();

        // Test basic role existence
        assert!(!config.roles.is_empty());

        Ok(())
    }
}