]> git.r.bdr.sh - rbdr/mobius/blob - hotline/transaction_test.go
git.r.bdr.sh / rbdr / mobius / blob
? search:


820b08c7f1fb6bf09cbd447bc49217a4582afb6a
[rbdr/mobius] / hotline / transaction_test.go
1 package hotline
2
3 import (
4 "fmt"
5 "github.com/stretchr/testify/assert"
6 "testing"
7 )
8
9 func TestReadFields(t *testing.T) {
10 type args struct {
11 paramCount []byte
12 buf []byte
13 }
14 tests := []struct {
15 name string
16 args args
17 want []Field
18 wantErr bool
19 }{
20 {
21 name: "valid field data",
22 args: args{
23 paramCount: []byte{0x00, 0x02},
24 buf: []byte{
25 0x00, 0x65, // ID: FieldData
26 0x00, 0x04, // Size: 2 bytes
27 0x01, 0x02, 0x03, 0x04, // Data
28 0x00, 0x66, // ID: FieldUserName
29 0x00, 0x02, // Size: 2 bytes
30 0x00, 0x01, // Data
31 },
32 },
33 want: []Field{
34 {
35 ID: [2]byte{0x00, 0x65},
36 FieldSize: [2]byte{0x00, 0x04},
37 Data: []byte{0x01, 0x02, 0x03, 0x04},
38 },
39 {
40 ID: [2]byte{0x00, 0x66},
41 FieldSize: [2]byte{0x00, 0x02},
42 Data: []byte{0x00, 0x01},
43 },
44 },
45 wantErr: false,
46 },
47 {
48 name: "empty bytes",
49 args: args{
50 paramCount: []byte{0x00, 0x00},
51 buf: []byte{},
52 },
53 want: []Field(nil),
54 wantErr: false,
55 },
56 {
57 name: "when field size does not match data length",
58 args: args{
59 paramCount: []byte{0x00, 0x01},
60 buf: []byte{
61 0x00, 0x65, // ID: FieldData
62 0x00, 0x04, // Size: 4 bytes
63 0x01, 0x02, 0x03, // Data
64 },
65 },
66 want: []Field{},
67 wantErr: true,
68 },
69 {
70 name: "when field size of second field does not match data length",
71 args: args{
72 paramCount: []byte{0x00, 0x01},
73 buf: []byte{
74 0x00, 0x65, // ID: FieldData
75 0x00, 0x02, // Size: 2 bytes
76 0x01, 0x02, // Data
77 0x00, 0x65, // ID: FieldData
78 0x00, 0x04, // Size: 4 bytes
79 0x01, 0x02, 0x03, // Data
80 },
81 },
82 want: []Field{},
83 wantErr: true,
84 },
85 {
86 name: "when field data has extra bytes",
87 args: args{
88 paramCount: []byte{0x00, 0x01},
89 buf: []byte{
90 0x00, 0x65, // ID: FieldData
91 0x00, 0x02, // Size: 2 bytes
92 0x01, 0x02, 0x03, // Data
93 },
94 },
95 want: []Field{},
96 wantErr: true,
97 },
98 }
99 for _, tt := range tests {
100 t.Run(tt.name, func(t *testing.T) {
101 got, err := ReadFields(tt.args.paramCount, tt.args.buf)
102 if (err != nil) != tt.wantErr {
103 t.Errorf("ReadFields() error = %v, wantErr %v", err, tt.wantErr)
104 return
105 }
106
107 if !assert.Equal(t, tt.want, got) {
108 t.Errorf("ReadFields() got = %v, want %v", got, tt.want)
109 }
110 })
111 }
112 }
113
114 func Test_transactionScanner(t *testing.T) {
115 type args struct {
116 data []byte
117 in1 bool
118 }
119 tests := []struct {
120 name string
121 args args
122 wantAdvance int
123 wantToken []byte
124 wantErr assert.ErrorAssertionFunc
125 }{
126 {
127 name: "when too few bytes are provided to read the transaction size",
128 args: args{
129 data: []byte{},
130 in1: false,
131 },
132 wantAdvance: 0,
133 wantToken: []byte(nil),
134 wantErr: assert.NoError,
135 },
136 {
137 name: "when too few bytes are provided to read the full payload",
138 args: args{
139 data: []byte{
140 0,
141 1,
142 0, 0,
143 0, 00, 00, 04,
144 00, 00, 00, 00,
145 00, 00, 00, 10,
146 00, 00, 00, 10,
147 },
148 in1: false,
149 },
150 wantAdvance: 0,
151 wantToken: []byte(nil),
152 wantErr: assert.NoError,
153 },
154 {
155 name: "when a full transaction is provided",
156 args: args{
157 data: []byte{
158 0,
159 1,
160 0, 0,
161 0, 00, 00, 0x04,
162 00, 00, 00, 0x00,
163 00, 00, 00, 0x10,
164 00, 00, 00, 0x10,
165 00, 02,
166 00, 0x6c, // 108 - FieldTransferSize
167 00, 02,
168 0x63, 0x3b,
169 00, 0x6b, // 107 = FieldRefNum
170 00, 0x04,
171 00, 0x02, 0x93, 0x47,
172 },
173 in1: false,
174 },
175 wantAdvance: 36,
176 wantToken: []byte{
177 0,
178 1,
179 0, 0,
180 0, 00, 00, 0x04,
181 00, 00, 00, 0x00,
182 00, 00, 00, 0x10,
183 00, 00, 00, 0x10,
184 00, 02,
185 00, 0x6c, // 108 - FieldTransferSize
186 00, 02,
187 0x63, 0x3b,
188 00, 0x6b, // 107 = FieldRefNum
189 00, 0x04,
190 00, 0x02, 0x93, 0x47,
191 },
192 wantErr: assert.NoError,
193 },
194 {
195 name: "when a full transaction plus extra bytes are provided",
196 args: args{
197 data: []byte{
198 0,
199 1,
200 0, 0,
201 0, 00, 00, 0x04,
202 00, 00, 00, 0x00,
203 00, 00, 00, 0x10,
204 00, 00, 00, 0x10,
205 00, 02,
206 00, 0x6c, // 108 - FieldTransferSize
207 00, 02,
208 0x63, 0x3b,
209 00, 0x6b, // 107 = FieldRefNum
210 00, 0x04,
211 00, 0x02, 0x93, 0x47,
212 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
213 },
214 in1: false,
215 },
216 wantAdvance: 36,
217 wantToken: []byte{
218 0,
219 1,
220 0, 0,
221 0, 00, 00, 0x04,
222 00, 00, 00, 0x00,
223 00, 00, 00, 0x10,
224 00, 00, 00, 0x10,
225 00, 02,
226 00, 0x6c, // 108 - FieldTransferSize
227 00, 02,
228 0x63, 0x3b,
229 00, 0x6b, // 107 = FieldRefNum
230 00, 0x04,
231 00, 0x02, 0x93, 0x47,
232 },
233 wantErr: assert.NoError,
234 },
235 {
236 name: "when two full transactions are provided",
237 args: args{
238 data: []byte{
239 0,
240 1,
241 0, 0,
242 0, 00, 00, 0x04,
243 00, 00, 00, 0x00,
244 00, 00, 00, 0x10,
245 00, 00, 00, 0x10,
246 00, 02,
247 00, 0x6c, // 108 - FieldTransferSize
248 00, 02,
249 0x63, 0x3b,
250 00, 0x6b, // 107 = FieldRefNum
251 00, 0x04,
252 00, 0x02, 0x93, 0x47,
253 0,
254 1,
255 0, 0,
256 0, 00, 00, 0x04,
257 00, 00, 00, 0x00,
258 00, 00, 00, 0x10,
259 00, 00, 00, 0x10,
260 00, 02,
261 00, 0x6c, // 108 - FieldTransferSize
262 00, 02,
263 0x63, 0x3b,
264 00, 0x6b, // 107 = FieldRefNum
265 00, 0x04,
266 00, 0x02, 0x93, 0x47,
267 },
268 in1: false,
269 },
270 wantAdvance: 36,
271 wantToken: []byte{
272 0,
273 1,
274 0, 0,
275 0, 00, 00, 0x04,
276 00, 00, 00, 0x00,
277 00, 00, 00, 0x10,
278 00, 00, 00, 0x10,
279 00, 02,
280 00, 0x6c, // 108 - FieldTransferSize
281 00, 02,
282 0x63, 0x3b,
283 00, 0x6b, // 107 = FieldRefNum
284 00, 0x04,
285 00, 0x02, 0x93, 0x47,
286 },
287 wantErr: assert.NoError,
288 },
289 }
290 for _, tt := range tests {
291 t.Run(tt.name, func(t *testing.T) {
292 gotAdvance, gotToken, err := transactionScanner(tt.args.data, tt.args.in1)
293 if !tt.wantErr(t, err, fmt.Sprintf("transactionScanner(%v, %v)", tt.args.data, tt.args.in1)) {
294 return
295 }
296 assert.Equalf(t, tt.wantAdvance, gotAdvance, "transactionScanner(%v, %v)", tt.args.data, tt.args.in1)
297 assert.Equalf(t, tt.wantToken, gotToken, "transactionScanner(%v, %v)", tt.args.data, tt.args.in1)
298 })
299 }
300 }
301
302 func TestTransaction_Read(t1 *testing.T) {
303 type fields struct {
304 clientID [2]byte
305 Flags byte
306 IsReply byte
307 Type [2]byte
308 ID [4]byte
309 ErrorCode [4]byte
310 TotalSize [4]byte
311 DataSize [4]byte
312 ParamCount [2]byte
313 Fields []Field
314 readOffset int
315 }
316 type args struct {
317 p []byte
318 }
319 tests := []struct {
320 name string
321 fields fields
322 args args
323 want int
324 wantErr assert.ErrorAssertionFunc
325 wantBytes []byte
326 }{
327 {
328 name: "returns transaction bytes",
329 fields: fields{
330 Flags: 0x00,
331 IsReply: 0x01,
332 Type: [2]byte{0, 0},
333 ID: [4]byte{0x9a, 0xcb, 0x04, 0x42},
334 ErrorCode: [4]byte{0, 0, 0, 0},
335 Fields: []Field{
336 NewField(FieldData, []byte("TEST")),
337 },
338 },
339 args: args{
340 p: make([]byte, 1024),
341 },
342 want: 30,
343 wantErr: assert.NoError,
344 wantBytes: []byte{0x0, 0x1, 0x0, 0x0, 0x9a, 0xcb, 0x4, 0x42, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0xa, 0x0, 0x1, 0x0, 0x65, 0x0, 0x4, 0x54, 0x45, 0x53, 0x54},
345 },
346 {
347 name: "returns transaction bytes from readOffset",
348 fields: fields{
349 Flags: 0x00,
350 IsReply: 0x01,
351 Type: [2]byte{0, 0},
352 ID: [4]byte{0x9a, 0xcb, 0x04, 0x42},
353 ErrorCode: [4]byte{0, 0, 0, 0},
354 Fields: []Field{
355 NewField(FieldData, []byte("TEST")),
356 },
357 readOffset: 20,
358 },
359 args: args{
360 p: make([]byte, 1024),
361 },
362 want: 10,
363 wantErr: assert.NoError,
364 wantBytes: []byte{0x0, 0x1, 0x0, 0x65, 0x0, 0x4, 0x54, 0x45, 0x53, 0x54},
365 },
366 {
367 name: "returns io.EOF when all bytes read",
368 fields: fields{
369 Flags: 0x00,
370 IsReply: 0x01,
371 Type: [2]byte{0, 0},
372 ID: [4]byte{0x9a, 0xcb, 0x04, 0x42},
373 ErrorCode: [4]byte{0, 0, 0, 0},
374 Fields: []Field{
375 NewField(FieldData, []byte("TEST")),
376 },
377 readOffset: 30,
378 },
379 args: args{
380 p: make([]byte, 1024),
381 },
382 want: 0,
383 wantErr: assert.Error,
384 wantBytes: []byte{},
385 },
386 }
387 for _, tt := range tests {
388 t1.Run(tt.name, func(t1 *testing.T) {
389 t := &Transaction{
390 clientID: tt.fields.clientID,
391 Flags: tt.fields.Flags,
392 IsReply: tt.fields.IsReply,
393 Type: tt.fields.Type,
394 ID: tt.fields.ID,
395 ErrorCode: tt.fields.ErrorCode,
396 TotalSize: tt.fields.TotalSize,
397 DataSize: tt.fields.DataSize,
398 ParamCount: tt.fields.ParamCount,
399 Fields: tt.fields.Fields,
400 readOffset: tt.fields.readOffset,
401 }
402 got, err := t.Read(tt.args.p)
403 if !tt.wantErr(t1, err, fmt.Sprintf("Read(%v)", tt.args.p)) {
404 return
405 }
406 assert.Equalf(t1, tt.want, got, "Read(%v)", tt.args.p)
407 assert.Equalf(t1, tt.wantBytes, tt.args.p[:got], "Read(%v)", tt.args.p)
408 })
409 }
410 }
411
412 func TestTransaction_Write(t1 *testing.T) {
413 type args struct {
414 p []byte
415 }
416 tests := []struct {
417 name string
418 args args
419 wantN int
420 wantErr assert.ErrorAssertionFunc
421 wantTransaction Transaction
422 }{
423 {
424 name: "returns error if arg p is too small",
425 args: args{p: []byte{
426 0x00, 0x00,
427 }},
428 wantN: 0,
429 wantErr: assert.Error,
430 wantTransaction: Transaction{},
431 },
432 //{
433 // name: "returns error if param data is invalid",
434 // args: args{p: []byte{
435 // 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x15, 0x72,
436 // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
437 // 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x65,
438 // 0x00, 0x03, 0x68, 0x61, 0x69,
439 // }},
440 // wantN: 0,
441 // wantErr: assert.Error,
442 // wantTransaction: Transaction{},
443 //},
444 {
445 name: "writes bytes to transaction",
446 args: args{p: []byte{
447 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x15, 0x72,
448 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
449 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x65,
450 0x00, 0x03, 0x68, 0x61, 0x69,
451 }},
452 wantN: 29,
453 wantErr: assert.NoError,
454 wantTransaction: Transaction{
455 Flags: 0,
456 IsReply: 0,
457 Type: TranChatSend,
458 ID: [4]byte{},
459 ErrorCode: [4]byte{},
460 TotalSize: [4]byte{0, 0, 0, 9},
461 DataSize: [4]byte{0, 0, 0, 9},
462 ParamCount: [2]byte{0, 1},
463 Fields: []Field{
464 {
465 ID: FieldData,
466 FieldSize: [2]byte{0, 3},
467 Data: []byte("hai"),
468 },
469 },
470 clientID: [2]byte{},
471 readOffset: 0,
472 },
473 },
474 }
475 for _, tt := range tests {
476 t1.Run(tt.name, func(t1 *testing.T) {
477 t := &Transaction{}
478 gotN, err := t.Write(tt.args.p)
479 if !tt.wantErr(t1, err, fmt.Sprintf("Write(%v)", tt.args.p)) {
480 return
481 }
482 assert.Equalf(t1, tt.wantN, gotN, "Write(%v)", tt.args.p)
483
484 tranAssertEqual(t1, []Transaction{tt.wantTransaction}, []Transaction{*t})
485 })
486 }
487 }
Friendship Quest remix of mobius, a hotline server in go #cli