opencrabs 0.3.57

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Install with: cargo install opencrabs
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

use crate::db::models::Session;
use crate::db::models::*;
use chrono::Utc;
use uuid::Uuid;

#[test]
fn test_session_new() {
    let session = Session::new(
        Some("Test Session".to_string()),
        Some("claude-sonnet-4-5".to_string()),
        Some("anthropic".to_string()),
    );

    assert_eq!(session.title, Some("Test Session".to_string()));
    assert_eq!(session.model, Some("claude-sonnet-4-5".to_string()));
    assert_eq!(session.token_count, 0);
    assert!(!session.is_archived());
}

#[test]
fn test_message_new() {
    let session_id = Uuid::new_v4();
    let message = Message::new(session_id, "user".to_string(), "Hello!".to_string(), 1);

    assert_eq!(message.session_id, session_id);
    assert_eq!(message.role, "user");
    assert_eq!(message.content, "Hello!");
    assert_eq!(message.sequence, 1);
    assert!(message.token_count.is_none());
}

#[test]
fn test_file_new() {
    let session_id = Uuid::new_v4();
    let path = std::path::PathBuf::from("/path/to/file.rs");
    let file = File::new(session_id, path.clone(), None);

    assert_eq!(file.session_id, session_id);
    assert_eq!(file.path, path);
    assert!(file.content.is_none());
}

#[test]
fn test_feedback_entry_from_row_fields() {
    // Covered by integration tests in feedback_ledger_test.rs;
    // this verifies struct construction.
    let entry = FeedbackEntry {
        id: 1,
        session_id: "abc".to_string(),
        event_type: "tool_success".to_string(),
        dimension: "bash".to_string(),
        value: 1.0,
        metadata: None,
        created_at: Utc::now(),
    };
    assert_eq!(entry.event_type, "tool_success");
    assert_eq!(entry.dimension, "bash");
    assert!((entry.value - 1.0).abs() < f64::EPSILON);
}

#[test]
fn test_session_archived() {
    let mut session = Session::new(Some("Test".to_string()), Some("model".to_string()), None);

    assert!(!session.is_archived());

    session.archived_at = Some(Utc::now());
    assert!(session.is_archived());
}