refactor(netx): move dns transports in netxlite/dnsx (#503)

While there, modernize the way in which we run tests to avoid
depending on the fake files scattered around the tree and to
use some well defined mock structures instead.

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

internal/netxlite/dnsx/mocks/decoder.go

@@ -0,0 +1,11 @@
+package mocks
+
+// Decoder allows mocking dnsx.Decoder.
+type Decoder struct {
+	MockDecode func(qtype uint16, reply []byte) ([]string, error)
+}
+
+// Decode calls MockDecode.
+func (e *Decoder) Decode(qtype uint16, reply []byte) ([]string, error) {
+	return e.MockDecode(qtype, reply)
+}

internal/netxlite/dnsx/mocks/decoder_test.go

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

internal/netxlite/dnsx/mocks/doc.go

@@ -0,0 +1,2 @@
+// Package mocks contains mocks for dnsx.
+package mocks

internal/netxlite/dnsx/mocks/encoder.go

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

internal/netxlite/dnsx/mocks/encoder_test.go

@@ -0,0 +1,26 @@
+package mocks
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/miekg/dns"
+)
+
+func TestEncoder(t *testing.T) {
+	t.Run("Encode", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		e := &Encoder{
+			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/dnsx/mocks/roundtripper.go

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

internal/netxlite/dnsx/mocks/roundtripper_test.go

@@ -0,0 +1,73 @@
+package mocks
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/ooni/probe-cli/v3/internal/atomicx"
+)
+
+func TestRoundTripper(t *testing.T) {
+	t.Run("RoundTrip", func(t *testing.T) {
+		expected := errors.New("mocked error")
+		txp := &RoundTripper{
+			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 := &RoundTripper{
+			MockRequiresPadding: func() bool {
+				return true
+			},
+		}
+		if txp.RequiresPadding() != true {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("Network", func(t *testing.T) {
+		txp := &RoundTripper{
+			MockNetwork: func() string {
+				return "antani"
+			},
+		}
+		if txp.Network() != "antani" {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("Address", func(t *testing.T) {
+		txp := &RoundTripper{
+			MockAddress: func() string {
+				return "mascetti"
+			},
+		}
+		if txp.Address() != "mascetti" {
+			t.Fatal("unexpected result")
+		}
+	})
+
+	t.Run("CloseIdleConnections", func(t *testing.T) {
+		called := &atomicx.Int64{}
+		txp := &RoundTripper{
+			MockCloseIdleConnections: func() {
+				called.Add(1)
+			},
+		}
+		txp.CloseIdleConnections()
+		if called.Load() != 1 {
+			t.Fatal("not called")
+		}
+	})
+}