testsupport

type ALPN int

type Action int

type Allocs struct {
	// Mallocs is the number of heap objects allocated
	// (runtime.MemStats.Mallocs).
	Mallocs uint64
	// Bytes is the number of heap bytes allocated
	// (runtime.MemStats.TotalAlloc).
	Bytes uint64
}

type BodySum [sha256.Size]byte

type ConnInfo struct {
	// Index is the connection's position in accept order, from 0.
	Index int
	// Protocol is the ALPN protocol negotiated ("h2", "http/1.1" or "").
	Protocol string
	// HandshakeErr is the server side's TLS handshake error, if any (for
	// example the refusal behind alert 120 in ALPNHTTP1Only mode).
	HandshakeErr string
	// GoAwaySeq, CloseWriteSeq, PeerClosedSeq and ClosedSeq record how an
	// HTTP/2 connection ended, as numbers of one sequence the server shares
	// across its connections, so they order events without a clock; 0 means
	// the event did not happen. GoAwaySeq is the last GOAWAY frame, taken
	// before it is written; CloseWriteSeq is the server beginning its
	// graceful close ([LoopbackServer.CloseConns], ActionClose, or the end
	// of a connection after GOAWAY once no stream at or below its
	// LastStreamID is left), taken before its close_notify and FIN leave;
	// PeerClosedSeq is the reader reading the end of the client's side;
	// ClosedSeq is the socket's close. 0 < PeerClosedSeq < ClosedSeq shows
	// that the socket closed with nothing the client sent left unread, and
	// CloseWriteSeq < PeerClosedSeq that the server's close came first. The
	// client may close first: net/http closes a connection that GOAWAY ended
	// as soon as its last stream is done, and then PeerClosedSeq precedes
	// CloseWriteSeq, or CloseWriteSeq is 0.
	GoAwaySeq, CloseWriteSeq, PeerClosedSeq, ClosedSeq int64
	// Drained lists the types of the frames the reader read and discarded,
	// answering none, once the graceful close had begun: what the client
	// was still sending when the server's close_notify reached it.
	Drained []string
}

type ErrCode uint32

type FakeAPI struct {
	// contains filtered or unexported fields
}

type FakeH2CServer struct {
	*httptest.Server
	// contains filtered or unexported fields
}

type GatedDialer struct {
	// contains filtered or unexported fields
}

type Guard struct {
	// contains filtered or unexported fields
}

type H2Conn struct {
	// contains filtered or unexported fields
}

type LogRecord struct {
	// Time is the record's time (zero when the logger set none).
	Time time.Time
	// Level is the record's level.
	Level slog.Level
	// Message is the record's message.
	Message string
	// Attrs are the handler's and the record's attributes, flattened.
	Attrs []slog.Attr
}

type LogRecorder struct {
	// contains filtered or unexported fields
}

type LoopbackServer struct {
	// contains filtered or unexported fields
}

type PeerSettings struct {
	// Protocol is the ALPN protocol the TLS handshake negotiated: "h2".
	Protocol string
	// Values holds every setting of the frame by its RFC 9113 name, such as
	// "MAX_CONCURRENT_STREAMS"; a setting the server leaves out keeps its
	// initial value and has no entry (for MAX_CONCURRENT_STREAMS, no limit).
	Values map[string]uint32
	// Handshake is the time from the start of the dial to the end of the
	// TLS handshake; FirstSettings the time from the start of the dial to
	// the arrival of the SETTINGS frame.
	Handshake, FirstSettings time.Duration
}

type Proxy struct {
	// contains filtered or unexported fields
}

type ProxyConnect struct {
	// Conn is the index of the proxy connection it arrived on.
	Conn int
	// Target is the requested authority, such as "example.com:443".
	Target string
	// Status is the status the proxy answered: 200 when the tunnel opened,
	// 502 when the target had no route or could not be dialed, 405 for a
	// method other than CONNECT.
	Status int
}

type ProxyMode int

type RecordedRequest struct {
	// Index is the request's position among all RoundTrip calls, from 0.
	Index int
	// Method is the request method.
	Method string
	// URL is the request URL as a string; empty when the Recorder discards.
	URL string
	// Host is the request's Host (the authority the transport would send).
	Host string
	// Header is a copy of the request header.
	Header http.Header
	// Body is the whole request body, read before RoundTrip returned; nil
	// when the request had none or the Recorder discards bodies.
	Body []byte
	// ContentLength is the request's declared length.
	ContentLength int64
	// HasGetBody reports whether the request carried GetBody, which a
	// transport needs to replay it.
	HasGetBody bool
	// Canceled reports that the request's context was already done, so the
	// Recorder returned the context's error and served no reply.
	Canceled bool
}

type Recorder struct {
	// Replies are served in order; once they run out, the last one repeats.
	Replies []Reply
	// Respond, when set, chooses the reply for each request instead of
	// Replies. It runs on the goroutine that called RoundTrip and gets its
	// own copy of the record, which it may change.
	Respond func(RecordedRequest) Reply
	// Discard drains and closes each request body without keeping it, and
	// keeps only the count of requests, so a steady-state allocation test
	// measures little beyond the response it is handed. Requests then
	// returns nothing and Respond sees a nil Body.
	Discard bool
	// contains filtered or unexported fields
}

type Reply struct {
	// Status is the response status code; zero means 200.
	Status int
	// Header is copied into the response.
	Header http.Header
	// Body is the response body. The Recorder never modifies it.
	Body []byte
	// ContentLength is the length the response declares. Zero means
	// len(Body); -1 declares no length (a chunked body); a value above
	// len(Body) makes the body end with io.ErrUnexpectedEOF after len(Body)
	// bytes, as a connection that closes early would. A declared zero with a
	// non-empty body cannot be expressed.
	ContentLength int64
	// Err, when set, is returned by RoundTrip instead of a response.
	Err error
}

type RoundTripFunc func(*http.Request) (*http.Response, error)

type Routes map[string]string

type SeenRequest struct {
	// Seq is the request's position among all requests seen, from 0.
	Seq int
	// Conn is the index of the connection it arrived on (see ConnInfo).
	Conn int
	// StreamID is the HTTP/2 stream identifier; 0 for HTTP/1.1.
	StreamID uint32
	// Proto is "HTTP/2.0" or "HTTP/1.1".
	Proto string
	// Method, Path and Authority are the request's method, request target
	// and authority (Host).
	Method, Path, Authority string
	// Header holds the regular header fields.
	Header http.Header
	// Action is what the server did with it; always ActionServe for
	// HTTP/1.1. A stream refused for exceeding MaxConcurrentStreams shows
	// ActionRefuse.
	Action Action
	// Dropped reports that the stream ended before the server finished its
	// response: GOAWAY dropped it, the client reset it, or its connection
	// closed. Action keeps what the server chose first, so a stream whose
	// handler had started shows ActionServe and Dropped. The flag is decided
	// when the frame that ends the server's side is cleared for writing: a
	// stream whose final frame was cleared but whose write then failed shows
	// neither Dropped nor a completed response. Always false for HTTP/1.1.
	Dropped bool
}

type ServerConfig struct {
	// ALPN selects the protocols offered in the TLS handshake.
	ALPN ALPN
	// MaxConcurrentStreams, when non-zero, is advertised in the server's
	// SETTINGS frame; a stream that would exceed it is reset with
	// REFUSED_STREAM and counted by [LoopbackServer.OverLimit]. It is each
	// HTTP/2 connection's limit until [H2Conn.SetMaxConcurrentStreams]
	// changes it.
	MaxConcurrentStreams uint32
	// Handler serves every request, HTTP/2 and HTTP/1.1. Nil answers 200 with
	// an empty body. Over HTTP/2 the response carries no Content-Length unless
	// the handler sets one, so a test can declare a length that differs from
	// the body or none at all.
	Handler http.Handler
	// OnStream, when set, chooses what happens to each HTTP/2 stream when its
	// request headers arrive; nil serves every stream. It runs on the
	// connection's reader goroutine, so it must not block; it may call the
	// stream's connection methods (GoAway, Close).
	OnStream func(*Stream) Action
}

type SilentListener struct {
	// contains filtered or unexported fields
}

type Stream struct {
	// Conn is the connection the stream arrived on.
	Conn *H2Conn
	// ID is the stream identifier.
	ID uint32
	// Seq is the stream's position among every request the server has seen,
	// from 0.
	Seq int
	// Method, Path and Authority are the :method, :path and :authority
	// pseudo-headers.
	Method, Path, Authority string
	// Header holds the regular header fields.
	Header http.Header
}