Skip to content

Commit

Permalink
all: imp tests drastically
Browse files Browse the repository at this point in the history
  • Loading branch information
@EugeneOne1
EugeneOne1 committed Feb 10, 2021
1 parent 6471504 commit 9e74adb
Show file tree
Hide file tree
Showing 10 changed files with 570 additions and 423 deletions.
7 changes: 4 additions & 3 deletions internal/aghio/limitedreadcloser_test.go
View file
Expand Up @@ -8,6 +8,7 @@ import (
"testing"

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestLimitReadCloser(t *testing.T) {
Expand Down Expand Up @@ -78,11 +79,11 @@ func TestLimitedReadCloser_Read(t *testing.T) {
buf := make([]byte, tc.limit+1)

lreader, err := LimitReadCloser(readCloser, tc.limit)
assert.Nil(t, err)
require.Nil(t, err)

n, err := lreader.Read(buf)
assert.Equal(t, n, tc.want)
assert.Equal(t, tc.err, err)
require.Equal(t, tc.err, err)
assert.Equal(t, tc.want, n)
})
}
}
Expand Down
193 changes: 117 additions & 76 deletions internal/dhcpd/dhcpd_test.go
View file
Expand Up @@ -11,6 +11,7 @@ import (

"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestMain(m *testing.M) {
Expand All @@ -20,116 +21,156 @@ func TestMain(m *testing.M) {
func testNotify(flags uint32) {
}

// Leases database store/load
// Leases database store/load.
func TestDB(t *testing.T) {
var err error
s := Server{}
s.conf.DBFilePath = dbFilename
s := Server{
conf: ServerConfig{
DBFilePath: dbFilename,
},
}

conf := V4ServerConf{
s.srv4, err = v4Create(V4ServerConf{
Enabled: true,
RangeStart: net.IP{192, 168, 10, 100},
RangeEnd: net.IP{192, 168, 10, 200},
GatewayIP: net.IP{192, 168, 10, 1},
SubnetMask: net.IP{255, 255, 255, 0},
notify: testNotify,
}
s.srv4, err = v4Create(conf)
assert.Nil(t, err)
})
require.Nil(t, err)

s.srv6, err = v6Create(V6ServerConf{})
assert.Nil(t, err)
require.Nil(t, err)

l := Lease{}
l.IP = net.IP{192, 168, 10, 100}
l.HWAddr, _ = net.ParseMAC("aa:aa:aa:aa:aa:aa")
exp1 := time.Now().Add(time.Hour)
l.Expiry = exp1
leases := []Lease{{
IP: net.IP{192, 168, 10, 100},
HWAddr: net.HardwareAddr{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA},
Expiry: time.Now().Add(time.Hour),
}, {
IP: net.IP{192, 168, 10, 101},
HWAddr: net.HardwareAddr{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB},
}}

srv4, ok := s.srv4.(*v4Server)
assert.True(t, ok)
require.True(t, ok)

srv4.addLease(&l)
srv4.addLease(&leases[0])
require.Nil(t, s.srv4.AddStaticLease(leases[1]))

l2 := Lease{}
l2.IP = net.IP{192, 168, 10, 101}
l2.HWAddr, _ = net.ParseMAC("aa:aa:aa:aa:aa:bb")
err = s.srv4.AddStaticLease(l2)
assert.Nil(t, err)

_ = os.Remove("leases.db")
s.dbStore()
t.Cleanup(func() {
assert.Nil(t, os.Remove(dbFilename))
})
s.srv4.ResetLeases(nil)

s.dbLoad()

ll := s.srv4.GetLeases(LeasesAll)
require.Len(t, ll, len(leases))

assert.Equal(t, "aa:aa:aa:aa:aa:bb", ll[0].HWAddr.String())
assert.True(t, net.IP{192, 168, 10, 101}.Equal(ll[0].IP))
assert.Equal(t, leases[1].HWAddr, ll[0].HWAddr)
assert.Equal(t, leases[1].IP, ll[0].IP)
assert.EqualValues(t, leaseExpireStatic, ll[0].Expiry.Unix())

assert.Equal(t, "aa:aa:aa:aa:aa:aa", ll[1].HWAddr.String())
assert.True(t, net.IP{192, 168, 10, 100}.Equal(ll[1].IP))
assert.Equal(t, exp1.Unix(), ll[1].Expiry.Unix())

_ = os.Remove("leases.db")
assert.Equal(t, leases[0].HWAddr, ll[1].HWAddr)
assert.Equal(t, leases[0].IP, ll[1].IP)
assert.Equal(t, leases[0].Expiry.Unix(), ll[1].Expiry.Unix())
}

func TestIsValidSubnetMask(t *testing.T) {
assert.True(t, isValidSubnetMask([]byte{255, 255, 255, 0}))
assert.True(t, isValidSubnetMask([]byte{255, 255, 254, 0}))
assert.True(t, isValidSubnetMask([]byte{255, 255, 252, 0}))
assert.False(t, isValidSubnetMask([]byte{255, 255, 253, 0}))
assert.False(t, isValidSubnetMask([]byte{255, 255, 255, 1}))
testCases := []struct {
mask net.IP
want bool
}{{
mask: net.IP{255, 255, 255, 0},
want: true,
}, {
mask: net.IP{255, 255, 254, 0},
want: true,
}, {
mask: net.IP{255, 255, 252, 0},
want: true,
}, {
mask: net.IP{255, 255, 253, 0},
}, {
mask: net.IP{255, 255, 255, 1},
}}

for _, tc := range testCases {
t.Run(tc.mask.String(), func(t *testing.T) {
assert.Equal(t, tc.want, isValidSubnetMask(tc.mask))
})
}
}

func TestNormalizeLeases(t *testing.T) {
dynLeases := []*Lease{}
staticLeases := []*Lease{}

lease := &Lease{}
lease.HWAddr = []byte{1, 2, 3, 4}
dynLeases = append(dynLeases, lease)
lease = new(Lease)
lease.HWAddr = []byte{1, 2, 3, 5}
dynLeases = append(dynLeases, lease)

lease = new(Lease)
lease.HWAddr = []byte{1, 2, 3, 4}
lease.IP = []byte{0, 2, 3, 4}
staticLeases = append(staticLeases, lease)
lease = new(Lease)
lease.HWAddr = []byte{2, 2, 3, 4}
staticLeases = append(staticLeases, lease)
dynLeases := []*Lease{{
HWAddr: net.HardwareAddr{1, 2, 3, 4},
}, {
HWAddr: net.HardwareAddr{1, 2, 3, 5},
}}

staticLeases := []*Lease{{
HWAddr: net.HardwareAddr{1, 2, 3, 4},
IP: net.IP{0, 2, 3, 4},
}, {
HWAddr: net.HardwareAddr{2, 2, 3, 4},
}}

leases := normalizeLeases(staticLeases, dynLeases)
require.Len(t, leases, 3)

assert.Len(t, leases, 3)
assert.True(t, bytes.Equal(leases[0].HWAddr, []byte{1, 2, 3, 4}))
assert.True(t, bytes.Equal(leases[0].IP, []byte{0, 2, 3, 4}))
assert.True(t, bytes.Equal(leases[1].HWAddr, []byte{2, 2, 3, 4}))
assert.True(t, bytes.Equal(leases[2].HWAddr, []byte{1, 2, 3, 5}))
assert.Equal(t, leases[0].HWAddr, dynLeases[0].HWAddr)
assert.Equal(t, leases[0].IP, staticLeases[0].IP)
assert.Equal(t, leases[1].HWAddr, staticLeases[1].HWAddr)
assert.Equal(t, leases[2].HWAddr, dynLeases[1].HWAddr)
}

func TestOptions(t *testing.T) {
code, val := parseOptionString(" 12 hex abcdef ")
assert.EqualValues(t, 12, code)
assert.True(t, bytes.Equal([]byte{0xab, 0xcd, 0xef}, val))

code, _ = parseOptionString(" 12 hex abcdef1 ")
assert.EqualValues(t, 0, code)

code, val = parseOptionString("123 ip 1.2.3.4")
assert.EqualValues(t, 123, code)
assert.True(t, net.IP{1, 2, 3, 4}.Equal(net.IP(val)))

code, _ = parseOptionString("256 ip 1.1.1.1")
assert.EqualValues(t, 0, code)
code, _ = parseOptionString("-1 ip 1.1.1.1")
assert.EqualValues(t, 0, code)
code, _ = parseOptionString("12 ip 1.1.1.1x")
assert.EqualValues(t, 0, code)
code, _ = parseOptionString("12 x 1.1.1.1")
assert.EqualValues(t, 0, code)
testCases := []struct {
name string
optStr string
wantCode uint8
wantVal []byte
}{{
name: "all_right_hex",
optStr: " 12 hex abcdef ",
wantCode: 12,
wantVal: []byte{0xab, 0xcd, 0xef},
}, {
name: "bad_hex",
optStr: " 12 hex abcdef1 ",
wantCode: 0,
}, {
name: "all_right_ip",
optStr: "123 ip 1.2.3.4",
wantCode: 123,
wantVal: net.IPv4(1, 2, 3, 4),
}, {
name: "bad_code",
optStr: "256 ip 1.1.1.1",
wantCode: 0,
}, {
name: "negative_code",
optStr: "-1 ip 1.1.1.1",
wantCode: 0,
}, {
name: "bad_ip",
optStr: "12 ip 1.1.1.1x",
wantCode: 0,
}, {
name: "bad_mode",
optStr: "12 x 1.1.1.1",
wantCode: 0,
}}

for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
code, val := parseOptionString(tc.optStr)
require.EqualValues(t, tc.wantCode, code)
if tc.wantVal != nil {
assert.True(t, bytes.Equal(tc.wantVal, val))
}
})
}
}
3 changes: 2 additions & 1 deletion internal/dhcpd/dhcphttp_test.go
View file
Expand Up @@ -6,6 +6,7 @@ import (
"testing"

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestServer_notImplemented(t *testing.T) {
Expand All @@ -14,7 +15,7 @@ func TestServer_notImplemented(t *testing.T) {

w := httptest.NewRecorder()
r, err := http.NewRequest(http.MethodGet, "/unsupported", nil)
assert.Nil(t, err)
require.Nil(t, err)

h(w, r)
assert.Equal(t, http.StatusNotImplemented, w.Code)
Expand Down
8 changes: 3 additions & 5 deletions internal/dhcpd/routeradv_test.go
View file
@@ -1,24 +1,22 @@
package dhcpd

import (
"bytes"
"net"
"testing"

"github.com/stretchr/testify/assert"
)

func TestRA(t *testing.T) {
ra := icmpv6RA{
data := createICMPv6RAPacket(icmpv6RA{
managedAddressConfiguration: false,
otherConfiguration: true,
mtu: 1500,
prefix: net.ParseIP("1234::"),
prefixLen: 64,
recursiveDNSServer: net.ParseIP("fe80::800:27ff:fe00:0"),
sourceLinkLayerAddress: []byte{0x0a, 0x00, 0x27, 0x00, 0x00, 0x00},
}
data := createICMPv6RAPacket(ra)
})
dataCorrect := []byte{
0x86, 0x00, 0x00, 0x00, 0x40, 0x40, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x0e, 0x10, 0x00, 0x00, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00,
Expand All @@ -27,5 +25,5 @@ func TestRA(t *testing.T) {
0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x10, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0x00, 0x27, 0xff, 0xfe, 0x00, 0x00, 0x00,
}
assert.True(t, bytes.Equal(data, dataCorrect))
assert.Equal(t, dataCorrect, data)
}
3 changes: 2 additions & 1 deletion internal/dhcpd/v4.go
View file
Expand Up @@ -23,7 +23,8 @@ type v4Server struct {
srv *server4.Server
leasesLock sync.Mutex
leases []*Lease
ipAddrs [256]byte
// TODO(e.burkov): Use smarter approach.
ipAddrs [256]byte

conf V4ServerConf
}
Expand Down
21 changes: 7 additions & 14 deletions internal/dhcpd/v46_test.go
View file
Expand Up @@ -7,6 +7,7 @@ import (

"github.com/AdguardTeam/AdGuardHome/internal/agherr"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

type fakeIface struct {
Expand Down Expand Up @@ -79,8 +80,8 @@ func TestIfaceIPAddrs(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
got, gotErr := ifaceIPAddrs(tc.iface, tc.ipv)
require.True(t, errors.Is(gotErr, tc.wantErr))
assert.Equal(t, tc.want, got)
assert.True(t, errors.Is(gotErr, tc.wantErr))
})
}
}
Expand Down Expand Up @@ -140,12 +141,8 @@ func TestIfaceDNSIPAddrs(t *testing.T) {
want: nil,
wantErr: errTest,
}, {
name: "ipv4_wait",
iface: &waitingFakeIface{
addrs: []net.Addr{addr4},
err: nil,
n: 1,
},
name: "ipv4_wait",
iface: &waitingFakeIface{addrs: []net.Addr{addr4}, err: nil, n: 1},
ipv: ipVersion4,
want: []net.IP{ip4, ip4},
wantErr: nil,
Expand All @@ -168,12 +165,8 @@ func TestIfaceDNSIPAddrs(t *testing.T) {
want: nil,
wantErr: errTest,
}, {
name: "ipv6_wait",
iface: &waitingFakeIface{
addrs: []net.Addr{addr6},
err: nil,
n: 1,
},
name: "ipv6_wait",
iface: &waitingFakeIface{addrs: []net.Addr{addr6}, err: nil, n: 1},
ipv: ipVersion6,
want: []net.IP{ip6, ip6},
wantErr: nil,
Expand All @@ -182,8 +175,8 @@ func TestIfaceDNSIPAddrs(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
got, gotErr := ifaceDNSIPAddrs(tc.iface, tc.ipv, 2, 0)
require.True(t, errors.Is(gotErr, tc.wantErr))
assert.Equal(t, tc.want, got)
assert.True(t, errors.Is(gotErr, tc.wantErr))
})
}
}

0 comments on commit 9e74adb

Please sign in to comment.