From 1cb820b19d61553f667aecf428ec0d25da42c033 Mon Sep 17 00:00:00 2001 From: Simone Basso Date: Thu, 2 Jun 2022 11:51:21 +0200 Subject: [PATCH] cleanup(netx): remove subpackages and unnecessary code (#788) This pull request consists of several small and obvious cleanups in the netx directory. See https://github.com/ooni/probe/issues/2121 --- .../{resolver/cache.go => cacheresolver.go} | 2 +- .../cache_test.go => cacheresolver_test.go} | 44 ++-- internal/engine/netx/{dialer => }/dialer.go | 13 +- .../engine/netx/{dialer => }/dialer_test.go | 6 +- internal/engine/netx/fake_test.go | 59 ----- .../netx/{httptransport => }/httptransport.go | 15 +- internal/engine/netx/integration_test.go | 89 ------- internal/engine/netx/netx.go | 17 +- internal/engine/netx/netx_internal_test.go | 8 - internal/engine/netx/netx_test.go | 219 ++++++++++++------ internal/engine/netx/resolver/fake_test.go | 128 ---------- .../engine/netx/resolver/genreply_test.go | 76 ------ .../engine/netx/resolver/integration_test.go | 119 ---------- internal/engine/netx/tlsdialer/eof_test.go | 80 ------- internal/engine/netx/tlsdialer/fake_test.go | 71 ------ .../engine/netx/tlsdialer/integration_test.go | 35 --- internal/engine/netx/tlsdialer/tls_test.go | 35 --- 17 files changed, 201 insertions(+), 815 deletions(-) rename internal/engine/netx/{resolver/cache.go => cacheresolver.go} (98%) rename internal/engine/netx/{resolver/cache_test.go => cacheresolver_test.go} (55%) rename internal/engine/netx/{dialer => }/dialer.go (82%) rename internal/engine/netx/{dialer => }/dialer_test.go (90%) delete mode 100644 internal/engine/netx/fake_test.go rename internal/engine/netx/{httptransport => }/httptransport.go (64%) delete mode 100644 internal/engine/netx/integration_test.go delete mode 100644 internal/engine/netx/netx_internal_test.go delete mode 100644 internal/engine/netx/resolver/fake_test.go delete mode 100644 internal/engine/netx/resolver/genreply_test.go delete mode 100644 internal/engine/netx/resolver/integration_test.go delete mode 100644 internal/engine/netx/tlsdialer/eof_test.go delete mode 100644 internal/engine/netx/tlsdialer/fake_test.go delete mode 100644 internal/engine/netx/tlsdialer/integration_test.go delete mode 100644 internal/engine/netx/tlsdialer/tls_test.go diff --git a/internal/engine/netx/resolver/cache.go b/internal/engine/netx/cacheresolver.go similarity index 98% rename from internal/engine/netx/resolver/cache.go rename to internal/engine/netx/cacheresolver.go index 8c4ece7..b00a6b8 100644 --- a/internal/engine/netx/resolver/cache.go +++ b/internal/engine/netx/cacheresolver.go @@ -1,4 +1,4 @@ -package resolver +package netx import ( "context" diff --git a/internal/engine/netx/resolver/cache_test.go b/internal/engine/netx/cacheresolver_test.go similarity index 55% rename from internal/engine/netx/resolver/cache_test.go rename to internal/engine/netx/cacheresolver_test.go index f768c0f..d0ab603 100644 --- a/internal/engine/netx/resolver/cache_test.go +++ b/internal/engine/netx/cacheresolver_test.go @@ -1,17 +1,21 @@ -package resolver_test +package netx import ( "context" "errors" "testing" - "github.com/ooni/probe-cli/v3/internal/engine/netx/resolver" + "github.com/ooni/probe-cli/v3/internal/model/mocks" ) -func TestCacheFailure(t *testing.T) { +func TestCacheResolverFailure(t *testing.T) { expected := errors.New("mocked error") - r := resolver.NewFakeResolverWithExplicitError(expected) - cache := &resolver.CacheResolver{Resolver: r} + r := &mocks.Resolver{ + MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { + return nil, expected + }, + } + cache := &CacheResolver{Resolver: r} addrs, err := cache.LookupHost(context.Background(), "www.google.com") if !errors.Is(err, expected) { t.Fatal("not the error we expected") @@ -24,10 +28,14 @@ func TestCacheFailure(t *testing.T) { } } -func TestCacheHitSuccess(t *testing.T) { +func TestCacheResolverHitSuccess(t *testing.T) { expected := errors.New("mocked error") - r := resolver.NewFakeResolverWithExplicitError(expected) - cache := &resolver.CacheResolver{Resolver: r} + r := &mocks.Resolver{ + MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { + return nil, expected + }, + } + cache := &CacheResolver{Resolver: r} cache.Set("dns.google.com", []string{"8.8.8.8"}) addrs, err := cache.LookupHost(context.Background(), "dns.google.com") if err != nil { @@ -38,9 +46,13 @@ func TestCacheHitSuccess(t *testing.T) { } } -func TestCacheMissSuccess(t *testing.T) { - r := resolver.NewFakeResolverWithResult([]string{"8.8.8.8"}) - cache := &resolver.CacheResolver{Resolver: r} +func TestCacheResolverMissSuccess(t *testing.T) { + r := &mocks.Resolver{ + MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { + return []string{"8.8.8.8"}, nil + }, + } + cache := &CacheResolver{Resolver: r} addrs, err := cache.LookupHost(context.Background(), "dns.google.com") if err != nil { t.Fatal(err) @@ -53,9 +65,13 @@ func TestCacheMissSuccess(t *testing.T) { } } -func TestCacheReadonlySuccess(t *testing.T) { - r := resolver.NewFakeResolverWithResult([]string{"8.8.8.8"}) - cache := &resolver.CacheResolver{Resolver: r, ReadOnly: true} +func TestCacheResolverReadonlySuccess(t *testing.T) { + r := &mocks.Resolver{ + MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { + return []string{"8.8.8.8"}, nil + }, + } + cache := &CacheResolver{Resolver: r, ReadOnly: true} addrs, err := cache.LookupHost(context.Background(), "dns.google.com") if err != nil { t.Fatal(err) diff --git a/internal/engine/netx/dialer/dialer.go b/internal/engine/netx/dialer.go similarity index 82% rename from internal/engine/netx/dialer/dialer.go rename to internal/engine/netx/dialer.go index cf896e2..25693a3 100644 --- a/internal/engine/netx/dialer/dialer.go +++ b/internal/engine/netx/dialer.go @@ -1,7 +1,4 @@ -// Package dialer allows you to create a net.Dialer-compatible -// DialContext-enabled dialer with error wrapping, optional logging, -// optional network-events saving, and optional proxying. -package dialer +package netx import ( "net/url" @@ -12,8 +9,8 @@ import ( "github.com/ooni/probe-cli/v3/internal/tracex" ) -// Config contains the settings for New. -type Config struct { +// dialerConfig contains the settings for New. +type dialerConfig struct { // ContextByteCounting optionally configures context-based // byte counting. By default we don't do that. // @@ -48,8 +45,8 @@ type Config struct { ReadWriteSaver *tracex.Saver } -// New creates a new Dialer from the specified config and resolver. -func New(config *Config, resolver model.Resolver) model.Dialer { +// newDialer creates a new Dialer from the specified config and resolver. +func newDialer(config *dialerConfig, resolver model.Resolver) model.Dialer { var logger model.DebugLogger = model.DiscardLogger if config.Logger != nil { logger = config.Logger diff --git a/internal/engine/netx/dialer/dialer_test.go b/internal/engine/netx/dialer_test.go similarity index 90% rename from internal/engine/netx/dialer/dialer_test.go rename to internal/engine/netx/dialer_test.go index 44eca76..65830b3 100644 --- a/internal/engine/netx/dialer/dialer_test.go +++ b/internal/engine/netx/dialer_test.go @@ -1,4 +1,4 @@ -package dialer +package netx import ( "net/http" @@ -13,7 +13,7 @@ import ( func TestNewCreatesTheExpectedChain(t *testing.T) { saver := &tracex.Saver{} - dlr := New(&Config{ + dlr := newDialer(&dialerConfig{ ContextByteCounting: true, DialSaver: saver, Logger: log.Log, @@ -37,7 +37,7 @@ func TestDialerNewSuccess(t *testing.T) { t.Skip("skip test in short mode") } log.SetLevel(log.DebugLevel) - d := New(&Config{Logger: log.Log}, netxlite.DefaultResolver) + d := newDialer(&dialerConfig{Logger: log.Log}, netxlite.DefaultResolver) txp := &http.Transport{DialContext: d.DialContext} client := &http.Client{Transport: txp} resp, err := client.Get("http://www.google.com") diff --git a/internal/engine/netx/fake_test.go b/internal/engine/netx/fake_test.go deleted file mode 100644 index a0d94d2..0000000 --- a/internal/engine/netx/fake_test.go +++ /dev/null @@ -1,59 +0,0 @@ -package netx - -import ( - "context" - "net" - "net/http" - "time" - - "github.com/ooni/probe-cli/v3/internal/netxlite" -) - -type FakeDialer struct { - Conn net.Conn - Err error -} - -func (d FakeDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { - time.Sleep(10 * time.Microsecond) - return d.Conn, d.Err -} - -func (d FakeDialer) CloseIdleConnections() {} - -type FakeTransport struct { - Err error - Func func(*http.Request) (*http.Response, error) - Resp *http.Response -} - -func (txp FakeTransport) RoundTrip(req *http.Request) (*http.Response, error) { - time.Sleep(10 * time.Microsecond) - if txp.Func != nil { - return txp.Func(req) - } - if req.Body != nil { - netxlite.ReadAllContext(req.Context(), req.Body) - req.Body.Close() - } - if txp.Err != nil { - return nil, txp.Err - } - txp.Resp.Request = req // non thread safe but it doesn't matter - return txp.Resp, nil -} - -func (txp FakeTransport) CloseIdleConnections() {} - -type FakeBody struct { - Err error -} - -func (fb FakeBody) Read(p []byte) (int, error) { - time.Sleep(10 * time.Microsecond) - return 0, fb.Err -} - -func (fb FakeBody) Close() error { - return nil -} diff --git a/internal/engine/netx/httptransport/httptransport.go b/internal/engine/netx/httptransport.go similarity index 64% rename from internal/engine/netx/httptransport/httptransport.go rename to internal/engine/netx/httptransport.go index 6fb8c07..c794a36 100644 --- a/internal/engine/netx/httptransport/httptransport.go +++ b/internal/engine/netx/httptransport.go @@ -1,5 +1,4 @@ -// Package httptransport contains HTTP transport extensions. -package httptransport +package netx import ( "crypto/tls" @@ -8,32 +7,32 @@ import ( "github.com/ooni/probe-cli/v3/internal/netxlite" ) -// Config contains the configuration required for constructing an HTTP transport -type Config struct { +// httpTransportConfig contains the configuration required for constructing an HTTP transport +type httpTransportConfig struct { Dialer model.Dialer QUICDialer model.QUICDialer TLSDialer model.TLSDialer TLSConfig *tls.Config } -// NewHTTP3Transport creates a new HTTP3Transport instance. +// newHTTP3Transport creates a new HTTP3Transport instance. // // Deprecation warning // // New code should use netxlite.NewHTTP3Transport instead. -func NewHTTP3Transport(config Config) model.HTTPTransport { +func newHTTP3Transport(config httpTransportConfig) model.HTTPTransport { // Rationale for using NoLogger here: previously this code did // not use a logger as well, so it's fine to keep it as is. return netxlite.NewHTTP3Transport(model.DiscardLogger, config.QUICDialer, config.TLSConfig) } -// NewSystemTransport creates a new "system" HTTP transport. That is a transport +// newSystemTransport creates a new "system" HTTP transport. That is a transport // using the Go standard library with custom dialer and TLS dialer. // // Deprecation warning // // New code should use netxlite.NewHTTPTransport instead. -func NewSystemTransport(config Config) model.HTTPTransport { +func newSystemTransport(config httpTransportConfig) model.HTTPTransport { return netxlite.NewOOHTTPBaseTransport(config.Dialer, config.TLSDialer) } diff --git a/internal/engine/netx/integration_test.go b/internal/engine/netx/integration_test.go deleted file mode 100644 index 19e8dba..0000000 --- a/internal/engine/netx/integration_test.go +++ /dev/null @@ -1,89 +0,0 @@ -package netx_test - -import ( - "context" - "errors" - "net/http" - "testing" - - "github.com/apex/log" - "github.com/ooni/probe-cli/v3/internal/bytecounter" - "github.com/ooni/probe-cli/v3/internal/engine/netx" - "github.com/ooni/probe-cli/v3/internal/netxlite" - "github.com/ooni/probe-cli/v3/internal/tracex" -) - -func TestSuccess(t *testing.T) { - if testing.Short() { - t.Skip("skip test in short mode") - } - log.SetLevel(log.DebugLevel) - counter := bytecounter.New() - config := netx.Config{ - BogonIsError: true, - ByteCounter: counter, - CacheResolutions: true, - ContextByteCounting: true, - DialSaver: &tracex.Saver{}, - HTTPSaver: &tracex.Saver{}, - Logger: log.Log, - ReadWriteSaver: &tracex.Saver{}, - ResolveSaver: &tracex.Saver{}, - TLSSaver: &tracex.Saver{}, - } - txp := netx.NewHTTPTransport(config) - client := &http.Client{Transport: txp} - resp, err := client.Get("https://www.google.com") - if err != nil { - t.Fatal(err) - } - if _, err = netxlite.ReadAllContext(context.Background(), resp.Body); err != nil { - t.Fatal(err) - } - if err = resp.Body.Close(); err != nil { - t.Fatal(err) - } - if counter.Sent.Load() <= 0 { - t.Fatal("no bytes sent?!") - } - if counter.Received.Load() <= 0 { - t.Fatal("no bytes received?!") - } - if ev := config.DialSaver.Read(); len(ev) <= 0 { - t.Fatal("no dial events?!") - } - if ev := config.HTTPSaver.Read(); len(ev) <= 0 { - t.Fatal("no HTTP events?!") - } - if ev := config.ReadWriteSaver.Read(); len(ev) <= 0 { - t.Fatal("no R/W events?!") - } - if ev := config.ResolveSaver.Read(); len(ev) <= 0 { - t.Fatal("no resolver events?!") - } - if ev := config.TLSSaver.Read(); len(ev) <= 0 { - t.Fatal("no TLS events?!") - } -} - -func TestBogonResolutionNotBroken(t *testing.T) { - saver := new(tracex.Saver) - r := netx.NewResolver(netx.Config{ - BogonIsError: true, - DNSCache: map[string][]string{ - "www.google.com": {"127.0.0.1"}, - }, - ResolveSaver: saver, - Logger: log.Log, - }) - addrs, err := r.LookupHost(context.Background(), "www.google.com") - if !errors.Is(err, netxlite.ErrDNSBogon) { - t.Fatal("not the error we expected") - } - if err.Error() != netxlite.FailureDNSBogonError { - t.Fatal("error not correctly wrapped") - } - if len(addrs) > 0 { - t.Fatal("expected no addresses here") - } -} diff --git a/internal/engine/netx/netx.go b/internal/engine/netx/netx.go index 8d80a82..a5048b3 100644 --- a/internal/engine/netx/netx.go +++ b/internal/engine/netx/netx.go @@ -31,9 +31,6 @@ import ( "net/url" "github.com/ooni/probe-cli/v3/internal/bytecounter" - "github.com/ooni/probe-cli/v3/internal/engine/netx/dialer" - "github.com/ooni/probe-cli/v3/internal/engine/netx/httptransport" - "github.com/ooni/probe-cli/v3/internal/engine/netx/resolver" "github.com/ooni/probe-cli/v3/internal/model" "github.com/ooni/probe-cli/v3/internal/netxlite" "github.com/ooni/probe-cli/v3/internal/tracex" @@ -85,10 +82,10 @@ func NewResolver(config Config) model.Resolver { Resolver: r, } if config.CacheResolutions { - r = &resolver.CacheResolver{Resolver: r} + r = &CacheResolver{Resolver: r} } if config.DNSCache != nil { - cache := &resolver.CacheResolver{Resolver: r, ReadOnly: true} + cache := &CacheResolver{Resolver: r, ReadOnly: true} for key, values := range config.DNSCache { cache.Set(key, values) } @@ -113,7 +110,7 @@ func NewDialer(config Config) model.Dialer { if config.FullResolver == nil { config.FullResolver = NewResolver(config) } - return dialer.New(&dialer.Config{ + return newDialer(&dialerConfig{ ContextByteCounting: config.ContextByteCounting, DialSaver: config.DialSaver, Logger: config.Logger, @@ -175,7 +172,7 @@ func NewHTTPTransport(config Config) model.HTTPTransport { } tInfo := allTransportsInfo[config.HTTP3Enabled] - txp := tInfo.Factory(httptransport.Config{ + txp := tInfo.Factory(httpTransportConfig{ Dialer: config.Dialer, QUICDialer: config.QUICDialer, TLSDialer: config.TLSDialer, TLSConfig: config.TLSConfig}) @@ -195,17 +192,17 @@ func NewHTTPTransport(config Config) model.HTTPTransport { // httpTransportInfo contains the constructing function as well as the transport name type httpTransportInfo struct { - Factory func(httptransport.Config) model.HTTPTransport + Factory func(httpTransportConfig) model.HTTPTransport TransportName string } var allTransportsInfo = map[bool]httpTransportInfo{ false: { - Factory: httptransport.NewSystemTransport, + Factory: newSystemTransport, TransportName: "tcp", }, true: { - Factory: httptransport.NewHTTP3Transport, + Factory: newHTTP3Transport, TransportName: "quic", }, } diff --git a/internal/engine/netx/netx_internal_test.go b/internal/engine/netx/netx_internal_test.go deleted file mode 100644 index 9784316..0000000 --- a/internal/engine/netx/netx_internal_test.go +++ /dev/null @@ -1,8 +0,0 @@ -package netx - -import "crypto/x509" - -// DefaultCertPool allows tests to access the default cert pool. -func DefaultCertPool() *x509.CertPool { - return defaultCertPool -} diff --git a/internal/engine/netx/netx_test.go b/internal/engine/netx/netx_test.go index e159aa5..fc372db 100644 --- a/internal/engine/netx/netx_test.go +++ b/internal/engine/netx/netx_test.go @@ -1,4 +1,4 @@ -package netx_test +package netx import ( "context" @@ -11,15 +11,13 @@ import ( "github.com/apex/log" "github.com/ooni/probe-cli/v3/internal/bytecounter" - "github.com/ooni/probe-cli/v3/internal/engine/netx" - "github.com/ooni/probe-cli/v3/internal/engine/netx/resolver" "github.com/ooni/probe-cli/v3/internal/model/mocks" "github.com/ooni/probe-cli/v3/internal/netxlite" "github.com/ooni/probe-cli/v3/internal/tracex" ) func TestNewResolverVanilla(t *testing.T) { - r := netx.NewResolver(netx.Config{}) + r := NewResolver(Config{}) ir, ok := r.(*netxlite.ResolverIDNA) if !ok { t.Fatal("not the resolver we expected") @@ -39,7 +37,7 @@ func TestNewResolverVanilla(t *testing.T) { } func TestNewResolverSpecificResolver(t *testing.T) { - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ BaseResolver: &netxlite.BogonResolver{ // not initialized because it doesn't matter in this context }, @@ -63,7 +61,7 @@ func TestNewResolverSpecificResolver(t *testing.T) { } func TestNewResolverWithBogonFilter(t *testing.T) { - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ BogonIsError: true, }) ir, ok := r.(*netxlite.ResolverIDNA) @@ -89,7 +87,7 @@ func TestNewResolverWithBogonFilter(t *testing.T) { } func TestNewResolverWithLogging(t *testing.T) { - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ Logger: log.Log, }) ir, ok := r.(*netxlite.ResolverIDNA) @@ -119,7 +117,7 @@ func TestNewResolverWithLogging(t *testing.T) { func TestNewResolverWithSaver(t *testing.T) { saver := new(tracex.Saver) - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ ResolveSaver: saver, }) ir, ok := r.(*netxlite.ResolverIDNA) @@ -148,7 +146,7 @@ func TestNewResolverWithSaver(t *testing.T) { } func TestNewResolverWithReadWriteCache(t *testing.T) { - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ CacheResolutions: true, }) ir, ok := r.(*netxlite.ResolverIDNA) @@ -159,7 +157,7 @@ func TestNewResolverWithReadWriteCache(t *testing.T) { if !ok { t.Fatal("not the resolver we expected") } - cr, ok := ewr.Resolver.(*resolver.CacheResolver) + cr, ok := ewr.Resolver.(*CacheResolver) if !ok { t.Fatal("not the resolver we expected") } @@ -177,7 +175,7 @@ func TestNewResolverWithReadWriteCache(t *testing.T) { } func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) { - r := netx.NewResolver(netx.Config{ + r := NewResolver(Config{ DNSCache: map[string][]string{ "dns.google.com": {"8.8.8.8"}, }, @@ -190,7 +188,7 @@ func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) { if !ok { t.Fatal("not the resolver we expected") } - cr, ok := ewr.Resolver.(*resolver.CacheResolver) + cr, ok := ewr.Resolver.(*CacheResolver) if !ok { t.Fatal("not the resolver we expected") } @@ -211,7 +209,7 @@ func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) { } func TestNewTLSDialerVanilla(t *testing.T) { - td := netx.NewTLSDialer(netx.Config{}) + td := NewTLSDialer(Config{}) rtd, ok := td.(*netxlite.TLSDialerLegacy) if !ok { t.Fatal("not the TLSDialer we expected") @@ -222,7 +220,7 @@ func TestNewTLSDialerVanilla(t *testing.T) { if rtd.Config.NextProtos[0] != "h2" || rtd.Config.NextProtos[1] != "http/1.1" { t.Fatal("invalid Config.NextProtos") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -241,7 +239,7 @@ func TestNewTLSDialerVanilla(t *testing.T) { } func TestNewTLSDialerWithConfig(t *testing.T) { - td := netx.NewTLSDialer(netx.Config{ + td := NewTLSDialer(Config{ TLSConfig: new(tls.Config), }) rtd, ok := td.(*netxlite.TLSDialerLegacy) @@ -251,7 +249,7 @@ func TestNewTLSDialerWithConfig(t *testing.T) { if len(rtd.Config.NextProtos) != 0 { t.Fatal("invalid len(config.NextProtos)") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -270,7 +268,7 @@ func TestNewTLSDialerWithConfig(t *testing.T) { } func TestNewTLSDialerWithLogging(t *testing.T) { - td := netx.NewTLSDialer(netx.Config{ + td := NewTLSDialer(Config{ Logger: log.Log, }) rtd, ok := td.(*netxlite.TLSDialerLegacy) @@ -283,7 +281,7 @@ func TestNewTLSDialerWithLogging(t *testing.T) { if rtd.Config.NextProtos[0] != "h2" || rtd.Config.NextProtos[1] != "http/1.1" { t.Fatal("invalid Config.NextProtos") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -310,7 +308,7 @@ func TestNewTLSDialerWithLogging(t *testing.T) { func TestNewTLSDialerWithSaver(t *testing.T) { saver := new(tracex.Saver) - td := netx.NewTLSDialer(netx.Config{ + td := NewTLSDialer(Config{ TLSSaver: saver, }) rtd, ok := td.(*netxlite.TLSDialerLegacy) @@ -323,7 +321,7 @@ func TestNewTLSDialerWithSaver(t *testing.T) { if rtd.Config.NextProtos[0] != "h2" || rtd.Config.NextProtos[1] != "http/1.1" { t.Fatal("invalid Config.NextProtos") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -349,7 +347,7 @@ func TestNewTLSDialerWithSaver(t *testing.T) { } func TestNewTLSDialerWithNoTLSVerifyAndConfig(t *testing.T) { - td := netx.NewTLSDialer(netx.Config{ + td := NewTLSDialer(Config{ TLSConfig: new(tls.Config), NoTLSVerify: true, }) @@ -363,7 +361,7 @@ func TestNewTLSDialerWithNoTLSVerifyAndConfig(t *testing.T) { if rtd.Config.InsecureSkipVerify != true { t.Fatal("expected true InsecureSkipVerify") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -382,7 +380,7 @@ func TestNewTLSDialerWithNoTLSVerifyAndConfig(t *testing.T) { } func TestNewTLSDialerWithNoTLSVerifyAndNoConfig(t *testing.T) { - td := netx.NewTLSDialer(netx.Config{ + td := NewTLSDialer(Config{ NoTLSVerify: true, }) rtd, ok := td.(*netxlite.TLSDialerLegacy) @@ -398,7 +396,7 @@ func TestNewTLSDialerWithNoTLSVerifyAndNoConfig(t *testing.T) { if rtd.Config.InsecureSkipVerify != true { t.Fatal("expected true InsecureSkipVerify") } - if rtd.Config.RootCAs != netx.DefaultCertPool() { + if rtd.Config.RootCAs != defaultCertPool { t.Fatal("invalid Config.RootCAs") } if rtd.Dialer == nil { @@ -417,7 +415,7 @@ func TestNewTLSDialerWithNoTLSVerifyAndNoConfig(t *testing.T) { } func TestNewVanilla(t *testing.T) { - txp := netx.NewHTTPTransport(netx.Config{}) + txp := NewHTTPTransport(Config{}) if _, ok := txp.(*netxlite.HTTPTransportWrapper); !ok { t.Fatal("not the transport we expected") } @@ -425,8 +423,12 @@ func TestNewVanilla(t *testing.T) { func TestNewWithDialer(t *testing.T) { expected := errors.New("mocked error") - dialer := netx.FakeDialer{Err: expected} - txp := netx.NewHTTPTransport(netx.Config{ + dialer := &mocks.Dialer{ + MockDialContext: func(ctx context.Context, network, address string) (net.Conn, error) { + return nil, expected + }, + } + txp := NewHTTPTransport(Config{ Dialer: dialer, }) client := &http.Client{Transport: txp} @@ -453,7 +455,7 @@ func TestNewWithTLSDialer(t *testing.T) { }, TLSHandshaker: &netxlite.TLSHandshakerConfigurable{}, } - txp := netx.NewHTTPTransport(netx.Config{ + txp := NewHTTPTransport(Config{ TLSDialer: tlsDialer, }) client := &http.Client{Transport: txp} @@ -468,7 +470,7 @@ func TestNewWithTLSDialer(t *testing.T) { func TestNewWithByteCounter(t *testing.T) { counter := bytecounter.New() - txp := netx.NewHTTPTransport(netx.Config{ + txp := NewHTTPTransport(Config{ ByteCounter: counter, }) bctxp, ok := txp.(*bytecounter.HTTPTransport) @@ -484,7 +486,7 @@ func TestNewWithByteCounter(t *testing.T) { } func TestNewWithLogger(t *testing.T) { - txp := netx.NewHTTPTransport(netx.Config{ + txp := NewHTTPTransport(Config{ Logger: log.Log, }) ltxp, ok := txp.(*netxlite.HTTPTransportLogger) @@ -501,7 +503,7 @@ func TestNewWithLogger(t *testing.T) { func TestNewWithSaver(t *testing.T) { saver := new(tracex.Saver) - txp := netx.NewHTTPTransport(netx.Config{ + txp := NewHTTPTransport(Config{ HTTPSaver: saver, }) stxptxp, ok := txp.(*tracex.HTTPTransportSaver) @@ -520,7 +522,7 @@ func TestNewWithSaver(t *testing.T) { } func TestNewDNSClientInvalidURL(t *testing.T) { - dnsclient, err := netx.NewDNSClient(netx.Config{}, "\t\t\t") + dnsclient, err := NewDNSClient(Config{}, "\t\t\t") if err == nil || !strings.HasSuffix(err.Error(), "invalid control character in URL") { t.Fatal("not the error we expected") } @@ -530,7 +532,7 @@ func TestNewDNSClientInvalidURL(t *testing.T) { } func TestNewDNSClientUnsupportedScheme(t *testing.T) { - dnsclient, err := netx.NewDNSClient(netx.Config{}, "antani:///") + dnsclient, err := NewDNSClient(Config{}, "antani:///") if err == nil || err.Error() != "unsupported resolver scheme" { t.Fatal("not the error we expected") } @@ -540,8 +542,8 @@ func TestNewDNSClientUnsupportedScheme(t *testing.T) { } func TestNewDNSClientSystemResolver(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "system:///") + dnsclient, err := NewDNSClient( + Config{}, "system:///") if err != nil { t.Fatal(err) } @@ -552,8 +554,8 @@ func TestNewDNSClientSystemResolver(t *testing.T) { } func TestNewDNSClientEmpty(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "") + dnsclient, err := NewDNSClient( + Config{}, "") if err != nil { t.Fatal(err) } @@ -564,8 +566,8 @@ func TestNewDNSClientEmpty(t *testing.T) { } func TestNewDNSClientPowerdnsDoH(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "doh://powerdns") + dnsclient, err := NewDNSClient( + Config{}, "doh://powerdns") if err != nil { t.Fatal(err) } @@ -580,8 +582,8 @@ func TestNewDNSClientPowerdnsDoH(t *testing.T) { } func TestNewDNSClientGoogleDoH(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "doh://google") + dnsclient, err := NewDNSClient( + Config{}, "doh://google") if err != nil { t.Fatal(err) } @@ -596,8 +598,8 @@ func TestNewDNSClientGoogleDoH(t *testing.T) { } func TestNewDNSClientCloudflareDoH(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "doh://cloudflare") + dnsclient, err := NewDNSClient( + Config{}, "doh://cloudflare") if err != nil { t.Fatal(err) } @@ -613,8 +615,8 @@ func TestNewDNSClientCloudflareDoH(t *testing.T) { func TestNewDNSClientCloudflareDoHSaver(t *testing.T) { saver := new(tracex.Saver) - dnsclient, err := netx.NewDNSClient( - netx.Config{ResolveSaver: saver}, "doh://cloudflare") + dnsclient, err := NewDNSClient( + Config{ResolveSaver: saver}, "doh://cloudflare") if err != nil { t.Fatal(err) } @@ -633,8 +635,8 @@ func TestNewDNSClientCloudflareDoHSaver(t *testing.T) { } func TestNewDNSClientUDP(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "udp://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{}, "udp://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -650,8 +652,8 @@ func TestNewDNSClientUDP(t *testing.T) { func TestNewDNSClientUDPDNSSaver(t *testing.T) { saver := new(tracex.Saver) - dnsclient, err := netx.NewDNSClient( - netx.Config{ResolveSaver: saver}, "udp://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{ResolveSaver: saver}, "udp://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -670,8 +672,8 @@ func TestNewDNSClientUDPDNSSaver(t *testing.T) { } func TestNewDNSClientTCP(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "tcp://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{}, "tcp://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -691,8 +693,8 @@ func TestNewDNSClientTCP(t *testing.T) { func TestNewDNSClientTCPDNSSaver(t *testing.T) { saver := new(tracex.Saver) - dnsclient, err := netx.NewDNSClient( - netx.Config{ResolveSaver: saver}, "tcp://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{ResolveSaver: saver}, "tcp://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -715,8 +717,8 @@ func TestNewDNSClientTCPDNSSaver(t *testing.T) { } func TestNewDNSClientDoT(t *testing.T) { - dnsclient, err := netx.NewDNSClient( - netx.Config{}, "dot://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{}, "dot://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -736,8 +738,8 @@ func TestNewDNSClientDoT(t *testing.T) { func TestNewDNSClientDoTDNSSaver(t *testing.T) { saver := new(tracex.Saver) - dnsclient, err := netx.NewDNSClient( - netx.Config{ResolveSaver: saver}, "dot://8.8.8.8:53") + dnsclient, err := NewDNSClient( + Config{ResolveSaver: saver}, "dot://8.8.8.8:53") if err != nil { t.Fatal(err) } @@ -760,8 +762,8 @@ func TestNewDNSClientDoTDNSSaver(t *testing.T) { } func TestNewDNSCLientDoTWithoutPort(t *testing.T) { - c, err := netx.NewDNSClientWithOverrides( - netx.Config{}, "dot://8.8.8.8", "", "8.8.8.8", "") + c, err := NewDNSClientWithOverrides( + Config{}, "dot://8.8.8.8", "", "8.8.8.8", "") if err != nil { t.Fatal(err) } @@ -771,8 +773,8 @@ func TestNewDNSCLientDoTWithoutPort(t *testing.T) { } func TestNewDNSCLientTCPWithoutPort(t *testing.T) { - c, err := netx.NewDNSClientWithOverrides( - netx.Config{}, "tcp://8.8.8.8", "", "8.8.8.8", "") + c, err := NewDNSClientWithOverrides( + Config{}, "tcp://8.8.8.8", "", "8.8.8.8", "") if err != nil { t.Fatal(err) } @@ -782,8 +784,8 @@ func TestNewDNSCLientTCPWithoutPort(t *testing.T) { } func TestNewDNSCLientUDPWithoutPort(t *testing.T) { - c, err := netx.NewDNSClientWithOverrides( - netx.Config{}, "udp://8.8.8.8", "", "8.8.8.8", "") + c, err := NewDNSClientWithOverrides( + Config{}, "udp://8.8.8.8", "", "8.8.8.8", "") if err != nil { t.Fatal(err) } @@ -793,33 +795,108 @@ func TestNewDNSCLientUDPWithoutPort(t *testing.T) { } func TestNewDNSClientBadDoTEndpoint(t *testing.T) { - _, err := netx.NewDNSClient( - netx.Config{}, "dot://bad:endpoint:53") + _, err := NewDNSClient( + Config{}, "dot://bad:endpoint:53") if err == nil || !strings.Contains(err.Error(), "too many colons in address") { t.Fatal("expected error with bad endpoint") } } func TestNewDNSClientBadTCPEndpoint(t *testing.T) { - _, err := netx.NewDNSClient( - netx.Config{}, "tcp://bad:endpoint:853") + _, err := NewDNSClient( + Config{}, "tcp://bad:endpoint:853") if err == nil || !strings.Contains(err.Error(), "too many colons in address") { t.Fatal("expected error with bad endpoint") } } func TestNewDNSClientBadUDPEndpoint(t *testing.T) { - _, err := netx.NewDNSClient( - netx.Config{}, "udp://bad:endpoint:853") + _, err := NewDNSClient( + Config{}, "udp://bad:endpoint:853") if err == nil || !strings.Contains(err.Error(), "too many colons in address") { t.Fatal("expected error with bad endpoint") } } func TestNewDNSCLientWithInvalidTLSVersion(t *testing.T) { - _, err := netx.NewDNSClientWithOverrides( - netx.Config{}, "dot://8.8.8.8", "", "", "TLSv999") + _, err := NewDNSClientWithOverrides( + Config{}, "dot://8.8.8.8", "", "", "TLSv999") if !errors.Is(err, netxlite.ErrInvalidTLSVersion) { t.Fatalf("not the error we expected: %+v", err) } } + +func TestSuccess(t *testing.T) { + if testing.Short() { + t.Skip("skip test in short mode") + } + log.SetLevel(log.DebugLevel) + counter := bytecounter.New() + config := Config{ + BogonIsError: true, + ByteCounter: counter, + CacheResolutions: true, + ContextByteCounting: true, + DialSaver: &tracex.Saver{}, + HTTPSaver: &tracex.Saver{}, + Logger: log.Log, + ReadWriteSaver: &tracex.Saver{}, + ResolveSaver: &tracex.Saver{}, + TLSSaver: &tracex.Saver{}, + } + txp := NewHTTPTransport(config) + client := &http.Client{Transport: txp} + resp, err := client.Get("https://www.google.com") + if err != nil { + t.Fatal(err) + } + if _, err = netxlite.ReadAllContext(context.Background(), resp.Body); err != nil { + t.Fatal(err) + } + if err = resp.Body.Close(); err != nil { + t.Fatal(err) + } + if counter.Sent.Load() <= 0 { + t.Fatal("no bytes sent?!") + } + if counter.Received.Load() <= 0 { + t.Fatal("no bytes received?!") + } + if ev := config.DialSaver.Read(); len(ev) <= 0 { + t.Fatal("no dial events?!") + } + if ev := config.HTTPSaver.Read(); len(ev) <= 0 { + t.Fatal("no HTTP events?!") + } + if ev := config.ReadWriteSaver.Read(); len(ev) <= 0 { + t.Fatal("no R/W events?!") + } + if ev := config.ResolveSaver.Read(); len(ev) <= 0 { + t.Fatal("no resolver events?!") + } + if ev := config.TLSSaver.Read(); len(ev) <= 0 { + t.Fatal("no TLS events?!") + } +} + +func TestBogonResolutionNotBroken(t *testing.T) { + saver := new(tracex.Saver) + r := NewResolver(Config{ + BogonIsError: true, + DNSCache: map[string][]string{ + "www.google.com": {"127.0.0.1"}, + }, + ResolveSaver: saver, + Logger: log.Log, + }) + addrs, err := r.LookupHost(context.Background(), "www.google.com") + if !errors.Is(err, netxlite.ErrDNSBogon) { + t.Fatal("not the error we expected") + } + if err.Error() != netxlite.FailureDNSBogonError { + t.Fatal("error not correctly wrapped") + } + if len(addrs) > 0 { + t.Fatal("expected no addresses here") + } +} diff --git a/internal/engine/netx/resolver/fake_test.go b/internal/engine/netx/resolver/fake_test.go deleted file mode 100644 index 9c62447..0000000 --- a/internal/engine/netx/resolver/fake_test.go +++ /dev/null @@ -1,128 +0,0 @@ -package resolver - -import ( - "context" - "errors" - "io" - "net" - "time" - - "github.com/ooni/probe-cli/v3/internal/model" - "github.com/ooni/probe-cli/v3/internal/model/mocks" - "github.com/ooni/probe-cli/v3/internal/netxlite" - "github.com/ooni/probe-cli/v3/internal/runtimex" -) - -type FakeDialer struct { - Conn net.Conn - Err error -} - -func (d FakeDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { - time.Sleep(10 * time.Microsecond) - return d.Conn, d.Err -} - -type FakeConn struct { - ReadError error - ReadData []byte - SetDeadlineError error - SetReadDeadlineError error - SetWriteDeadlineError error - WriteError error -} - -func (c *FakeConn) Read(b []byte) (int, error) { - if len(c.ReadData) > 0 { - n := copy(b, c.ReadData) - c.ReadData = c.ReadData[n:] - return n, nil - } - if c.ReadError != nil { - return 0, c.ReadError - } - return 0, io.EOF -} - -func (c *FakeConn) Write(b []byte) (n int, err error) { - if c.WriteError != nil { - return 0, c.WriteError - } - n = len(b) - return -} - -func (*FakeConn) Close() (err error) { - return -} - -func (*FakeConn) LocalAddr() net.Addr { - return &net.TCPAddr{} -} - -func (*FakeConn) RemoteAddr() net.Addr { - return &net.TCPAddr{} -} - -func (c *FakeConn) SetDeadline(t time.Time) (err error) { - return c.SetDeadlineError -} - -func (c *FakeConn) SetReadDeadline(t time.Time) (err error) { - return c.SetReadDeadlineError -} - -func (c *FakeConn) SetWriteDeadline(t time.Time) (err error) { - return c.SetWriteDeadlineError -} - -func NewFakeResolverThatFails() model.Resolver { - return NewFakeResolverWithExplicitError(netxlite.ErrOODNSNoSuchHost) -} - -func NewFakeResolverWithExplicitError(err error) model.Resolver { - runtimex.PanicIfNil(err, "passed nil error") - return &mocks.Resolver{ - MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { - return nil, err - }, - MockNetwork: func() string { - return "fake" - }, - MockAddress: func() string { - return "" - }, - MockCloseIdleConnections: func() { - // nothing - }, - MockLookupHTTPS: func(ctx context.Context, domain string) (*model.HTTPSSvc, error) { - return nil, errors.New("not implemented") - }, - MockLookupNS: func(ctx context.Context, domain string) ([]*net.NS, error) { - return nil, errors.New("not implemented") - }, - } -} - -func NewFakeResolverWithResult(r []string) model.Resolver { - return &mocks.Resolver{ - MockLookupHost: func(ctx context.Context, domain string) ([]string, error) { - return r, nil - }, - MockNetwork: func() string { - return "fake" - }, - MockAddress: func() string { - return "" - }, - MockCloseIdleConnections: func() { - // nothing - }, - MockLookupHTTPS: func(ctx context.Context, domain string) (*model.HTTPSSvc, error) { - return nil, errors.New("not implemented") - }, - MockLookupNS: func(ctx context.Context, domain string) ([]*net.NS, error) { - return nil, errors.New("not implemented") - }, - } -} diff --git a/internal/engine/netx/resolver/genreply_test.go b/internal/engine/netx/resolver/genreply_test.go deleted file mode 100644 index 0901588..0000000 --- a/internal/engine/netx/resolver/genreply_test.go +++ /dev/null @@ -1,76 +0,0 @@ -package resolver - -import ( - "net" - "testing" - - "github.com/miekg/dns" -) - -func GenReplyError(t *testing.T, code int) []byte { - question := dns.Question{ - Name: dns.Fqdn("x.org"), - Qtype: dns.TypeA, - Qclass: dns.ClassINET, - } - query := new(dns.Msg) - query.Id = dns.Id() - query.RecursionDesired = true - query.Question = make([]dns.Question, 1) - query.Question[0] = question - reply := new(dns.Msg) - reply.Compress = true - reply.MsgHdr.RecursionAvailable = true - reply.SetRcode(query, code) - data, err := reply.Pack() - if err != nil { - t.Fatal(err) - } - return data -} - -func GenReplySuccess(t *testing.T, qtype uint16, ips ...string) []byte { - question := dns.Question{ - Name: dns.Fqdn("x.org"), - Qtype: qtype, - Qclass: dns.ClassINET, - } - query := new(dns.Msg) - query.Id = dns.Id() - query.RecursionDesired = true - query.Question = make([]dns.Question, 1) - query.Question[0] = question - reply := new(dns.Msg) - reply.Compress = true - reply.MsgHdr.RecursionAvailable = true - reply.SetReply(query) - for _, ip := range ips { - switch qtype { - case dns.TypeA: - reply.Answer = append(reply.Answer, &dns.A{ - Hdr: dns.RR_Header{ - Name: dns.Fqdn("x.org"), - Rrtype: qtype, - Class: dns.ClassINET, - Ttl: 0, - }, - A: net.ParseIP(ip), - }) - case dns.TypeAAAA: - reply.Answer = append(reply.Answer, &dns.AAAA{ - Hdr: dns.RR_Header{ - Name: dns.Fqdn("x.org"), - Rrtype: qtype, - Class: dns.ClassINET, - Ttl: 0, - }, - AAAA: net.ParseIP(ip), - }) - } - } - data, err := reply.Pack() - if err != nil { - t.Fatal(err) - } - return data -} diff --git a/internal/engine/netx/resolver/integration_test.go b/internal/engine/netx/resolver/integration_test.go deleted file mode 100644 index 822ce35..0000000 --- a/internal/engine/netx/resolver/integration_test.go +++ /dev/null @@ -1,119 +0,0 @@ -package resolver_test - -import ( - "context" - "crypto/tls" - "net" - "net/http" - "testing" - - "github.com/apex/log" - "github.com/ooni/probe-cli/v3/internal/model" - "github.com/ooni/probe-cli/v3/internal/netxlite" -) - -func init() { - log.SetLevel(log.DebugLevel) -} - -func testresolverquick(t *testing.T, reso model.Resolver) { - if testing.Short() { - t.Skip("skip test in short mode") - } - reso = &netxlite.ResolverLogger{ - Logger: log.Log, - Resolver: reso, - } - addrs, err := reso.LookupHost(context.Background(), "dns.google.com") - if err != nil { - t.Fatal(err) - } - if addrs == nil { - t.Fatal("expected non-nil addrs here") - } - var foundquad8 bool - for _, addr := range addrs { - // See https://github.com/ooni/probe-engine/pull/954/checks?check_run_id=1182269025 - if addr == "8.8.8.8" || addr == "2001:4860:4860::8888" { - foundquad8 = true - } - } - if !foundquad8 { - t.Fatalf("did not find 8.8.8.8 in output; output=%+v", addrs) - } -} - -// Ensuring we can handle Internationalized Domain Names (IDNs) without issues -func testresolverquickidna(t *testing.T, reso model.Resolver) { - if testing.Short() { - t.Skip("skip test in short mode") - } - reso = &netxlite.ResolverIDNA{ - Resolver: &netxlite.ResolverLogger{ - Logger: log.Log, - Resolver: reso, - }, - } - addrs, err := reso.LookupHost(context.Background(), "яндекс.рф") - if err != nil { - t.Fatal(err) - } - if addrs == nil { - t.Fatal("expected non-nil addrs here") - } -} - -func TestNewResolverSystem(t *testing.T) { - reso := netxlite.NewResolverSystem() - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverUDPAddress(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverUDPTransport(netxlite.DefaultDialer, "8.8.8.8:53")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverUDPDomain(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverUDPTransport(netxlite.DefaultDialer, "dns.google.com:53")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverTCPAddress(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverTCPTransport(new(net.Dialer).DialContext, "8.8.8.8:53")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverTCPDomain(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverTCPTransport(new(net.Dialer).DialContext, "dns.google.com:53")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverDoTAddress(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverTLSTransport(new(tls.Dialer).DialContext, "8.8.8.8:853")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverDoTDomain(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverTLSTransport(new(tls.Dialer).DialContext, "dns.google.com:853")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} - -func TestNewResolverDoH(t *testing.T) { - reso := netxlite.NewUnwrappedSerialResolver( - netxlite.NewUnwrappedDNSOverHTTPSTransport(http.DefaultClient, "https://cloudflare-dns.com/dns-query")) - testresolverquick(t, reso) - testresolverquickidna(t, reso) -} diff --git a/internal/engine/netx/tlsdialer/eof_test.go b/internal/engine/netx/tlsdialer/eof_test.go deleted file mode 100644 index 56612a3..0000000 --- a/internal/engine/netx/tlsdialer/eof_test.go +++ /dev/null @@ -1,80 +0,0 @@ -package tlsdialer - -import ( - "context" - "crypto/tls" - "io" - "net" - "time" -) - -type EOFDialer struct{} - -func (EOFDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { - time.Sleep(10 * time.Microsecond) - return nil, io.EOF -} - -type EOFConnDialer struct{} - -func (EOFConnDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { - return EOFConn{}, nil -} - -type EOFConn struct { - net.Conn -} - -func (EOFConn) Read(p []byte) (int, error) { - time.Sleep(10 * time.Microsecond) - return 0, io.EOF -} - -func (EOFConn) Write(p []byte) (int, error) { - time.Sleep(10 * time.Microsecond) - return 0, io.EOF -} - -func (EOFConn) Close() error { - time.Sleep(10 * time.Microsecond) - return io.EOF -} - -func (EOFConn) LocalAddr() net.Addr { - return EOFAddr{} -} - -func (EOFConn) RemoteAddr() net.Addr { - return EOFAddr{} -} - -func (EOFConn) SetDeadline(t time.Time) error { - return nil -} - -func (EOFConn) SetReadDeadline(t time.Time) error { - return nil -} - -func (EOFConn) SetWriteDeadline(t time.Time) error { - return nil -} - -type EOFAddr struct{} - -func (EOFAddr) Network() string { - return "tcp" -} - -func (EOFAddr) String() string { - return "127.0.0.1:1234" -} - -type EOFTLSHandshaker struct{} - -func (EOFTLSHandshaker) Handshake( - ctx context.Context, conn net.Conn, config *tls.Config, -) (net.Conn, tls.ConnectionState, error) { - time.Sleep(10 * time.Microsecond) - return nil, tls.ConnectionState{}, io.EOF -} diff --git a/internal/engine/netx/tlsdialer/fake_test.go b/internal/engine/netx/tlsdialer/fake_test.go deleted file mode 100644 index 1b4e0b3..0000000 --- a/internal/engine/netx/tlsdialer/fake_test.go +++ /dev/null @@ -1,71 +0,0 @@ -package tlsdialer - -import ( - "context" - "io" - "net" - "time" -) - -type FakeDialer struct { - Conn net.Conn - Err error -} - -func (d FakeDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { - time.Sleep(10 * time.Microsecond) - return d.Conn, d.Err -} - -type FakeConn struct { - ReadError error - ReadData []byte - SetDeadlineError error - SetReadDeadlineError error - SetWriteDeadlineError error - WriteError error -} - -func (c *FakeConn) Read(b []byte) (int, error) { - if len(c.ReadData) > 0 { - n := copy(b, c.ReadData) - c.ReadData = c.ReadData[n:] - return n, nil - } - if c.ReadError != nil { - return 0, c.ReadError - } - return 0, io.EOF -} - -func (c *FakeConn) Write(b []byte) (n int, err error) { - if c.WriteError != nil { - return 0, c.WriteError - } - n = len(b) - return -} - -func (*FakeConn) Close() (err error) { - return -} - -func (*FakeConn) LocalAddr() net.Addr { - return &net.TCPAddr{} -} - -func (*FakeConn) RemoteAddr() net.Addr { - return &net.TCPAddr{} -} - -func (c *FakeConn) SetDeadline(t time.Time) (err error) { - return c.SetDeadlineError -} - -func (c *FakeConn) SetReadDeadline(t time.Time) (err error) { - return c.SetReadDeadlineError -} - -func (c *FakeConn) SetWriteDeadline(t time.Time) (err error) { - return c.SetWriteDeadlineError -} diff --git a/internal/engine/netx/tlsdialer/integration_test.go b/internal/engine/netx/tlsdialer/integration_test.go deleted file mode 100644 index dc086c9..0000000 --- a/internal/engine/netx/tlsdialer/integration_test.go +++ /dev/null @@ -1,35 +0,0 @@ -package tlsdialer_test - -import ( - "net/http" - "testing" - - "github.com/apex/log" - oohttp "github.com/ooni/oohttp" - "github.com/ooni/probe-cli/v3/internal/netxlite" -) - -func TestTLSDialerSuccess(t *testing.T) { - if testing.Short() { - t.Skip("skip test in short mode") - } - log.SetLevel(log.DebugLevel) - dialer := &netxlite.TLSDialerLegacy{Dialer: netxlite.DefaultDialer, - TLSHandshaker: &netxlite.TLSHandshakerLogger{ - TLSHandshaker: &netxlite.TLSHandshakerConfigurable{}, - DebugLogger: log.Log, - }, - } - txp := &oohttp.StdlibTransport{ - Transport: &oohttp.Transport{ - DialTLSContext: dialer.DialTLSContext, - ForceAttemptHTTP2: true, - }, - } - client := &http.Client{Transport: txp} - resp, err := client.Get("https://www.google.com") - if err != nil { - t.Fatal(err) - } - resp.Body.Close() -} diff --git a/internal/engine/netx/tlsdialer/tls_test.go b/internal/engine/netx/tlsdialer/tls_test.go deleted file mode 100644 index 9efeb98..0000000 --- a/internal/engine/netx/tlsdialer/tls_test.go +++ /dev/null @@ -1,35 +0,0 @@ -package tlsdialer_test - -import ( - "context" - "crypto/tls" - "io" - "testing" - "time" - - "github.com/ooni/probe-cli/v3/internal/engine/netx/tlsdialer" - "github.com/ooni/probe-cli/v3/internal/netxlite" -) - -func TestSystemTLSHandshakerEOFError(t *testing.T) { - h := &netxlite.TLSHandshakerConfigurable{} - conn, _, err := h.Handshake(context.Background(), tlsdialer.EOFConn{}, &tls.Config{ - ServerName: "x.org", - }) - if err != io.EOF { - t.Fatal("not the error that we expected") - } - if conn != nil { - t.Fatal("expected nil con here") - } -} - -type SetDeadlineConn struct { - tlsdialer.EOFConn - deadlines []time.Time -} - -func (c *SetDeadlineConn) SetDeadline(t time.Time) error { - c.deadlines = append(c.deadlines, t) - return nil -}