1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
package dhcpv6
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestBytesToTransactionID(t *testing.T) {
// only the first three bytes should be used
tid, err := BytesToTransactionID([]byte{0x11, 0x22, 0x33, 0xaa})
require.NoError(t, err)
require.Equal(t, uint32(0x112233), *tid)
}
func TestBytesToTransactionIDShortData(t *testing.T) {
// short sequence, less than three bytes
tid, err := BytesToTransactionID([]byte{0x11, 0x22})
require.Error(t, err)
require.Nil(t, tid)
}
func TestGenerateTransactionID(t *testing.T) {
tid, err := GenerateTransactionID()
require.NoError(t, err)
require.NotNil(t, *tid)
require.True(t, *tid <= 0xffffff, "transaction ID should be smaller than 0xffffff")
}
func TestNewMessage(t *testing.T) {
d, err := NewMessage()
require.NoError(t, err)
require.NotNil(t, d)
require.Equal(t, SOLICIT, d.Type())
require.NotEqual(t, 0, d.(*DHCPv6Message).transactionID)
require.Empty(t, d.(*DHCPv6Message).options)
}
func TestSettersAndGetters(t *testing.T) {
d := DHCPv6Message{}
// Message
d.SetMessage(SOLICIT)
require.Equal(t, SOLICIT, d.Type())
d.SetMessage(ADVERTISE)
require.Equal(t, ADVERTISE, d.Type())
// TransactionID
d.SetTransactionID(12345)
require.Equal(t, uint32(12345), d.TransactionID())
// Options
require.Empty(t, d.Options())
expectedOptions := []Option{&OptionGeneric{OptionCode: 0, OptionData: []byte{}}}
d.SetOptions(expectedOptions)
require.Equal(t, expectedOptions, d.Options())
}
func TestAddOption(t *testing.T) {
d := DHCPv6Message{}
require.Empty(t, d.Options())
opt := OptionGeneric{OptionCode: 0, OptionData: []byte{}}
d.AddOption(&opt)
require.Equal(t, []Option{&opt}, d.Options())
}
func TestToBytes(t *testing.T) {
d := DHCPv6Message{}
d.SetMessage(SOLICIT)
d.SetTransactionID(0xabcdef)
opt := OptionGeneric{OptionCode: 0, OptionData: []byte{}}
d.AddOption(&opt)
bytes := d.ToBytes()
expected := []byte{01, 0xab, 0xcd, 0xef, 0x00, 0x00, 0x00, 0x00}
require.Equal(t, expected, bytes)
}
func TestFromAndToBytes(t *testing.T) {
expected := []byte{01, 0xab, 0xcd, 0xef, 0x00, 0x00, 0x00, 0x00}
d, err := FromBytes(expected)
require.NoError(t, err)
toBytes := d.ToBytes()
require.Equal(t, expected, toBytes)
}
func withServerID(d DHCPv6) DHCPv6 {
sid := OptServerId{}
d.AddOption(&sid)
return d
}
func TestNewAdvertiseFromSolicit(t *testing.T) {
s := DHCPv6Message{}
s.SetMessage(SOLICIT)
s.SetTransactionID(0xabcdef)
cid := OptClientId{}
s.AddOption(&cid)
a, err := NewAdvertiseFromSolicit(&s, withServerID)
require.NoError(t, err)
require.Equal(t, a.(*DHCPv6Message).TransactionID(), s.TransactionID())
require.Equal(t, a.Type(), ADVERTISE)
}
func TestNewReplyFromRequest(t *testing.T) {
req := DHCPv6Message{}
req.SetMessage(REQUEST)
req.SetTransactionID(0xabcdef)
cid := OptClientId{}
req.AddOption(&cid)
sid := OptServerId{}
req.AddOption(&sid)
rep, err := NewReplyFromRequest(&req)
require.NoError(t, err)
require.Equal(t, rep.(*DHCPv6Message).TransactionID(), req.TransactionID())
require.Equal(t, rep.Type(), REPLY)
}
// TODO test NewSolicit
// test String and Summary
|
