// Heads and chunked bodies as RFC 9112 (§4, §5, §6.3, §7.1) writes them; // the chunked encoder below is the test's own, written from §7.1. import gen import gen/check import response. {type Dechunker, type Head, Chunked, Head, Length, NoBody, UntilClose} import std/bytes import std/list import std/random.{type random} import std/result import std/string import std/test.{assert, assert_equal} fn head_of :: text: String -> Result, String> { response.head (bytes.from_string text) 65536 } // ---- heads --------------------------------------------------------------------- @test fn a_head_and_its_size :: { assert_equal ( head_of "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nX-A: b c \r\n\r\nbody" ) Ok(Some(Head(200, [("Content-Type", "text/html"), ("X-A", "b c")], 56))) assert_equal (head_of "HTTP/1.0 404 \r\n\r\n") Ok(Some(Head(404, [], 17))) assert_equal (head_of "HTTP/1.1 204\r\n\r\n") Ok(Some(Head(204, [], 16))) } @test fn an_incomplete_head_asks_for_more :: { assert_equal (head_of "") Ok(None) assert_equal (head_of "HTTP/1.1 200 OK\r\n") Ok(None) assert_equal (head_of "HTTP/1.1 200 OK\r\nA: b\r\n\r") Ok(None) } @test fn a_head_over_the_limit :: { let long = "HTTP/1.1 200 OK\r\nX: " <> string.repeat "a" 100 assert (result.is_error (response.head (bytes.from_string long) 64)) "result.is_error (response.head (bytes.from_string long) 64)" assert ( result.is_error (response.head (bytes.from_string (long <> "\r\n\r\n")) 64) ) "result.is_error (response.head (bytes.from_string (long <> rnrn)) 64)" assert (result.is_ok (response.head (bytes.from_string (long <> "\r\n\r\n")) 1000)) "result.is_ok (response.head (bytes.from_string (long <> rnrn)) 1000)" } @test fn malformed_heads :: { let bad = fn text { result.is_error (head_of (text <> "\r\n\r\n")) } assert (bad "HTTP/2 200 OK") "bad HTTP/2 200 OK" assert (bad "HTTP/1.1 20 OK") "bad HTTP/1.1 20 OK" assert (bad "HTTP/1.1 2000 OK") "bad HTTP/1.1 2000 OK" assert (bad "HTTP/1.1 099 Low") "bad HTTP/1.1 099 Low" assert (bad "HTTP/1.1 600 High") "bad HTTP/1.1 600 High" assert (bad "HTTP/1.1 abc OK") "bad HTTP/1.1 abc OK" assert (bad "ICY 200 OK") "bad ICY 200 OK" assert (bad "HTTP/1.1 200 OK\r\nNo-Colon") "bad HTTP/1.1 200 OKrnNo-Colon" assert (bad "HTTP/1.1 200 OK\r\nSpace : before") "bad HTTP/1.1 200 OKrnSpace : before" assert (bad "HTTP/1.1 200 OK\r\n: empty name") "bad HTTP/1.1 200 OKrn: empty name" assert (bad "HTTP/1.1 200 OK\r\nA: b\r\n folded") "bad HTTP/1.1 200 OKrnA: brn folded" assert (bad "HTTP/1.1 200 OK\r\nA: b\rc") "bad HTTP/1.1 200 OKrnA: brc" assert (bad "HTTP/1.1 200 OK\r\nA: b\u{0}") "bad HTTP/1.1 200 OKrnA: bu0" } @test fn a_header_by_any_case :: { let headers = [("Location", "/a"), ("location", "/b")] assert_equal (response.header headers "LOCATION") Some("/a") assert_equal (response.header headers "etag") None } // ---- framing ------------------------------------------------------------------- fn framed :: status: Int headers: List<(String, String)> -> Result { response.framing (Head(status, headers, 0)) } @test fn framing :: { assert_equal (framed 200 []) Ok(UntilClose) assert_equal (framed 200 [("Content-Length", "12")]) Ok(Length(12)) assert_equal (framed 200 [("content-length", "0")]) Ok(Length(0)) assert_equal (framed 200 [("Content-Length", "5, 5"), ("Content-Length", "5")]) Ok(Length(5)) assert_equal (framed 200 [("Transfer-Encoding", "Chunked")]) Ok(Chunked) assert_equal (framed 200 [("Transfer-Encoding", "chunked"), ("Content-Length", "3")]) Ok(Chunked) assert_equal (framed 204 [("Content-Length", "3")]) Ok(NoBody) assert_equal (framed 304 []) Ok(NoBody) assert_equal (framed 103 []) Ok(NoBody) assert_equal (framed 302 [("Content-Length", "3")]) Ok(Length(3)) } @test fn framing_that_is_refused :: { let refused = fn headers { result.is_error (framed 200 headers) } assert (refused [("Content-Length", "5"), ("Content-Length", "6")]) "refused [(Content-Length, 5), (Content-Length, 6)]" assert (refused [("Content-Length", "5, 6")]) "refused [(Content-Length, 5, 6)]" assert (refused [("Content-Length", "-1")]) "refused [(Content-Length, -1)]" assert (refused [("Content-Length", "+5")]) "refused [(Content-Length, +5)]" assert (refused [("Content-Length", "")]) "refused [(Content-Length, )]" assert (refused [("Content-Length", "0x10")]) "refused [(Content-Length, 0x10)]" assert (refused [("Content-Length", "99999999999999999999")]) "refused [(Content-Length, 99999999999999999999)]" assert (refused [("Transfer-Encoding", "gzip, chunked")]) "refused [(Transfer-Encoding, gzip, chunked)]" assert (refused [("Transfer-Encoding", "gzip")]) "refused [(Transfer-Encoding, gzip)]" assert ( refused [("Transfer-Encoding", "chunked"), ("Transfer-Encoding", "chunked")] ) "refused [(Transfer-Encoding, chunked), (Transfer-Encoding, chunked)]" } // ---- chunked bodies ------------------------------------------------------------ fn decoded :: text: String max: Int -> Result<(String, Bool, Bool), String> { use d <- result.try (response.feed (response.dechunker max) (bytes.from_string text)) let (body, cut) = response.body d Ok((bytes.to_string_lossy body, cut, response.is_done d)) } @test fn a_chunked_body :: { assert_equal ( decoded "4\r\nWiki\r\n5;ext=1\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n" 100 ) Ok(("Wikipedia in\r\n\r\nchunks.", False, True)) assert_equal (decoded "3\r\nabc\r\n0\r\nExpires: never\r\nX: y\r\n\r\n" 100) Ok(("abc", False, True)) assert_equal (decoded "0\r\n\r\n" 100) Ok(("", False, True)) } @test fn an_unfinished_chunked_body_is_not_done :: { assert_equal (decoded "3\r\nab" 100) Ok(("ab", False, False)) assert_equal (decoded "3\r\nabc\r\n0\r\n" 100) Ok(("abc", False, False)) assert_equal (decoded "" 100) Ok(("", False, False)) } @test fn a_chunked_body_over_the_limit_is_cut :: { assert_equal (decoded "4\r\nWiki\r\n5\r\npedia\r\n" 6) Ok(("Wikipe", True, True)) assert_equal (decoded "4\r\nWiki\r\n0\r\n\r\n" 4) Ok(("Wiki", False, True)) assert_equal (decoded "4\r\nWiki\r\n1\r\n!" 4) Ok(("Wiki", True, True)) } @test fn taking_hands_out_data_as_it_is_decoded_under_one_limit :: { let feed = fn d text { result.expect (response.feed d (bytes.from_string text)) text } let d = feed (response.dechunker 6) "4\r\nWi" let (first, d) = response.take d assert_equal (bytes.to_string_lossy first) "Wi" let d = feed d "ki\r\n5\r\npedia\r\n" let (second, d) = response.take d // The limit counts what was taken: 6 bytes in all. assert_equal (bytes.to_string_lossy second) "kipe" assert (response.is_done d) "cut at the limit" let (rest, cut) = response.body d assert_equal (bytes.length rest) 0 assert cut "cut" } @test fn malformed_chunked_bodies :: { let bad = fn text { result.is_error (decoded text 100) } assert (bad "x\r\n") "bad xrn" assert (bad "\r\n") "bad rn" assert (bad "-1\r\n") "bad -1rn" assert (bad "1000000000000000\r\n") "bad 1000000000000000rn" assert (bad "3\r\nabcd\r\n") "bad 3rnabcdrn" assert (bad "3\r\nabc0\r\n\r\n") "bad 3rnabc0rnrn" assert (bad (string.repeat "1" 5000)) "bad (string.repeat 1 5000)" assert (bad ("0\r\n" <> string.repeat "X" 5000)) "bad (0rn <> string.repeat X 5000)" } // ---- properties ---------------------------------------------------------------- fn hex :: n: Int -> String { let digits = "0123456789abcdef" let last = string.slice digits (n % 16) (n % 16 + 1) if n < 16 { last } else { hex (n / 16) <> last } } /// `body` in chunks of the given sizes (the rest in one more chunk), /// then the last chunk, and maybe a trailer. fn chunked :: body: Bytes sizes: List trailer: Bool -> Bytes { let frames = list.flat_map (cut body 0 sizes) fn p { [ bytes.from_string (hex (bytes.length p) <> "\r\n") , p , bytes.from_string "\r\n" ] } let last = if trailer { "0\r\nX-T: 1\r\n\r\n" } else { "0\r\n\r\n" } bytes.concat_all (list.append frames [bytes.from_string last]) } fn cut :: body: Bytes at: Int sizes: List -> List { let n = bytes.length body if at >= n { [] } else { match sizes { [size, ..rest] -> [ bytes.slice body at (at + size) , ..cut body (at + size) rest ] , [] -> [bytes.slice body at n] } } } /// `data` fed in pieces ending at `splits`. fn fed :: d: Dechunker data: Bytes at: Int splits: List -> Result { match splits { [] -> response.feed d (bytes.slice data at (bytes.length data)) , [end, ..rest] -> { use d <- result.try (response.feed d (bytes.slice data at end)) fed d data end rest } } } @derive Debug type Case { Case( body: Bytes , sizes: List , trailer: Bool , splits: List , max: Int ) } fn any_case :: -> Case / { let body = bytes.from_list ( gen.list ~min: 0 ~max: 200 fn { gen.pick [13, 10, 48, 59, 0, 255, gen.int ~low: 0 ~high: 255] } ) let sizes = gen.list ~min: 0 ~max: 6 fn { gen.int ~low: 1 ~high: 40 } let trailer = gen.bool () let encoded = bytes.length (chunked body sizes trailer) let splits = list.sort (gen.list ~min: 0 ~max: 8 fn { gen.int ~low: 0 ~high: encoded }) Case(body, sizes, trailer, splits, gen.int ~low: 0 ~high: 250) } @test fn decoding_undoes_encoding_at_any_split :: -> () / { check.property ~runs: 400 any_case fn c { let encoded = chunked c.body c.sizes c.trailer match fed (response.dechunker 1000) encoded 0 c.splits { Ok(d) -> response.is_done d && response.body d == (c.body, False) , Error(_) -> False } } } @test fn a_body_is_cut_at_the_limit :: -> () / { check.property ~runs: 400 any_case fn c { let encoded = chunked c.body c.sizes c.trailer let n = bytes.length c.body match fed (response.dechunker c.max) encoded 0 c.splits { Ok(d) -> response.is_done d && if n > c.max { response.body d == (bytes.slice c.body 0 c.max, True) } else { response.body d == (c.body, False) } , Error(_) -> False } } } @test fn a_prefix_is_never_done_and_never_wrong :: -> () / { check.property ~runs: 300 any_case fn c { let encoded = chunked c.body c.sizes c.trailer let end = match c.splits { [s, ..] -> s, [] -> 0 } let short = bytes.length encoded - 1 let prefix = bytes.slice encoded 0 (if end < short { end } else { short }) match response.feed (response.dechunker 1000) prefix { Ok(d) -> { let (body, _) = response.body d !response.is_done d && bytes.slice c.body 0 (bytes.length body) == body } , Error(_) -> False } } }