ooni-probe-cli/internal/netxlite/http3_test.go
Simone Basso b78b9aca51
refactor(datafmt): use "udp" instead of "quic" (#946)
This diff changes the data format to prefer "udp" to "quic" everywhere we were previously using "quic".

Previously, the code inconsistently used "quic" for operations where we knew we were using "quic" and "udp" otherwise (e.g., for generic operations like ReadFrom).

While it would be more correct to say that a specific HTTP request used "quic" rather than "udp", using "udp" consistently allows one to see how distinct events such as ReadFrom and an handshake all refer to the same address, port, and protocol triple. Therefore, this change makes it easier to programmatically unpack a single measurement and create endpoint stats.

Before implementing this change, I discussed the problem with @hellais who mentioned that ooni/data is not currently using the "quic" string anywhere. I know that ooni/pipeline also doesn't rely on this string. The only users of this feature have been research-oriented experiments such as urlgetter, for which such a change would actually be acceptable.

See https://github.com/ooni/probe/issues/2238 and https://github.com/ooni/spec/pull/262.
2022-09-08 17:19:59 +02:00

141 lines
3.8 KiB
Go

package netxlite
import (
"crypto/tls"
"errors"
"net/http"
"testing"
"github.com/lucas-clemente/quic-go/http3"
"github.com/ooni/probe-cli/v3/internal/model"
"github.com/ooni/probe-cli/v3/internal/model/mocks"
nlmocks "github.com/ooni/probe-cli/v3/internal/netxlite/mocks"
)
func TestHTTP3Transport(t *testing.T) {
t.Run("CloseIdleConnections", func(t *testing.T) {
var (
calledHTTP3 bool
calledDialer bool
)
txp := &http3Transport{
child: &nlmocks.HTTP3RoundTripper{
MockClose: func() error {
calledHTTP3 = true
return nil
},
},
dialer: &mocks.QUICDialer{
MockCloseIdleConnections: func() {
calledDialer = true
},
},
}
txp.CloseIdleConnections()
if !calledHTTP3 || !calledDialer {
t.Fatal("not called")
}
})
t.Run("Network", func(t *testing.T) {
txp := &http3Transport{}
if txp.Network() != "udp" {
t.Fatal("unexpected .Network return value")
}
})
t.Run("RoundTrip", func(t *testing.T) {
expected := errors.New("mocked error")
txp := &http3Transport{
child: &nlmocks.HTTP3RoundTripper{
MockRoundTrip: func(req *http.Request) (*http.Response, error) {
return nil, expected
},
},
}
resp, err := txp.RoundTrip(&http.Request{})
if !errors.Is(err, expected) {
t.Fatal("unexpected err", err)
}
if resp != nil {
t.Fatal("unexpected resp")
}
})
}
// verifyTypeChainForHTTP3 helps to verify type chains for HTTP3.
//
// Arguments:
//
// - t is the MANDATORY testing ref;
//
// - txp is the MANDATORY HTTP transport to verify;
//
// - underlyingLogger is the MANDATORY logger we expect to find;
//
// - qd is the OPTIONAL QUIC dialer: if not nil, we expect to
// see this value as the QUIC dialer, otherwise we will check the
// type chain of the real dialer;
//
// - config is the MANDATORY TLS config: we'll always check
// whether the TLSClientConfig is equal to this value: passing
// nil here means we expect to see nil in the object;
//
// - reso is the OPTIONAL resolver: if present and the qd is
// nil, we'll unwrap the QUIC dialer and check whether we have
// this resolver as the underlying resolver.
func verifyTypeChainForHTTP3(t *testing.T, txp model.HTTPTransport,
underlyingLogger model.DebugLogger, qd model.QUICDialer,
config *tls.Config, reso model.Resolver) {
logger := txp.(*httpTransportLogger)
if logger.Logger != underlyingLogger {
t.Fatal("invalid logger")
}
ew := logger.HTTPTransport.(*httpTransportErrWrapper)
h3txp := ew.HTTPTransport.(*http3Transport)
if qd != nil && h3txp.dialer != qd {
t.Fatal("invalid dialer")
}
if qd == nil {
qdlog := h3txp.dialer.(*quicDialerLogger)
qdr := qdlog.Dialer.(*quicDialerResolver)
if reso != nil && qdr.Resolver != reso {
t.Fatal("invalid resolver")
}
}
h3 := h3txp.child.(*http3.RoundTripper)
if h3.Dial == nil {
t.Fatal("invalid Dial")
}
if !h3.DisableCompression {
t.Fatal("invalid DisableCompression")
}
if h3.TLSClientConfig != config {
t.Fatal("invalid TLSClientConfig")
}
}
func TestNewHTTP3Transport(t *testing.T) {
t.Run("creates the correct type chain", func(t *testing.T) {
qd := &mocks.QUICDialer{}
config := &tls.Config{}
txp := NewHTTP3Transport(model.DiscardLogger, qd, config)
verifyTypeChainForHTTP3(t, txp, model.DiscardLogger, qd, config, nil)
})
}
func TestNewHTTP3TransportStdlib(t *testing.T) {
t.Run("creates the correct type chain", func(t *testing.T) {
txp := NewHTTP3TransportStdlib(model.DiscardLogger)
verifyTypeChainForHTTP3(t, txp, model.DiscardLogger, nil, nil, nil)
})
}
func TestNewHTTP3TransportWithResolver(t *testing.T) {
t.Run("creates the correct type chain", func(t *testing.T) {
reso := &mocks.Resolver{}
txp := NewHTTP3TransportWithResolver(model.DiscardLogger, reso)
verifyTypeChainForHTTP3(t, txp, model.DiscardLogger, nil, nil, reso)
})
}