test {
  let client = @req.Client::new()
  assert_eq(client.cookies().map(jar => jar.length()), Some(0))
  client.close()
}

• base_url: prefixed to relative URLs; a call's URL is appended to it with one /, so "/users" and "users" both land under its path.
• headers: sent with every call, after User-Agent: gaato-req/<version>, which a User-Agent here replaces.
• params: query parameters added to every call.
• auth: sets Authorization on calls that do not set it themselves.
• timeout: milliseconds one exchange may take, 30 s by default: up to the whole response, or for a streamed one up to its head and then each read of its body.
• max_body_bytes: the largest body buffered, 64 MiB by default, counted after decoding; None lifts it. The default transport applies it to each call; Response::read applies it to a streamed body.
• steps: links of the chain around the transport, the first outermost; they see the call's first request and its final response, before redirects, retries and auth.
• retry: when a call is sent again, Retry::new() by default: up to 3 retries of idempotent methods on 408, 429, 500, 502, 503, 504 and transport failures, of any method when nothing was sent; Retry::none() turns it off.
• follow_redirects: follows 301, 302, 303, 307 and 308 responses, at most max_redirects (10) in a row, as gaato/http's follow_redirects does: 303, and 301 or 302 after POST, turn into GET without the body; Authorization, Cookie and Proxy-Authorization are dropped when the origin changes; https to http is refused. On by default; each call can turn it off or on. On JS, fetch follows redirects before the client sees them.
• cookies: by default the client keeps cookies in a jar of its own on its clock (Client::cookies), at most 50 per domain and 3000 in all, applied on every redirect hop. Jar(jar) uses jar instead, Off keeps none.
• transport: replaces the default AsyncTransport of gaato/http-async.
• clock: measures timeout and elapsed, and waits between retries.
• random: values in [0, 1) for retry jitter, Digest client nonces and multipart boundaries; host randomness by default.

• connect_timeout, write_timeout, read_timeout, pool_timeout: milliseconds for making a connection, sending the request, waiting for each read of the response, and waiting for a free connection. Unset, only timeout applies.
• max_connections, max_connections_per_origin: open connections in all and to one origin; a call beyond them waits for one to be free. Unset, gaato/http-async's defaults apply.
• max_idle_per_origin: connections kept open between calls, per origin.
• proxy: an http:// or https:// proxy URL, credentials optional, for every call. Without it, trust_env (on by default) reads HTTP_PROXY, HTTPS_PROXY, ALL_PROXY and NO_PROXY.

test {
  let client = @req.Client::new(
    base_url="https://api.example.com/v1",
    headers=[("Accept", "application/json")],
    auth=Bearer("token"),
  )
  client.close()
}

• url is joined to base_url, then parsed and normalised as Url does; one that is not an absolute http or https URL is refused before anything is sent. Credentials in it (user:pass@) are taken out of the URL and sent as Basic Authorization, in place of the client's auth, unless the call sets Authorization itself.
• params are added to the URL's query, after the client's; a name given here replaces the client's parameters of that name.
• headers replace the client's headers of the same names.
• At most one body: content (bytes, no Content-Type), text (text/plain; charset=utf-8), data (a URL-encoded form), files (multipart/form-data), json (compact application/json) or body_stream (sent as it is read, with Content-Length when body_length gives it and chunked otherwise). A Content-Type in the headers wins over the implied one. A body that streams, including files made with Part::file_stream, is sent at most once: retries and redirects that would send it again stop instead.
• timeout and retry replace the client's for this call.
• follow_redirects replaces the client's for this call. The response carries the redirects followed in history and the final URL in url.

async test {
  let client = @req.Client::new(
    transport=@req.MockTransport::new(_ => {
      status: 200,
      headers: @http.Headers::from_array([("Content-Type", "text/event-stream")]),
      body: b"id: 7\ndata: hello\n\n",
    }),
  )
  let seen = []
  client.sse("GET", "https://example.com/events", event => seen.push(event))
  assert_eq(seen.map(event => (event.data, event.id)), [("hello", Some("7"))])
}

async test {
  let client = @req.Client::new(
    transport=@req.MockTransport::new(_ => {
      status: 200,
      headers: @http.Headers::new(),
      body: b"line one",
    }),
  )
  let size = client.stream("GET", "https://example.com/export", response => {
    let mut size = 0
    response.each_chunk(chunk => size += chunk.length())
    size
  })
  assert_eq(size, 8)
}

async test {
  let client = @req.Client::new(
    transport=@req.MockTransport::new(_ => {
      status: 200,
      headers: @http.Headers::from_array([("Content-Type", "text/event-stream")]),
      body: b"data: one\n\nevent: done\ndata: two\n\n",
    }),
  )
  let seen = []
  client.stream("GET", "https://example.com/events", response => {
    response.each_event(event => seen.push("\{event.event} \{event.data}"))
  })
  assert_eq(seen, ["message one", "done two"])
}

async test {
  let client = @req.Client::new(
    transport=@req.MockTransport::new(_ => {
      status: 200,
      headers: @http.Headers::new(),
      body: b"{\"n\":1}\n{\"n\":2}\n",
    }),
  )
  let lines = []
  client.stream("GET", "https://example.com/feed.ndjson", response => {
    response.each_line(line => lines.push(line))
  })
  assert_eq(lines, ["{\"n\":1}", "{\"n\":2}"])
}

test {
  let request = @http.Request::get("https://example.com/")
  let response = @req.Response::new(200, request, content=b"cached")
  assert_eq(response.text(), "cached")
  assert_eq(response.url, "https://example.com/")
}

• max_retries: sends after the first, 3 by default.
• statuses: response statuses worth another try, by default 408, 429, 500, 502, 503 and 504.
• methods: methods sent again after such a status or a Timeout or Network failure, by default GET, HEAD, OPTIONS, PUT, DELETE and TRACE.
• max_retry_after: the longest Retry-After honoured, in milliseconds, 60 s by default; a server asking for more gets no retry.
• base_delay, max_delay: milliseconds of the backoff, 1 s and 30 s by default.