refactor: merge dnsx and errorsx into netxlite (#517)

When preparing a tutorial for netxlite, I figured it is easier
to tell people "hey, this is the package you should use for all
low-level networking stuff" rather than introducing people to
a set of packages working together where some piece of functionality
is here and some other piece is there.

Part of https://github.com/ooni/probe/issues/1591

internal/netxlite/mocks/dnsdecoder.go

@@ -0,0 +1,23 @@
+package mocks
+
+import "github.com/ooni/probe-cli/v3/internal/netxlite/dnsx"
+
+// HTTPSSvc is the result of HTTPS queries.
+type HTTPSSvc = dnsx.HTTPSSvc
+
+// DNSDecoder allows mocking dnsx.DNSDecoder.
+type DNSDecoder struct {
+	MockDecodeLookupHost func(qtype uint16, reply []byte) ([]string, error)
+
+	MockDecodeHTTPS func(reply []byte) (*HTTPSSvc, error)
+}
+
+// DecodeLookupHost calls MockDecodeLookupHost.
+func (e *DNSDecoder) DecodeLookupHost(qtype uint16, reply []byte) ([]string, error) {
+	return e.MockDecodeLookupHost(qtype, reply)
+}
+
+// DecodeHTTPS calls MockDecodeHTTPS.
+func (e *DNSDecoder) DecodeHTTPS(reply []byte) (*HTTPSSvc, error) {
+	return e.MockDecodeHTTPS(reply)
+}

internal/netxlite/mocks/dnsdecoder_test.go

@@ -0,0 +1,42 @@
+package mocks
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/miekg/dns"
+)
+
+func TestDNSDecoder(t *testing.T) {
+	t.Run("DecodeLookupHost", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		e := &DNSDecoder{
+			MockDecodeLookupHost: func(qtype uint16, reply []byte) ([]string, error) {
+				return nil, expected
+			},
+		}
+		out, err := e.DecodeLookupHost(dns.TypeA, make([]byte, 17))
+		if !errors.Is(err, expected) {
+			t.Fatal("unexpected err", err)
+		}
+		if out != nil {
+			t.Fatal("unexpected out")
+		}
+	})
+
+	t.Run("DecodeHTTPS", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		e := &DNSDecoder{
+			MockDecodeHTTPS: func(reply []byte) (*HTTPSSvc, error) {
+				return nil, expected
+			},
+		}
+		out, err := e.DecodeHTTPS(make([]byte, 17))
+		if !errors.Is(err, expected) {
+			t.Fatal("unexpected err", err)
+		}
+		if out != nil {
+			t.Fatal("unexpected out")
+		}
+	})
+}

internal/netxlite/mocks/dnsencoder.go

@@ -0,0 +1,11 @@
+package mocks
+
+// DNSEncoder allows mocking dnsx.DNSEncoder.
+type DNSEncoder struct {
+	MockEncode func(domain string, qtype uint16, padding bool) ([]byte, error)
+}
+
+// Encode calls MockEncode.
+func (e *DNSEncoder) Encode(domain string, qtype uint16, padding bool) ([]byte, error) {
+	return e.MockEncode(domain, qtype, padding)
+}

internal/netxlite/mocks/dnsencoder_test.go

@@ -0,0 +1,26 @@
+package mocks
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/miekg/dns"
+)
+
+func TestDNSEncoder(t *testing.T) {
+	t.Run("Encode", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		e := &DNSEncoder{
+			MockEncode: func(domain string, qtype uint16, padding bool) ([]byte, error) {
+				return nil, expected
+			},
+		}
+		out, err := e.Encode("dns.google", dns.TypeA, true)
+		if !errors.Is(err, expected) {
+			t.Fatal("unexpected err", err)
+		}
+		if out != nil {
+			t.Fatal("unexpected out")
+		}
+	})
+}

internal/netxlite/mocks/dnstransport.go

@@ -0,0 +1,41 @@
+package mocks
+
+import "context"
+
+// DNSTransport allows mocking dnsx.DNSTransport.
+type DNSTransport struct {
+	MockRoundTrip func(ctx context.Context, query []byte) (reply []byte, err error)
+
+	MockRequiresPadding func() bool
+
+	MockNetwork func() string
+
+	MockAddress func() string
+
+	MockCloseIdleConnections func()
+}
+
+// RoundTrip calls MockRoundTrip.
+func (txp *DNSTransport) RoundTrip(ctx context.Context, query []byte) (reply []byte, err error) {
+	return txp.MockRoundTrip(ctx, query)
+}
+
+// RequiresPadding calls MockRequiresPadding.
+func (txp *DNSTransport) RequiresPadding() bool {
+	return txp.MockRequiresPadding()
+}
+
+// Network calls MockNetwork.
+func (txp *DNSTransport) Network() string {
+	return txp.MockNetwork()
+}
+
+// Address calls MockAddress.
+func (txp *DNSTransport) Address() string {
+	return txp.MockAddress()
+}
+
+// CloseIdleConnections calls MockCloseIdleConnections.
+func (txp *DNSTransport) CloseIdleConnections() {
+	txp.MockCloseIdleConnections()
+}

internal/netxlite/mocks/dnstransport_test.go

@@ -0,0 +1,73 @@
+package mocks
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/ooni/probe-cli/v3/internal/atomicx"
+)
+
+func TestDNSTransport(t *testing.T) {
+	t.Run("RoundTrip", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		txp := &DNSTransport{
+			MockRoundTrip: func(ctx context.Context, query []byte) ([]byte, error) {
+				return nil, expected
+			},
+		}
+		resp, err := txp.RoundTrip(context.Background(), make([]byte, 16))
+		if !errors.Is(err, expected) {
+			t.Fatal("not the error we expected", err)
+		}
+		if resp != nil {
+			t.Fatal("expected nil response here")
+		}
+	})
+
+	t.Run("RequiresPadding", func(t *testing.T) {
+		txp := &DNSTransport{
+			MockRequiresPadding: func() bool {
+				return true
+			},
+		}
+		if txp.RequiresPadding() != true {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("Network", func(t *testing.T) {
+		txp := &DNSTransport{
+			MockNetwork: func() string {
+				return "antani"
+			},
+		}
+		if txp.Network() != "antani" {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("Address", func(t *testing.T) {
+		txp := &DNSTransport{
+			MockAddress: func() string {
+				return "mascetti"
+			},
+		}
+		if txp.Address() != "mascetti" {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("CloseIdleConnections", func(t *testing.T) {
+		called := &atomicx.Int64{}
+		txp := &DNSTransport{
+			MockCloseIdleConnections: func() {
+				called.Add(1)
+			},
+		}
+		txp.CloseIdleConnections()
+		if called.Load() != 1 {
+			t.Fatal("not called")
+		}
+	})
+}

internal/netxlite/mocks/resolver.go

@@ -2,8 +2,6 @@ package mocks
 
 import (
 	"context"
-
-	"github.com/ooni/probe-cli/v3/internal/netxlite/dnsx/model"
 )
 
 // Resolver is a mockable Resolver.
@@ -35,9 +33,6 @@ func (r *Resolver) CloseIdleConnections() {
 	r.MockCloseIdleConnections()
 }
 
-// HTTPSSvc is an HTTPSSvc reply.
-type HTTPSSvc = model.HTTPSSvc
-
 // LookupHTTPS calls MockLookupHTTPS.
 func (r *Resolver) LookupHTTPS(ctx context.Context, domain string) (*HTTPSSvc, error) {
 	return r.MockLookupHTTPS(ctx, domain)