gdelt 0.1.0

CLI for GDELT Project - optimized for agentic usage with local data caching
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Database integration tests

use gdelt::db::duckdb::{AnalyticsDb, EventFilters};
use gdelt::db::cache::CacheDb;

#[test]
fn test_analytics_db_open_memory() {
    let db = AnalyticsDb::open_memory();
    assert!(db.is_ok(), "Failed to open in-memory analytics database");
}

#[test]
fn test_cache_db_open_memory() {
    let db = CacheDb::open_memory();
    assert!(db.is_ok(), "Failed to open in-memory cache database");
}

#[test]
fn test_db_stats_empty() {
    let db = AnalyticsDb::open_memory().unwrap();
    let stats = db.stats();
    assert!(stats.is_ok(), "Failed to get stats");

    let stats = stats.unwrap();
    assert_eq!(stats.events_count, 0);
    assert_eq!(stats.gkg_count, 0);
    assert_eq!(stats.mentions_count, 0);
}

#[test]
fn test_query_empty_events() {
    let db = AnalyticsDb::open_memory().unwrap();
    let filters = EventFilters::default();
    let events = db.query_events(filters);
    assert!(events.is_ok(), "Failed to query events");
    assert_eq!(events.unwrap().len(), 0);
}

#[test]
fn test_query_with_filters() {
    let db = AnalyticsDb::open_memory().unwrap();
    let filters = EventFilters {
        actor: Some("USA".to_string()),
        country: Some("US".to_string()),
        limit: 10,
        offset: 0,
        ..Default::default()
    };
    let events = db.query_events(filters);
    assert!(events.is_ok(), "Failed to query events with filters");
}

#[test]
fn test_raw_query() {
    let db = AnalyticsDb::open_memory().unwrap();
    let result = db.query("SELECT COUNT(*) as cnt FROM events");
    assert!(result.is_ok(), "Failed to run raw query");

    let result = result.unwrap();
    // Verify we got results
    assert!(!result.columns.is_empty(), "Should have columns");
}

#[test]
fn test_lookup_nonexistent_event() {
    let db = AnalyticsDb::open_memory().unwrap();
    let event = db.lookup_event(999999999);
    assert!(event.is_ok());
    assert!(event.unwrap().is_none(), "Should not find nonexistent event");
}

#[test]
fn test_cache_db_get_set_setting() {
    let db = CacheDb::open_memory().unwrap();

    // Set a setting
    let result = db.set_setting("test_key", "test_value");
    assert!(result.is_ok(), "Failed to set setting");

    // Get the setting
    let value = db.get_setting("test_key");
    assert!(value.is_ok());
    assert_eq!(value.unwrap(), Some("test_value".to_string()));
}

#[test]
fn test_cache_db_get_nonexistent_setting() {
    let db = CacheDb::open_memory().unwrap();
    let value = db.get_setting("nonexistent_key");
    assert!(value.is_ok());
    assert!(value.unwrap().is_none());
}

#[test]
fn test_cache_db_api_cache() {
    let db = CacheDb::open_memory().unwrap();

    // Put a cached response
    let result = db.put_cached(
        "https://example.com/api",
        r#"{"result": "test"}"#,
        Some("application/json"),
        3600,
    );
    assert!(result.is_ok(), "Failed to cache response");

    // Get the cached response
    let cached = db.get_cached("https://example.com/api");
    assert!(cached.is_ok());
    let cached = cached.unwrap();
    assert!(cached.is_some(), "Should find cached response");
    assert_eq!(cached.unwrap().body, r#"{"result": "test"}"#);
}

#[test]
fn test_cache_db_prune_expired() {
    let db = CacheDb::open_memory().unwrap();
    let pruned = db.prune_expired();
    assert!(pruned.is_ok(), "Failed to prune expired entries");
}

#[test]
fn test_cache_db_clear() {
    let db = CacheDb::open_memory().unwrap();

    // Add some data
    let _ = db.set_setting("key", "value");
    let _ = db.put_cached("https://test.com", "{}", None, 3600);

    // Clear the cache
    let result = db.clear();
    assert!(result.is_ok(), "Failed to clear cache");

    // Verify it's cleared
    let stats = db.stats().unwrap();
    assert_eq!(stats.api_cache_entries, 0);
}

#[test]
fn test_cache_db_stats() {
    let db = CacheDb::open_memory().unwrap();
    let stats = db.stats();
    assert!(stats.is_ok(), "Failed to get cache stats");
}