dialog_final_v2_lib 0.1.0

Dialog library — Nostr-based encrypted notes-to-self (core Rust SDK)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

mod common;
use common::TestServer;

#[tokio::test]
async fn test_dialog_complete() {
    let server = TestServer::new().await;
    let dialog = server.create_dialog().await;

    println!("=== Testing basic note creation and listing ===");

    // Create a simple note
    let text = "Test note #test #example";
    let id = dialog.create_note(text).await.unwrap();

    // Small delay for async database ingestion
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    // Should find it immediately
    let notes = dialog.list_notes(10).await.unwrap();
    assert!(
        notes.iter().any(|n| n.id == id),
        "Should find the note we just created"
    );

    // Verify content and tags
    let note = notes.iter().find(|n| n.id == id).unwrap();
    assert_eq!(note.text, text);
    assert!(note.tags.contains(&"test".to_string()));
    assert!(note.tags.contains(&"example".to_string()));

    println!("=== Testing encryption/decryption ===");

    // Test with unicode and special characters
    let secret_text = "Secret message with unicode and special chars!";
    let secret_id = dialog.create_note(secret_text).await.unwrap();
    println!("Created secret note with id: {secret_id}");

    // Small delay for async database ingestion
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let notes = dialog.list_notes(20).await.unwrap();
    println!("Found {} total notes", notes.len());

    let secret_note = notes
        .iter()
        .find(|n| n.id == secret_id)
        .expect("Should find the secret note we just created");
    assert_eq!(
        secret_note.text, secret_text,
        "Decrypted text should match exactly"
    );

    println!("=== Testing tag filtering ===");

    // Create notes with different tags for filtering
    dialog.create_note("Note A #alpha #beta").await.unwrap();
    dialog.create_note("Note B #alpha #gamma").await.unwrap();
    dialog.create_note("Note C #beta #delta").await.unwrap();
    dialog.create_note("Note D #gamma #delta").await.unwrap();

    // Test various tag filters
    let alpha_notes = dialog.list_by_tag("alpha", 10).await.unwrap();
    assert!(
        alpha_notes.len() >= 2,
        "Should have at least 2 notes with #alpha"
    );

    let delta_notes = dialog.list_by_tag("delta", 10).await.unwrap();
    assert!(
        delta_notes.len() >= 2,
        "Should have at least 2 notes with #delta"
    );

    let beta_notes = dialog.list_by_tag("beta", 10).await.unwrap();
    assert!(
        beta_notes.len() >= 2,
        "Should have at least 2 notes with #beta"
    );

    // Test case insensitivity
    let gamma_upper = dialog.list_by_tag("GAMMA", 10).await.unwrap();
    let gamma_lower = dialog.list_by_tag("gamma", 10).await.unwrap();
    assert_eq!(
        gamma_upper.len(),
        gamma_lower.len(),
        "Tag filtering should be case-insensitive"
    );

    println!("=== Testing batch creation ===");

    // Create multiple notes rapidly
    for i in 0..10 {
        let batch_text = format!("Batch note {i} #batch #stress");
        dialog.create_note(&batch_text).await.unwrap();
    }

    // Small delay for async database ingestion of batch
    tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    // Verify all batch notes exist
    let batch_notes = dialog.list_by_tag("batch", 20).await.unwrap();
    assert!(
        batch_notes.len() >= 10,
        "Should have at least 10 batch notes"
    );

    // Verify they're properly ordered (newest first)
    let all_notes = dialog.list_notes(50).await.unwrap();
    let batch_subset: Vec<_> = all_notes
        .iter()
        .filter(|n| n.tags.contains(&"batch".to_string()))
        .collect();
    assert!(
        batch_subset.len() >= 10,
        "Should find all batch notes in full list"
    );

    println!("=== Testing sync (if available) ===");

    // Test sync doesn't break anything
    match dialog.sync_notes().await {
        Ok(_) => println!("Sync successful"),
        Err(e) => println!("Sync not available: {e} (this is ok)"),
    }

    // Verify data still intact after sync attempt
    let final_notes = dialog.list_notes(100).await.unwrap();
    assert!(final_notes.len() >= 16, "Should have all notes after sync");

    println!("=== All tests passed! ===");
}