forked from coder/coder
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathcodec_test.go
More file actions
145 lines (119 loc) · 3.48 KB
/
Copy pathcodec_test.go
File metadata and controls
145 lines (119 loc) · 3.48 KB
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package codec_test
import (
"bytes"
"encoding/binary"
"io"
"testing"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/agent/boundarylogproxy/codec"
)
func TestRoundTrip(t *testing.T) {
t.Parallel()
tests := []struct {
name string
tag codec.Tag
data []byte
}{
{
name: "empty data",
tag: codec.TagV1,
data: []byte{},
},
{
name: "simple data",
tag: codec.TagV1,
data: []byte("hello world"),
},
{
name: "binary data",
tag: codec.TagV1,
data: []byte{0x00, 0x01, 0x02, 0xff, 0xfe},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
err := codec.WriteFrame(&buf, tt.tag, tt.data)
require.NoError(t, err)
readBuf := make([]byte, codec.MaxMessageSizeV1)
tag, data, err := codec.ReadFrame(&buf, readBuf)
require.NoError(t, err)
require.Equal(t, tt.tag, tag)
require.Equal(t, tt.data, data)
})
}
}
func TestReadFrameTooLarge(t *testing.T) {
t.Parallel()
// Hand construct a header that indicates the message size exceeds the maximum
// message size for codec.TagV1 by one. We just write the header to buf because
// we expect codec.ReadFrame to bail out when reading the invalid length.
header := uint32(codec.TagV1)<<codec.DataLength | (codec.MaxMessageSizeV1 + 1)
data := make([]byte, 4)
binary.BigEndian.PutUint32(data, header)
var buf bytes.Buffer
_, err := buf.Write(data)
require.NoError(t, err)
readBuf := make([]byte, 1)
_, _, err = codec.ReadFrame(&buf, readBuf)
require.ErrorIs(t, err, codec.ErrMessageTooLarge)
}
func TestReadFrameEmptyReader(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
readBuf := make([]byte, codec.MaxMessageSizeV1)
_, _, err := codec.ReadFrame(&buf, readBuf)
require.ErrorIs(t, err, io.EOF)
}
func TestReadFrameInvalidTag(t *testing.T) {
t.Parallel()
// Hand construct a header that indicates a tag we don't know about. We just
// write the header to buf because we expect codec.ReadFrame to bail out when
// reading the invalid tag.
const (
dataLength uint32 = 10
bogusTag uint32 = 222
)
header := bogusTag<<codec.DataLength | dataLength
data := make([]byte, 4)
binary.BigEndian.PutUint32(data, header)
var buf bytes.Buffer
_, err := buf.Write(data)
require.NoError(t, err)
readBuf := make([]byte, 1)
_, _, err = codec.ReadFrame(&buf, readBuf)
require.ErrorIs(t, err, codec.ErrUnsupportedTag)
}
func TestReadFrameAllocatesWhenNeeded(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
data := []byte("this message is longer than the buffer")
err := codec.WriteFrame(&buf, codec.TagV1, data)
require.NoError(t, err)
// Buffer with insufficient capacity triggers allocation.
readBuf := make([]byte, 4)
tag, got, err := codec.ReadFrame(&buf, readBuf)
require.NoError(t, err)
require.Equal(t, codec.TagV1, tag)
require.Equal(t, data, got)
}
func TestWriteFrameDataSize(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
data := make([]byte, codec.MaxMessageSizeV1)
err := codec.WriteFrame(&buf, codec.TagV1, data)
require.NoError(t, err)
//nolint: makezero // This intentionally increases the slice length.
data = append(data, 0) // One byte over the maximum
err = codec.WriteFrame(&buf, codec.TagV1, data)
require.ErrorIs(t, err, codec.ErrMessageTooLarge)
}
func TestWriteFrameInvalidTag(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
data := make([]byte, 1)
const bogusTag = 222
err := codec.WriteFrame(&buf, codec.Tag(bogusTag), data)
require.ErrorIs(t, err, codec.ErrUnsupportedTag)
}