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.
Dernier runRéussi#28 · main · 3 min 34 s
0Étoiles
0Forks
3Issues
| 1 | // The server-sent events parser (fetch/sse): pure, so these run in both |
| 2 | // back ends. |
| 3 | |
| 4 | import gen |
| 5 | import gen/check |
| 6 | import sse.{type Event, Event} |
| 7 | import std/bytes |
| 8 | import std/list |
| 9 | import std/random.{type random} |
| 10 | import std/string |
| 11 | import std/test.{assert_equal} |
| 12 | |
| 13 | /// The events of `text` fed in one piece. |
| 14 | fn 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. |
| 20 | fn 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 |
| 35 | fn 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 |
| 43 | fn 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 |
| 52 | fn 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 |
| 60 | fn 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 |
| 72 | fn 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 |
| 85 | fn 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 |
| 103 | fn 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 |
| 112 | fn 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 |
| 125 | fn 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 | |
| 138 | fn field_text :: -> String / <random> |
| 139 | { |
| 140 | gen.string ~alphabet: "abc éZ:9" ~min: 0 ~max: 6 |
| 141 | } |
| 142 | |
| 143 | fn 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. |
| 174 | fn 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 | |
| 181 | fn 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 |
| 188 | fn 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 | } |