Skip to main content

mutil_ai/
sse.rs

1use std::borrow::Cow;
2use std::time::Duration;
3
4use thiserror::Error;
5
6pub(crate) const DEFAULT_MAX_LINE_BYTES: usize = 4 * 1024 * 1024;
7pub(crate) const DEFAULT_MAX_EVENT_BYTES: usize = 16 * 1024 * 1024;
8const UTF8_BOM: [u8; 3] = [0xEF, 0xBB, 0xBF];
9
10/// A parsed SSE message.
11#[derive(Debug, Clone, PartialEq, Eq)]
12pub struct SseMessage {
13    /// The `event` field, or `None` when the event used the default type.
14    pub event: Option<String>,
15    /// The `data` field, with multiple data lines joined by `\n`.
16    pub data: String,
17    /// The most recent `id` field seen before this message.
18    pub id: Option<String>,
19}
20
21/// An event emitted by [`SseParser`].
22#[derive(Debug, Clone, PartialEq, Eq)]
23pub enum SseEvent {
24    /// A complete SSE message, dispatched on a blank line.
25    Message(SseMessage),
26    /// A server-directed `retry` reconnection delay.
27    Retry(Duration),
28}
29
30/// How invalid UTF-8 in field values is handled.
31#[derive(Debug, Clone, Copy, PartialEq, Eq)]
32pub enum SseUtf8Policy {
33    /// WHATWG EventSource behavior: invalid UTF-8 becomes U+FFFD.
34    Replace,
35    /// Stricter provider-client behavior: invalid UTF-8 is an error.
36    Strict,
37}
38
39/// How an incomplete trailing event is handled by [`SseParser::finish`].
40#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
41pub enum TailPolicy {
42    /// WHATWG EventSource behavior: discard the incomplete final event.
43    #[default]
44    Discard,
45    /// Flush the trailing event. Lenient LLM gateways routinely end a stream
46    /// right after the final `data:` line — without the blank-line
47    /// terminator, with a bare trailing CR, or mid-line. Discarding that
48    /// frame silently loses bytes (typically the tail of a tool-call
49    /// arguments JSON); Flush dispatches whatever arrived instead, so a
50    /// genuinely truncated payload surfaces as a mapper/JSON error rather
51    /// than silent loss.
52    Flush,
53}
54
55/// Errors that can occur while parsing an SSE stream.
56#[derive(Debug, Clone, PartialEq, Eq, Error)]
57pub enum SseError {
58    /// Invalid UTF-8 was encountered under [`SseUtf8Policy::Strict`].
59    #[error("invalid UTF-8 in an SSE field (strict mode)")]
60    Utf8,
61
62    /// A single line exceeded the configured byte limit.
63    #[error("SSE line exceeded {limit} bytes")]
64    LineTooLong { limit: usize },
65
66    /// A single event exceeded the configured byte limit.
67    #[error("SSE event exceeded {limit} bytes")]
68    EventTooLarge { limit: usize },
69}
70
71/// Incremental, zero-I/O SSE parser.
72///
73/// Feed arbitrary byte chunks with [`SseParser::push`]. It does not assume
74/// chunks end on lines or events. By default a final incomplete event is
75/// discarded by [`SseParser::finish`], matching the usual EventSource
76/// behavior; [`TailPolicy::Flush`] recovers it instead.
77pub struct SseParser {
78    line: Vec<u8>,
79    pending_cr: bool,
80    bom_checked: bool,
81    bom_prefix: [u8; UTF8_BOM.len()],
82    bom_prefix_len: u8,
83
84    event_type: Option<String>,
85    data: Vec<u8>,
86    last_event_id: Option<String>,
87    retry: Option<Duration>,
88
89    max_line_bytes: usize,
90    max_event_bytes: usize,
91    utf8_policy: SseUtf8Policy,
92    tail_policy: TailPolicy,
93}
94
95impl Default for SseParser {
96    fn default() -> Self {
97        Self::new()
98    }
99}
100
101impl SseParser {
102    /// Creates a parser with default limits: 4 MiB per line and 16 MiB per
103    /// event, using [`SseUtf8Policy::Replace`].
104    pub fn new() -> Self {
105        Self::with_limits(DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_EVENT_BYTES)
106    }
107
108    /// Strict UTF-8 behavior matching `sse-stream` rather than EventSource.
109    pub fn strict() -> Self {
110        Self::new().with_utf8_policy(SseUtf8Policy::Strict)
111    }
112
113    /// Creates a parser with the given per-line and per-event byte limits.
114    ///
115    /// A limit of `0` rejects any non-empty line or data field.
116    pub fn with_limits(max_line_bytes: usize, max_event_bytes: usize) -> Self {
117        Self {
118            line: Vec::with_capacity(256),
119            pending_cr: false,
120            bom_checked: false,
121            bom_prefix: [0; UTF8_BOM.len()],
122            bom_prefix_len: 0,
123            event_type: None,
124            data: Vec::with_capacity(1024),
125            last_event_id: None,
126            retry: None,
127            max_line_bytes,
128            max_event_bytes,
129            utf8_policy: SseUtf8Policy::Replace,
130            tail_policy: TailPolicy::Discard,
131        }
132    }
133
134    /// Sets how invalid UTF-8 in field values is handled.
135    pub(crate) fn with_byte_limits(mut self, line: usize, event: usize) -> Self {
136        self.max_line_bytes = line;
137        self.max_event_bytes = event;
138        self
139    }
140
141    /// Sets how invalid UTF-8 in field values is handled.
142    pub fn with_utf8_policy(mut self, utf8_policy: SseUtf8Policy) -> Self {
143        self.utf8_policy = utf8_policy;
144        self
145    }
146
147    /// Sets how the incomplete final event is handled by
148    /// [`SseParser::finish`].
149    pub fn with_tail_policy(mut self, tail_policy: TailPolicy) -> Self {
150        self.tail_policy = tail_policy;
151        self
152    }
153
154    /// Returns the configured tail policy.
155    pub fn tail_policy(&self) -> TailPolicy {
156        self.tail_policy
157    }
158
159    /// Start a reconnected parser from the last event id seen on the previous
160    /// connection.
161    pub fn with_last_event_id(mut self, last_event_id: impl Into<String>) -> Self {
162        self.last_event_id = Some(last_event_id.into());
163        self
164    }
165
166    /// Returns the last event id seen on this connection, if any.
167    pub fn last_event_id(&self) -> Option<&str> {
168        self.last_event_id.as_deref()
169    }
170
171    /// Returns the reconnect delay most recently requested by a `retry` field.
172    pub fn retry(&self) -> Option<Duration> {
173        self.retry
174    }
175
176    /// Clears all state, including [`last_event_id`](Self::last_event_id) and
177    /// [`retry`](Self::retry).
178    pub fn reset(&mut self) {
179        self.clear_pending();
180        self.last_event_id = None;
181        self.retry = None;
182    }
183
184    /// Clear partial connection state while preserving Last-Event-ID and the
185    /// server retry hint.
186    pub fn reset_for_reconnect(&mut self) {
187        self.clear_pending();
188    }
189
190    fn clear_pending(&mut self) {
191        self.line.clear();
192        self.pending_cr = false;
193        self.bom_checked = false;
194        self.bom_prefix_len = 0;
195        self.event_type = None;
196        self.data.clear();
197    }
198
199    /// Feed one arbitrary byte chunk and return all complete events.
200    pub fn push(&mut self, chunk: &[u8]) -> Result<Vec<SseEvent>, SseError> {
201        let mut events = Vec::new();
202        self.push_into(chunk, &mut events)?;
203        Ok(events)
204    }
205
206    /// Feed one arbitrary byte chunk into an existing event buffer.
207    ///
208    /// Reusing the same buffer across chunks avoids one allocation per chunk.
209    pub fn push_into(&mut self, chunk: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
210        let mut input = chunk;
211
212        if !self.bom_checked {
213            let prefix_len = usize::from(self.bom_prefix_len);
214            let needed = UTF8_BOM.len().saturating_sub(prefix_len);
215            let take = needed.min(input.len());
216            self.bom_prefix[prefix_len..prefix_len + take].copy_from_slice(&input[..take]);
217            self.bom_prefix_len += take as u8;
218            input = &input[take..];
219
220            let prefix_len = usize::from(self.bom_prefix_len);
221            if prefix_len < UTF8_BOM.len() && UTF8_BOM.starts_with(&self.bom_prefix[..prefix_len]) {
222                return Ok(());
223            }
224
225            self.bom_checked = true;
226            if self.bom_prefix[..prefix_len] != UTF8_BOM {
227                let mut prefix = [0_u8; UTF8_BOM.len()];
228                prefix[..prefix_len].copy_from_slice(&self.bom_prefix[..prefix_len]);
229                self.feed_bytes(&prefix[..prefix_len], events)?;
230            }
231        }
232
233        self.feed_bytes(input, events)
234    }
235
236    /// Finish the stream. An incomplete final event is discarded.
237    pub fn finish(&mut self) -> Result<Vec<SseEvent>, SseError> {
238        let mut events = Vec::new();
239        self.finish_into(&mut events)?;
240        Ok(events)
241    }
242
243    /// Finish the stream into an existing event buffer.
244    pub fn finish_into(&mut self, events: &mut Vec<SseEvent>) -> Result<(), SseError> {
245        if !self.bom_checked {
246            self.bom_checked = true;
247            let prefix_len = usize::from(self.bom_prefix_len);
248            if prefix_len != 0 && self.bom_prefix[..prefix_len] != UTF8_BOM {
249                let mut prefix = [0_u8; UTF8_BOM.len()];
250                prefix[..prefix_len].copy_from_slice(&self.bom_prefix[..prefix_len]);
251                self.feed_bytes(&prefix[..prefix_len], events)?;
252            }
253        }
254
255        if self.tail_policy == TailPolicy::Discard {
256            // A non-empty line without a following blank line is an
257            // incomplete event. EventSource implementations discard it at
258            // EOF.
259            self.line.clear();
260            self.event_type = None;
261            self.data.clear();
262            self.pending_cr = false;
263            return Ok(());
264        }
265
266        // TailPolicy::Flush: recover the trailing event instead of
267        // discarding it.
268        if self.pending_cr {
269            // A trailing bare CR terminates the buffered line (if any).
270            self.pending_cr = false;
271            self.end_line(events)?;
272        }
273        if !self.line.is_empty() {
274            let line = std::mem::take(&mut self.line);
275            self.process_line(&line, events)?;
276        }
277        if self.data.is_empty() {
278            self.event_type = None;
279        } else {
280            self.dispatch(events);
281        }
282        Ok(())
283    }
284
285    fn feed_bytes(&mut self, bytes: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
286        let mut input = bytes;
287
288        loop {
289            if self.pending_cr {
290                self.pending_cr = false;
291                if input.first() == Some(&b'\n') {
292                    input = &input[1..];
293                }
294            }
295
296            let Some(delimiter) = input.iter().position(|byte| matches!(*byte, b'\r' | b'\n'))
297            else {
298                self.push_line_bytes(input)?;
299                return Ok(());
300            };
301
302            let delimiter_byte = input[delimiter];
303            let segment = &input[..delimiter];
304            input = &input[delimiter + 1..];
305            self.finish_line_segment(segment, events)?;
306
307            if delimiter_byte == b'\r' {
308                if input.first() == Some(&b'\n') {
309                    input = &input[1..];
310                } else if input.is_empty() {
311                    self.pending_cr = true;
312                    return Ok(());
313                }
314            }
315
316            if input.is_empty() {
317                return Ok(());
318            }
319        }
320    }
321
322    fn finish_line_segment(
323        &mut self,
324        segment: &[u8],
325        events: &mut Vec<SseEvent>,
326    ) -> Result<(), SseError> {
327        if self.line.is_empty() {
328            if segment.is_empty() {
329                self.dispatch(events);
330                return Ok(());
331            }
332            return self.process_line(segment, events);
333        }
334
335        self.push_line_bytes(segment)?;
336        self.end_line(events)
337    }
338
339    fn push_line_bytes(&mut self, value: &[u8]) -> Result<(), SseError> {
340        let next_len = self
341            .line
342            .len()
343            .checked_add(value.len())
344            .ok_or(SseError::LineTooLong {
345                limit: self.max_line_bytes,
346            })?;
347        if next_len > self.max_line_bytes {
348            return Err(SseError::LineTooLong {
349                limit: self.max_line_bytes,
350            });
351        }
352        self.line.extend_from_slice(value);
353        Ok(())
354    }
355
356    fn end_line(&mut self, events: &mut Vec<SseEvent>) -> Result<(), SseError> {
357        if self.line.is_empty() {
358            self.dispatch(events);
359            return Ok(());
360        }
361
362        let mut line = std::mem::take(&mut self.line);
363        let result = self.process_line(&line, events);
364        line.clear();
365        self.line = line;
366        result
367    }
368
369    fn process_line(&mut self, line: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
370        if line.first() == Some(&b':') {
371            return Ok(());
372        }
373
374        let (field, value) = split_field(line);
375
376        match field {
377            b"data" => self.append_data(value)?,
378            b"event" => {
379                self.event_type = Some(self.decode(value)?.into_owned());
380            }
381            b"id" => {
382                if !value.contains(&0) {
383                    self.last_event_id = Some(self.decode(value)?.into_owned());
384                }
385            }
386            b"retry" => {
387                if let Some(millis) = parse_retry(value) {
388                    let retry = Duration::from_millis(millis);
389                    self.retry = Some(retry);
390                    events.push(SseEvent::Retry(retry));
391                }
392            }
393            _ => {}
394        }
395
396        Ok(())
397    }
398
399    fn append_data(&mut self, value: &[u8]) -> Result<(), SseError> {
400        let value = self.decode(value)?;
401        let next_len = self
402            .data
403            .len()
404            .checked_add(value.len())
405            .and_then(|len| len.checked_add(1))
406            .ok_or(SseError::EventTooLarge {
407                limit: self.max_event_bytes,
408            })?;
409
410        if next_len > self.max_event_bytes {
411            return Err(SseError::EventTooLarge {
412                limit: self.max_event_bytes,
413            });
414        }
415
416        self.data.extend_from_slice(value.as_bytes());
417        self.data.push(b'\n');
418        Ok(())
419    }
420
421    fn decode<'a>(&self, value: &'a [u8]) -> Result<Cow<'a, str>, SseError> {
422        match self.utf8_policy {
423            SseUtf8Policy::Replace => Ok(String::from_utf8_lossy(value)),
424            SseUtf8Policy::Strict => std::str::from_utf8(value)
425                .map(Cow::Borrowed)
426                .map_err(|_| SseError::Utf8),
427        }
428    }
429
430    fn dispatch(&mut self, events: &mut Vec<SseEvent>) {
431        if self.data.is_empty() {
432            self.event_type = None;
433            return;
434        }
435
436        self.data.pop(); // trailing LF added by append_data
437        let Ok(data) = String::from_utf8(std::mem::take(&mut self.data)) else {
438            // append_data validated every line, so this is unreachable.
439            self.event_type = None;
440            return;
441        };
442
443        events.push(SseEvent::Message(SseMessage {
444            event: self.event_type.take(),
445            data,
446            id: self.last_event_id.clone(),
447        }));
448    }
449}
450
451fn split_field(line: &[u8]) -> (&[u8], &[u8]) {
452    let Some(colon) = line.iter().position(|byte| *byte == b':') else {
453        return (line, &[]);
454    };
455
456    let mut value = &line[colon + 1..];
457    if value.first() == Some(&b' ') {
458        value = &value[1..];
459    }
460    (&line[..colon], value)
461}
462
463fn parse_retry(value: &[u8]) -> Option<u64> {
464    if value.is_empty() || !value.iter().all(u8::is_ascii_digit) {
465        return None;
466    }
467
468    let mut result = 0_u64;
469    for byte in value {
470        result = result
471            .checked_mul(10)?
472            .checked_add(u64::from(byte - b'0'))?;
473    }
474    Some(result)
475}
476
477#[cfg(test)]
478mod tests {
479    use super::*;
480
481    fn message(data: &str) -> SseEvent {
482        SseEvent::Message(SseMessage {
483            event: None,
484            data: data.to_string(),
485            id: None,
486        })
487    }
488
489    #[test]
490    fn reset_for_reconnect_preserves_last_event_id() {
491        let mut parser = SseParser::new();
492        parser.push(b"id: 42\ndata: first\n\n").unwrap();
493        parser.reset_for_reconnect();
494
495        assert_eq!(parser.last_event_id(), Some("42"));
496        let events = parser.push(b"data: second\n\n").unwrap();
497        assert_eq!(
498            events,
499            vec![SseEvent::Message(SseMessage {
500                event: None,
501                data: "second".to_string(),
502                id: Some("42".to_string()),
503            })]
504        );
505    }
506
507    #[test]
508    fn parses_basic_event() {
509        let mut parser = SseParser::new();
510        let events = parser.push(b"data: hello\n\n").unwrap();
511        assert_eq!(events, vec![message("hello")]);
512    }
513
514    #[test]
515    fn push_into_reuses_event_buffer() {
516        let mut parser = SseParser::new();
517        let mut events = Vec::new();
518
519        parser.push_into(b"data: one\n\n", &mut events).unwrap();
520        assert_eq!(events, vec![message("one")]);
521
522        events.clear();
523        parser.push_into(b"data: two\n\n", &mut events).unwrap();
524        assert_eq!(events, vec![message("two")]);
525    }
526
527    #[test]
528    fn parses_multiline_data() {
529        let mut parser = SseParser::new();
530        let events = parser.push(b"data: hello\ndata: world\n\n").unwrap();
531        assert_eq!(events, vec![message("hello\nworld")]);
532    }
533
534    #[test]
535    fn handles_every_byte_boundary() {
536        let input = b"event: update\nid: 42\ndata: hello\ndata: world\n\n";
537        for split in 0..input.len() {
538            let mut parser = SseParser::new();
539            let mut events = parser.push(&input[..split]).unwrap();
540            events.extend(parser.push(&input[split..]).unwrap());
541            assert_eq!(events.len(), 1, "split={split}");
542            assert_eq!(
543                events[0],
544                SseEvent::Message(SseMessage {
545                    event: Some("update".to_string()),
546                    data: "hello\nworld".to_string(),
547                    id: Some("42".to_string()),
548                })
549            );
550        }
551    }
552
553    #[test]
554    fn handles_crlf_split_across_chunks() {
555        let mut parser = SseParser::new();
556        assert!(parser.push(b"data: hello\r").unwrap().is_empty());
557        let events = parser.push(b"\n\r\n").unwrap();
558        assert_eq!(events, vec![message("hello")]);
559    }
560
561    #[test]
562    fn ignores_bom_split_across_chunks() {
563        let mut parser = SseParser::new();
564        assert!(parser.push(&UTF8_BOM[..1]).unwrap().is_empty());
565        assert!(parser.push(&UTF8_BOM[1..]).unwrap().is_empty());
566        let events = parser.push(b"data: hello\n\n").unwrap();
567        assert_eq!(events, vec![message("hello")]);
568    }
569
570    #[test]
571    fn emits_retry_and_keeps_last_id() {
572        let mut parser = SseParser::new();
573        let events = parser.push(b"retry: 1500\nid: 7\ndata: hi\n\n").unwrap();
574        assert_eq!(
575            events,
576            vec![
577                SseEvent::Retry(Duration::from_millis(1500)),
578                SseEvent::Message(SseMessage {
579                    event: None,
580                    data: "hi".to_string(),
581                    id: Some("7".to_string()),
582                }),
583            ]
584        );
585        assert_eq!(parser.last_event_id(), Some("7"));
586        assert_eq!(parser.retry(), Some(Duration::from_millis(1500)));
587    }
588
589    #[test]
590    fn ignores_comments_and_unknown_fields() {
591        let mut parser = SseParser::new();
592        let events = parser
593            .push(b": keepalive\nunknown: value\ndata: hi\n\n")
594            .unwrap();
595        assert_eq!(events, vec![message("hi")]);
596    }
597
598    #[test]
599    fn empty_data_field_dispatches_empty_message() {
600        let mut parser = SseParser::new();
601        let events = parser.push(b"data:\n\n").unwrap();
602        assert_eq!(events, vec![message("")]);
603    }
604
605    #[test]
606    fn no_data_field_does_not_dispatch() {
607        let mut parser = SseParser::new();
608        let events = parser.push(b"event: ping\n\n").unwrap();
609        assert!(events.is_empty());
610    }
611
612    #[test]
613    fn discards_incomplete_final_event() {
614        let mut parser = SseParser::new();
615        let events = parser.push(b"data: incomplete").unwrap();
616        assert!(events.is_empty());
617        assert!(parser.finish().unwrap().is_empty());
618    }
619
620    #[test]
621    fn flush_policy_dispatches_final_data_line_without_blank_terminator() {
622        let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
623        let mut events = parser.push(b"data: {\"q\":1}").unwrap();
624        assert!(events.is_empty());
625        parser.finish_into(&mut events).unwrap();
626        assert_eq!(events, vec![message("{\"q\":1}")]);
627    }
628
629    #[test]
630    fn flush_policy_flushes_aggregated_multi_data_tail() {
631        let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
632        let mut events = parser.push(b"data: A\ndata: B").unwrap();
633        parser.finish_into(&mut events).unwrap();
634        assert_eq!(events, vec![message("A\nB")]);
635    }
636
637    #[test]
638    fn flush_policy_treats_trailing_bare_cr_as_terminator() {
639        let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
640        let mut events = parser.push(b"data: hi\r").unwrap();
641        parser.finish_into(&mut events).unwrap();
642        assert_eq!(events, vec![message("hi")]);
643    }
644
645    #[test]
646    fn flush_policy_ignores_partial_unknown_field_tail() {
647        let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
648        let mut events = parser.push(b"data: hi\neven").unwrap();
649        parser.finish_into(&mut events).unwrap();
650        assert_eq!(events, vec![message("hi")]);
651    }
652
653    #[test]
654    fn flush_policy_without_pending_data_is_a_noop() {
655        let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
656        let events = parser.push(b"data: done\n\n").unwrap();
657        assert_eq!(events, vec![message("done")]);
658        let extra = parser.finish().unwrap();
659        assert!(extra.is_empty());
660    }
661
662    #[test]
663    fn enforces_line_limit() {
664        let mut parser = SseParser::with_limits(4, 1024);
665        assert_eq!(
666            parser.push(b"data: hello\n\n"),
667            Err(SseError::LineTooLong { limit: 4 })
668        );
669    }
670
671    #[test]
672    fn default_parser_accepts_large_responses_terminal_lines() {
673        let mut parser = SseParser::new();
674        let payload = format!("data: {}\n\n", "x".repeat(128 * 1024));
675        assert!(parser.push(payload.as_bytes()).is_ok());
676    }
677
678    #[test]
679    fn enforces_event_limit() {
680        let mut parser = SseParser::with_limits(1024, 4);
681        assert_eq!(
682            parser.push(b"data: hello\n\n"),
683            Err(SseError::EventTooLarge { limit: 4 })
684        );
685    }
686
687    #[test]
688    fn replaces_invalid_utf8_by_default() {
689        let mut parser = SseParser::new();
690        let events = parser.push(b"data: \xFF\n\n").unwrap();
691        assert_eq!(events, vec![message("\u{FFFD}")]);
692    }
693
694    #[test]
695    fn strict_mode_rejects_invalid_utf8() {
696        let mut parser = SseParser::strict();
697        assert_eq!(parser.push(b"data: \xFF\n\n"), Err(SseError::Utf8));
698    }
699
700    #[test]
701    fn last_event_id_persists_without_new_id() {
702        let mut parser = SseParser::new();
703        let events = parser.push(b"id: 7\ndata: one\n\ndata: two\n\n").unwrap();
704        assert_eq!(events.len(), 2);
705        assert_eq!(
706            events[0],
707            SseEvent::Message(SseMessage {
708                event: None,
709                data: "one".to_string(),
710                id: Some("7".to_string()),
711            })
712        );
713        assert_eq!(
714            events[1],
715            SseEvent::Message(SseMessage {
716                event: None,
717                data: "two".to_string(),
718                id: Some("7".to_string()),
719            })
720        );
721    }
722
723    #[test]
724    fn event_type_resets_after_dispatch() {
725        let mut parser = SseParser::new();
726        let events = parser
727            .push(b"event: update\ndata: one\n\ndata: two\n\n")
728            .unwrap();
729        assert_eq!(events.len(), 2);
730        assert_eq!(
731            events[0],
732            SseEvent::Message(SseMessage {
733                event: Some("update".to_string()),
734                data: "one".to_string(),
735                id: None,
736            })
737        );
738        assert_eq!(events[1], message("two"));
739    }
740
741    #[test]
742    fn invalid_and_overflowing_retry_values_are_ignored() {
743        let mut parser = SseParser::new();
744        let events = parser
745            .push(b"retry: nope\nretry: 18446744073709551616\ndata: hi\n\n")
746            .unwrap();
747        assert_eq!(events, vec![message("hi")]);
748        assert_eq!(parser.retry(), None);
749    }
750
751    #[test]
752    fn handles_cr_only_line_endings() {
753        let mut parser = SseParser::new();
754        let mut events = parser.push(b"data: hello\r\r").unwrap();
755        events.extend(parser.finish().unwrap());
756        assert_eq!(events, vec![message("hello")]);
757    }
758
759    #[test]
760    fn removes_only_one_leading_space() {
761        let mut parser = SseParser::new();
762        let events = parser.push(b"data:  hello\n\n").unwrap();
763        assert_eq!(events, vec![message(" hello")]);
764    }
765
766    #[test]
767    fn ignores_id_containing_nul() {
768        let mut parser = SseParser::new();
769        let events = parser.push(b"id: a\x00b\ndata: hi\n\n").unwrap();
770        assert_eq!(events, vec![message("hi")]);
771        assert_eq!(parser.last_event_id(), None);
772    }
773
774    #[test]
775    fn colonless_data_is_an_empty_data_field() {
776        let mut parser = SseParser::new();
777        let events = parser.push(b"data\n\n").unwrap();
778        assert_eq!(events, vec![message("")]);
779    }
780
781    #[test]
782    fn parses_cjk_data() {
783        let mut parser = SseParser::new();
784        let events = parser.push("data: 你好,世界\n\n".as_bytes()).unwrap();
785        assert_eq!(events, vec![message("你好,世界")]);
786    }
787
788    #[test]
789    fn parses_cjk_split_inside_codepoints() {
790        let input = "data: 中文\n\n".as_bytes();
791        for split in 0..input.len() {
792            let mut parser = SseParser::new();
793            let mut events = parser.push(&input[..split]).unwrap();
794            events.extend(parser.push(&input[split..]).unwrap());
795            assert_eq!(events, vec![message("中文")], "split={split}");
796        }
797    }
798
799    #[test]
800    fn parses_cjk_event_and_id() {
801        let mut parser = SseParser::new();
802        let events = parser
803            .push("event: 更新\nid: 会话-7\ndata: 内容\n\n".as_bytes())
804            .unwrap();
805        assert_eq!(
806            events,
807            vec![SseEvent::Message(SseMessage {
808                event: Some("更新".to_string()),
809                data: "内容".to_string(),
810                id: Some("会话-7".to_string()),
811            })]
812        );
813    }
814
815    #[test]
816    fn parses_emoji_split_inside_codepoint() {
817        let input = "data: 🦀🚀\n\n".as_bytes();
818        for split in 0..input.len() {
819            let mut parser = SseParser::new();
820            let mut events = parser.push(&input[..split]).unwrap();
821            events.extend(parser.push(&input[split..]).unwrap());
822            assert_eq!(events, vec![message("🦀🚀")], "split={split}");
823        }
824    }
825
826    #[test]
827    fn line_limit_counts_utf8_bytes() {
828        let mut parser = SseParser::with_limits(8, 1024);
829        assert_eq!(
830            parser.push("data: 中文\n\n".as_bytes()),
831            Err(SseError::LineTooLong { limit: 8 })
832        );
833    }
834
835    #[test]
836    fn bom_before_cjk_is_ignored() {
837        let mut parser = SseParser::new();
838        let mut input = UTF8_BOM.to_vec();
839        input.extend_from_slice("data: 中文\n\n".as_bytes());
840        let events = parser.push(&input).unwrap();
841        assert_eq!(events, vec![message("中文")]);
842    }
843
844    #[test]
845    fn partial_bom_at_eof_is_discarded() {
846        let mut parser = SseParser::new();
847        assert!(parser.push(&UTF8_BOM[..2]).unwrap().is_empty());
848        assert!(parser.finish().unwrap().is_empty());
849    }
850}