tobogganSe connecter

packages

The Louise packages, each released on its own

Clone avec HTTPS, un jeton personnel en mot de passe, ou avec SSH, une clé ajoutée dans vos paramètres.

198 lignes · 4792 octetsBrut · Historique
1// The server-sent events parser (fetch/sse): pure, so these run in both
2// back ends.
3
4import gen
5import gen/check
6import sse.{type Event, Event}
7import std/bytes
8import std/list
9import std/random.{type random}
10import std/string
11import std/test.{assert_equal}
12
13/// The events of `text` fed in one piece.
14fn events_of :: text: String -> List<Event>
15{
16 (sse.feed (sse.parser ()) (bytes.from_string text)).1
17}
18
19/// The events of `pieces`, fed one after the other.
20fn events_of_pieces :: pieces: List<Bytes> -> List<Event>
21{
22 let (_, events) =
23 list.fold
24 pieces
25 (sse.parser (), [])
26 fn acc piece
27 {
28 let (p, new) = sse.feed acc.0 piece
29 (p, list.append acc.1 new)
30 }
31 events
32}
33
34@test
35fn named_events_and_the_default_name :: -> ()
36{
37 assert_equal
38 (events_of "event: delta\ndata: Bon\n\ndata: jour\n\n")
39 [Event("delta", "Bon", ""), Event("message", "jour", "")]
40}
41
42@test
43fn data_lines_join_and_one_space_is_dropped :: -> ()
44{
45 assert_equal
46 (events_of "data:a\ndata: b\ndata\n\n")
47 [Event("message", "a\n b\n", "")]
48 assert_equal (events_of "data\n\n") [Event("message", "", "")]
49}
50
51@test
52fn comments_unknown_fields_and_events_without_data :: -> ()
53{
54 assert_equal
55 (events_of ": keep-alive\nevent: ping\n\nfoo: bar\ndata: x\n\n")
56 [Event("message", "x", "")]
57}
58
59@test
60fn every_line_ending :: -> ()
61{
62 let expected = [Event("a", "1", ""), Event("b", "2", "")]
63 assert_equal
64 (events_of "event: a\r\ndata: 1\r\n\r\nevent: b\rdata: 2\r\r")
65 expected
66 assert_equal
67 (events_of "event: a\ndata: 1\r\n\nevent: b\r\ndata: 2\n\r")
68 expected
69}
70
71@test
72fn a_cr_lf_split_across_pieces_is_one_line_end :: -> ()
73{
74 assert_equal
75 ( events_of_pieces
76 [ bytes.from_string "data: 1\r"
77 , bytes.from_string "\n\r"
78 , bytes.from_string "\n"
79 ]
80 )
81 [Event("message", "1", "")]
82}
83
84@test
85fn ids_persist_and_a_nul_is_refused :: -> ()
86{
87 let nul = bytes.concat (bytes.from_string "id: b") (bytes.from_list [0, 10])
88 assert_equal
89 ( events_of_pieces
90 [ bytes.from_string "id: 7\ndata: a\n\ndata: b\n\n"
91 , nul
92 , bytes.from_string "data: c\n\nid\ndata: d\n\n"
93 ]
94 )
95 [ Event("message", "a", "7")
96 , Event("message", "b", "7")
97 , Event("message", "c", "7")
98 , Event("message", "d", "")
99 ]
100}
101
102@test
103fn retry_takes_digits_only :: -> ()
104{
105 let (p, _) = sse.feed (sse.parser ()) (bytes.from_string "retry: 3000\n")
106 assert_equal (sse.retry p) Some(3000)
107 let (p, _) = sse.feed p (bytes.from_string "retry: 12a\nretry:\n")
108 assert_equal (sse.retry p) Some(3000)
109}
110
111@test
112fn a_byte_order_mark_is_dropped_even_split :: -> ()
113{
114 let bom = bytes.from_list [239, 187, 191]
115 let body = bytes.from_string "data: x\n\n"
116 assert_equal
117 (events_of_pieces [bytes.concat bom body])
118 [Event("message", "x", "")]
119 assert_equal
120 (events_of_pieces [bytes.slice bom 0 1, bytes.slice bom 1 3, body])
121 [Event("message", "x", "")]
122}
123
124@test
125fn invalid_utf8_is_replaced_and_unfinished_events_wait :: -> ()
126{
127 let (p, events) =
128 sse.feed
129 (sse.parser ())
130 (bytes.concat (bytes.from_string "data: caf") (bytes.from_list [233, 10]))
131 assert_equal events []
132 let (_, events) = sse.feed p (bytes.from_string "\n")
133 assert_equal events [Event("message", "caf\u{FFFD}", "")]
134}
135
136// ---- property: any split gives the same events --------------------------------
137
138fn field_text :: -> String / <random>
139{
140 gen.string ~alphabet: "abc éZ:9" ~min: 0 ~max: 6
141}
142
143fn stream :: -> String / <random>
144{
145 let parts =
146 gen.list
147 ~min: 0
148 ~max: 6
149 fn
150 {
151 let ending = gen.pick ["\n", "\r", "\r\n"]
152 let name = if gen.bool ()
153 {
154 "event: " <> field_text () <> ending
155 }
156 else
157 {
158 ""
159 }
160 let data =
161 string.concat
162 ( gen.list
163 ~min: 0
164 ~max: 3
165 fn { "data: " <> field_text () <> ending }
166 )
167 let comment = if gen.bool () { ": c" <> ending } else { "" }
168 name <> comment <> data <> ending
169 }
170 string.concat parts
171}
172
173/// A stream and where to cut it.
174fn split_case :: -> (String, List<Int>) / <random>
175{
176 let text = stream ()
177 let n = bytes.length (bytes.from_string text)
178 (text, gen.list ~min: 0 ~max: 5 fn { gen.int ~low: 0 ~high: n })
179}
180
181fn cut :: data: Bytes at: List<Int> -> List<Bytes>
182{
183 let points = list.sort (list.append [0, ..at] [bytes.length data])
184 list.zip_with points (list.drop points 1) fn a b { bytes.slice data a b }
185}
186
187@test
188fn any_split_parses_the_same :: -> () / <random>
189{
190 check.property
191 ~runs: 300
192 split_case
193 fn c
194 {
195 let data = bytes.from_string c.0
196 events_of_pieces (cut data c.1) == events_of c.0
197 }
198}