tests: add rudimentary tests for resolveIPs

This mocks net.LookupIP with a wrapper type. In future, this might
be easier to accomplish with the help of the standard library (see
discussion in golang/go#12503).

With muety#1 in the pipeline, I might consider
swapping the stdlib resolver with a full fledged DNS client
(github.com/miekg/dns), as the stdlib resolver does not return
TTL values.

Author: dmke

dns.go

@@ -0,0 +1,36 @@
+package caddy_remote_host
+
+import (
+	"context"
+	"net"
+)
+
+// A resolver is able to lookup IP addresses from a given host name.
+// The net.Resolver type (found at net.DefaultResolver) matches this
+// interface.
+//
+// This is intended for testing.
+type resolver interface {
+	LookupIPAddr(ctx context.Context, host string) (addrs []net.IPAddr, err error)
+}
+
+// lookupIP does the same thing as net.LookupIP, except it doesn't use
+// net.DefaultResolver when given an alternative resolver implementation
+// as first argument.
+// (Setting resolv to nil will fallback to net.DefaultResolver.)
+func lookupIP(resolv resolver, host string) ([]net.IP, error) {
+	r := resolv
+	if r == nil {
+		r = net.DefaultResolver
+	}
+
+	addrs, err := r.LookupIPAddr(context.Background(), host)
+	if err != nil {
+		return nil, err
+	}
+	ips := make([]net.IP, len(addrs))
+	for i, ia := range addrs {
+		ips[i] = ia.IP
+	}
+	return ips, nil
+}

plugin.go

@@ -48,6 +48,9 @@ type MatchRemoteHost struct {
 
 	logger *zap.Logger
 	cache  *cache.Cache
+
+	// resolver is set in tests to provide canned results
+	resolver resolver
 }
 
 // CaddyModule returns the Caddy module information.
@@ -160,7 +163,7 @@ func (m *MatchRemoteHost) resolveIPs() ([]net.IP, error) {
 	allIPs := make([]net.IP, 0)
 
 	for _, h := range m.Hosts {
-		ips, err := net.LookupIP(h)
+		ips, err := lookupIP(m.resolver, h)
 		if err != nil {
 			return nil, err
 		}

plugin_internals_test.go

@@ -4,6 +4,9 @@ package caddy_remote_host
 // public API see package caddy_remote_host_test.
 
 import (
+	"context"
+	"errors"
+	"net"
 	"testing"
 
 	"github.com/caddyserver/caddy/v2"
@@ -19,5 +22,92 @@ func TestMatchRemoteHost_Provision(t *testing.T) {
 	require.NoError(t, err)
 	assert.NotNil(t, subject.logger)
 	assert.NotNil(t, subject.cache)
+	assert.Nil(t, subject.resolver)
 	assert.NotNil(t, hostRegex)
 }
+
+type lookupResult struct {
+	ips []net.IPAddr
+	err error
+}
+
+func resolvesTo(ips ...string) lookupResult {
+	r := lookupResult{ips: make([]net.IPAddr, len(ips))}
+	for i, ip := range ips {
+		r.ips[i] = net.IPAddr{IP: net.ParseIP(ip)}
+	}
+	return r
+}
+
+type mockResolver struct {
+	addrs map[string]lookupResult
+}
+
+func (m *mockResolver) LookupIPAddr(_ context.Context, h string) ([]net.IPAddr, error) {
+	if result, ok := m.addrs[h]; ok {
+		return result.ips, result.err
+	}
+	return nil, errors.New("no suitable address found")
+}
+
+func TestMatchRemoteHost_resolveIPs(t *testing.T) {
+	require := require.New(t)
+	assert := assert.New(t)
+
+	mock := &mockResolver{
+		addrs: map[string]lookupResult{
+			"example.com":         resolvesTo("127.0.0.1", "127.0.0.2"),
+			"example.org":         resolvesTo("::1", "fe80::1"),
+			"nil.records.example": {},
+			"no.records.example":  {ips: make([]net.IPAddr, 0)},
+		},
+	}
+
+	subject := MatchRemoteHost{resolver: mock}
+	for host := range mock.addrs {
+		subject.Hosts = append(subject.Hosts, host)
+	}
+
+	require.NoError(subject.Provision(caddy.Context{}))
+	ips, err := subject.resolveIPs()
+	require.NoError(err)
+
+	var haveIPs []string
+	for _, result := range mock.addrs {
+		for _, ip := range result.ips {
+			haveIPs = append(haveIPs, ip.String())
+		}
+	}
+
+	toStrings := func(ips []net.IP) []string {
+		s := make([]string, len(ips))
+		for i, ip := range ips {
+			s[i] = ip.String()
+		}
+		return s
+	}
+
+	assert.ElementsMatch(haveIPs, toStrings(ips))
+
+	cachedIPs, ok := subject.cache.Get(cacheKey)
+	require.True(ok)
+	require.NotNil(cachedIPs)
+	assert.ElementsMatch(haveIPs, toStrings(cachedIPs.([]net.IP)))
+}
+
+func TestMatchRemoteHost_resolveIPs_failure(t *testing.T) {
+	subject := MatchRemoteHost{
+		Hosts: []string{"example.com"},
+		resolver: &mockResolver{map[string]lookupResult{
+			"example.com": {err: &net.DNSError{Err: "no suitable host found"}},
+		}},
+	}
+
+	require.NoError(t, subject.Provision(caddy.Context{}))
+
+	ips, err := subject.resolveIPs()
+	// XXX: the expected message is constructed within package net
+	// and might change with future Go versions
+	assert.EqualError(t, err, "lookup : no suitable host found")
+	assert.Empty(t, ips)
+}