elicitation 0.10.0

Conversational elicitation of strongly-typed Rust values via MCP
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
132
133
134
135
136

//! Tests for jiff datetime elicitation.

#![cfg(feature = "jiff")]

use elicitation::{Elicitation, Prompt};
use jiff::{Timestamp, Zoned, civil::DateTime as CivilDateTime};

// Compile-time trait bound checks
#[test]
fn test_timestamp_implements_elicitation() {
    fn assert_elicitation<T: Elicitation>() {}
    assert_elicitation::<Timestamp>();
}

#[test]
fn test_zoned_implements_elicitation() {
    fn assert_elicitation<T: Elicitation>() {}
    assert_elicitation::<Zoned>();
}

#[test]
fn test_civil_datetime_implements_elicitation() {
    fn assert_elicitation<T: Elicitation>() {}
    assert_elicitation::<CivilDateTime>();
}

#[test]
fn test_timestamp_has_prompt() {
    assert!(Timestamp::prompt().is_some());
}

#[test]
fn test_zoned_has_prompt() {
    assert!(Zoned::prompt().is_some());
}

#[test]
fn test_civil_datetime_has_prompt() {
    assert!(CivilDateTime::prompt().is_some());
}

// Integration tests (require MCP client)
#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_timestamp_iso() {
    // Test ISO 8601: "2024-07-11T15:30:00Z"
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_timestamp_components() {
    // Test manual components
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_zoned_iso() {
    // Test ISO 8601 with timezone: "2024-07-11T15:30:00-05[America/New_York]"
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_zoned_components() {
    // Test manual components with IANA timezone
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_civil_datetime_iso() {
    // Test ISO 8601 no timezone: "2024-07-11T15:30:00"
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_elicit_civil_datetime_components() {
    // Test manual components
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_invalid_iso_format() {
    // Test error handling for malformed ISO strings
}

#[tokio::test]
#[ignore = "Requires MCP client connection"]
async fn test_invalid_components() {
    // Test error handling for invalid date components
}

// Unit tests for datetime parsing
#[test]
fn test_jiff_parses_valid_timestamp() {
    let result = "2024-07-11T15:30:00Z".parse::<Timestamp>();
    assert!(result.is_ok());
}

#[test]
fn test_jiff_parses_valid_zoned() {
    // Use -04 for EDT (America/New_York in July)
    let result = "2024-07-11T15:30:00-04:00[America/New_York]".parse::<Zoned>();
    if let Err(e) = &result {
        eprintln!("Parse error: {}", e);
    }
    assert!(result.is_ok());
}

#[test]
fn test_jiff_parses_valid_civil() {
    let result = "2024-07-11T15:30:00".parse::<CivilDateTime>();
    assert!(result.is_ok());
}

#[test]
fn test_jiff_rejects_invalid_timestamp() {
    let result = "not-a-date".parse::<Timestamp>();
    assert!(result.is_err());
}

#[test]
fn test_jiff_constructs_civil_from_components() {
    let result = CivilDateTime::new(2024, 7, 11, 15, 30, 0, 0);
    assert!(result.is_ok());
}

#[test]
fn test_jiff_rejects_invalid_month() {
    let result = CivilDateTime::new(2024, 13, 11, 15, 30, 0, 0);
    assert!(result.is_err());
}

#[test]
fn test_jiff_rejects_invalid_day() {
    let result = CivilDateTime::new(2024, 2, 30, 15, 30, 0, 0);
    assert!(result.is_err());
}