helpers_test.go

package dhcp4

import (
	"bytes"
	"net"
	"reflect"
	"sort"
	"testing"
	"time"
)

// Verify that all options are returned by Options.SelectOrderOrAll if
// the input order value is nil.
func TestSelectOrderOrAllNil(t *testing.T) {
	assertOptionsSlices(t, 0, "nil order", allOptionsSlice, optMap.SelectOrderOrAll(nil))
}

// Verify that all options are returned by Options.SelectOrderOrAll if
// the input order value is not nil over several tests.
func TestSelectOrderOrAllNotNil(t *testing.T) {
	for i, tt := range selectOrderTests {
		assertOptionsSlices(t, i, tt.description, tt.result, optMap.SelectOrderOrAll(tt.order))
	}
}

// Verify that no options are returned by Options.SelectOrder if
// the input order value is nil.
func TestSelectOrderNil(t *testing.T) {
	assertOptionsSlices(t, 0, "nil order", nil, optMap.SelectOrder(nil))
}

// Verify that all options are returned by Options.SelectOrder if
// the input order value is not nil over several tests.
func TestSelectOrderNotNil(t *testing.T) {
	for i, tt := range selectOrderTests {
		assertOptionsSlices(t, i, tt.description, tt.result, optMap.SelectOrder(tt.order))
	}
}

func TestIPRange(t *testing.T) {
	var tests = []struct {
		start  net.IP
		stop   net.IP
		result int
	}{
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 1, 1),
			result: 1,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 1, 254),
			result: 254,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 10, 1),
			result: 2305,
		},
		{
			start:  net.IPv4(172, 16, 1, 1),
			stop:   net.IPv4(192, 168, 1, 1),
			result: 345505793,
		},
	}

	for _, tt := range tests {
		if result := IPRange(tt.start, tt.stop); result != tt.result {
			t.Fatalf("IPRange(%s, %s), unexpected result: %v != %v",
				tt.start, tt.stop, result, tt.result)
		}
	}
}

func TestIPAdd(t *testing.T) {
	var tests = []struct {
		start  net.IP
		add    int
		result net.IP
	}{
		{
			start:  net.IPv4(192, 168, 1, 1),
			add:    0,
			result: net.IPv4(192, 168, 1, 1),
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			add:    253,
			result: net.IPv4(192, 168, 1, 254),
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			add:    1024,
			result: net.IPv4(192, 168, 5, 1),
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			add:    4096,
			result: net.IPv4(192, 168, 17, 1),
		},
	}

	for _, tt := range tests {
		if result := IPAdd(tt.start, tt.add); !result.Equal(tt.result) {
			t.Fatalf("IPAdd(%s, %d), unexpected result: %v != %v",
				tt.start, tt.add, result, tt.result)
		}
	}
}

func TestIPLess(t *testing.T) {
	var tests = []struct {
		a      net.IP
		b      net.IP
		result bool
	}{
		{
			a:      net.IPv4(192, 168, 1, 1),
			b:      net.IPv4(192, 168, 1, 1),
			result: false,
		},
		{
			a:      net.IPv4(192, 168, 1, 1),
			b:      net.IPv4(192, 168, 0, 1),
			result: false,
		},
		{
			a:      net.IPv4(192, 168, 0, 1),
			b:      net.IPv4(192, 168, 1, 1),
			result: true,
		},
		{
			a:      net.IPv4(192, 168, 0, 1),
			b:      net.IPv4(192, 168, 10, 1),
			result: true,
		},
	}

	for _, tt := range tests {
		if result := IPLess(tt.a, tt.b); result != tt.result {
			t.Fatalf("IPLess(%s, %s), unexpected result: %v != %v",
				tt.a, tt.b, result, tt.result)
		}
	}
}

func TestIPInRange(t *testing.T) {
	var tests = []struct {
		start  net.IP
		stop   net.IP
		ip     net.IP
		result bool
	}{
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 2, 1),
			ip:     net.IPv4(192, 168, 3, 1),
			result: false,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 10, 1),
			ip:     net.IPv4(192, 168, 0, 1),
			result: false,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 10, 1),
			ip:     net.IPv4(192, 168, 5, 1),
			result: true,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 3, 1),
			ip:     net.IPv4(192, 168, 3, 0),
			result: true,
		},
		{
			start:  net.IPv4(192, 168, 1, 1),
			stop:   net.IPv4(192, 168, 1, 1),
			ip:     net.IPv4(192, 168, 1, 1),
			result: true,
		},
	}

	for _, tt := range tests {
		if result := IPInRange(tt.start, tt.stop, tt.ip); result != tt.result {
			t.Fatalf("IPInRange(%s, %s, %s), unexpected result: %v != %v",
				tt.start, tt.stop, tt.ip, result, tt.result)
		}
	}
}

func TestOptionsLeaseTime(t *testing.T) {
	var tests = []struct {
		duration time.Duration
		result   []byte
	}{
		{
			duration: 0 * time.Second,
			result:   []byte{0, 0, 0, 0},
		},
		{
			duration: 2 * time.Second,
			result:   []byte{0, 0, 0, 2},
		},
		{
			duration: 60 * time.Second,
			result:   []byte{0, 0, 0, 60},
		},
		{
			duration: 6 * time.Hour,
			result:   []byte{0, 0, 84, 96},
		},
		{
			duration: 24 * time.Hour,
			result:   []byte{0, 1, 81, 128},
		},
		{
			duration: 365 * 24 * time.Hour,
			result:   []byte{1, 225, 51, 128},
		},
	}

	for _, tt := range tests {
		if result := OptionsLeaseTime(tt.duration); !bytes.Equal(result, tt.result) {
			t.Fatalf("OptionsLeaseTime(%s), unexpected result: %v != %v",
				tt.duration, result, tt.result)
		}
	}
}

func TestJoinIPs(t *testing.T) {
	var tests = []struct {
		ips    []net.IP
		result []byte
	}{
		{
			ips:    []net.IP{net.IPv4(10, 0, 0, 1)},
			result: []byte{10, 0, 0, 1},
		},
		{
			ips:    []net.IP{net.IPv4(192, 168, 1, 1), net.IPv4(192, 168, 2, 1)},
			result: []byte{192, 168, 1, 1, 192, 168, 2, 1},
		},
		{
			ips:    []net.IP{net.IPv4(10, 0, 0, 1), net.IPv4(255, 255, 255, 254)},
			result: []byte{10, 0, 0, 1, 255, 255, 255, 254},
		},
		{
			ips:    []net.IP{net.IPv4(8, 8, 8, 8), net.IPv4(8, 8, 4, 4), net.IPv4(192, 168, 1, 1)},
			result: []byte{8, 8, 8, 8, 8, 8, 4, 4, 192, 168, 1, 1},
		},
	}

	for _, tt := range tests {
		if result := JoinIPs(tt.ips); !bytes.Equal(result, tt.result) {
			t.Fatalf("JoinIPs(%s), unexpected result: %v != %v",
				tt.ips, result, tt.result)
		}
	}
}

// byOptionCode implements sort.Interface for []Option.
type byOptionCode []Option

func (b byOptionCode) Len() int               { return len(b) }
func (b byOptionCode) Less(i int, j int) bool { return b[i].Code < b[j].Code }
func (b byOptionCode) Swap(i int, j int)      { b[i], b[j] = b[j], b[i] }

// assertOptionsSlices is a test helper which verifies that two options slices
// are identical.  Several parameters are passed for easy identification of
// failing tests.
func assertOptionsSlices(t *testing.T, i int, description string, want []Option, got []Option) {
	// Verify slices are same length
	if want, got := len(want), len(got); want != got {
		t.Fatalf("%02d: test %q, mismatched length: %d != %d",
			i, description, want, got)
	}

	// Sort slices
	sort.Sort(byOptionCode(want))
	sort.Sort(byOptionCode(got))

	// Verify slices are identical
	if len(want) > 0 && len(got) > 0 && !reflect.DeepEqual(want, got) {
		t.Fatalf("%02d: test %q, unexpected options: %v != %v",
			i, description, want, got)
	}
}

// optMap is an Options map which contains a number of option
// codes and values, used for testing.
var optMap = Options{
	OptionSubnetMask:       []byte{255, 255, 255, 0},
	OptionRouter:           []byte{192, 168, 1, 1},
	OptionDomainNameServer: []byte{192, 168, 1, 2},
	OptionTimeServer:       []byte{192, 168, 1, 3},
	OptionLogServer:        []byte{192, 168, 1, 4},
}

// allOptionsSlice is a []Option derived from optMap.  It is used
// for some tests.
var allOptionsSlice = []Option{
	Option{
		Code:  OptionSubnetMask,
		Value: optMap[OptionSubnetMask],
	},
	Option{
		Code:  OptionRouter,
		Value: optMap[OptionRouter],
	},
	Option{
		Code:  OptionDomainNameServer,
		Value: optMap[OptionDomainNameServer],
	},
	Option{
		Code:  OptionTimeServer,
		Value: optMap[OptionTimeServer],
	},
	Option{
		Code:  OptionLogServer,
		Value: optMap[OptionLogServer],
	},
}

// selectOrderTests is a set of tests used for Options.SelectOrder
// and Options.SelectOrderOrAll methods.
var selectOrderTests = []struct {
	description string
	order       []byte
	result      []Option
}{
	{
		description: "subnet mask only",
		order: []byte{
			byte(OptionSubnetMask),
		},
		result: []Option{
			Option{
				Code:  OptionSubnetMask,
				Value: optMap[OptionSubnetMask],
			},
		},
	},
	{
		description: "subnet mask and time server",
		order: []byte{
			byte(OptionSubnetMask),
			byte(OptionTimeServer),
		},
		result: []Option{
			Option{
				Code:  OptionSubnetMask,
				Value: optMap[OptionSubnetMask],
			},
			Option{
				Code:  OptionTimeServer,
				Value: optMap[OptionTimeServer],
			},
		},
	},
	{
		description: "domain name server, time server, router",
		order: []byte{
			byte(OptionDomainNameServer),
			byte(OptionTimeServer),
			byte(OptionRouter),
		},
		result: []Option{
			Option{
				Code:  OptionDomainNameServer,
				Value: optMap[OptionDomainNameServer],
			},
			Option{
				Code:  OptionTimeServer,
				Value: optMap[OptionTimeServer],
			},
			Option{
				Code:  OptionRouter,
				Value: optMap[OptionRouter],
			},
		},
	},
	{
		description: "all options in order",
		order: []byte{
			byte(OptionSubnetMask),
			byte(OptionRouter),
			byte(OptionDomainNameServer),
			byte(OptionTimeServer),
			byte(OptionLogServer),
		},
		result: allOptionsSlice,
	},
}