461 lines
11 KiB
Go
461 lines
11 KiB
Go
package aghnet_test
|
|
|
|
import (
|
|
"net/netip"
|
|
"path"
|
|
"path/filepath"
|
|
"sync/atomic"
|
|
"testing"
|
|
"testing/fstest"
|
|
"time"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghchan"
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghnet"
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
|
|
"github.com/AdguardTeam/golibs/errors"
|
|
"github.com/AdguardTeam/golibs/hostsfile"
|
|
"github.com/AdguardTeam/golibs/netutil"
|
|
"github.com/AdguardTeam/golibs/testutil"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// nl is a newline character.
|
|
const nl = "\n"
|
|
|
|
// Variables mirroring the etc_hosts file from testdata.
|
|
var (
|
|
addr1000 = netip.MustParseAddr("1.0.0.0")
|
|
addr1001 = netip.MustParseAddr("1.0.0.1")
|
|
addr1002 = netip.MustParseAddr("1.0.0.2")
|
|
addr1003 = netip.MustParseAddr("1.0.0.3")
|
|
addr1004 = netip.MustParseAddr("1.0.0.4")
|
|
addr1357 = netip.MustParseAddr("1.3.5.7")
|
|
addr4216 = netip.MustParseAddr("4.2.1.6")
|
|
addr7531 = netip.MustParseAddr("7.5.3.1")
|
|
|
|
addr0 = netip.MustParseAddr("::")
|
|
addr1 = netip.MustParseAddr("::1")
|
|
addr2 = netip.MustParseAddr("::2")
|
|
addr3 = netip.MustParseAddr("::3")
|
|
addr4 = netip.MustParseAddr("::4")
|
|
addr42 = netip.MustParseAddr("::42")
|
|
addr13 = netip.MustParseAddr("::13")
|
|
addr31 = netip.MustParseAddr("::31")
|
|
|
|
hostsSrc = "./" + filepath.Join("./testdata", "etc_hosts")
|
|
|
|
testHosts = map[netip.Addr][]*hostsfile.Record{
|
|
addr1000: {{
|
|
Addr: addr1000,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello", "hello.world"},
|
|
}, {
|
|
Addr: addr1000,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello.world.again"},
|
|
}, {
|
|
Addr: addr1000,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello.world"},
|
|
}},
|
|
addr1001: {{
|
|
Addr: addr1001,
|
|
Source: hostsSrc,
|
|
Names: []string{"simplehost"},
|
|
}, {
|
|
Addr: addr1001,
|
|
Source: hostsSrc,
|
|
Names: []string{"simplehost"},
|
|
}},
|
|
addr1002: {{
|
|
Addr: addr1002,
|
|
Source: hostsSrc,
|
|
Names: []string{"a.whole", "lot.of", "aliases", "for.testing"},
|
|
}},
|
|
addr1003: {{
|
|
Addr: addr1003,
|
|
Source: hostsSrc,
|
|
Names: []string{"*"},
|
|
}},
|
|
addr1004: {{
|
|
Addr: addr1004,
|
|
Source: hostsSrc,
|
|
Names: []string{"*.com"},
|
|
}},
|
|
addr1357: {{
|
|
Addr: addr1357,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain4", "domain4.alias"},
|
|
}},
|
|
addr7531: {{
|
|
Addr: addr7531,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain4.alias", "domain4"},
|
|
}},
|
|
addr4216: {{
|
|
Addr: addr4216,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain", "domain.alias"},
|
|
}},
|
|
addr0: {{
|
|
Addr: addr0,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello", "hello.world"},
|
|
}, {
|
|
Addr: addr0,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello.world.again"},
|
|
}, {
|
|
Addr: addr0,
|
|
Source: hostsSrc,
|
|
Names: []string{"hello.world"},
|
|
}},
|
|
addr1: {{
|
|
Addr: addr1,
|
|
Source: hostsSrc,
|
|
Names: []string{"simplehost"},
|
|
}, {
|
|
Addr: addr1,
|
|
Source: hostsSrc,
|
|
Names: []string{"simplehost"},
|
|
}},
|
|
addr2: {{
|
|
Addr: addr2,
|
|
Source: hostsSrc,
|
|
Names: []string{"a.whole", "lot.of", "aliases", "for.testing"},
|
|
}},
|
|
addr3: {{
|
|
Addr: addr3,
|
|
Source: hostsSrc,
|
|
Names: []string{"*"},
|
|
}},
|
|
addr4: {{
|
|
Addr: addr4,
|
|
Source: hostsSrc,
|
|
Names: []string{"*.com"},
|
|
}},
|
|
addr42: {{
|
|
Addr: addr42,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain.alias", "domain"},
|
|
}},
|
|
addr13: {{
|
|
Addr: addr13,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain6", "domain6.alias"},
|
|
}},
|
|
addr31: {{
|
|
Addr: addr31,
|
|
Source: hostsSrc,
|
|
Names: []string{"domain6.alias", "domain6"},
|
|
}},
|
|
}
|
|
)
|
|
|
|
func TestNewHostsContainer(t *testing.T) {
|
|
const dirname = "dir"
|
|
const filename = "file1"
|
|
|
|
p := path.Join(dirname, filename)
|
|
|
|
testFS := fstest.MapFS{
|
|
p: &fstest.MapFile{Data: []byte("127.0.0.1 localhost")},
|
|
}
|
|
|
|
testCases := []struct {
|
|
wantErr error
|
|
name string
|
|
paths []string
|
|
}{{
|
|
wantErr: nil,
|
|
name: "one_file",
|
|
paths: []string{p},
|
|
}, {
|
|
wantErr: aghnet.ErrNoHostsPaths,
|
|
name: "no_files",
|
|
paths: []string{},
|
|
}, {
|
|
wantErr: aghnet.ErrNoHostsPaths,
|
|
name: "non-existent_file",
|
|
paths: []string{path.Join(dirname, filename+"2")},
|
|
}, {
|
|
wantErr: nil,
|
|
name: "whole_dir",
|
|
paths: []string{dirname},
|
|
}}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
onAdd := func(name string) (err error) {
|
|
assert.Contains(t, tc.paths, name)
|
|
|
|
return nil
|
|
}
|
|
|
|
var eventsCalledCounter uint32
|
|
eventsCh := make(chan struct{})
|
|
onEvents := func() (e <-chan struct{}) {
|
|
assert.Equal(t, uint32(1), atomic.AddUint32(&eventsCalledCounter, 1))
|
|
|
|
return eventsCh
|
|
}
|
|
|
|
hc, err := aghnet.NewHostsContainer(testFS, &aghtest.FSWatcher{
|
|
OnEvents: onEvents,
|
|
OnAdd: onAdd,
|
|
OnClose: func() (err error) { return nil },
|
|
}, tc.paths...)
|
|
if tc.wantErr != nil {
|
|
require.ErrorIs(t, err, tc.wantErr)
|
|
|
|
assert.Nil(t, hc)
|
|
|
|
return
|
|
}
|
|
testutil.CleanupAndRequireSuccess(t, hc.Close)
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, hc)
|
|
|
|
assert.NotNil(t, <-hc.Upd())
|
|
|
|
eventsCh <- struct{}{}
|
|
assert.Equal(t, uint32(1), atomic.LoadUint32(&eventsCalledCounter))
|
|
})
|
|
}
|
|
|
|
t.Run("nil_fs", func(t *testing.T) {
|
|
require.Panics(t, func() {
|
|
_, _ = aghnet.NewHostsContainer(nil, &aghtest.FSWatcher{
|
|
// Those shouldn't panic.
|
|
OnEvents: func() (e <-chan struct{}) { return nil },
|
|
OnAdd: func(name string) (err error) { return nil },
|
|
OnClose: func() (err error) { return nil },
|
|
}, p)
|
|
})
|
|
})
|
|
|
|
t.Run("nil_watcher", func(t *testing.T) {
|
|
require.Panics(t, func() {
|
|
_, _ = aghnet.NewHostsContainer(testFS, nil, p)
|
|
})
|
|
})
|
|
|
|
t.Run("err_watcher", func(t *testing.T) {
|
|
const errOnAdd errors.Error = "error"
|
|
|
|
errWatcher := &aghtest.FSWatcher{
|
|
OnEvents: func() (e <-chan struct{}) { panic("not implemented") },
|
|
OnAdd: func(name string) (err error) { return errOnAdd },
|
|
OnClose: func() (err error) { return nil },
|
|
}
|
|
|
|
hc, err := aghnet.NewHostsContainer(testFS, errWatcher, p)
|
|
require.ErrorIs(t, err, errOnAdd)
|
|
|
|
assert.Nil(t, hc)
|
|
})
|
|
}
|
|
|
|
func TestHostsContainer_refresh(t *testing.T) {
|
|
// TODO(e.burkov): Test the case with no actual updates.
|
|
|
|
ip := netutil.IPv4Localhost()
|
|
ipStr := ip.String()
|
|
|
|
anotherIPStr := "1.2.3.4"
|
|
anotherIP := netip.MustParseAddr(anotherIPStr)
|
|
|
|
testFS := fstest.MapFS{"dir/file1": &fstest.MapFile{Data: []byte(ipStr + ` hostname` + nl)}}
|
|
|
|
// event is a convenient alias for an empty struct{} to emit test events.
|
|
type event = struct{}
|
|
|
|
eventsCh := make(chan event, 1)
|
|
t.Cleanup(func() { close(eventsCh) })
|
|
|
|
w := &aghtest.FSWatcher{
|
|
OnEvents: func() (e <-chan event) { return eventsCh },
|
|
OnAdd: func(name string) (err error) {
|
|
assert.Equal(t, "dir", name)
|
|
|
|
return nil
|
|
},
|
|
OnClose: func() (err error) { return nil },
|
|
}
|
|
|
|
hc, err := aghnet.NewHostsContainer(testFS, w, "dir")
|
|
require.NoError(t, err)
|
|
testutil.CleanupAndRequireSuccess(t, hc.Close)
|
|
|
|
checkRefresh := func(t *testing.T, want aghnet.Hosts) {
|
|
t.Helper()
|
|
|
|
upd, ok := aghchan.MustReceive(hc.Upd(), 1*time.Second)
|
|
require.True(t, ok)
|
|
|
|
assert.Equal(t, want, upd)
|
|
}
|
|
|
|
t.Run("initial_refresh", func(t *testing.T) {
|
|
checkRefresh(t, aghnet.Hosts{
|
|
ip: {{
|
|
Addr: ip,
|
|
Source: "file1",
|
|
Names: []string{"hostname"},
|
|
}},
|
|
})
|
|
})
|
|
|
|
t.Run("second_refresh", func(t *testing.T) {
|
|
testFS["dir/file2"] = &fstest.MapFile{Data: []byte(anotherIPStr + ` alias` + nl)}
|
|
eventsCh <- event{}
|
|
|
|
checkRefresh(t, aghnet.Hosts{
|
|
ip: {{
|
|
Addr: ip,
|
|
Source: "file1",
|
|
Names: []string{"hostname"},
|
|
}},
|
|
anotherIP: {{
|
|
Addr: anotherIP,
|
|
Source: "file2",
|
|
Names: []string{"alias"},
|
|
}},
|
|
})
|
|
})
|
|
|
|
t.Run("double_refresh", func(t *testing.T) {
|
|
// Make a change once.
|
|
testFS["dir/file1"] = &fstest.MapFile{Data: []byte(ipStr + ` alias` + nl)}
|
|
eventsCh <- event{}
|
|
|
|
// Require the changes are written.
|
|
require.Eventually(t, func() bool {
|
|
ips := hc.MatchName("hostname")
|
|
|
|
return len(ips) == 0
|
|
}, 5*time.Second, time.Second/2)
|
|
|
|
// Make a change again.
|
|
testFS["dir/file2"] = &fstest.MapFile{Data: []byte(ipStr + ` hostname` + nl)}
|
|
eventsCh <- event{}
|
|
|
|
// Require the changes are written.
|
|
require.Eventually(t, func() bool {
|
|
ips := hc.MatchName("hostname")
|
|
|
|
return len(ips) > 0
|
|
}, 5*time.Second, time.Second/2)
|
|
|
|
assert.Len(t, hc.Upd(), 1)
|
|
})
|
|
}
|
|
|
|
func TestHostsContainer_MatchName(t *testing.T) {
|
|
require.NoError(t, fstest.TestFS(testdata, "etc_hosts"))
|
|
|
|
stubWatcher := aghtest.FSWatcher{
|
|
OnEvents: func() (e <-chan struct{}) { return nil },
|
|
OnAdd: func(name string) (err error) { return nil },
|
|
OnClose: func() (err error) { return nil },
|
|
}
|
|
|
|
testCases := []struct {
|
|
req string
|
|
name string
|
|
want []*hostsfile.Record
|
|
}{{
|
|
req: "simplehost",
|
|
name: "simple",
|
|
want: append(testHosts[addr1001], testHosts[addr1]...),
|
|
}, {
|
|
req: "hello.world",
|
|
name: "hello_alias",
|
|
want: []*hostsfile.Record{
|
|
testHosts[addr1000][0],
|
|
testHosts[addr1000][2],
|
|
testHosts[addr0][0],
|
|
testHosts[addr0][2],
|
|
},
|
|
}, {
|
|
req: "hello.world.again",
|
|
name: "other_line_alias",
|
|
want: []*hostsfile.Record{
|
|
testHosts[addr1000][1],
|
|
testHosts[addr0][1],
|
|
},
|
|
}, {
|
|
req: "say.hello",
|
|
name: "hello_subdomain",
|
|
want: nil,
|
|
}, {
|
|
req: "say.hello.world",
|
|
name: "hello_alias_subdomain",
|
|
want: nil,
|
|
}, {
|
|
req: "for.testing",
|
|
name: "lots_of_aliases",
|
|
want: append(testHosts[addr1002], testHosts[addr2]...),
|
|
}, {
|
|
req: "nonexistent.example",
|
|
name: "non-existing",
|
|
want: nil,
|
|
}, {
|
|
req: "domain",
|
|
name: "issue_4216_4_6",
|
|
want: append(testHosts[addr4216], testHosts[addr42]...),
|
|
}, {
|
|
req: "domain4",
|
|
name: "issue_4216_4",
|
|
want: append(testHosts[addr1357], testHosts[addr7531]...),
|
|
}, {
|
|
req: "domain6",
|
|
name: "issue_4216_6",
|
|
want: append(testHosts[addr13], testHosts[addr31]...),
|
|
}}
|
|
|
|
hc, err := aghnet.NewHostsContainer(testdata, &stubWatcher, "etc_hosts")
|
|
require.NoError(t, err)
|
|
testutil.CleanupAndRequireSuccess(t, hc.Close)
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
recs := hc.MatchName(tc.req)
|
|
assert.Equal(t, tc.want, recs)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHostsContainer_MatchAddr(t *testing.T) {
|
|
require.NoError(t, fstest.TestFS(testdata, "etc_hosts"))
|
|
|
|
stubWatcher := aghtest.FSWatcher{
|
|
OnEvents: func() (e <-chan struct{}) { return nil },
|
|
OnAdd: func(name string) (err error) { return nil },
|
|
OnClose: func() (err error) { return nil },
|
|
}
|
|
|
|
hc, err := aghnet.NewHostsContainer(testdata, &stubWatcher, "etc_hosts")
|
|
require.NoError(t, err)
|
|
testutil.CleanupAndRequireSuccess(t, hc.Close)
|
|
|
|
testCases := []struct {
|
|
req netip.Addr
|
|
name string
|
|
want []*hostsfile.Record
|
|
}{{
|
|
req: netip.AddrFrom4([4]byte{1, 0, 0, 1}),
|
|
name: "reverse",
|
|
want: testHosts[addr1001],
|
|
}}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
recs := hc.MatchAddr(tc.req)
|
|
assert.Equal(t, tc.want, recs)
|
|
})
|
|
}
|
|
}
|