#moonhttp

// An event stream: the frames as written, and the events an EventSource
// dispatches from them.
let received = "id: 1\nevent: tick\ndata: {\"seq\":1}\n\n"
let events = @sse.events(received)
assert_eq(events[0].data, "{\"seq\":1}")
assert_eq(events[0].kind, Some("tick"))
assert_eq(
  @sse.Event::new(data="{\"seq\":1}", kind="tick", id="1").encode(),
  "id: 1\nevent: tick\ndata: {\"seq\":1}\n\n",
)

// A cookie set on the way out, and read on the way back.
assert_eq(
  @cookie.Cookie::new("sid", "s3cr3t", http_only=true, secure=true).encode(),
  "sid=s3cr3t; Path=/; Secure; HttpOnly; SameSite=Lax",
)
assert_eq(@cookie.get("sid=s3cr3t; theme=dark", "theme"), Some("dark"))

// A posted form, whichever way the browser encoded it.
let form = @form.parse(
  b"name=ada&lang=mo"[:],
  "application/x-www-form-urlencoded"[:],
)
assert_eq(form.field("name"), Some("ada"))

// A second request for something that has not changed.
let etag = @conditional.hash(b"hello"[:], digest=@sha2.Hasher::new())
let ask = @conditional.Ask::read([("If-None-Match", etag.encode())])
assert_eq(ask.evaluate(verb="GET", etag~), @conditional.Verdict::Fresh)

// A frame is a byte layout: two header octets, a mask key, then the payload.
let frame : @ws.Frame = { fin: true, opcode: @ws.Opcode::Text, payload: b"hi" }
assert_eq(
  frame.encode(mask=b"\x01\x02\x03\x04"),
  b"\x81\x82\x01\x02\x03\x04\x69\x6b",
)

// A message compressed the way RFC 7692 asks, and the bit that says so.
let terms = @pmd.Extension::agree(
  @pmd.offers("permessage-deflate; client_max_window_bits"[:])[:],
)
assert_eq(terms is Some(_), true)
let (wire, compressed) = @pmd.Writer::new(extension=terms.unwrap()).frame(
  @ws.Opcode::Text,
  b"Hello"[:],
)
assert_eq(compressed, true)
assert_eq(wire.payload, b"\xf2H\xcd\xc9\xc9\x07\x00")

// The same WebSocket over HTTP/3: the extended CONNECT of RFC 9220, allowed by
// one setting the server sends and answered with 200 or 501.
let connect : @http3.Request = {
  meth: "CONNECT",
  scheme: "https",
  authority: "example.com",
  path: "/chat",
  protocol: "websocket",
  headers: [@header.Header::of("sec-websocket-version", "13")],
  body: b"",
}
let settings = @http3.Settings::new(
  4096, 16384, 100, enable_connect_protocol=true,
)
assert_eq(@http3.Upgrade::of(connect, settings~) is @http3.Upgrade::Accept, true)
assert_eq(@http3.websocket_response(connect, settings~).status, "200")

// A stored response, and what may be done with it.
let sent = @moondate.http("Sun, 06 Nov 1994 08:49:37 GMT")
let stored = @cache.Entry::read(
  status=200,
  headers=[("Cache-Control", "max-age=60")],
  request=[],
  sent~,
  received=sent,
)
assert_eq(stored.lifetime(), Some(60))

// And where a 302 sends the request next, with which method.
let from = @moonurl.Url::decode("https://example.com/a") catch {
  _ => abort("not a URL")
}
let step = @client.follow(
  status=302,
  location="/next",
  from~,
  verb=@method.Method::Post,
  visited=[from][:],
)
assert_eq(step.url.encode(), "https://example.com/next")
assert_eq(step.verb, @method.Method::Get)

moon run src/examples/04-ws-handshake       moon run src/examples/09-http3-frames
moon run src/examples/05-ws-frame           moon run src/examples/10-http3-message
moon run src/examples/06-qpack-primitives   moon run src/examples/11-http3-conn
moon run src/examples/07-qpack-field        moon run src/examples/12-range
moon run src/examples/08-qpack-dynamic      moon run src/examples/13-conditional
moon run src/examples/14-ws-compressed      moon run src/examples/15-cache

#Packages

#One vocabulary

#Configuration

// A bound belongs to an endpoint. Either form names one.
let body = b"name=ada&lang=mo"[:]
let content_type = "application/x-www-form-urlencoded"
let small = @moonmime.Limits::new(parts=8, part_size=64 * 1024)
let widened = { ..@moonmime.limits, parts: 8 }
assert_eq(small.parts, widened.parts)

let limited = @form.parse(body, content_type, limits=small)
assert_eq(limited.field("lang"), Some("mo"))

// By default a body that is not a form is an empty form, and a multipart body
// that stops making sense gives up the parts it read. `strict` says so instead.
let asked = @form.parse(body, content_type, strict=true) catch {
  _ => abort("this body is a form")
}
assert_eq(asked.field("name"), Some("ada"))

// The space after the colon is optional in the format and universal on the wire.
assert_eq(@sse.Event::of("hello").encode(), "data: hello\n\n")
assert_eq(@sse.Event::of("hello").encode(space=false), "data:hello\n\n")

// A writer can leave a message under this many octets alone, which is worth
// doing: a compressed "OK" is longer than "OK".
let (short, compressed) = @pmd.Writer::new(threshold=64).frame(
  @ws.Opcode::Text,
  b"OK"[:],
)
assert_eq(compressed, false)
assert_eq(short.payload, b"OK")

#Downloads

#Framing, not transport

#Refusals that close a connection

// A DATA frame where a request stream still owes its HEADERS.
let wire = b"\x00\x04body"
let reader = @http3.Incoming::new(limit=16384)   // SETTINGS_MAX_FIELD_SECTION_SIZE
let mut closed : @http3.Code? = None
let parts = reader.feed(wire) catch {
  e => {
    // e.code() is what the connection closes with; e.to_string() names the rule.
    closed = Some(e.code())
    []
  }
}
assert_eq(closed, Some(@http3.FrameUnexpected))
assert_eq(parts.length(), 0)

#What is checked

#What lives elsewhere

#Install

moon add moonbitstack/moonhttp

#Licence