refactor: move ErrorWrapperResolver to errorsx pkg (#419)

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

internal/errorsx/dialer_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/netxmocks"
 )
 
-func TestErrorWrapperFailure(t *testing.T) {
+func TestErrorWrapperDialerFailure(t *testing.T) {
 	ctx := context.Background()
 	d := &ErrorWrapperDialer{Dialer: &netxmocks.Dialer{
 		MockDialContext: func(ctx context.Context, network string, address string) (net.Conn, error) {
@@ -40,7 +40,7 @@ func errorWrapperCheckErr(t *testing.T, err error, op string) {
 	}
 }
 
-func TestErrorWrapperSuccess(t *testing.T) {
+func TestErrorWrapperDialerSuccess(t *testing.T) {
 	ctx := context.Background()
 	d := &ErrorWrapperDialer{Dialer: &netxmocks.Dialer{
 		MockDialContext: func(ctx context.Context, network string, address string) (net.Conn, error) {

internal/errorsx/resolver.go

@@ -0,0 +1,52 @@
+package errorsx
+
+import "context"
+
+// Resolver is a DNS resolver. The *net.Resolver used by Go implements
+// this interface, but other implementations are possible.
+type Resolver interface {
+	// LookupHost resolves a hostname to a list of IP addresses.
+	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
+}
+
+// ErrorWrapperResolver is a Resolver that knows about wrapping errors.
+type ErrorWrapperResolver struct {
+	Resolver
+}
+
+var _ Resolver = &ErrorWrapperResolver{}
+
+// LookupHost implements Resolver.LookupHost
+func (r *ErrorWrapperResolver) LookupHost(ctx context.Context, hostname string) ([]string, error) {
+	addrs, err := r.Resolver.LookupHost(ctx, hostname)
+	err = SafeErrWrapperBuilder{
+		Classifier: ClassifyResolveFailure,
+		Error:      err,
+		Operation:  ResolveOperation,
+	}.MaybeBuild()
+	return addrs, err
+}
+
+type resolverNetworker interface {
+	Network() string
+}
+
+// Network implements Resolver.Network.
+func (r *ErrorWrapperResolver) Network() string {
+	if rn, ok := r.Resolver.(resolverNetworker); ok {
+		return rn.Network()
+	}
+	return "errorWrapper"
+}
+
+type resolverAddresser interface {
+	Address() string
+}
+
+// Address implements Resolver.Address.
+func (r *ErrorWrapperResolver) Address() string {
+	if ra, ok := r.Resolver.(resolverAddresser); ok {
+		return ra.Address()
+	}
+	return ""
+}

internal/errorsx/resolver_test.go

@@ -0,0 +1,80 @@
+package errorsx
+
+import (
+	"context"
+	"errors"
+	"net"
+	"testing"
+
+	"github.com/ooni/probe-cli/v3/internal/netxmocks"
+)
+
+func TestErrorWrapperResolverSuccess(t *testing.T) {
+	orig := []string{"8.8.8.8"}
+	r := &ErrorWrapperResolver{
+		Resolver: &netxmocks.Resolver{
+			MockLookupHost: func(ctx context.Context, domain string) ([]string, error) {
+				return orig, nil
+			},
+		},
+	}
+	addrs, err := r.LookupHost(context.Background(), "dns.google.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(addrs) != len(orig) || addrs[0] != orig[0] {
+		t.Fatal("not the result we expected")
+	}
+}
+
+func TestErrorWrapperResolverFailure(t *testing.T) {
+	r := &ErrorWrapperResolver{
+		Resolver: &netxmocks.Resolver{
+			MockLookupHost: func(ctx context.Context, domain string) ([]string, error) {
+				return nil, errors.New("no such host")
+			},
+		},
+	}
+	ctx := context.Background()
+	addrs, err := r.LookupHost(ctx, "dns.google.com")
+	if addrs != nil {
+		t.Fatal("expected nil addr here")
+	}
+	var errWrapper *ErrWrapper
+	if !errors.As(err, &errWrapper) {
+		t.Fatal("cannot properly cast the returned error")
+	}
+	if errWrapper.Failure != FailureDNSNXDOMAINError {
+		t.Fatal("unexpected failure")
+	}
+	if errWrapper.Operation != ResolveOperation {
+		t.Fatal("unexpected Operation")
+	}
+}
+
+func TestErrorWrapperResolverChildNetworkAddress(t *testing.T) {
+	r := &ErrorWrapperResolver{Resolver: &netxmocks.Resolver{
+		MockNetwork: func() string {
+			return "udp"
+		},
+		MockAddress: func() string {
+			return "8.8.8.8:53"
+		},
+	}}
+	if r.Network() != "udp" {
+		t.Fatal("invalid Network")
+	}
+	if r.Address() != "8.8.8.8:53" {
+		t.Fatal("invalid Address")
+	}
+}
+
+func TestErrorWrapperResolverNoChildNetworkAddress(t *testing.T) {
+	r := &ErrorWrapperResolver{Resolver: &net.Resolver{}}
+	if r.Network() != "errorWrapper" {
+		t.Fatal("invalid Network")
+	}
+	if r.Address() != "" {
+		t.Fatal("invalid Address")
+	}
+}