mirror of
https://github.com/AdguardTeam/AdGuardHome.git
synced 2024-12-16 11:52:58 +03:00
306c1983a2
Merge in DNS/adguard-home from 1472-edns-custom-ip-api to master Updates #1472 Squashed commit of the following: commit 7605ec5bd5467ddd28a650385193eb2332653bb6 Merge: 8b2ac227194ead34
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Wed Mar 22 13:39:25 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit 8b2ac22793a51d2555d32c1f5b5c118118807d1f Merge: d5ca8b6ec3edab43
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 21 18:26:55 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit d5ca8b6e1d87480d4ee4afd346e6bf04907fca95 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 21 18:26:24 2023 +0300 dnsforward: imp tests commit 1302586d22812c22755ea1c7e7fcd32330d707c5 Author: Vladislav Abdulmyanov <v.abdulmyanov@adguard.com> Date: Tue Mar 21 16:47:56 2023 +0200 client: change validation for custom edns ip commit 44e4dc6d1e47de6597ed9ee328db9639e38b4868 Author: Vladislav Abdulmyanov <v.abdulmyanov@adguard.com> Date: Tue Mar 21 16:31:42 2023 +0200 client: implement edns custom ip commit 8a3e7ad8ebf16262818821340da23baa5f004bff Merge: 04ac1112f736d85e
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 21 15:04:40 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit 04ac1112dda2e778243555b2f54819e5ba586e05 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 21 15:03:39 2023 +0300 dnsforward: imp tests commit b44f6d0ccb3ba7b7a5be07c9cf293dad9c83c794 Merge: 19c6851e48431f8b
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Mon Mar 20 17:55:49 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit 19c6851e30f30b0572334822e8639e03760de986 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Fri Mar 10 10:40:15 2023 +0300 all: fix chlog commit 6dcdcbd666ebf3a56a38251e8ead09c605068ce3 Merge: a7f1bf71a2053526
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Fri Mar 10 10:23:37 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit a7f1bf715e3557c710b700b9bd923868eb07715b Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 19:24:18 2023 +0300 home: fix default value commit 0311a9bb6571975963d747ef4ef427b59dca03bc Merge: 7e0bb3df1011b8f9
Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 19:04:18 2023 +0300 Merge branch 'master' into 1472-edns-custom-ip-api commit 7e0bb3df78f10f4b4ae0fd49681d1aa0040521c5 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 19:03:24 2023 +0300 all: fix chlog commit 202d7ccf4721ccf39726da01d237e07317bfaa58 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 11:35:41 2023 +0300 dnsforward: fix typo commit fe95e003a0c3b316a44b5ec0b848a60ddd4c85cf Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 11:28:21 2023 +0300 all: fix docs commit 66835a9aa22b3015f9238c1d6f5aa9bd6067db8a Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Tue Mar 7 10:48:08 2023 +0300 dnsforward: add todo commit b58255e1e6660a8229bb9c40f2acddebb3dbdc66 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Mon Mar 6 15:40:02 2023 +0300 all: upd chlog commit 9b2be7facba30c815144e08a7835353cad14c405 Author: Stanislav Chzhen <s.chzhen@adguard.com> Date: Fri Mar 3 11:22:19 2023 +0300 dnsforward: edns custom ip api
560 lines
15 KiB
Go
560 lines
15 KiB
Go
package dnsforward
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/netip"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghnet"
|
|
"github.com/AdguardTeam/AdGuardHome/internal/filtering"
|
|
"github.com/AdguardTeam/golibs/netutil"
|
|
"github.com/AdguardTeam/golibs/testutil"
|
|
"github.com/miekg/dns"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// fakeSystemResolvers is a mock aghnet.SystemResolvers implementation for
|
|
// tests.
|
|
type fakeSystemResolvers struct {
|
|
// SystemResolvers is embedded here simply to make *fakeSystemResolvers
|
|
// an aghnet.SystemResolvers without actually implementing all methods.
|
|
aghnet.SystemResolvers
|
|
}
|
|
|
|
// Get implements the aghnet.SystemResolvers interface for *fakeSystemResolvers.
|
|
// It always returns nil.
|
|
func (fsr *fakeSystemResolvers) Get() (rs []string) {
|
|
return nil
|
|
}
|
|
|
|
func loadTestData(t *testing.T, casesFileName string, cases any) {
|
|
t.Helper()
|
|
|
|
var f *os.File
|
|
f, err := os.Open(filepath.Join("testdata", casesFileName))
|
|
require.NoError(t, err)
|
|
testutil.CleanupAndRequireSuccess(t, f.Close)
|
|
|
|
err = json.NewDecoder(f).Decode(cases)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
const jsonExt = ".json"
|
|
|
|
func TestDNSForwardHTTP_handleGetConfig(t *testing.T) {
|
|
filterConf := &filtering.Config{
|
|
SafeBrowsingEnabled: true,
|
|
SafeBrowsingCacheSize: 1000,
|
|
SafeSearchConf: filtering.SafeSearchConfig{Enabled: true},
|
|
SafeSearchCacheSize: 1000,
|
|
ParentalCacheSize: 1000,
|
|
CacheTime: 30,
|
|
}
|
|
forwardConf := ServerConfig{
|
|
UDPListenAddrs: []*net.UDPAddr{},
|
|
TCPListenAddrs: []*net.TCPAddr{},
|
|
FilteringConfig: FilteringConfig{
|
|
ProtectionEnabled: true,
|
|
BlockingMode: BlockingModeDefault,
|
|
UpstreamDNS: []string{"8.8.8.8:53", "8.8.4.4:53"},
|
|
EDNSClientSubnet: &EDNSClientSubnet{Enabled: false},
|
|
},
|
|
ConfigModified: func() {},
|
|
}
|
|
s := createTestServer(t, filterConf, forwardConf, nil)
|
|
s.sysResolvers = &fakeSystemResolvers{}
|
|
|
|
require.NoError(t, s.Start())
|
|
testutil.CleanupAndRequireSuccess(t, s.Stop)
|
|
|
|
defaultConf := s.conf
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
testCases := []struct {
|
|
conf func() ServerConfig
|
|
name string
|
|
}{{
|
|
conf: func() ServerConfig {
|
|
return defaultConf
|
|
},
|
|
name: "all_right",
|
|
}, {
|
|
conf: func() ServerConfig {
|
|
conf := defaultConf
|
|
conf.FastestAddr = true
|
|
|
|
return conf
|
|
},
|
|
name: "fastest_addr",
|
|
}, {
|
|
conf: func() ServerConfig {
|
|
conf := defaultConf
|
|
conf.AllServers = true
|
|
|
|
return conf
|
|
},
|
|
name: "parallel",
|
|
}}
|
|
|
|
var data map[string]json.RawMessage
|
|
loadTestData(t, t.Name()+jsonExt, &data)
|
|
|
|
for _, tc := range testCases {
|
|
caseWant, ok := data[tc.name]
|
|
require.True(t, ok)
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Cleanup(w.Body.Reset)
|
|
|
|
s.conf = tc.conf()
|
|
s.handleGetConfig(w, nil)
|
|
|
|
cType := w.Header().Get(aghhttp.HdrNameContentType)
|
|
assert.Equal(t, aghhttp.HdrValApplicationJSON, cType)
|
|
assert.JSONEq(t, string(caseWant), w.Body.String())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDNSForwardHTTP_handleSetConfig(t *testing.T) {
|
|
filterConf := &filtering.Config{
|
|
SafeBrowsingEnabled: true,
|
|
SafeBrowsingCacheSize: 1000,
|
|
SafeSearchConf: filtering.SafeSearchConfig{Enabled: true},
|
|
SafeSearchCacheSize: 1000,
|
|
ParentalCacheSize: 1000,
|
|
CacheTime: 30,
|
|
}
|
|
forwardConf := ServerConfig{
|
|
UDPListenAddrs: []*net.UDPAddr{},
|
|
TCPListenAddrs: []*net.TCPAddr{},
|
|
FilteringConfig: FilteringConfig{
|
|
ProtectionEnabled: true,
|
|
BlockingMode: BlockingModeDefault,
|
|
UpstreamDNS: []string{"8.8.8.8:53", "8.8.4.4:53"},
|
|
EDNSClientSubnet: &EDNSClientSubnet{Enabled: false},
|
|
},
|
|
ConfigModified: func() {},
|
|
}
|
|
s := createTestServer(t, filterConf, forwardConf, nil)
|
|
s.sysResolvers = &fakeSystemResolvers{}
|
|
|
|
defaultConf := s.conf
|
|
|
|
err := s.Start()
|
|
assert.NoError(t, err)
|
|
testutil.CleanupAndRequireSuccess(t, s.Stop)
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
testCases := []struct {
|
|
name string
|
|
wantSet string
|
|
}{{
|
|
name: "upstream_dns",
|
|
wantSet: "",
|
|
}, {
|
|
name: "bootstraps",
|
|
wantSet: "",
|
|
}, {
|
|
name: "blocking_mode_good",
|
|
wantSet: "",
|
|
}, {
|
|
name: "blocking_mode_bad",
|
|
wantSet: "blocking_ipv4 must be set when blocking_mode is custom_ip",
|
|
}, {
|
|
name: "ratelimit",
|
|
wantSet: "",
|
|
}, {
|
|
name: "edns_cs_enabled",
|
|
wantSet: "",
|
|
}, {
|
|
name: "edns_cs_use_custom",
|
|
wantSet: "",
|
|
}, {
|
|
name: "edns_cs_use_custom_bad_ip",
|
|
wantSet: "decoding request: ParseAddr(\"bad.ip\"): unexpected character (at \"bad.ip\")",
|
|
}, {
|
|
name: "dnssec_enabled",
|
|
wantSet: "",
|
|
}, {
|
|
name: "cache_size",
|
|
wantSet: "",
|
|
}, {
|
|
name: "upstream_mode_parallel",
|
|
wantSet: "",
|
|
}, {
|
|
name: "upstream_mode_fastest_addr",
|
|
wantSet: "",
|
|
}, {
|
|
name: "upstream_dns_bad",
|
|
wantSet: `validating upstream servers: validating upstream "!!!": not an ip:port`,
|
|
}, {
|
|
name: "bootstraps_bad",
|
|
wantSet: `checking bootstrap a: invalid address: ` +
|
|
`Resolver a is not eligible to be a bootstrap DNS server`,
|
|
}, {
|
|
name: "cache_bad_ttl",
|
|
wantSet: `cache_ttl_min must be less or equal than cache_ttl_max`,
|
|
}, {
|
|
name: "upstream_mode_bad",
|
|
wantSet: `upstream_mode: incorrect value`,
|
|
}, {
|
|
name: "local_ptr_upstreams_good",
|
|
wantSet: "",
|
|
}, {
|
|
name: "local_ptr_upstreams_bad",
|
|
wantSet: `validating private upstream servers: checking domain-specific upstreams: ` +
|
|
`bad arpa domain name "non.arpa.": not a reversed ip network`,
|
|
}, {
|
|
name: "local_ptr_upstreams_null",
|
|
wantSet: "",
|
|
}}
|
|
|
|
var data map[string]struct {
|
|
Req json.RawMessage `json:"req"`
|
|
Want json.RawMessage `json:"want"`
|
|
}
|
|
|
|
testData := t.Name() + jsonExt
|
|
loadTestData(t, testData, &data)
|
|
|
|
for _, tc := range testCases {
|
|
// NOTE: Do not use require.Contains, because the size of the data
|
|
// prevents it from printing a meaningful error message.
|
|
caseData, ok := data[tc.name]
|
|
require.Truef(t, ok, "%q does not contain test data for test case %s", testData, tc.name)
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
s.conf = defaultConf
|
|
s.conf.FilteringConfig.EDNSClientSubnet = &EDNSClientSubnet{}
|
|
})
|
|
|
|
rBody := io.NopCloser(bytes.NewReader(caseData.Req))
|
|
var r *http.Request
|
|
r, err = http.NewRequest(http.MethodPost, "http://example.com", rBody)
|
|
require.NoError(t, err)
|
|
|
|
s.handleSetConfig(w, r)
|
|
assert.Equal(t, tc.wantSet, strings.TrimSuffix(w.Body.String(), "\n"))
|
|
w.Body.Reset()
|
|
|
|
s.handleGetConfig(w, nil)
|
|
assert.JSONEq(t, string(caseData.Want), w.Body.String())
|
|
w.Body.Reset()
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsCommentOrEmpty(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
want assert.BoolAssertionFunc
|
|
str string
|
|
}{{
|
|
want: assert.True,
|
|
str: "",
|
|
}, {
|
|
want: assert.True,
|
|
str: "# comment",
|
|
}, {
|
|
want: assert.False,
|
|
str: "1.2.3.4",
|
|
}} {
|
|
tc.want(t, IsCommentOrEmpty(tc.str))
|
|
}
|
|
}
|
|
|
|
func TestValidateUpstreams(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
wantErr string
|
|
set []string
|
|
}{{
|
|
name: "empty",
|
|
wantErr: ``,
|
|
set: nil,
|
|
}, {
|
|
name: "comment",
|
|
wantErr: ``,
|
|
set: []string{"# comment"},
|
|
}, {
|
|
name: "no_default",
|
|
wantErr: `no default upstreams specified`,
|
|
set: []string{
|
|
"[/host.com/]1.1.1.1",
|
|
"[//]tls://1.1.1.1",
|
|
"[/www.host.com/]#",
|
|
"[/host.com/google.com/]8.8.8.8",
|
|
"[/host/]sdns://AQMAAAAAAAAAFDE3Ni4xMDMuMTMwLjEzMDo1NDQzINErR_JS3PLCu_iZEIbq95zkSV2LFsigxDIuUso_OQhzIjIuZG5zY3J5cHQuZGVmYXVsdC5uczEuYWRndWFyZC5jb20",
|
|
},
|
|
}, {
|
|
name: "with_default",
|
|
wantErr: ``,
|
|
set: []string{
|
|
"[/host.com/]1.1.1.1",
|
|
"[//]tls://1.1.1.1",
|
|
"[/www.host.com/]#",
|
|
"[/host.com/google.com/]8.8.8.8",
|
|
"[/host/]sdns://AQMAAAAAAAAAFDE3Ni4xMDMuMTMwLjEzMDo1NDQzINErR_JS3PLCu_iZEIbq95zkSV2LFsigxDIuUso_OQhzIjIuZG5zY3J5cHQuZGVmYXVsdC5uczEuYWRndWFyZC5jb20",
|
|
"8.8.8.8",
|
|
},
|
|
}, {
|
|
name: "invalid",
|
|
wantErr: `validating upstream "dhcp://fake.dns": bad protocol "dhcp"`,
|
|
set: []string{"dhcp://fake.dns"},
|
|
}, {
|
|
name: "invalid",
|
|
wantErr: `validating upstream "1.2.3.4.5": not an ip:port`,
|
|
set: []string{"1.2.3.4.5"},
|
|
}, {
|
|
name: "invalid",
|
|
wantErr: `validating upstream "123.3.7m": not an ip:port`,
|
|
set: []string{"123.3.7m"},
|
|
}, {
|
|
name: "invalid",
|
|
wantErr: `bad upstream for domain "[/host.com]tls://dns.adguard.com": missing separator`,
|
|
set: []string{"[/host.com]tls://dns.adguard.com"},
|
|
}, {
|
|
name: "invalid",
|
|
wantErr: `validating upstream "[host.ru]#": not an ip:port`,
|
|
set: []string{"[host.ru]#"},
|
|
}, {
|
|
name: "valid_default",
|
|
wantErr: ``,
|
|
set: []string{
|
|
"1.1.1.1",
|
|
"tls://1.1.1.1",
|
|
"https://dns.adguard.com/dns-query",
|
|
"sdns://AQMAAAAAAAAAFDE3Ni4xMDMuMTMwLjEzMDo1NDQzINErR_JS3PLCu_iZEIbq95zkSV2LFsigxDIuUso_OQhzIjIuZG5zY3J5cHQuZGVmYXVsdC5uczEuYWRndWFyZC5jb20",
|
|
"udp://dns.google",
|
|
"udp://8.8.8.8",
|
|
"[/host.com/]1.1.1.1",
|
|
"[//]tls://1.1.1.1",
|
|
"[/www.host.com/]#",
|
|
"[/host.com/google.com/]8.8.8.8",
|
|
"[/host/]sdns://AQMAAAAAAAAAFDE3Ni4xMDMuMTMwLjEzMDo1NDQzINErR_JS3PLCu_iZEIbq95zkSV2LFsigxDIuUso_OQhzIjIuZG5zY3J5cHQuZGVmYXVsdC5uczEuYWRndWFyZC5jb20",
|
|
"[/пример.рф/]8.8.8.8",
|
|
},
|
|
}, {
|
|
name: "bad_domain",
|
|
wantErr: `bad upstream for domain "[/!/]8.8.8.8": domain at index 0: ` +
|
|
`bad domain name "!": bad top-level domain name label "!": ` +
|
|
`bad top-level domain name label rune '!'`,
|
|
set: []string{"[/!/]8.8.8.8"},
|
|
}}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
err := ValidateUpstreams(tc.set)
|
|
testutil.AssertErrorMsg(t, tc.wantErr, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateUpstreamsPrivate(t *testing.T) {
|
|
ss := netutil.SubnetSetFunc(netutil.IsLocallyServed)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
wantErr string
|
|
u string
|
|
}{{
|
|
name: "success_address",
|
|
wantErr: ``,
|
|
u: "[/1.0.0.127.in-addr.arpa/]#",
|
|
}, {
|
|
name: "success_subnet",
|
|
wantErr: ``,
|
|
u: "[/127.in-addr.arpa/]#",
|
|
}, {
|
|
name: "not_arpa_subnet",
|
|
wantErr: `checking domain-specific upstreams: ` +
|
|
`bad arpa domain name "hello.world.": not a reversed ip network`,
|
|
u: "[/hello.world/]#",
|
|
}, {
|
|
name: "non-private_arpa_address",
|
|
wantErr: `checking domain-specific upstreams: ` +
|
|
`arpa domain "1.2.3.4.in-addr.arpa." should point to a locally-served network`,
|
|
u: "[/1.2.3.4.in-addr.arpa/]#",
|
|
}, {
|
|
name: "non-private_arpa_subnet",
|
|
wantErr: `checking domain-specific upstreams: ` +
|
|
`arpa domain "128.in-addr.arpa." should point to a locally-served network`,
|
|
u: "[/128.in-addr.arpa/]#",
|
|
}, {
|
|
name: "several_bad",
|
|
wantErr: `checking domain-specific upstreams: 2 errors: ` +
|
|
`"arpa domain \"1.2.3.4.in-addr.arpa.\" should point to a locally-served network", ` +
|
|
`"bad arpa domain name \"non.arpa.\": not a reversed ip network"`,
|
|
u: "[/non.arpa/1.2.3.4.in-addr.arpa/127.in-addr.arpa/]#",
|
|
}, {
|
|
name: "partial_good",
|
|
wantErr: "",
|
|
u: "[/a.1.2.3.10.in-addr.arpa/a.10.in-addr.arpa/]#",
|
|
}}
|
|
|
|
for _, tc := range testCases {
|
|
set := []string{"192.168.0.1", tc.u}
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
err := ValidateUpstreamsPrivate(set, ss)
|
|
testutil.AssertErrorMsg(t, tc.wantErr, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func newLocalUpstreamListener(t *testing.T, port int, handler dns.Handler) (real net.Addr) {
|
|
startCh := make(chan struct{})
|
|
upsSrv := &dns.Server{
|
|
Addr: netip.AddrPortFrom(netutil.IPv4Localhost(), uint16(port)).String(),
|
|
Net: "tcp",
|
|
Handler: handler,
|
|
NotifyStartedFunc: func() { close(startCh) },
|
|
}
|
|
go func() {
|
|
t := testutil.PanicT{}
|
|
|
|
err := upsSrv.ListenAndServe()
|
|
require.NoError(t, err)
|
|
}()
|
|
<-startCh
|
|
testutil.CleanupAndRequireSuccess(t, upsSrv.Shutdown)
|
|
|
|
return upsSrv.Listener.Addr()
|
|
}
|
|
|
|
func TestServer_handleTestUpstreaDNS(t *testing.T) {
|
|
goodHandler := dns.HandlerFunc(func(w dns.ResponseWriter, m *dns.Msg) {
|
|
err := w.WriteMsg(new(dns.Msg).SetReply(m))
|
|
require.NoError(testutil.PanicT{}, err)
|
|
})
|
|
badHandler := dns.HandlerFunc(func(w dns.ResponseWriter, _ *dns.Msg) {
|
|
err := w.WriteMsg(new(dns.Msg))
|
|
require.NoError(testutil.PanicT{}, err)
|
|
})
|
|
|
|
goodUps := (&url.URL{
|
|
Scheme: "tcp",
|
|
Host: newLocalUpstreamListener(t, 0, goodHandler).String(),
|
|
}).String()
|
|
badUps := (&url.URL{
|
|
Scheme: "tcp",
|
|
Host: newLocalUpstreamListener(t, 0, badHandler).String(),
|
|
}).String()
|
|
|
|
const upsTimeout = 100 * time.Millisecond
|
|
|
|
srv := createTestServer(t, &filtering.Config{}, ServerConfig{
|
|
UDPListenAddrs: []*net.UDPAddr{{}},
|
|
TCPListenAddrs: []*net.TCPAddr{{}},
|
|
UpstreamTimeout: upsTimeout,
|
|
FilteringConfig: FilteringConfig{
|
|
EDNSClientSubnet: &EDNSClientSubnet{Enabled: false},
|
|
},
|
|
}, nil)
|
|
startDeferStop(t, srv)
|
|
|
|
testCases := []struct {
|
|
body map[string]any
|
|
wantResp map[string]any
|
|
name string
|
|
}{{
|
|
body: map[string]any{
|
|
"upstream_dns": []string{goodUps},
|
|
},
|
|
wantResp: map[string]any{
|
|
goodUps: "OK",
|
|
},
|
|
name: "success",
|
|
}, {
|
|
body: map[string]any{
|
|
"upstream_dns": []string{badUps},
|
|
},
|
|
wantResp: map[string]any{
|
|
badUps: `upstream "` + badUps + `" fails to exchange: ` +
|
|
`couldn't communicate with upstream: dns: id mismatch`,
|
|
},
|
|
name: "broken",
|
|
}, {
|
|
body: map[string]any{
|
|
"upstream_dns": []string{goodUps, badUps},
|
|
},
|
|
wantResp: map[string]any{
|
|
goodUps: "OK",
|
|
badUps: `upstream "` + badUps + `" fails to exchange: ` +
|
|
`couldn't communicate with upstream: dns: id mismatch`,
|
|
},
|
|
name: "both",
|
|
}}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
reqBody, err := json.Marshal(tc.body)
|
|
require.NoError(t, err)
|
|
|
|
w := httptest.NewRecorder()
|
|
r, err := http.NewRequest(http.MethodPost, "", bytes.NewReader(reqBody))
|
|
require.NoError(t, err)
|
|
|
|
srv.handleTestUpstreamDNS(w, r)
|
|
require.Equal(t, http.StatusOK, w.Code)
|
|
|
|
resp := map[string]any{}
|
|
err = json.NewDecoder(w.Body).Decode(&resp)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, tc.wantResp, resp)
|
|
})
|
|
}
|
|
|
|
t.Run("timeout", func(t *testing.T) {
|
|
slowHandler := dns.HandlerFunc(func(w dns.ResponseWriter, m *dns.Msg) {
|
|
time.Sleep(upsTimeout * 2)
|
|
writeErr := w.WriteMsg(new(dns.Msg).SetReply(m))
|
|
require.NoError(testutil.PanicT{}, writeErr)
|
|
})
|
|
sleepyUps := (&url.URL{
|
|
Scheme: "tcp",
|
|
Host: newLocalUpstreamListener(t, 0, slowHandler).String(),
|
|
}).String()
|
|
|
|
req := map[string]any{
|
|
"upstream_dns": []string{sleepyUps},
|
|
}
|
|
reqBody, err := json.Marshal(req)
|
|
require.NoError(t, err)
|
|
|
|
w := httptest.NewRecorder()
|
|
r, err := http.NewRequest(http.MethodPost, "", bytes.NewReader(reqBody))
|
|
require.NoError(t, err)
|
|
|
|
srv.handleTestUpstreamDNS(w, r)
|
|
require.Equal(t, http.StatusOK, w.Code)
|
|
|
|
resp := map[string]any{}
|
|
err = json.NewDecoder(w.Body).Decode(&resp)
|
|
require.NoError(t, err)
|
|
|
|
require.Contains(t, resp, sleepyUps)
|
|
require.IsType(t, "", resp[sleepyUps])
|
|
sleepyRes, _ := resp[sleepyUps].(string)
|
|
|
|
// TODO(e.burkov): Improve the format of an error in dnsproxy.
|
|
assert.True(t, strings.HasSuffix(sleepyRes, "i/o timeout"))
|
|
})
|
|
}
|