]> git.r.bdr.sh - rbdr/mobius/blob - hotline/transaction_handlers_test.go
git.r.bdr.sh / rbdr / mobius / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Replace zap logger with slog
[rbdr/mobius] / hotline / transaction_handlers_test.go
1 package hotline
2
3 import (
4 "errors"
5 "fmt"
6 "github.com/stretchr/testify/assert"
7 "github.com/stretchr/testify/mock"
8 "io"
9 "io/fs"
10 "math/rand"
11 "os"
12 "path/filepath"
13 "strings"
14 "testing"
15 "time"
16 )
17
18 func TestHandleSetChatSubject(t *testing.T) {
19 type args struct {
20 cc *ClientConn
21 t *Transaction
22 }
23 tests := []struct {
24 name string
25 args args
26 want []Transaction
27 wantErr bool
28 }{
29 {
30 name: "sends chat subject to private chat members",
31 args: args{
32 cc: &ClientConn{
33 UserName: []byte{0x00, 0x01},
34 Server: &Server{
35 PrivateChats: map[uint32]*PrivateChat{
36 uint32(1): {
37 Subject: "unset",
38 ClientConn: map[uint16]*ClientConn{
39 uint16(1): {
40 Account: &Account{
41 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
42 },
43 ID: &[]byte{0, 1},
44 },
45 uint16(2): {
46 Account: &Account{
47 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
48 },
49 ID: &[]byte{0, 2},
50 },
51 },
52 },
53 },
54 Clients: map[uint16]*ClientConn{
55 uint16(1): {
56 Account: &Account{
57 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
58 },
59 ID: &[]byte{0, 1},
60 },
61 uint16(2): {
62 Account: &Account{
63 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
64 },
65 ID: &[]byte{0, 2},
66 },
67 },
68 },
69 },
70 t: &Transaction{
71 Flags: 0x00,
72 IsReply: 0x00,
73 Type: []byte{0, 0x6a},
74 ID: []byte{0, 0, 0, 1},
75 ErrorCode: []byte{0, 0, 0, 0},
76 Fields: []Field{
77 NewField(FieldChatID, []byte{0, 0, 0, 1}),
78 NewField(FieldChatSubject, []byte("Test Subject")),
79 },
80 },
81 },
82 want: []Transaction{
83 {
84 clientID: &[]byte{0, 1},
85 Flags: 0x00,
86 IsReply: 0x00,
87 Type: []byte{0, 0x77},
88 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
89 ErrorCode: []byte{0, 0, 0, 0},
90 Fields: []Field{
91 NewField(FieldChatID, []byte{0, 0, 0, 1}),
92 NewField(FieldChatSubject, []byte("Test Subject")),
93 },
94 },
95 {
96 clientID: &[]byte{0, 2},
97 Flags: 0x00,
98 IsReply: 0x00,
99 Type: []byte{0, 0x77},
100 ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
101 ErrorCode: []byte{0, 0, 0, 0},
102 Fields: []Field{
103 NewField(FieldChatID, []byte{0, 0, 0, 1}),
104 NewField(FieldChatSubject, []byte("Test Subject")),
105 },
106 },
107 },
108 wantErr: false,
109 },
110 }
111 for _, tt := range tests {
112 rand.Seed(1) // reset seed between tests to make transaction IDs predictable
113
114 t.Run(tt.name, func(t *testing.T) {
115 got, err := HandleSetChatSubject(tt.args.cc, tt.args.t)
116 if (err != nil) != tt.wantErr {
117 t.Errorf("HandleSetChatSubject() error = %v, wantErr %v", err, tt.wantErr)
118 return
119 }
120 if !assert.Equal(t, tt.want, got) {
121 t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want)
122 }
123 })
124 }
125 }
126
127 func TestHandleLeaveChat(t *testing.T) {
128 type args struct {
129 cc *ClientConn
130 t *Transaction
131 }
132 tests := []struct {
133 name string
134 args args
135 want []Transaction
136 wantErr bool
137 }{
138 {
139 name: "returns expected transactions",
140 args: args{
141 cc: &ClientConn{
142 ID: &[]byte{0, 2},
143 Server: &Server{
144 PrivateChats: map[uint32]*PrivateChat{
145 uint32(1): {
146 ClientConn: map[uint16]*ClientConn{
147 uint16(1): {
148 Account: &Account{
149 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
150 },
151 ID: &[]byte{0, 1},
152 },
153 uint16(2): {
154 Account: &Account{
155 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
156 },
157 ID: &[]byte{0, 2},
158 },
159 },
160 },
161 },
162 Clients: map[uint16]*ClientConn{
163 uint16(1): {
164 Account: &Account{
165 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
166 },
167 ID: &[]byte{0, 1},
168 },
169 uint16(2): {
170 Account: &Account{
171 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
172 },
173 ID: &[]byte{0, 2},
174 },
175 },
176 },
177 },
178 t: NewTransaction(TranDeleteUser, nil, NewField(FieldChatID, []byte{0, 0, 0, 1})),
179 },
180 want: []Transaction{
181 {
182 clientID: &[]byte{0, 1},
183 Flags: 0x00,
184 IsReply: 0x00,
185 Type: []byte{0, 0x76},
186 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
187 ErrorCode: []byte{0, 0, 0, 0},
188 Fields: []Field{
189 NewField(FieldChatID, []byte{0, 0, 0, 1}),
190 NewField(FieldUserID, []byte{0, 2}),
191 },
192 },
193 },
194 wantErr: false,
195 },
196 }
197 for _, tt := range tests {
198 rand.Seed(1)
199 t.Run(tt.name, func(t *testing.T) {
200 got, err := HandleLeaveChat(tt.args.cc, tt.args.t)
201 if (err != nil) != tt.wantErr {
202 t.Errorf("HandleLeaveChat() error = %v, wantErr %v", err, tt.wantErr)
203 return
204 }
205 if !assert.Equal(t, tt.want, got) {
206 t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want)
207 }
208 })
209 }
210 }
211
212 func TestHandleGetUserNameList(t *testing.T) {
213 type args struct {
214 cc *ClientConn
215 t *Transaction
216 }
217 tests := []struct {
218 name string
219 args args
220 want []Transaction
221 wantErr bool
222 }{
223 {
224 name: "replies with userlist transaction",
225 args: args{
226 cc: &ClientConn{
227
228 ID: &[]byte{1, 1},
229 Server: &Server{
230 Clients: map[uint16]*ClientConn{
231 uint16(1): {
232 ID: &[]byte{0, 1},
233 Icon: []byte{0, 2},
234 Flags: []byte{0, 3},
235 UserName: []byte{0, 4},
236 },
237 uint16(2): {
238 ID: &[]byte{0, 2},
239 Icon: []byte{0, 2},
240 Flags: []byte{0, 3},
241 UserName: []byte{0, 4},
242 },
243 },
244 },
245 },
246 t: &Transaction{
247 ID: []byte{0, 0, 0, 1},
248 Type: []byte{0, 1},
249 },
250 },
251 want: []Transaction{
252 {
253 clientID: &[]byte{1, 1},
254 Flags: 0x00,
255 IsReply: 0x01,
256 Type: []byte{0, 0},
257 ID: []byte{0, 0, 0, 1},
258 ErrorCode: []byte{0, 0, 0, 0},
259 Fields: []Field{
260 NewField(
261 FieldUsernameWithInfo,
262 []byte{00, 01, 00, 02, 00, 03, 00, 02, 00, 04},
263 ),
264 NewField(
265 FieldUsernameWithInfo,
266 []byte{00, 02, 00, 02, 00, 03, 00, 02, 00, 04},
267 ),
268 },
269 },
270 },
271 wantErr: false,
272 },
273 }
274 for _, tt := range tests {
275 t.Run(tt.name, func(t *testing.T) {
276 got, err := HandleGetUserNameList(tt.args.cc, tt.args.t)
277 if (err != nil) != tt.wantErr {
278 t.Errorf("HandleGetUserNameList() error = %v, wantErr %v", err, tt.wantErr)
279 return
280 }
281 assert.Equal(t, tt.want, got)
282 })
283 }
284 }
285
286 func TestHandleChatSend(t *testing.T) {
287 type args struct {
288 cc *ClientConn
289 t *Transaction
290 }
291 tests := []struct {
292 name string
293 args args
294 want []Transaction
295 wantErr bool
296 }{
297 {
298 name: "sends chat msg transaction to all clients",
299 args: args{
300 cc: &ClientConn{
301 Account: &Account{
302 Access: func() accessBitmap {
303 var bits accessBitmap
304 bits.Set(accessSendChat)
305 return bits
306 }(),
307 },
308 UserName: []byte{0x00, 0x01},
309 Server: &Server{
310 Clients: map[uint16]*ClientConn{
311 uint16(1): {
312 Account: &Account{
313 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
314 },
315 ID: &[]byte{0, 1},
316 },
317 uint16(2): {
318 Account: &Account{
319 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
320 },
321 ID: &[]byte{0, 2},
322 },
323 },
324 },
325 },
326 t: &Transaction{
327 Fields: []Field{
328 NewField(FieldData, []byte("hai")),
329 },
330 },
331 },
332 want: []Transaction{
333 {
334 clientID: &[]byte{0, 1},
335 Flags: 0x00,
336 IsReply: 0x00,
337 Type: []byte{0, 0x6a},
338 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
339 ErrorCode: []byte{0, 0, 0, 0},
340 Fields: []Field{
341 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
342 },
343 },
344 {
345 clientID: &[]byte{0, 2},
346 Flags: 0x00,
347 IsReply: 0x00,
348 Type: []byte{0, 0x6a},
349 ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
350 ErrorCode: []byte{0, 0, 0, 0},
351 Fields: []Field{
352 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
353 },
354 },
355 },
356 wantErr: false,
357 },
358 {
359 name: "treats Chat ID 00 00 00 00 as a public chat message",
360 args: args{
361 cc: &ClientConn{
362 Account: &Account{
363 Access: func() accessBitmap {
364 var bits accessBitmap
365 bits.Set(accessSendChat)
366 return bits
367 }(),
368 },
369 UserName: []byte{0x00, 0x01},
370 Server: &Server{
371 Clients: map[uint16]*ClientConn{
372 uint16(1): {
373 Account: &Account{
374 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
375 },
376 ID: &[]byte{0, 1},
377 },
378 uint16(2): {
379 Account: &Account{
380 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
381 },
382 ID: &[]byte{0, 2},
383 },
384 },
385 },
386 },
387 t: &Transaction{
388 Fields: []Field{
389 NewField(FieldData, []byte("hai")),
390 NewField(FieldChatID, []byte{0, 0, 0, 0}),
391 },
392 },
393 },
394 want: []Transaction{
395 {
396 clientID: &[]byte{0, 1},
397 Flags: 0x00,
398 IsReply: 0x00,
399 Type: []byte{0, 0x6a},
400 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
401 ErrorCode: []byte{0, 0, 0, 0},
402 Fields: []Field{
403 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
404 },
405 },
406 {
407 clientID: &[]byte{0, 2},
408 Flags: 0x00,
409 IsReply: 0x00,
410 Type: []byte{0, 0x6a},
411 ID: []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
412 ErrorCode: []byte{0, 0, 0, 0},
413 Fields: []Field{
414 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
415 },
416 },
417 },
418 wantErr: false,
419 },
420 {
421 name: "when user does not have required permission",
422 args: args{
423 cc: &ClientConn{
424 Account: &Account{
425 Access: func() accessBitmap {
426 var bits accessBitmap
427 return bits
428 }(),
429 },
430 Server: &Server{
431 Accounts: map[string]*Account{},
432 },
433 },
434 t: NewTransaction(
435 TranChatSend, &[]byte{0, 1},
436 NewField(FieldData, []byte("hai")),
437 ),
438 },
439 want: []Transaction{
440 {
441 Flags: 0x00,
442 IsReply: 0x01,
443 Type: []byte{0, 0},
444 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
445 ErrorCode: []byte{0, 0, 0, 1},
446 Fields: []Field{
447 NewField(FieldError, []byte("You are not allowed to participate in chat.")),
448 },
449 },
450 },
451 wantErr: false,
452 },
453 {
454 name: "sends chat msg as emote if FieldChatOptions is set to 1",
455 args: args{
456 cc: &ClientConn{
457 Account: &Account{
458 Access: func() accessBitmap {
459 var bits accessBitmap
460 bits.Set(accessSendChat)
461 return bits
462 }(),
463 },
464 UserName: []byte("Testy McTest"),
465 Server: &Server{
466 Clients: map[uint16]*ClientConn{
467 uint16(1): {
468 Account: &Account{
469 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
470 },
471 ID: &[]byte{0, 1},
472 },
473 uint16(2): {
474 Account: &Account{
475 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
476 },
477 ID: &[]byte{0, 2},
478 },
479 },
480 },
481 },
482 t: &Transaction{
483 Fields: []Field{
484 NewField(FieldData, []byte("performed action")),
485 NewField(FieldChatOptions, []byte{0x00, 0x01}),
486 },
487 },
488 },
489 want: []Transaction{
490 {
491 clientID: &[]byte{0, 1},
492 Flags: 0x00,
493 IsReply: 0x00,
494 Type: []byte{0, 0x6a},
495 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
496 ErrorCode: []byte{0, 0, 0, 0},
497 Fields: []Field{
498 NewField(FieldData, []byte("\r*** Testy McTest performed action")),
499 },
500 },
501 {
502 clientID: &[]byte{0, 2},
503 Flags: 0x00,
504 IsReply: 0x00,
505 Type: []byte{0, 0x6a},
506 ID: []byte{0xf0, 0xc5, 0x34, 0x1e},
507 ErrorCode: []byte{0, 0, 0, 0},
508 Fields: []Field{
509 NewField(FieldData, []byte("\r*** Testy McTest performed action")),
510 },
511 },
512 },
513 wantErr: false,
514 },
515 {
516 name: "does not send chat msg as emote if FieldChatOptions is set to 0",
517 args: args{
518 cc: &ClientConn{
519 Account: &Account{
520 Access: func() accessBitmap {
521 var bits accessBitmap
522 bits.Set(accessSendChat)
523 return bits
524 }(),
525 },
526 UserName: []byte("Testy McTest"),
527 Server: &Server{
528 Clients: map[uint16]*ClientConn{
529 uint16(1): {
530 Account: &Account{
531 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
532 },
533 ID: &[]byte{0, 1},
534 },
535 uint16(2): {
536 Account: &Account{
537 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
538 },
539 ID: &[]byte{0, 2},
540 },
541 },
542 },
543 },
544 t: &Transaction{
545 Fields: []Field{
546 NewField(FieldData, []byte("hello")),
547 NewField(FieldChatOptions, []byte{0x00, 0x00}),
548 },
549 },
550 },
551 want: []Transaction{
552 {
553 clientID: &[]byte{0, 1},
554 Flags: 0x00,
555 IsReply: 0x00,
556 Type: []byte{0, 0x6a},
557 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
558 ErrorCode: []byte{0, 0, 0, 0},
559 Fields: []Field{
560 NewField(FieldData, []byte("\r Testy McTest: hello")),
561 },
562 },
563 {
564 clientID: &[]byte{0, 2},
565 Flags: 0x00,
566 IsReply: 0x00,
567 Type: []byte{0, 0x6a},
568 ID: []byte{0xf0, 0xc5, 0x34, 0x1e},
569 ErrorCode: []byte{0, 0, 0, 0},
570 Fields: []Field{
571 NewField(FieldData, []byte("\r Testy McTest: hello")),
572 },
573 },
574 },
575 wantErr: false,
576 },
577 {
578 name: "only sends chat msg to clients with accessReadChat permission",
579 args: args{
580 cc: &ClientConn{
581 Account: &Account{
582 Access: func() accessBitmap {
583 var bits accessBitmap
584 bits.Set(accessSendChat)
585 return bits
586 }(),
587 },
588 UserName: []byte{0x00, 0x01},
589 Server: &Server{
590 Clients: map[uint16]*ClientConn{
591 uint16(1): {
592 Account: &Account{
593 Access: func() accessBitmap {
594 var bits accessBitmap
595 bits.Set(accessReadChat)
596 return bits
597 }()},
598 ID: &[]byte{0, 1},
599 },
600 uint16(2): {
601 Account: &Account{
602 Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
603 },
604 ID: &[]byte{0, 2},
605 },
606 },
607 },
608 },
609 t: &Transaction{
610 Fields: []Field{
611 NewField(FieldData, []byte("hai")),
612 },
613 },
614 },
615 want: []Transaction{
616 {
617 clientID: &[]byte{0, 1},
618 Flags: 0x00,
619 IsReply: 0x00,
620 Type: []byte{0, 0x6a},
621 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
622 ErrorCode: []byte{0, 0, 0, 0},
623 Fields: []Field{
624 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
625 },
626 },
627 },
628 wantErr: false,
629 },
630 {
631 name: "only sends private chat msg to members of private chat",
632 args: args{
633 cc: &ClientConn{
634 Account: &Account{
635 Access: func() accessBitmap {
636 var bits accessBitmap
637 bits.Set(accessSendChat)
638 return bits
639 }(),
640 },
641 UserName: []byte{0x00, 0x01},
642 Server: &Server{
643 PrivateChats: map[uint32]*PrivateChat{
644 uint32(1): {
645 ClientConn: map[uint16]*ClientConn{
646 uint16(1): {
647 ID: &[]byte{0, 1},
648 },
649 uint16(2): {
650 ID: &[]byte{0, 2},
651 },
652 },
653 },
654 },
655 Clients: map[uint16]*ClientConn{
656 uint16(1): {
657 Account: &Account{
658 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
659 },
660 ID: &[]byte{0, 1},
661 },
662 uint16(2): {
663 Account: &Account{
664 Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
665 },
666 ID: &[]byte{0, 2},
667 },
668 uint16(3): {
669 Account: &Account{
670 Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
671 },
672 ID: &[]byte{0, 3},
673 },
674 },
675 },
676 },
677 t: &Transaction{
678 Fields: []Field{
679 NewField(FieldData, []byte("hai")),
680 NewField(FieldChatID, []byte{0, 0, 0, 1}),
681 },
682 },
683 },
684 want: []Transaction{
685 {
686 clientID: &[]byte{0, 1},
687 Flags: 0x00,
688 IsReply: 0x00,
689 Type: []byte{0, 0x6a},
690 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
691 ErrorCode: []byte{0, 0, 0, 0},
692 Fields: []Field{
693 NewField(FieldChatID, []byte{0, 0, 0, 1}),
694 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
695 },
696 },
697 {
698 clientID: &[]byte{0, 2},
699 Flags: 0x00,
700 IsReply: 0x00,
701 Type: []byte{0, 0x6a},
702 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
703 ErrorCode: []byte{0, 0, 0, 0},
704 Fields: []Field{
705 NewField(FieldChatID, []byte{0, 0, 0, 1}),
706 NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
707 },
708 },
709 },
710 wantErr: false,
711 },
712 }
713 for _, tt := range tests {
714 t.Run(tt.name, func(t *testing.T) {
715 got, err := HandleChatSend(tt.args.cc, tt.args.t)
716
717 if (err != nil) != tt.wantErr {
718 t.Errorf("HandleChatSend() error = %v, wantErr %v", err, tt.wantErr)
719 return
720 }
721 tranAssertEqual(t, tt.want, got)
722 })
723 }
724 }
725
726 func TestHandleGetFileInfo(t *testing.T) {
727 rand.Seed(1) // reset seed between tests to make transaction IDs predictable
728
729 type args struct {
730 cc *ClientConn
731 t *Transaction
732 }
733 tests := []struct {
734 name string
735 args args
736 wantRes []Transaction
737 wantErr bool
738 }{
739 {
740 name: "returns expected fields when a valid file is requested",
741 args: args{
742 cc: &ClientConn{
743 ID: &[]byte{0x00, 0x01},
744 Server: &Server{
745 FS: &OSFileStore{},
746 Config: &Config{
747 FileRoot: func() string {
748 path, _ := os.Getwd()
749 return filepath.Join(path, "/test/config/Files")
750 }(),
751 },
752 },
753 },
754 t: NewTransaction(
755 TranGetFileInfo, nil,
756 NewField(FieldFileName, []byte("testfile.txt")),
757 NewField(FieldFilePath, []byte{0x00, 0x00}),
758 ),
759 },
760 wantRes: []Transaction{
761 {
762 clientID: &[]byte{0, 1},
763 Flags: 0x00,
764 IsReply: 0x01,
765 Type: []byte{0, 0},
766 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
767 ErrorCode: []byte{0, 0, 0, 0},
768 Fields: []Field{
769 NewField(FieldFileName, []byte("testfile.txt")),
770 NewField(FieldFileTypeString, []byte("Text File")),
771 NewField(FieldFileCreatorString, []byte("ttxt")),
772 NewField(FieldFileType, []byte("TEXT")),
773 NewField(FieldFileCreateDate, make([]byte, 8)),
774 NewField(FieldFileModifyDate, make([]byte, 8)),
775 NewField(FieldFileSize, []byte{0x0, 0x0, 0x0, 0x17}),
776 },
777 },
778 },
779 wantErr: false,
780 },
781 }
782 for _, tt := range tests {
783 t.Run(tt.name, func(t *testing.T) {
784 rand.Seed(1) // reset seed between tests to make transaction IDs predictable
785
786 gotRes, err := HandleGetFileInfo(tt.args.cc, tt.args.t)
787 if (err != nil) != tt.wantErr {
788 t.Errorf("HandleGetFileInfo() error = %v, wantErr %v", err, tt.wantErr)
789 return
790 }
791
792 // Clear the fileWrapper timestamp fields to work around problems running the tests in multiple timezones
793 // TODO: revisit how to test this by mocking the stat calls
794 gotRes[0].Fields[4].Data = make([]byte, 8)
795 gotRes[0].Fields[5].Data = make([]byte, 8)
796 if !assert.Equal(t, tt.wantRes, gotRes) {
797 t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes)
798 }
799 })
800 }
801 }
802
803 func TestHandleNewFolder(t *testing.T) {
804 type args struct {
805 cc *ClientConn
806 t *Transaction
807 }
808 tests := []struct {
809 name string
810 args args
811 wantRes []Transaction
812 wantErr bool
813 }{
814 {
815 name: "without required permission",
816 args: args{
817 cc: &ClientConn{
818 Account: &Account{
819 Access: func() accessBitmap {
820 var bits accessBitmap
821 return bits
822 }(),
823 },
824 },
825 t: NewTransaction(
826 accessCreateFolder,
827 &[]byte{0, 0},
828 ),
829 },
830 wantRes: []Transaction{
831 {
832 Flags: 0x00,
833 IsReply: 0x01,
834 Type: []byte{0, 0},
835 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
836 ErrorCode: []byte{0, 0, 0, 1},
837 Fields: []Field{
838 NewField(FieldError, []byte("You are not allowed to create folders.")),
839 },
840 },
841 },
842 wantErr: false,
843 },
844 {
845 name: "when path is nested",
846 args: args{
847 cc: &ClientConn{
848 Account: &Account{
849 Access: func() accessBitmap {
850 var bits accessBitmap
851 bits.Set(accessCreateFolder)
852 return bits
853 }(),
854 },
855 ID: &[]byte{0, 1},
856 Server: &Server{
857 Config: &Config{
858 FileRoot: "/Files/",
859 },
860 FS: func() *MockFileStore {
861 mfs := &MockFileStore{}
862 mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil)
863 mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist)
864 return mfs
865 }(),
866 },
867 },
868 t: NewTransaction(
869 TranNewFolder, &[]byte{0, 1},
870 NewField(FieldFileName, []byte("testFolder")),
871 NewField(FieldFilePath, []byte{
872 0x00, 0x01,
873 0x00, 0x00,
874 0x03,
875 0x61, 0x61, 0x61,
876 }),
877 ),
878 },
879 wantRes: []Transaction{
880 {
881 clientID: &[]byte{0, 1},
882 Flags: 0x00,
883 IsReply: 0x01,
884 Type: []byte{0, 0},
885 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
886 ErrorCode: []byte{0, 0, 0, 0},
887 },
888 },
889 wantErr: false,
890 },
891 {
892 name: "when path is not nested",
893 args: args{
894 cc: &ClientConn{
895 Account: &Account{
896 Access: func() accessBitmap {
897 var bits accessBitmap
898 bits.Set(accessCreateFolder)
899 return bits
900 }(),
901 },
902 ID: &[]byte{0, 1},
903 Server: &Server{
904 Config: &Config{
905 FileRoot: "/Files",
906 },
907 FS: func() *MockFileStore {
908 mfs := &MockFileStore{}
909 mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
910 mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
911 return mfs
912 }(),
913 },
914 },
915 t: NewTransaction(
916 TranNewFolder, &[]byte{0, 1},
917 NewField(FieldFileName, []byte("testFolder")),
918 ),
919 },
920 wantRes: []Transaction{
921 {
922 clientID: &[]byte{0, 1},
923 Flags: 0x00,
924 IsReply: 0x01,
925 Type: []byte{0, 0},
926 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
927 ErrorCode: []byte{0, 0, 0, 0},
928 },
929 },
930 wantErr: false,
931 },
932 {
933 name: "when Write returns an err",
934 args: args{
935 cc: &ClientConn{
936 Account: &Account{
937 Access: func() accessBitmap {
938 var bits accessBitmap
939 bits.Set(accessCreateFolder)
940 return bits
941 }(),
942 },
943 ID: &[]byte{0, 1},
944 Server: &Server{
945 Config: &Config{
946 FileRoot: "/Files/",
947 },
948 FS: func() *MockFileStore {
949 mfs := &MockFileStore{}
950 mfs.On("Mkdir", "/Files/aaa/testFolder", fs.FileMode(0777)).Return(nil)
951 mfs.On("Stat", "/Files/aaa/testFolder").Return(nil, os.ErrNotExist)
952 return mfs
953 }(),
954 },
955 },
956 t: NewTransaction(
957 TranNewFolder, &[]byte{0, 1},
958 NewField(FieldFileName, []byte("testFolder")),
959 NewField(FieldFilePath, []byte{
960 0x00,
961 }),
962 ),
963 },
964 wantRes: []Transaction{},
965 wantErr: true,
966 },
967 {
968 name: "FieldFileName does not allow directory traversal",
969 args: args{
970 cc: &ClientConn{
971 Account: &Account{
972 Access: func() accessBitmap {
973 var bits accessBitmap
974 bits.Set(accessCreateFolder)
975 return bits
976 }(),
977 },
978 ID: &[]byte{0, 1},
979 Server: &Server{
980 Config: &Config{
981 FileRoot: "/Files/",
982 },
983 FS: func() *MockFileStore {
984 mfs := &MockFileStore{}
985 mfs.On("Mkdir", "/Files/testFolder", fs.FileMode(0777)).Return(nil)
986 mfs.On("Stat", "/Files/testFolder").Return(nil, os.ErrNotExist)
987 return mfs
988 }(),
989 },
990 },
991 t: NewTransaction(
992 TranNewFolder, &[]byte{0, 1},
993 NewField(FieldFileName, []byte("../../testFolder")),
994 ),
995 },
996 wantRes: []Transaction{
997 {
998 clientID: &[]byte{0, 1},
999 Flags: 0x00,
1000 IsReply: 0x01,
1001 Type: []byte{0, 0},
1002 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
1003 ErrorCode: []byte{0, 0, 0, 0},
1004 },
1005 }, wantErr: false,
1006 },
1007 {
1008 name: "FieldFilePath does not allow directory traversal",
1009 args: args{
1010 cc: &ClientConn{
1011 Account: &Account{
1012 Access: func() accessBitmap {
1013 var bits accessBitmap
1014 bits.Set(accessCreateFolder)
1015 return bits
1016 }(),
1017 },
1018 ID: &[]byte{0, 1},
1019 Server: &Server{
1020 Config: &Config{
1021 FileRoot: "/Files/",
1022 },
1023 FS: func() *MockFileStore {
1024 mfs := &MockFileStore{}
1025 mfs.On("Mkdir", "/Files/foo/testFolder", fs.FileMode(0777)).Return(nil)
1026 mfs.On("Stat", "/Files/foo/testFolder").Return(nil, os.ErrNotExist)
1027 return mfs
1028 }(),
1029 },
1030 },
1031 t: NewTransaction(
1032 TranNewFolder, &[]byte{0, 1},
1033 NewField(FieldFileName, []byte("testFolder")),
1034 NewField(FieldFilePath, []byte{
1035 0x00, 0x02,
1036 0x00, 0x00,
1037 0x03,
1038 0x2e, 0x2e, 0x2f,
1039 0x00, 0x00,
1040 0x03,
1041 0x66, 0x6f, 0x6f,
1042 }),
1043 ),
1044 },
1045 wantRes: []Transaction{
1046 {
1047 clientID: &[]byte{0, 1},
1048 Flags: 0x00,
1049 IsReply: 0x01,
1050 Type: []byte{0, 0},
1051 ID: []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
1052 ErrorCode: []byte{0, 0, 0, 0},
1053 },
1054 }, wantErr: false,
1055 },
1056 }
1057 for _, tt := range tests {
1058 t.Run(tt.name, func(t *testing.T) {
1059 gotRes, err := HandleNewFolder(tt.args.cc, tt.args.t)
1060 if (err != nil) != tt.wantErr {
1061 t.Errorf("HandleNewFolder() error = %v, wantErr %v", err, tt.wantErr)
1062 return
1063 }
1064
1065 if !tranAssertEqual(t, tt.wantRes, gotRes) {
1066 t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes)
1067 }
1068 })
1069 }
1070 }
1071
1072 func TestHandleUploadFile(t *testing.T) {
1073 type args struct {
1074 cc *ClientConn
1075 t *Transaction
1076 }
1077 tests := []struct {
1078 name string
1079 args args
1080 wantRes []Transaction
1081 wantErr bool
1082 }{
1083 {
1084 name: "when request is valid and user has Upload Anywhere permission",
1085 args: args{
1086 cc: &ClientConn{
1087 Server: &Server{
1088 FS: &OSFileStore{},
1089 fileTransfers: map[[4]byte]*FileTransfer{},
1090 Config: &Config{
1091 FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(),
1092 }},
1093 transfers: map[int]map[[4]byte]*FileTransfer{
1094 FileUpload: {},
1095 },
1096 Account: &Account{
1097 Access: func() accessBitmap {
1098 var bits accessBitmap
1099 bits.Set(accessUploadFile)
1100 bits.Set(accessUploadAnywhere)
1101 return bits
1102 }(),
1103 },
1104 },
1105 t: NewTransaction(
1106 TranUploadFile, &[]byte{0, 1},
1107 NewField(FieldFileName, []byte("testFile")),
1108 NewField(FieldFilePath, []byte{
1109 0x00, 0x01,
1110 0x00, 0x00,
1111 0x03,
1112 0x2e, 0x2e, 0x2f,
1113 }),
1114 ),
1115 },
1116 wantRes: []Transaction{
1117 {
1118 Flags: 0x00,
1119 IsReply: 0x01,
1120 Type: []byte{0, 0},
1121 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1122 ErrorCode: []byte{0, 0, 0, 0},
1123 Fields: []Field{
1124 NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
1125 },
1126 },
1127 },
1128 wantErr: false,
1129 },
1130 {
1131 name: "when user does not have required access",
1132 args: args{
1133 cc: &ClientConn{
1134 Account: &Account{
1135 Access: func() accessBitmap {
1136 var bits accessBitmap
1137 return bits
1138 }(),
1139 },
1140 },
1141 t: NewTransaction(
1142 TranUploadFile, &[]byte{0, 1},
1143 NewField(FieldFileName, []byte("testFile")),
1144 NewField(FieldFilePath, []byte{
1145 0x00, 0x01,
1146 0x00, 0x00,
1147 0x03,
1148 0x2e, 0x2e, 0x2f,
1149 }),
1150 ),
1151 },
1152 wantRes: []Transaction{
1153 {
1154 Flags: 0x00,
1155 IsReply: 0x01,
1156 Type: []byte{0, 0},
1157 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1158 ErrorCode: []byte{0, 0, 0, 1},
1159 Fields: []Field{
1160 NewField(FieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
1161 },
1162 },
1163 },
1164 wantErr: false,
1165 },
1166 }
1167 for _, tt := range tests {
1168 t.Run(tt.name, func(t *testing.T) {
1169 rand.Seed(1)
1170 gotRes, err := HandleUploadFile(tt.args.cc, tt.args.t)
1171 if (err != nil) != tt.wantErr {
1172 t.Errorf("HandleUploadFile() error = %v, wantErr %v", err, tt.wantErr)
1173 return
1174 }
1175
1176 tranAssertEqual(t, tt.wantRes, gotRes)
1177 })
1178 }
1179 }
1180
1181 func TestHandleMakeAlias(t *testing.T) {
1182 type args struct {
1183 cc *ClientConn
1184 t *Transaction
1185 }
1186 tests := []struct {
1187 name string
1188 args args
1189 wantRes []Transaction
1190 wantErr bool
1191 }{
1192 {
1193 name: "with valid input and required permissions",
1194 args: args{
1195 cc: &ClientConn{
1196 logger: NewTestLogger(),
1197 Account: &Account{
1198 Access: func() accessBitmap {
1199 var bits accessBitmap
1200 bits.Set(accessMakeAlias)
1201 return bits
1202 }(),
1203 },
1204 Server: &Server{
1205 Config: &Config{
1206 FileRoot: func() string {
1207 path, _ := os.Getwd()
1208 return path + "/test/config/Files"
1209 }(),
1210 },
1211 Logger: NewTestLogger(),
1212 FS: func() *MockFileStore {
1213 mfs := &MockFileStore{}
1214 path, _ := os.Getwd()
1215 mfs.On(
1216 "Symlink",
1217 path+"/test/config/Files/foo/testFile",
1218 path+"/test/config/Files/bar/testFile",
1219 ).Return(nil)
1220 return mfs
1221 }(),
1222 },
1223 },
1224 t: NewTransaction(
1225 TranMakeFileAlias, &[]byte{0, 1},
1226 NewField(FieldFileName, []byte("testFile")),
1227 NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
1228 NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
1229 ),
1230 },
1231 wantRes: []Transaction{
1232 {
1233 Flags: 0x00,
1234 IsReply: 0x01,
1235 Type: []byte{0, 0},
1236 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1237 ErrorCode: []byte{0, 0, 0, 0},
1238 Fields: []Field(nil),
1239 },
1240 },
1241 wantErr: false,
1242 },
1243 {
1244 name: "when symlink returns an error",
1245 args: args{
1246 cc: &ClientConn{
1247 logger: NewTestLogger(),
1248 Account: &Account{
1249 Access: func() accessBitmap {
1250 var bits accessBitmap
1251 bits.Set(accessMakeAlias)
1252 return bits
1253 }(),
1254 },
1255 Server: &Server{
1256 Config: &Config{
1257 FileRoot: func() string {
1258 path, _ := os.Getwd()
1259 return path + "/test/config/Files"
1260 }(),
1261 },
1262 Logger: NewTestLogger(),
1263 FS: func() *MockFileStore {
1264 mfs := &MockFileStore{}
1265 path, _ := os.Getwd()
1266 mfs.On(
1267 "Symlink",
1268 path+"/test/config/Files/foo/testFile",
1269 path+"/test/config/Files/bar/testFile",
1270 ).Return(errors.New("ohno"))
1271 return mfs
1272 }(),
1273 },
1274 },
1275 t: NewTransaction(
1276 TranMakeFileAlias, &[]byte{0, 1},
1277 NewField(FieldFileName, []byte("testFile")),
1278 NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
1279 NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
1280 ),
1281 },
1282 wantRes: []Transaction{
1283 {
1284 Flags: 0x00,
1285 IsReply: 0x01,
1286 Type: []byte{0, 0},
1287 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1288 ErrorCode: []byte{0, 0, 0, 1},
1289 Fields: []Field{
1290 NewField(FieldError, []byte("Error creating alias")),
1291 },
1292 },
1293 },
1294 wantErr: false,
1295 },
1296 {
1297 name: "when user does not have required permission",
1298 args: args{
1299 cc: &ClientConn{
1300 logger: NewTestLogger(),
1301 Account: &Account{
1302 Access: func() accessBitmap {
1303 var bits accessBitmap
1304 return bits
1305 }(),
1306 },
1307 Server: &Server{
1308 Config: &Config{
1309 FileRoot: func() string {
1310 path, _ := os.Getwd()
1311 return path + "/test/config/Files"
1312 }(),
1313 },
1314 },
1315 },
1316 t: NewTransaction(
1317 TranMakeFileAlias, &[]byte{0, 1},
1318 NewField(FieldFileName, []byte("testFile")),
1319 NewField(FieldFilePath, []byte{
1320 0x00, 0x01,
1321 0x00, 0x00,
1322 0x03,
1323 0x2e, 0x2e, 0x2e,
1324 }),
1325 NewField(FieldFileNewPath, []byte{
1326 0x00, 0x01,
1327 0x00, 0x00,
1328 0x03,
1329 0x2e, 0x2e, 0x2e,
1330 }),
1331 ),
1332 },
1333 wantRes: []Transaction{
1334 {
1335 Flags: 0x00,
1336 IsReply: 0x01,
1337 Type: []byte{0, 0},
1338 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1339 ErrorCode: []byte{0, 0, 0, 1},
1340 Fields: []Field{
1341 NewField(FieldError, []byte("You are not allowed to make aliases.")),
1342 },
1343 },
1344 },
1345 wantErr: false,
1346 },
1347 }
1348 for _, tt := range tests {
1349 t.Run(tt.name, func(t *testing.T) {
1350 gotRes, err := HandleMakeAlias(tt.args.cc, tt.args.t)
1351 if (err != nil) != tt.wantErr {
1352 t.Errorf("HandleMakeAlias(%v, %v)", tt.args.cc, tt.args.t)
1353 return
1354 }
1355
1356 tranAssertEqual(t, tt.wantRes, gotRes)
1357 })
1358 }
1359 }
1360
1361 func TestHandleGetUser(t *testing.T) {
1362 type args struct {
1363 cc *ClientConn
1364 t *Transaction
1365 }
1366 tests := []struct {
1367 name string
1368 args args
1369 wantRes []Transaction
1370 wantErr assert.ErrorAssertionFunc
1371 }{
1372 {
1373 name: "when account is valid",
1374 args: args{
1375 cc: &ClientConn{
1376 Account: &Account{
1377 Access: func() accessBitmap {
1378 var bits accessBitmap
1379 bits.Set(accessOpenUser)
1380 return bits
1381 }(),
1382 },
1383 Server: &Server{
1384 Accounts: map[string]*Account{
1385 "guest": {
1386 Login: "guest",
1387 Name: "Guest",
1388 Password: "password",
1389 Access: accessBitmap{},
1390 },
1391 },
1392 },
1393 },
1394 t: NewTransaction(
1395 TranGetUser, &[]byte{0, 1},
1396 NewField(FieldUserLogin, []byte("guest")),
1397 ),
1398 },
1399 wantRes: []Transaction{
1400 {
1401 Flags: 0x00,
1402 IsReply: 0x01,
1403 Type: []byte{0, 0},
1404 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1405 ErrorCode: []byte{0, 0, 0, 0},
1406 Fields: []Field{
1407 NewField(FieldUserName, []byte("Guest")),
1408 NewField(FieldUserLogin, encodeString([]byte("guest"))),
1409 NewField(FieldUserPassword, []byte("password")),
1410 NewField(FieldUserAccess, []byte{0, 0, 0, 0, 0, 0, 0, 0}),
1411 },
1412 },
1413 },
1414 wantErr: assert.NoError,
1415 },
1416 {
1417 name: "when user does not have required permission",
1418 args: args{
1419 cc: &ClientConn{
1420 Account: &Account{
1421 Access: func() accessBitmap {
1422 var bits accessBitmap
1423 return bits
1424 }(),
1425 },
1426 Server: &Server{
1427 Accounts: map[string]*Account{},
1428 },
1429 },
1430 t: NewTransaction(
1431 TranGetUser, &[]byte{0, 1},
1432 NewField(FieldUserLogin, []byte("nonExistentUser")),
1433 ),
1434 },
1435 wantRes: []Transaction{
1436 {
1437 Flags: 0x00,
1438 IsReply: 0x01,
1439 Type: []byte{0, 0},
1440 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1441 ErrorCode: []byte{0, 0, 0, 1},
1442 Fields: []Field{
1443 NewField(FieldError, []byte("You are not allowed to view accounts.")),
1444 },
1445 },
1446 },
1447 wantErr: assert.NoError,
1448 },
1449 {
1450 name: "when account does not exist",
1451 args: args{
1452 cc: &ClientConn{
1453 Account: &Account{
1454 Access: func() accessBitmap {
1455 var bits accessBitmap
1456 bits.Set(accessOpenUser)
1457 return bits
1458 }(),
1459 },
1460 Server: &Server{
1461 Accounts: map[string]*Account{},
1462 },
1463 },
1464 t: NewTransaction(
1465 TranGetUser, &[]byte{0, 1},
1466 NewField(FieldUserLogin, []byte("nonExistentUser")),
1467 ),
1468 },
1469 wantRes: []Transaction{
1470 {
1471 Flags: 0x00,
1472 IsReply: 0x01,
1473 Type: []byte{0, 0},
1474 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1475 ErrorCode: []byte{0, 0, 0, 1},
1476 Fields: []Field{
1477 NewField(FieldError, []byte("Account does not exist.")),
1478 },
1479 },
1480 },
1481 wantErr: assert.NoError,
1482 },
1483 }
1484 for _, tt := range tests {
1485 t.Run(tt.name, func(t *testing.T) {
1486 gotRes, err := HandleGetUser(tt.args.cc, tt.args.t)
1487 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetUser(%v, %v)", tt.args.cc, tt.args.t)) {
1488 return
1489 }
1490
1491 tranAssertEqual(t, tt.wantRes, gotRes)
1492 })
1493 }
1494 }
1495
1496 func TestHandleDeleteUser(t *testing.T) {
1497 type args struct {
1498 cc *ClientConn
1499 t *Transaction
1500 }
1501 tests := []struct {
1502 name string
1503 args args
1504 wantRes []Transaction
1505 wantErr assert.ErrorAssertionFunc
1506 }{
1507 {
1508 name: "when user dataFile",
1509 args: args{
1510 cc: &ClientConn{
1511 Account: &Account{
1512 Access: func() accessBitmap {
1513 var bits accessBitmap
1514 bits.Set(accessDeleteUser)
1515 return bits
1516 }(),
1517 },
1518 Server: &Server{
1519 Accounts: map[string]*Account{
1520 "testuser": {
1521 Login: "testuser",
1522 Name: "Testy McTest",
1523 Password: "password",
1524 Access: accessBitmap{},
1525 },
1526 },
1527 FS: func() *MockFileStore {
1528 mfs := &MockFileStore{}
1529 mfs.On("Remove", "Users/testuser.yaml").Return(nil)
1530 return mfs
1531 }(),
1532 },
1533 },
1534 t: NewTransaction(
1535 TranDeleteUser, &[]byte{0, 1},
1536 NewField(FieldUserLogin, encodeString([]byte("testuser"))),
1537 ),
1538 },
1539 wantRes: []Transaction{
1540 {
1541 Flags: 0x00,
1542 IsReply: 0x01,
1543 Type: []byte{0, 0},
1544 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1545 ErrorCode: []byte{0, 0, 0, 0},
1546 Fields: []Field(nil),
1547 },
1548 },
1549 wantErr: assert.NoError,
1550 },
1551 {
1552 name: "when user does not have required permission",
1553 args: args{
1554 cc: &ClientConn{
1555 Account: &Account{
1556 Access: func() accessBitmap {
1557 var bits accessBitmap
1558 return bits
1559 }(),
1560 },
1561 Server: &Server{
1562 Accounts: map[string]*Account{},
1563 },
1564 },
1565 t: NewTransaction(
1566 TranDeleteUser, &[]byte{0, 1},
1567 NewField(FieldUserLogin, encodeString([]byte("testuser"))),
1568 ),
1569 },
1570 wantRes: []Transaction{
1571 {
1572 Flags: 0x00,
1573 IsReply: 0x01,
1574 Type: []byte{0, 0},
1575 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1576 ErrorCode: []byte{0, 0, 0, 1},
1577 Fields: []Field{
1578 NewField(FieldError, []byte("You are not allowed to delete accounts.")),
1579 },
1580 },
1581 },
1582 wantErr: assert.NoError,
1583 },
1584 }
1585 for _, tt := range tests {
1586 t.Run(tt.name, func(t *testing.T) {
1587 gotRes, err := HandleDeleteUser(tt.args.cc, tt.args.t)
1588 if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteUser(%v, %v)", tt.args.cc, tt.args.t)) {
1589 return
1590 }
1591
1592 tranAssertEqual(t, tt.wantRes, gotRes)
1593 })
1594 }
1595 }
1596
1597 func TestHandleGetMsgs(t *testing.T) {
1598 type args struct {
1599 cc *ClientConn
1600 t *Transaction
1601 }
1602 tests := []struct {
1603 name string
1604 args args
1605 wantRes []Transaction
1606 wantErr assert.ErrorAssertionFunc
1607 }{
1608 {
1609 name: "returns news data",
1610 args: args{
1611 cc: &ClientConn{
1612 Account: &Account{
1613 Access: func() accessBitmap {
1614 var bits accessBitmap
1615 bits.Set(accessNewsReadArt)
1616 return bits
1617 }(),
1618 },
1619 Server: &Server{
1620 FlatNews: []byte("TEST"),
1621 },
1622 },
1623 t: NewTransaction(
1624 TranGetMsgs, &[]byte{0, 1},
1625 ),
1626 },
1627 wantRes: []Transaction{
1628 {
1629 Flags: 0x00,
1630 IsReply: 0x01,
1631 Type: []byte{0, 0},
1632 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1633 ErrorCode: []byte{0, 0, 0, 0},
1634 Fields: []Field{
1635 NewField(FieldData, []byte("TEST")),
1636 },
1637 },
1638 },
1639 wantErr: assert.NoError,
1640 },
1641 {
1642 name: "when user does not have required permission",
1643 args: args{
1644 cc: &ClientConn{
1645 Account: &Account{
1646 Access: func() accessBitmap {
1647 var bits accessBitmap
1648 return bits
1649 }(),
1650 },
1651 Server: &Server{
1652 Accounts: map[string]*Account{},
1653 },
1654 },
1655 t: NewTransaction(
1656 TranGetMsgs, &[]byte{0, 1},
1657 ),
1658 },
1659 wantRes: []Transaction{
1660 {
1661 Flags: 0x00,
1662 IsReply: 0x01,
1663 Type: []byte{0, 0},
1664 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1665 ErrorCode: []byte{0, 0, 0, 1},
1666 Fields: []Field{
1667 NewField(FieldError, []byte("You are not allowed to read news.")),
1668 },
1669 },
1670 },
1671 wantErr: assert.NoError,
1672 },
1673 }
1674 for _, tt := range tests {
1675 t.Run(tt.name, func(t *testing.T) {
1676 gotRes, err := HandleGetMsgs(tt.args.cc, tt.args.t)
1677 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetMsgs(%v, %v)", tt.args.cc, tt.args.t)) {
1678 return
1679 }
1680
1681 tranAssertEqual(t, tt.wantRes, gotRes)
1682 })
1683 }
1684 }
1685
1686 func TestHandleNewUser(t *testing.T) {
1687 type args struct {
1688 cc *ClientConn
1689 t *Transaction
1690 }
1691 tests := []struct {
1692 name string
1693 args args
1694 wantRes []Transaction
1695 wantErr assert.ErrorAssertionFunc
1696 }{
1697 {
1698 name: "when user does not have required permission",
1699 args: args{
1700 cc: &ClientConn{
1701 Account: &Account{
1702 Access: func() accessBitmap {
1703 var bits accessBitmap
1704 return bits
1705 }(),
1706 },
1707 Server: &Server{
1708 Accounts: map[string]*Account{},
1709 },
1710 },
1711 t: NewTransaction(
1712 TranNewUser, &[]byte{0, 1},
1713 ),
1714 },
1715 wantRes: []Transaction{
1716 {
1717 Flags: 0x00,
1718 IsReply: 0x01,
1719 Type: []byte{0, 0},
1720 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1721 ErrorCode: []byte{0, 0, 0, 1},
1722 Fields: []Field{
1723 NewField(FieldError, []byte("You are not allowed to create new accounts.")),
1724 },
1725 },
1726 },
1727 wantErr: assert.NoError,
1728 },
1729 {
1730 name: "when user attempts to create account with greater access",
1731 args: args{
1732 cc: &ClientConn{
1733 Account: &Account{
1734 Access: func() accessBitmap {
1735 var bits accessBitmap
1736 bits.Set(accessCreateUser)
1737 return bits
1738 }(),
1739 },
1740 Server: &Server{
1741 Accounts: map[string]*Account{},
1742 },
1743 },
1744 t: NewTransaction(
1745 TranNewUser, &[]byte{0, 1},
1746 NewField(FieldUserLogin, []byte("userB")),
1747 NewField(
1748 FieldUserAccess,
1749 func() []byte {
1750 var bits accessBitmap
1751 bits.Set(accessDisconUser)
1752 return bits[:]
1753 }(),
1754 ),
1755 ),
1756 },
1757 wantRes: []Transaction{
1758 {
1759 Flags: 0x00,
1760 IsReply: 0x01,
1761 Type: []byte{0, 0},
1762 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1763 ErrorCode: []byte{0, 0, 0, 1},
1764 Fields: []Field{
1765 NewField(FieldError, []byte("Cannot create account with more access than yourself.")),
1766 },
1767 },
1768 },
1769 wantErr: assert.NoError,
1770 },
1771 }
1772 for _, tt := range tests {
1773 t.Run(tt.name, func(t *testing.T) {
1774 gotRes, err := HandleNewUser(tt.args.cc, tt.args.t)
1775 if !tt.wantErr(t, err, fmt.Sprintf("HandleNewUser(%v, %v)", tt.args.cc, tt.args.t)) {
1776 return
1777 }
1778
1779 tranAssertEqual(t, tt.wantRes, gotRes)
1780 })
1781 }
1782 }
1783
1784 func TestHandleListUsers(t *testing.T) {
1785 type args struct {
1786 cc *ClientConn
1787 t *Transaction
1788 }
1789 tests := []struct {
1790 name string
1791 args args
1792 wantRes []Transaction
1793 wantErr assert.ErrorAssertionFunc
1794 }{
1795 {
1796 name: "when user does not have required permission",
1797 args: args{
1798 cc: &ClientConn{
1799 Account: &Account{
1800 Access: func() accessBitmap {
1801 var bits accessBitmap
1802 return bits
1803 }(),
1804 },
1805 Server: &Server{
1806 Accounts: map[string]*Account{},
1807 },
1808 },
1809 t: NewTransaction(
1810 TranNewUser, &[]byte{0, 1},
1811 ),
1812 },
1813 wantRes: []Transaction{
1814 {
1815 Flags: 0x00,
1816 IsReply: 0x01,
1817 Type: []byte{0, 0},
1818 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1819 ErrorCode: []byte{0, 0, 0, 1},
1820 Fields: []Field{
1821 NewField(FieldError, []byte("You are not allowed to view accounts.")),
1822 },
1823 },
1824 },
1825 wantErr: assert.NoError,
1826 },
1827 {
1828 name: "when user has required permission",
1829 args: args{
1830 cc: &ClientConn{
1831 Account: &Account{
1832 Access: func() accessBitmap {
1833 var bits accessBitmap
1834 bits.Set(accessOpenUser)
1835 return bits
1836 }(),
1837 },
1838 Server: &Server{
1839 Accounts: map[string]*Account{
1840 "guest": {
1841 Name: "guest",
1842 Login: "guest",
1843 Password: "zz",
1844 Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
1845 },
1846 },
1847 },
1848 },
1849 t: NewTransaction(
1850 TranGetClientInfoText, &[]byte{0, 1},
1851 NewField(FieldUserID, []byte{0, 1}),
1852 ),
1853 },
1854 wantRes: []Transaction{
1855 {
1856 Flags: 0x00,
1857 IsReply: 0x01,
1858 Type: []byte{0, 0},
1859 ID: []byte{0, 0, 0, 0},
1860 ErrorCode: []byte{0, 0, 0, 0},
1861 Fields: []Field{
1862 NewField(FieldData, []byte{
1863 0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98,
1864 0x8a, 0x9a, 0x8c, 0x8b, 0x00, 0x6e, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1865 0x00, 0x6a, 0x00, 0x01, 0x78,
1866 }),
1867 },
1868 },
1869 },
1870 wantErr: assert.NoError,
1871 },
1872 }
1873 for _, tt := range tests {
1874 t.Run(tt.name, func(t *testing.T) {
1875 gotRes, err := HandleListUsers(tt.args.cc, tt.args.t)
1876 if !tt.wantErr(t, err, fmt.Sprintf("HandleListUsers(%v, %v)", tt.args.cc, tt.args.t)) {
1877 return
1878 }
1879
1880 tranAssertEqual(t, tt.wantRes, gotRes)
1881 })
1882 }
1883 }
1884
1885 func TestHandleDownloadFile(t *testing.T) {
1886 type args struct {
1887 cc *ClientConn
1888 t *Transaction
1889 }
1890 tests := []struct {
1891 name string
1892 args args
1893 wantRes []Transaction
1894 wantErr assert.ErrorAssertionFunc
1895 }{
1896 {
1897 name: "when user does not have required permission",
1898 args: args{
1899 cc: &ClientConn{
1900 Account: &Account{
1901 Access: func() accessBitmap {
1902 var bits accessBitmap
1903 return bits
1904 }(),
1905 },
1906 Server: &Server{},
1907 },
1908 t: NewTransaction(TranDownloadFile, &[]byte{0, 1}),
1909 },
1910 wantRes: []Transaction{
1911 {
1912 Flags: 0x00,
1913 IsReply: 0x01,
1914 Type: []byte{0, 0},
1915 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1916 ErrorCode: []byte{0, 0, 0, 1},
1917 Fields: []Field{
1918 NewField(FieldError, []byte("You are not allowed to download files.")),
1919 },
1920 },
1921 },
1922 wantErr: assert.NoError,
1923 },
1924 {
1925 name: "with a valid file",
1926 args: args{
1927 cc: &ClientConn{
1928 transfers: map[int]map[[4]byte]*FileTransfer{
1929 FileDownload: {},
1930 },
1931 Account: &Account{
1932 Access: func() accessBitmap {
1933 var bits accessBitmap
1934 bits.Set(accessDownloadFile)
1935 return bits
1936 }(),
1937 },
1938 Server: &Server{
1939 FS: &OSFileStore{},
1940 fileTransfers: map[[4]byte]*FileTransfer{},
1941 Config: &Config{
1942 FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(),
1943 },
1944 Accounts: map[string]*Account{},
1945 },
1946 },
1947 t: NewTransaction(
1948 accessDownloadFile,
1949 &[]byte{0, 1},
1950 NewField(FieldFileName, []byte("testfile.txt")),
1951 NewField(FieldFilePath, []byte{0x0, 0x00}),
1952 ),
1953 },
1954 wantRes: []Transaction{
1955 {
1956 Flags: 0x00,
1957 IsReply: 0x01,
1958 Type: []byte{0, 0},
1959 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
1960 ErrorCode: []byte{0, 0, 0, 0},
1961 Fields: []Field{
1962 NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
1963 NewField(FieldWaitingCount, []byte{0x00, 0x00}),
1964 NewField(FieldTransferSize, []byte{0x00, 0x00, 0x00, 0xa5}),
1965 NewField(FieldFileSize, []byte{0x00, 0x00, 0x00, 0x17}),
1966 },
1967 },
1968 },
1969 wantErr: assert.NoError,
1970 },
1971 {
1972 name: "when client requests to resume 1k test file at offset 256",
1973 args: args{
1974 cc: &ClientConn{
1975 transfers: map[int]map[[4]byte]*FileTransfer{
1976 FileDownload: {},
1977 }, Account: &Account{
1978 Access: func() accessBitmap {
1979 var bits accessBitmap
1980 bits.Set(accessDownloadFile)
1981 return bits
1982 }(),
1983 },
1984 Server: &Server{
1985 FS: &OSFileStore{},
1986
1987 // FS: func() *MockFileStore {
1988 // path, _ := os.Getwd()
1989 // testFile, err := os.Open(path + "/test/config/Files/testfile-1k")
1990 // if err != nil {
1991 // panic(err)
1992 // }
1993 //
1994 // mfi := &MockFileInfo{}
1995 // mfi.On("Mode").Return(fs.FileMode(0))
1996 // mfs := &MockFileStore{}
1997 // mfs.On("Stat", "/fakeRoot/Files/testfile.txt").Return(mfi, nil)
1998 // mfs.On("Open", "/fakeRoot/Files/testfile.txt").Return(testFile, nil)
1999 // mfs.On("Stat", "/fakeRoot/Files/.info_testfile.txt").Return(nil, errors.New("no"))
2000 // mfs.On("Stat", "/fakeRoot/Files/.rsrc_testfile.txt").Return(nil, errors.New("no"))
2001 //
2002 // return mfs
2003 // }(),
2004 fileTransfers: map[[4]byte]*FileTransfer{},
2005 Config: &Config{
2006 FileRoot: func() string { path, _ := os.Getwd(); return path + "/test/config/Files" }(),
2007 },
2008 Accounts: map[string]*Account{},
2009 },
2010 },
2011 t: NewTransaction(
2012 accessDownloadFile,
2013 &[]byte{0, 1},
2014 NewField(FieldFileName, []byte("testfile-1k")),
2015 NewField(FieldFilePath, []byte{0x00, 0x00}),
2016 NewField(
2017 FieldFileResumeData,
2018 func() []byte {
2019 frd := FileResumeData{
2020 Format: [4]byte{},
2021 Version: [2]byte{},
2022 RSVD: [34]byte{},
2023 ForkCount: [2]byte{0, 2},
2024 ForkInfoList: []ForkInfoList{
2025 {
2026 Fork: [4]byte{0x44, 0x41, 0x54, 0x41}, // "DATA"
2027 DataSize: [4]byte{0, 0, 0x01, 0x00}, // request offset 256
2028 RSVDA: [4]byte{},
2029 RSVDB: [4]byte{},
2030 },
2031 {
2032 Fork: [4]byte{0x4d, 0x41, 0x43, 0x52}, // "MACR"
2033 DataSize: [4]byte{0, 0, 0, 0},
2034 RSVDA: [4]byte{},
2035 RSVDB: [4]byte{},
2036 },
2037 },
2038 }
2039 b, _ := frd.BinaryMarshal()
2040 return b
2041 }(),
2042 ),
2043 ),
2044 },
2045 wantRes: []Transaction{
2046 {
2047 Flags: 0x00,
2048 IsReply: 0x01,
2049 Type: []byte{0, 0},
2050 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2051 ErrorCode: []byte{0, 0, 0, 0},
2052 Fields: []Field{
2053 NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
2054 NewField(FieldWaitingCount, []byte{0x00, 0x00}),
2055 NewField(FieldTransferSize, []byte{0x00, 0x00, 0x03, 0x8d}),
2056 NewField(FieldFileSize, []byte{0x00, 0x00, 0x03, 0x00}),
2057 },
2058 },
2059 },
2060 wantErr: assert.NoError,
2061 },
2062 }
2063 for _, tt := range tests {
2064 t.Run(tt.name, func(t *testing.T) {
2065 gotRes, err := HandleDownloadFile(tt.args.cc, tt.args.t)
2066 if !tt.wantErr(t, err, fmt.Sprintf("HandleDownloadFile(%v, %v)", tt.args.cc, tt.args.t)) {
2067 return
2068 }
2069
2070 tranAssertEqual(t, tt.wantRes, gotRes)
2071 })
2072 }
2073 }
2074
2075 func TestHandleUpdateUser(t *testing.T) {
2076 type args struct {
2077 cc *ClientConn
2078 t *Transaction
2079 }
2080 tests := []struct {
2081 name string
2082 args args
2083 wantRes []Transaction
2084 wantErr assert.ErrorAssertionFunc
2085 }{
2086 {
2087 name: "when action is create user without required permission",
2088 args: args{
2089 cc: &ClientConn{
2090 logger: NewTestLogger(),
2091 Server: &Server{
2092 Logger: NewTestLogger(),
2093 },
2094 Account: &Account{
2095 Access: func() accessBitmap {
2096 var bits accessBitmap
2097 return bits
2098 }(),
2099 },
2100 },
2101 t: NewTransaction(
2102 TranUpdateUser,
2103 &[]byte{0, 0},
2104 NewField(FieldData, []byte{
2105 0x00, 0x04, // field count
2106
2107 0x00, 0x69, // FieldUserLogin = 105
2108 0x00, 0x03,
2109 0x9d, 0x9d, 0x9d,
2110
2111 0x00, 0x6a, // FieldUserPassword = 106
2112 0x00, 0x03,
2113 0x9c, 0x9c, 0x9c,
2114
2115 0x00, 0x66, // FieldUserName = 102
2116 0x00, 0x03,
2117 0x61, 0x61, 0x61,
2118
2119 0x00, 0x6e, // FieldUserAccess = 110
2120 0x00, 0x08,
2121 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
2122 }),
2123 ),
2124 },
2125 wantRes: []Transaction{
2126 {
2127 Flags: 0x00,
2128 IsReply: 0x01,
2129 Type: []byte{0, 0},
2130 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2131 ErrorCode: []byte{0, 0, 0, 1},
2132 Fields: []Field{
2133 NewField(FieldError, []byte("You are not allowed to create new accounts.")),
2134 },
2135 },
2136 },
2137 wantErr: assert.NoError,
2138 },
2139 {
2140 name: "when action is modify user without required permission",
2141 args: args{
2142 cc: &ClientConn{
2143 logger: NewTestLogger(),
2144 Server: &Server{
2145 Logger: NewTestLogger(),
2146 Accounts: map[string]*Account{
2147 "bbb": {},
2148 },
2149 },
2150 Account: &Account{
2151 Access: func() accessBitmap {
2152 var bits accessBitmap
2153 return bits
2154 }(),
2155 },
2156 },
2157 t: NewTransaction(
2158 TranUpdateUser,
2159 &[]byte{0, 0},
2160 NewField(FieldData, []byte{
2161 0x00, 0x04, // field count
2162
2163 0x00, 0x69, // FieldUserLogin = 105
2164 0x00, 0x03,
2165 0x9d, 0x9d, 0x9d,
2166
2167 0x00, 0x6a, // FieldUserPassword = 106
2168 0x00, 0x03,
2169 0x9c, 0x9c, 0x9c,
2170
2171 0x00, 0x66, // FieldUserName = 102
2172 0x00, 0x03,
2173 0x61, 0x61, 0x61,
2174
2175 0x00, 0x6e, // FieldUserAccess = 110
2176 0x00, 0x08,
2177 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
2178 }),
2179 ),
2180 },
2181 wantRes: []Transaction{
2182 {
2183 Flags: 0x00,
2184 IsReply: 0x01,
2185 Type: []byte{0, 0},
2186 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2187 ErrorCode: []byte{0, 0, 0, 1},
2188 Fields: []Field{
2189 NewField(FieldError, []byte("You are not allowed to modify accounts.")),
2190 },
2191 },
2192 },
2193 wantErr: assert.NoError,
2194 },
2195 {
2196 name: "when action is delete user without required permission",
2197 args: args{
2198 cc: &ClientConn{
2199 logger: NewTestLogger(),
2200 Server: &Server{
2201 Accounts: map[string]*Account{
2202 "bbb": {},
2203 },
2204 },
2205 Account: &Account{
2206 Access: func() accessBitmap {
2207 var bits accessBitmap
2208 return bits
2209 }(),
2210 },
2211 },
2212 t: NewTransaction(
2213 TranUpdateUser,
2214 &[]byte{0, 0},
2215 NewField(FieldData, []byte{
2216 0x00, 0x01,
2217 0x00, 0x65,
2218 0x00, 0x03,
2219 0x88, 0x9e, 0x8b,
2220 }),
2221 ),
2222 },
2223 wantRes: []Transaction{
2224 {
2225 Flags: 0x00,
2226 IsReply: 0x01,
2227 Type: []byte{0, 0},
2228 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2229 ErrorCode: []byte{0, 0, 0, 1},
2230 Fields: []Field{
2231 NewField(FieldError, []byte("You are not allowed to delete accounts.")),
2232 },
2233 },
2234 },
2235 wantErr: assert.NoError,
2236 },
2237 }
2238 for _, tt := range tests {
2239 t.Run(tt.name, func(t *testing.T) {
2240 gotRes, err := HandleUpdateUser(tt.args.cc, tt.args.t)
2241 if !tt.wantErr(t, err, fmt.Sprintf("HandleUpdateUser(%v, %v)", tt.args.cc, tt.args.t)) {
2242 return
2243 }
2244
2245 tranAssertEqual(t, tt.wantRes, gotRes)
2246 })
2247 }
2248 }
2249
2250 func TestHandleDelNewsArt(t *testing.T) {
2251 type args struct {
2252 cc *ClientConn
2253 t *Transaction
2254 }
2255 tests := []struct {
2256 name string
2257 args args
2258 wantRes []Transaction
2259 wantErr assert.ErrorAssertionFunc
2260 }{
2261 {
2262 name: "without required permission",
2263 args: args{
2264 cc: &ClientConn{
2265 Account: &Account{
2266 Access: func() accessBitmap {
2267 var bits accessBitmap
2268 return bits
2269 }(),
2270 },
2271 },
2272 t: NewTransaction(
2273 TranDelNewsArt,
2274 &[]byte{0, 0},
2275 ),
2276 },
2277 wantRes: []Transaction{
2278 {
2279 Flags: 0x00,
2280 IsReply: 0x01,
2281 Type: []byte{0, 0},
2282 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2283 ErrorCode: []byte{0, 0, 0, 1},
2284 Fields: []Field{
2285 NewField(FieldError, []byte("You are not allowed to delete news articles.")),
2286 },
2287 },
2288 },
2289 wantErr: assert.NoError,
2290 },
2291 }
2292 for _, tt := range tests {
2293 t.Run(tt.name, func(t *testing.T) {
2294 gotRes, err := HandleDelNewsArt(tt.args.cc, tt.args.t)
2295 if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsArt(%v, %v)", tt.args.cc, tt.args.t)) {
2296 return
2297 }
2298 tranAssertEqual(t, tt.wantRes, gotRes)
2299 })
2300 }
2301 }
2302
2303 func TestHandleDisconnectUser(t *testing.T) {
2304 type args struct {
2305 cc *ClientConn
2306 t *Transaction
2307 }
2308 tests := []struct {
2309 name string
2310 args args
2311 wantRes []Transaction
2312 wantErr assert.ErrorAssertionFunc
2313 }{
2314 {
2315 name: "without required permission",
2316 args: args{
2317 cc: &ClientConn{
2318 Account: &Account{
2319 Access: func() accessBitmap {
2320 var bits accessBitmap
2321 return bits
2322 }(),
2323 },
2324 },
2325 t: NewTransaction(
2326 TranDelNewsArt,
2327 &[]byte{0, 0},
2328 ),
2329 },
2330 wantRes: []Transaction{
2331 {
2332 Flags: 0x00,
2333 IsReply: 0x01,
2334 Type: []byte{0, 0},
2335 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2336 ErrorCode: []byte{0, 0, 0, 1},
2337 Fields: []Field{
2338 NewField(FieldError, []byte("You are not allowed to disconnect users.")),
2339 },
2340 },
2341 },
2342 wantErr: assert.NoError,
2343 },
2344 {
2345 name: "when target user has 'cannot be disconnected' priv",
2346 args: args{
2347 cc: &ClientConn{
2348 Server: &Server{
2349 Clients: map[uint16]*ClientConn{
2350 uint16(1): {
2351 Account: &Account{
2352 Login: "unnamed",
2353 Access: func() accessBitmap {
2354 var bits accessBitmap
2355 bits.Set(accessCannotBeDiscon)
2356 return bits
2357 }(),
2358 },
2359 },
2360 },
2361 },
2362 Account: &Account{
2363 Access: func() accessBitmap {
2364 var bits accessBitmap
2365 bits.Set(accessDisconUser)
2366 return bits
2367 }(),
2368 },
2369 },
2370 t: NewTransaction(
2371 TranDelNewsArt,
2372 &[]byte{0, 0},
2373 NewField(FieldUserID, []byte{0, 1}),
2374 ),
2375 },
2376 wantRes: []Transaction{
2377 {
2378 Flags: 0x00,
2379 IsReply: 0x01,
2380 Type: []byte{0, 0},
2381 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2382 ErrorCode: []byte{0, 0, 0, 1},
2383 Fields: []Field{
2384 NewField(FieldError, []byte("unnamed is not allowed to be disconnected.")),
2385 },
2386 },
2387 },
2388 wantErr: assert.NoError,
2389 },
2390 }
2391 for _, tt := range tests {
2392 t.Run(tt.name, func(t *testing.T) {
2393 gotRes, err := HandleDisconnectUser(tt.args.cc, tt.args.t)
2394 if !tt.wantErr(t, err, fmt.Sprintf("HandleDisconnectUser(%v, %v)", tt.args.cc, tt.args.t)) {
2395 return
2396 }
2397 tranAssertEqual(t, tt.wantRes, gotRes)
2398 })
2399 }
2400 }
2401
2402 func TestHandleSendInstantMsg(t *testing.T) {
2403 type args struct {
2404 cc *ClientConn
2405 t *Transaction
2406 }
2407 tests := []struct {
2408 name string
2409 args args
2410 wantRes []Transaction
2411 wantErr assert.ErrorAssertionFunc
2412 }{
2413 {
2414 name: "without required permission",
2415 args: args{
2416 cc: &ClientConn{
2417 Account: &Account{
2418 Access: func() accessBitmap {
2419 var bits accessBitmap
2420 return bits
2421 }(),
2422 },
2423 },
2424 t: NewTransaction(
2425 TranDelNewsArt,
2426 &[]byte{0, 0},
2427 ),
2428 },
2429 wantRes: []Transaction{
2430 {
2431 Flags: 0x00,
2432 IsReply: 0x01,
2433 Type: []byte{0, 0},
2434 ID: []byte{0, 0, 0, 0},
2435 ErrorCode: []byte{0, 0, 0, 1},
2436 Fields: []Field{
2437 NewField(FieldError, []byte("You are not allowed to send private messages.")),
2438 },
2439 },
2440 },
2441 wantErr: assert.Error,
2442 },
2443 {
2444 name: "when client 1 sends a message to client 2",
2445 args: args{
2446 cc: &ClientConn{
2447 Account: &Account{
2448 Access: func() accessBitmap {
2449 var bits accessBitmap
2450 bits.Set(accessSendPrivMsg)
2451 return bits
2452 }(),
2453 },
2454 ID: &[]byte{0, 1},
2455 UserName: []byte("User1"),
2456 Server: &Server{
2457 Clients: map[uint16]*ClientConn{
2458 uint16(2): {
2459 AutoReply: []byte(nil),
2460 Flags: []byte{0, 0},
2461 },
2462 },
2463 },
2464 },
2465 t: NewTransaction(
2466 TranSendInstantMsg,
2467 &[]byte{0, 1},
2468 NewField(FieldData, []byte("hai")),
2469 NewField(FieldUserID, []byte{0, 2}),
2470 ),
2471 },
2472 wantRes: []Transaction{
2473 *NewTransaction(
2474 TranServerMsg,
2475 &[]byte{0, 2},
2476 NewField(FieldData, []byte("hai")),
2477 NewField(FieldUserName, []byte("User1")),
2478 NewField(FieldUserID, []byte{0, 1}),
2479 NewField(FieldOptions, []byte{0, 1}),
2480 ),
2481 {
2482 clientID: &[]byte{0, 1},
2483 Flags: 0x00,
2484 IsReply: 0x01,
2485 Type: []byte{0, 0},
2486 ID: []byte{0, 0, 0, 0},
2487 ErrorCode: []byte{0, 0, 0, 0},
2488 Fields: []Field(nil),
2489 },
2490 },
2491 wantErr: assert.NoError,
2492 },
2493 {
2494 name: "when client 2 has autoreply enabled",
2495 args: args{
2496 cc: &ClientConn{
2497 Account: &Account{
2498 Access: func() accessBitmap {
2499 var bits accessBitmap
2500 bits.Set(accessSendPrivMsg)
2501 return bits
2502 }(),
2503 },
2504 ID: &[]byte{0, 1},
2505 UserName: []byte("User1"),
2506 Server: &Server{
2507 Clients: map[uint16]*ClientConn{
2508 uint16(2): {
2509 Flags: []byte{0, 0},
2510 ID: &[]byte{0, 2},
2511 UserName: []byte("User2"),
2512 AutoReply: []byte("autohai"),
2513 },
2514 },
2515 },
2516 },
2517 t: NewTransaction(
2518 TranSendInstantMsg,
2519 &[]byte{0, 1},
2520 NewField(FieldData, []byte("hai")),
2521 NewField(FieldUserID, []byte{0, 2}),
2522 ),
2523 },
2524 wantRes: []Transaction{
2525 *NewTransaction(
2526 TranServerMsg,
2527 &[]byte{0, 2},
2528 NewField(FieldData, []byte("hai")),
2529 NewField(FieldUserName, []byte("User1")),
2530 NewField(FieldUserID, []byte{0, 1}),
2531 NewField(FieldOptions, []byte{0, 1}),
2532 ),
2533 *NewTransaction(
2534 TranServerMsg,
2535 &[]byte{0, 1},
2536 NewField(FieldData, []byte("autohai")),
2537 NewField(FieldUserName, []byte("User2")),
2538 NewField(FieldUserID, []byte{0, 2}),
2539 NewField(FieldOptions, []byte{0, 1}),
2540 ),
2541 {
2542 clientID: &[]byte{0, 1},
2543 Flags: 0x00,
2544 IsReply: 0x01,
2545 Type: []byte{0, 0},
2546 ID: []byte{0, 0, 0, 0},
2547 ErrorCode: []byte{0, 0, 0, 0},
2548 Fields: []Field(nil),
2549 },
2550 },
2551 wantErr: assert.NoError,
2552 },
2553 {
2554 name: "when client 2 has refuse private messages enabled",
2555 args: args{
2556 cc: &ClientConn{
2557 Account: &Account{
2558 Access: func() accessBitmap {
2559 var bits accessBitmap
2560 bits.Set(accessSendPrivMsg)
2561 return bits
2562 }(),
2563 },
2564 ID: &[]byte{0, 1},
2565 UserName: []byte("User1"),
2566 Server: &Server{
2567 Clients: map[uint16]*ClientConn{
2568 uint16(2): {
2569 Flags: []byte{255, 255},
2570 ID: &[]byte{0, 2},
2571 UserName: []byte("User2"),
2572 },
2573 },
2574 },
2575 },
2576 t: NewTransaction(
2577 TranSendInstantMsg,
2578 &[]byte{0, 1},
2579 NewField(FieldData, []byte("hai")),
2580 NewField(FieldUserID, []byte{0, 2}),
2581 ),
2582 },
2583 wantRes: []Transaction{
2584 *NewTransaction(
2585 TranServerMsg,
2586 &[]byte{0, 1},
2587 NewField(FieldData, []byte("User2 does not accept private messages.")),
2588 NewField(FieldUserName, []byte("User2")),
2589 NewField(FieldUserID, []byte{0, 2}),
2590 NewField(FieldOptions, []byte{0, 2}),
2591 ),
2592 {
2593 clientID: &[]byte{0, 1},
2594 Flags: 0x00,
2595 IsReply: 0x01,
2596 Type: []byte{0, 0},
2597 ID: []byte{0, 0, 0, 0},
2598 ErrorCode: []byte{0, 0, 0, 0},
2599 Fields: []Field(nil),
2600 },
2601 },
2602 wantErr: assert.NoError,
2603 },
2604 }
2605 for _, tt := range tests {
2606 t.Run(tt.name, func(t *testing.T) {
2607 gotRes, err := HandleSendInstantMsg(tt.args.cc, tt.args.t)
2608 if !tt.wantErr(t, err, fmt.Sprintf("HandleSendInstantMsg(%v, %v)", tt.args.cc, tt.args.t)) {
2609 return
2610 }
2611
2612 tranAssertEqual(t, tt.wantRes, gotRes)
2613 })
2614 }
2615 }
2616
2617 func TestHandleDeleteFile(t *testing.T) {
2618 type args struct {
2619 cc *ClientConn
2620 t *Transaction
2621 }
2622 tests := []struct {
2623 name string
2624 args args
2625 wantRes []Transaction
2626 wantErr assert.ErrorAssertionFunc
2627 }{
2628 {
2629 name: "when user does not have required permission to delete a folder",
2630 args: args{
2631 cc: &ClientConn{
2632 Account: &Account{
2633 Access: func() accessBitmap {
2634 var bits accessBitmap
2635 return bits
2636 }(),
2637 },
2638 Server: &Server{
2639 Config: &Config{
2640 FileRoot: func() string {
2641 return "/fakeRoot/Files"
2642 }(),
2643 },
2644 FS: func() *MockFileStore {
2645 mfi := &MockFileInfo{}
2646 mfi.On("Mode").Return(fs.FileMode(0))
2647 mfi.On("Size").Return(int64(100))
2648 mfi.On("ModTime").Return(time.Parse(time.Layout, time.Layout))
2649 mfi.On("IsDir").Return(false)
2650 mfi.On("Name").Return("testfile")
2651
2652 mfs := &MockFileStore{}
2653 mfs.On("Stat", "/fakeRoot/Files/aaa/testfile").Return(mfi, nil)
2654 mfs.On("Stat", "/fakeRoot/Files/aaa/.info_testfile").Return(nil, errors.New("err"))
2655 mfs.On("Stat", "/fakeRoot/Files/aaa/.rsrc_testfile").Return(nil, errors.New("err"))
2656
2657 return mfs
2658 }(),
2659 Accounts: map[string]*Account{},
2660 },
2661 },
2662 t: NewTransaction(
2663 TranDeleteFile, &[]byte{0, 1},
2664 NewField(FieldFileName, []byte("testfile")),
2665 NewField(FieldFilePath, []byte{
2666 0x00, 0x01,
2667 0x00, 0x00,
2668 0x03,
2669 0x61, 0x61, 0x61,
2670 }),
2671 ),
2672 },
2673 wantRes: []Transaction{
2674 {
2675 Flags: 0x00,
2676 IsReply: 0x01,
2677 Type: []byte{0, 0},
2678 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
2679 ErrorCode: []byte{0, 0, 0, 1},
2680 Fields: []Field{
2681 NewField(FieldError, []byte("You are not allowed to delete files.")),
2682 },
2683 },
2684 },
2685 wantErr: assert.NoError,
2686 },
2687 {
2688 name: "deletes all associated metadata files",
2689 args: args{
2690 cc: &ClientConn{
2691 Account: &Account{
2692 Access: func() accessBitmap {
2693 var bits accessBitmap
2694 bits.Set(accessDeleteFile)
2695 return bits
2696 }(),
2697 },
2698 Server: &Server{
2699 Config: &Config{
2700 FileRoot: func() string {
2701 return "/fakeRoot/Files"
2702 }(),
2703 },
2704 FS: func() *MockFileStore {
2705 mfi := &MockFileInfo{}
2706 mfi.On("Mode").Return(fs.FileMode(0))
2707 mfi.On("Size").Return(int64(100))
2708 mfi.On("ModTime").Return(time.Parse(time.Layout, time.Layout))
2709 mfi.On("IsDir").Return(false)
2710 mfi.On("Name").Return("testfile")
2711
2712 mfs := &MockFileStore{}
2713 mfs.On("Stat", "/fakeRoot/Files/aaa/testfile").Return(mfi, nil)
2714 mfs.On("Stat", "/fakeRoot/Files/aaa/.info_testfile").Return(nil, errors.New("err"))
2715 mfs.On("Stat", "/fakeRoot/Files/aaa/.rsrc_testfile").Return(nil, errors.New("err"))
2716
2717 mfs.On("RemoveAll", "/fakeRoot/Files/aaa/testfile").Return(nil)
2718 mfs.On("Remove", "/fakeRoot/Files/aaa/testfile.incomplete").Return(nil)
2719 mfs.On("Remove", "/fakeRoot/Files/aaa/.rsrc_testfile").Return(nil)
2720 mfs.On("Remove", "/fakeRoot/Files/aaa/.info_testfile").Return(nil)
2721
2722 return mfs
2723 }(),
2724 Accounts: map[string]*Account{},
2725 },
2726 },
2727 t: NewTransaction(
2728 TranDeleteFile, &[]byte{0, 1},
2729 NewField(FieldFileName, []byte("testfile")),
2730 NewField(FieldFilePath, []byte{
2731 0x00, 0x01,
2732 0x00, 0x00,
2733 0x03,
2734 0x61, 0x61, 0x61,
2735 }),
2736 ),
2737 },
2738 wantRes: []Transaction{
2739 {
2740 Flags: 0x00,
2741 IsReply: 0x01,
2742 Type: []byte{0, 0},
2743 ID: []byte{0x0, 0x0, 0x0, 0x0},
2744 ErrorCode: []byte{0, 0, 0, 0},
2745 Fields: []Field(nil),
2746 },
2747 },
2748 wantErr: assert.NoError,
2749 },
2750 }
2751 for _, tt := range tests {
2752 t.Run(tt.name, func(t *testing.T) {
2753 gotRes, err := HandleDeleteFile(tt.args.cc, tt.args.t)
2754 if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteFile(%v, %v)", tt.args.cc, tt.args.t)) {
2755 return
2756 }
2757
2758 tranAssertEqual(t, tt.wantRes, gotRes)
2759
2760 tt.args.cc.Server.FS.(*MockFileStore).AssertExpectations(t)
2761 })
2762 }
2763 }
2764
2765 func TestHandleGetFileNameList(t *testing.T) {
2766 type args struct {
2767 cc *ClientConn
2768 t *Transaction
2769 }
2770 tests := []struct {
2771 name string
2772 args args
2773 wantRes []Transaction
2774 wantErr assert.ErrorAssertionFunc
2775 }{
2776 {
2777 name: "when FieldFilePath is a drop box, but user does not have accessViewDropBoxes ",
2778 args: args{
2779 cc: &ClientConn{
2780 Account: &Account{
2781 Access: func() accessBitmap {
2782 var bits accessBitmap
2783 return bits
2784 }(),
2785 },
2786 Server: &Server{
2787
2788 Config: &Config{
2789 FileRoot: func() string {
2790 path, _ := os.Getwd()
2791 return filepath.Join(path, "/test/config/Files/getFileNameListTestDir")
2792 }(),
2793 },
2794 },
2795 },
2796 t: NewTransaction(
2797 TranGetFileNameList, &[]byte{0, 1},
2798 NewField(FieldFilePath, []byte{
2799 0x00, 0x01,
2800 0x00, 0x00,
2801 0x08,
2802 0x64, 0x72, 0x6f, 0x70, 0x20, 0x62, 0x6f, 0x78, // "drop box"
2803 }),
2804 ),
2805 },
2806 wantRes: []Transaction{
2807 {
2808 Flags: 0x00,
2809 IsReply: 0x01,
2810 Type: []byte{0, 0},
2811 ID: []byte{0, 0, 0, 0},
2812 ErrorCode: []byte{0, 0, 0, 1},
2813 Fields: []Field{
2814 NewField(FieldError, []byte("You are not allowed to view drop boxes.")),
2815 },
2816 },
2817 },
2818 wantErr: assert.NoError,
2819 },
2820 {
2821 name: "with file root",
2822 args: args{
2823 cc: &ClientConn{
2824 Server: &Server{
2825 Config: &Config{
2826 FileRoot: func() string {
2827 path, _ := os.Getwd()
2828 return filepath.Join(path, "/test/config/Files/getFileNameListTestDir")
2829 }(),
2830 },
2831 },
2832 },
2833 t: NewTransaction(
2834 TranGetFileNameList, &[]byte{0, 1},
2835 NewField(FieldFilePath, []byte{
2836 0x00, 0x00,
2837 0x00, 0x00,
2838 }),
2839 ),
2840 },
2841 wantRes: []Transaction{
2842 {
2843 Flags: 0x00,
2844 IsReply: 0x01,
2845 Type: []byte{0, 0},
2846 ID: []byte{0, 0, 0, 0},
2847 ErrorCode: []byte{0, 0, 0, 0},
2848 Fields: []Field{
2849 NewField(
2850 FieldFileNameWithInfo,
2851 func() []byte {
2852 fnwi := FileNameWithInfo{
2853 fileNameWithInfoHeader: fileNameWithInfoHeader{
2854 Type: [4]byte{0x54, 0x45, 0x58, 0x54},
2855 Creator: [4]byte{0x54, 0x54, 0x58, 0x54},
2856 FileSize: [4]byte{0, 0, 0x04, 0},
2857 RSVD: [4]byte{},
2858 NameScript: [2]byte{},
2859 NameSize: [2]byte{0, 0x0b},
2860 },
2861 name: []byte("testfile-1k"),
2862 }
2863 b, _ := io.ReadAll(&fnwi)
2864 return b
2865 }(),
2866 ),
2867 },
2868 },
2869 },
2870 wantErr: assert.NoError,
2871 },
2872 }
2873 for _, tt := range tests {
2874 t.Run(tt.name, func(t *testing.T) {
2875 gotRes, err := HandleGetFileNameList(tt.args.cc, tt.args.t)
2876 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetFileNameList(%v, %v)", tt.args.cc, tt.args.t)) {
2877 return
2878 }
2879
2880 tranAssertEqual(t, tt.wantRes, gotRes)
2881 })
2882 }
2883 }
2884
2885 func TestHandleGetClientInfoText(t *testing.T) {
2886 type args struct {
2887 cc *ClientConn
2888 t *Transaction
2889 }
2890 tests := []struct {
2891 name string
2892 args args
2893 wantRes []Transaction
2894 wantErr assert.ErrorAssertionFunc
2895 }{
2896 {
2897 name: "when user does not have required permission",
2898 args: args{
2899 cc: &ClientConn{
2900 Account: &Account{
2901 Access: func() accessBitmap {
2902 var bits accessBitmap
2903 return bits
2904 }(),
2905 },
2906 Server: &Server{
2907 Accounts: map[string]*Account{},
2908 },
2909 },
2910 t: NewTransaction(
2911 TranGetClientInfoText, &[]byte{0, 1},
2912 NewField(FieldUserID, []byte{0, 1}),
2913 ),
2914 },
2915 wantRes: []Transaction{
2916 {
2917 Flags: 0x00,
2918 IsReply: 0x01,
2919 Type: []byte{0, 0},
2920 ID: []byte{0, 0, 0, 0},
2921 ErrorCode: []byte{0, 0, 0, 1},
2922 Fields: []Field{
2923 NewField(FieldError, []byte("You are not allowed to get client info.")),
2924 },
2925 },
2926 },
2927 wantErr: assert.NoError,
2928 },
2929 {
2930 name: "with a valid user",
2931 args: args{
2932 cc: &ClientConn{
2933 UserName: []byte("Testy McTest"),
2934 RemoteAddr: "1.2.3.4:12345",
2935 Account: &Account{
2936 Access: func() accessBitmap {
2937 var bits accessBitmap
2938 bits.Set(accessGetClientInfo)
2939 return bits
2940 }(),
2941 Name: "test",
2942 Login: "test",
2943 },
2944 Server: &Server{
2945 Accounts: map[string]*Account{},
2946 Clients: map[uint16]*ClientConn{
2947 uint16(1): {
2948 UserName: []byte("Testy McTest"),
2949 RemoteAddr: "1.2.3.4:12345",
2950 Account: &Account{
2951 Access: func() accessBitmap {
2952 var bits accessBitmap
2953 bits.Set(accessGetClientInfo)
2954 return bits
2955 }(),
2956 Name: "test",
2957 Login: "test",
2958 },
2959 },
2960 },
2961 },
2962 transfers: map[int]map[[4]byte]*FileTransfer{
2963 FileDownload: {},
2964 FileUpload: {},
2965 FolderDownload: {},
2966 FolderUpload: {},
2967 },
2968 },
2969 t: NewTransaction(
2970 TranGetClientInfoText, &[]byte{0, 1},
2971 NewField(FieldUserID, []byte{0, 1}),
2972 ),
2973 },
2974 wantRes: []Transaction{
2975 {
2976 Flags: 0x00,
2977 IsReply: 0x01,
2978 Type: []byte{0, 0},
2979 ID: []byte{0, 0, 0, 0},
2980 ErrorCode: []byte{0, 0, 0, 0},
2981 Fields: []Field{
2982 NewField(FieldData, []byte(
2983 strings.ReplaceAll(`Nickname: Testy McTest
2984 Name: test
2985 Account: test
2986 Address: 1.2.3.4:12345
2987
2988 -------- File Downloads ---------
2989
2990 None.
2991
2992 ------- Folder Downloads --------
2993
2994 None.
2995
2996 --------- File Uploads ----------
2997
2998 None.
2999
3000 -------- Folder Uploads ---------
3001
3002 None.
3003
3004 ------- Waiting Downloads -------
3005
3006 None.
3007
3008 `, "\n", "\r")),
3009 ),
3010 NewField(FieldUserName, []byte("Testy McTest")),
3011 },
3012 },
3013 },
3014 wantErr: assert.NoError,
3015 },
3016 }
3017 for _, tt := range tests {
3018 t.Run(tt.name, func(t *testing.T) {
3019 gotRes, err := HandleGetClientInfoText(tt.args.cc, tt.args.t)
3020 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetClientInfoText(%v, %v)", tt.args.cc, tt.args.t)) {
3021 return
3022 }
3023 tranAssertEqual(t, tt.wantRes, gotRes)
3024 })
3025 }
3026 }
3027
3028 func TestHandleTranAgreed(t *testing.T) {
3029 type args struct {
3030 cc *ClientConn
3031 t *Transaction
3032 }
3033 tests := []struct {
3034 name string
3035 args args
3036 wantRes []Transaction
3037 wantErr assert.ErrorAssertionFunc
3038 }{
3039 {
3040 name: "normal request flow",
3041 args: args{
3042 cc: &ClientConn{
3043 Account: &Account{
3044 Access: func() accessBitmap {
3045 var bits accessBitmap
3046 bits.Set(accessDisconUser)
3047 bits.Set(accessAnyName)
3048 return bits
3049 }()},
3050 Icon: []byte{0, 1},
3051 Flags: []byte{0, 1},
3052 Version: []byte{0, 1},
3053 ID: &[]byte{0, 1},
3054 logger: NewTestLogger(),
3055 Server: &Server{
3056 Config: &Config{
3057 BannerFile: "banner.jpg",
3058 },
3059 },
3060 },
3061 t: NewTransaction(
3062 TranAgreed, nil,
3063 NewField(FieldUserName, []byte("username")),
3064 NewField(FieldUserIconID, []byte{0, 1}),
3065 NewField(FieldOptions, []byte{0, 0}),
3066 ),
3067 },
3068 wantRes: []Transaction{
3069 {
3070 clientID: &[]byte{0, 1},
3071 Flags: 0x00,
3072 IsReply: 0x00,
3073 Type: []byte{0, 0x7a},
3074 ID: []byte{0, 0, 0, 0},
3075 ErrorCode: []byte{0, 0, 0, 0},
3076 Fields: []Field{
3077 NewField(FieldBannerType, []byte("JPEG")),
3078 },
3079 },
3080 {
3081 clientID: &[]byte{0, 1},
3082 Flags: 0x00,
3083 IsReply: 0x01,
3084 Type: []byte{0, 0},
3085 ID: []byte{0, 0, 0, 0},
3086 ErrorCode: []byte{0, 0, 0, 0},
3087 Fields: []Field{},
3088 },
3089 },
3090 wantErr: assert.NoError,
3091 },
3092 }
3093 for _, tt := range tests {
3094 t.Run(tt.name, func(t *testing.T) {
3095 gotRes, err := HandleTranAgreed(tt.args.cc, tt.args.t)
3096 if !tt.wantErr(t, err, fmt.Sprintf("HandleTranAgreed(%v, %v)", tt.args.cc, tt.args.t)) {
3097 return
3098 }
3099 tranAssertEqual(t, tt.wantRes, gotRes)
3100 })
3101 }
3102 }
3103
3104 func TestHandleSetClientUserInfo(t *testing.T) {
3105 type args struct {
3106 cc *ClientConn
3107 t *Transaction
3108 }
3109 tests := []struct {
3110 name string
3111 args args
3112 wantRes []Transaction
3113 wantErr assert.ErrorAssertionFunc
3114 }{
3115 {
3116 name: "when client does not have accessAnyName",
3117 args: args{
3118 cc: &ClientConn{
3119 Account: &Account{
3120 Access: func() accessBitmap {
3121 var bits accessBitmap
3122 return bits
3123 }(),
3124 },
3125 ID: &[]byte{0, 1},
3126 UserName: []byte("Guest"),
3127 Flags: []byte{0, 1},
3128 Server: &Server{
3129 Clients: map[uint16]*ClientConn{
3130 uint16(1): {
3131 ID: &[]byte{0, 1},
3132 },
3133 },
3134 },
3135 },
3136 t: NewTransaction(
3137 TranSetClientUserInfo, nil,
3138 NewField(FieldUserIconID, []byte{0, 1}),
3139 NewField(FieldUserName, []byte("NOPE")),
3140 ),
3141 },
3142 wantRes: []Transaction{
3143 {
3144 clientID: &[]byte{0, 1},
3145 Flags: 0x00,
3146 IsReply: 0x00,
3147 Type: []byte{0x01, 0x2d},
3148 ID: []byte{0, 0, 0, 0},
3149 ErrorCode: []byte{0, 0, 0, 0},
3150 Fields: []Field{
3151 NewField(FieldUserID, []byte{0, 1}),
3152 NewField(FieldUserIconID, []byte{0, 1}),
3153 NewField(FieldUserFlags, []byte{0, 1}),
3154 NewField(FieldUserName, []byte("Guest"))},
3155 },
3156 },
3157 wantErr: assert.NoError,
3158 },
3159 }
3160 for _, tt := range tests {
3161 t.Run(tt.name, func(t *testing.T) {
3162 gotRes, err := HandleSetClientUserInfo(tt.args.cc, tt.args.t)
3163 if !tt.wantErr(t, err, fmt.Sprintf("HandleSetClientUserInfo(%v, %v)", tt.args.cc, tt.args.t)) {
3164 return
3165 }
3166
3167 tranAssertEqual(t, tt.wantRes, gotRes)
3168 })
3169 }
3170 }
3171
3172 func TestHandleDelNewsItem(t *testing.T) {
3173 type args struct {
3174 cc *ClientConn
3175 t *Transaction
3176 }
3177 tests := []struct {
3178 name string
3179 args args
3180 wantRes []Transaction
3181 wantErr assert.ErrorAssertionFunc
3182 }{
3183 {
3184 name: "when user does not have permission to delete a news category",
3185 args: args{
3186 cc: &ClientConn{
3187 Account: &Account{
3188 Access: accessBitmap{},
3189 },
3190 ID: &[]byte{0, 1},
3191 Server: &Server{
3192 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
3193 "test": {
3194 Type: [2]byte{0, 3},
3195 Count: nil,
3196 NameSize: 0,
3197 Name: "zz",
3198 },
3199 }},
3200 },
3201 },
3202 t: NewTransaction(
3203 TranDelNewsItem, nil,
3204 NewField(FieldNewsPath,
3205 []byte{
3206 0, 1,
3207 0, 0,
3208 4,
3209 0x74, 0x65, 0x73, 0x74,
3210 },
3211 ),
3212 ),
3213 },
3214 wantRes: []Transaction{
3215 {
3216 clientID: &[]byte{0, 1},
3217 Flags: 0x00,
3218 IsReply: 0x01,
3219 Type: []byte{0, 0},
3220 ID: []byte{0, 0, 0, 0},
3221 ErrorCode: []byte{0, 0, 0, 1},
3222 Fields: []Field{
3223 NewField(FieldError, []byte("You are not allowed to delete news categories.")),
3224 },
3225 },
3226 },
3227 wantErr: assert.NoError,
3228 },
3229 {
3230 name: "when user does not have permission to delete a news folder",
3231 args: args{
3232 cc: &ClientConn{
3233 Account: &Account{
3234 Access: accessBitmap{},
3235 },
3236 ID: &[]byte{0, 1},
3237 Server: &Server{
3238 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
3239 "testcat": {
3240 Type: [2]byte{0, 2},
3241 Count: nil,
3242 NameSize: 0,
3243 Name: "test",
3244 },
3245 }},
3246 },
3247 },
3248 t: NewTransaction(
3249 TranDelNewsItem, nil,
3250 NewField(FieldNewsPath,
3251 []byte{
3252 0, 1,
3253 0, 0,
3254 4,
3255 0x74, 0x65, 0x73, 0x74,
3256 },
3257 ),
3258 ),
3259 },
3260 wantRes: []Transaction{
3261 {
3262 clientID: &[]byte{0, 1},
3263 Flags: 0x00,
3264 IsReply: 0x01,
3265 Type: []byte{0, 0},
3266 ID: []byte{0, 0, 0, 0},
3267 ErrorCode: []byte{0, 0, 0, 1},
3268 Fields: []Field{
3269 NewField(FieldError, []byte("You are not allowed to delete news folders.")),
3270 },
3271 },
3272 },
3273 wantErr: assert.NoError,
3274 },
3275 {
3276 name: "when user deletes a news folder",
3277 args: args{
3278 cc: &ClientConn{
3279 Account: &Account{
3280 Access: func() accessBitmap {
3281 var bits accessBitmap
3282 bits.Set(accessNewsDeleteFldr)
3283 return bits
3284 }(),
3285 },
3286 ID: &[]byte{0, 1},
3287 Server: &Server{
3288 ConfigDir: "/fakeConfigRoot",
3289 FS: func() *MockFileStore {
3290 mfs := &MockFileStore{}
3291 mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist)
3292 return mfs
3293 }(),
3294 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
3295 "testcat": {
3296 Type: [2]byte{0, 2},
3297 Count: nil,
3298 NameSize: 0,
3299 Name: "test",
3300 },
3301 }},
3302 },
3303 },
3304 t: NewTransaction(
3305 TranDelNewsItem, nil,
3306 NewField(FieldNewsPath,
3307 []byte{
3308 0, 1,
3309 0, 0,
3310 4,
3311 0x74, 0x65, 0x73, 0x74,
3312 },
3313 ),
3314 ),
3315 },
3316 wantRes: []Transaction{
3317 {
3318 clientID: &[]byte{0, 1},
3319 Flags: 0x00,
3320 IsReply: 0x01,
3321 Type: []byte{0, 0},
3322 ID: []byte{0, 0, 0, 0},
3323 ErrorCode: []byte{0, 0, 0, 0},
3324 Fields: []Field{},
3325 },
3326 },
3327 wantErr: assert.NoError,
3328 },
3329 }
3330 for _, tt := range tests {
3331 t.Run(tt.name, func(t *testing.T) {
3332 gotRes, err := HandleDelNewsItem(tt.args.cc, tt.args.t)
3333 if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsItem(%v, %v)", tt.args.cc, tt.args.t)) {
3334 return
3335 }
3336 tranAssertEqual(t, tt.wantRes, gotRes)
3337 })
3338 }
3339 }
3340
3341 func TestHandleTranOldPostNews(t *testing.T) {
3342 type args struct {
3343 cc *ClientConn
3344 t *Transaction
3345 }
3346 tests := []struct {
3347 name string
3348 args args
3349 wantRes []Transaction
3350 wantErr assert.ErrorAssertionFunc
3351 }{
3352 {
3353 name: "when user does not have required permission",
3354 args: args{
3355 cc: &ClientConn{
3356 Account: &Account{
3357 Access: func() accessBitmap {
3358 var bits accessBitmap
3359 return bits
3360 }(),
3361 },
3362 },
3363 t: NewTransaction(
3364 TranOldPostNews, &[]byte{0, 1},
3365 NewField(FieldData, []byte("hai")),
3366 ),
3367 },
3368 wantRes: []Transaction{
3369 {
3370 Flags: 0x00,
3371 IsReply: 0x01,
3372 Type: []byte{0, 0},
3373 ID: []byte{0, 0, 0, 0},
3374 ErrorCode: []byte{0, 0, 0, 1},
3375 Fields: []Field{
3376 NewField(FieldError, []byte("You are not allowed to post news.")),
3377 },
3378 },
3379 },
3380 wantErr: assert.NoError,
3381 },
3382 {
3383 name: "when user posts news update",
3384 args: args{
3385 cc: &ClientConn{
3386 Account: &Account{
3387 Access: func() accessBitmap {
3388 var bits accessBitmap
3389 bits.Set(accessNewsPostArt)
3390 return bits
3391 }(),
3392 },
3393 Server: &Server{
3394 FS: func() *MockFileStore {
3395 mfs := &MockFileStore{}
3396 mfs.On("WriteFile", "/fakeConfigRoot/MessageBoard.txt", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist)
3397 return mfs
3398 }(),
3399 ConfigDir: "/fakeConfigRoot",
3400 Config: &Config{},
3401 },
3402 },
3403 t: NewTransaction(
3404 TranOldPostNews, &[]byte{0, 1},
3405 NewField(FieldData, []byte("hai")),
3406 ),
3407 },
3408 wantRes: []Transaction{
3409 {
3410 Flags: 0x00,
3411 IsReply: 0x01,
3412 Type: []byte{0, 0},
3413 ID: []byte{0, 0, 0, 0},
3414 ErrorCode: []byte{0, 0, 0, 0},
3415 },
3416 },
3417 wantErr: assert.NoError,
3418 },
3419 }
3420 for _, tt := range tests {
3421 t.Run(tt.name, func(t *testing.T) {
3422 gotRes, err := HandleTranOldPostNews(tt.args.cc, tt.args.t)
3423 if !tt.wantErr(t, err, fmt.Sprintf("HandleTranOldPostNews(%v, %v)", tt.args.cc, tt.args.t)) {
3424 return
3425 }
3426
3427 tranAssertEqual(t, tt.wantRes, gotRes)
3428 })
3429 }
3430 }
3431
3432 func TestHandleInviteNewChat(t *testing.T) {
3433 type args struct {
3434 cc *ClientConn
3435 t *Transaction
3436 }
3437 tests := []struct {
3438 name string
3439 args args
3440 wantRes []Transaction
3441 wantErr assert.ErrorAssertionFunc
3442 }{
3443 {
3444 name: "when user does not have required permission",
3445 args: args{
3446 cc: &ClientConn{
3447 Account: &Account{
3448 Access: func() accessBitmap {
3449 var bits accessBitmap
3450 return bits
3451 }(),
3452 },
3453 },
3454 t: NewTransaction(TranInviteNewChat, &[]byte{0, 1}),
3455 },
3456 wantRes: []Transaction{
3457 {
3458 Flags: 0x00,
3459 IsReply: 0x01,
3460 Type: []byte{0, 0},
3461 ID: []byte{0, 0, 0, 0},
3462 ErrorCode: []byte{0, 0, 0, 1},
3463 Fields: []Field{
3464 NewField(FieldError, []byte("You are not allowed to request private chat.")),
3465 },
3466 },
3467 },
3468 wantErr: assert.NoError,
3469 },
3470 {
3471 name: "when userA invites userB to new private chat",
3472 args: args{
3473 cc: &ClientConn{
3474 ID: &[]byte{0, 1},
3475 Account: &Account{
3476 Access: func() accessBitmap {
3477 var bits accessBitmap
3478 bits.Set(accessOpenChat)
3479 return bits
3480 }(),
3481 },
3482 UserName: []byte("UserA"),
3483 Icon: []byte{0, 1},
3484 Flags: []byte{0, 0},
3485 Server: &Server{
3486 Clients: map[uint16]*ClientConn{
3487 uint16(2): {
3488 ID: &[]byte{0, 2},
3489 UserName: []byte("UserB"),
3490 Flags: []byte{0, 0},
3491 },
3492 },
3493 PrivateChats: make(map[uint32]*PrivateChat),
3494 },
3495 },
3496 t: NewTransaction(
3497 TranInviteNewChat, &[]byte{0, 1},
3498 NewField(FieldUserID, []byte{0, 2}),
3499 ),
3500 },
3501 wantRes: []Transaction{
3502 {
3503 clientID: &[]byte{0, 2},
3504 Flags: 0x00,
3505 IsReply: 0x00,
3506 Type: []byte{0, 0x71},
3507 ID: []byte{0, 0, 0, 0},
3508 ErrorCode: []byte{0, 0, 0, 0},
3509 Fields: []Field{
3510 NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
3511 NewField(FieldUserName, []byte("UserA")),
3512 NewField(FieldUserID, []byte{0, 1}),
3513 },
3514 },
3515
3516 {
3517 clientID: &[]byte{0, 1},
3518 Flags: 0x00,
3519 IsReply: 0x01,
3520 Type: []byte{0, 0},
3521 ID: []byte{0, 0, 0, 0},
3522 ErrorCode: []byte{0, 0, 0, 0},
3523 Fields: []Field{
3524 NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
3525 NewField(FieldUserName, []byte("UserA")),
3526 NewField(FieldUserID, []byte{0, 1}),
3527 NewField(FieldUserIconID, []byte{0, 1}),
3528 NewField(FieldUserFlags, []byte{0, 0}),
3529 },
3530 },
3531 },
3532 wantErr: assert.NoError,
3533 },
3534 {
3535 name: "when userA invites userB to new private chat, but UserB has refuse private chat enabled",
3536 args: args{
3537 cc: &ClientConn{
3538 ID: &[]byte{0, 1},
3539 Account: &Account{
3540 Access: func() accessBitmap {
3541 var bits accessBitmap
3542 bits.Set(accessOpenChat)
3543 return bits
3544 }(),
3545 },
3546 UserName: []byte("UserA"),
3547 Icon: []byte{0, 1},
3548 Flags: []byte{0, 0},
3549 Server: &Server{
3550 Clients: map[uint16]*ClientConn{
3551 uint16(2): {
3552 ID: &[]byte{0, 2},
3553 UserName: []byte("UserB"),
3554 Flags: []byte{255, 255},
3555 },
3556 },
3557 PrivateChats: make(map[uint32]*PrivateChat),
3558 },
3559 },
3560 t: NewTransaction(
3561 TranInviteNewChat, &[]byte{0, 1},
3562 NewField(FieldUserID, []byte{0, 2}),
3563 ),
3564 },
3565 wantRes: []Transaction{
3566 {
3567 clientID: &[]byte{0, 1},
3568 Flags: 0x00,
3569 IsReply: 0x00,
3570 Type: []byte{0, 0x68},
3571 ID: []byte{0, 0, 0, 0},
3572 ErrorCode: []byte{0, 0, 0, 0},
3573 Fields: []Field{
3574 NewField(FieldData, []byte("UserB does not accept private chats.")),
3575 NewField(FieldUserName, []byte("UserB")),
3576 NewField(FieldUserID, []byte{0, 2}),
3577 NewField(FieldOptions, []byte{0, 2}),
3578 },
3579 },
3580 {
3581 clientID: &[]byte{0, 1},
3582 Flags: 0x00,
3583 IsReply: 0x01,
3584 Type: []byte{0, 0},
3585 ID: []byte{0, 0, 0, 0},
3586 ErrorCode: []byte{0, 0, 0, 0},
3587 Fields: []Field{
3588 NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
3589 NewField(FieldUserName, []byte("UserA")),
3590 NewField(FieldUserID, []byte{0, 1}),
3591 NewField(FieldUserIconID, []byte{0, 1}),
3592 NewField(FieldUserFlags, []byte{0, 0}),
3593 },
3594 },
3595 },
3596 wantErr: assert.NoError,
3597 },
3598 }
3599 for _, tt := range tests {
3600 t.Run(tt.name, func(t *testing.T) {
3601 rand.Seed(1)
3602 gotRes, err := HandleInviteNewChat(tt.args.cc, tt.args.t)
3603 if !tt.wantErr(t, err, fmt.Sprintf("HandleInviteNewChat(%v, %v)", tt.args.cc, tt.args.t)) {
3604 return
3605 }
3606 tranAssertEqual(t, tt.wantRes, gotRes)
3607 })
3608 }
3609 }
3610
3611 func TestHandleGetNewsArtData(t *testing.T) {
3612 type args struct {
3613 cc *ClientConn
3614 t *Transaction
3615 }
3616 tests := []struct {
3617 name string
3618 args args
3619 wantRes []Transaction
3620 wantErr assert.ErrorAssertionFunc
3621 }{
3622 {
3623 name: "when user does not have required permission",
3624 args: args{
3625 cc: &ClientConn{
3626 Account: &Account{
3627 Access: func() accessBitmap {
3628 var bits accessBitmap
3629 return bits
3630 }(),
3631 },
3632 Server: &Server{
3633 Accounts: map[string]*Account{},
3634 },
3635 },
3636 t: NewTransaction(
3637 TranGetNewsArtData, &[]byte{0, 1},
3638 ),
3639 },
3640 wantRes: []Transaction{
3641 {
3642 Flags: 0x00,
3643 IsReply: 0x01,
3644 Type: []byte{0, 0},
3645 ID: []byte{0x9a, 0xcb, 0x04, 0x42},
3646 ErrorCode: []byte{0, 0, 0, 1},
3647 Fields: []Field{
3648 NewField(FieldError, []byte("You are not allowed to read news.")),
3649 },
3650 },
3651 },
3652 wantErr: assert.NoError,
3653 },
3654 }
3655 for _, tt := range tests {
3656 t.Run(tt.name, func(t *testing.T) {
3657 gotRes, err := HandleGetNewsArtData(tt.args.cc, tt.args.t)
3658 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetNewsArtData(%v, %v)", tt.args.cc, tt.args.t)) {
3659 return
3660 }
3661 tranAssertEqual(t, tt.wantRes, gotRes)
3662 })
3663 }
3664 }
3665
3666 func TestHandleGetNewsArtNameList(t *testing.T) {
3667 type args struct {
3668 cc *ClientConn
3669 t *Transaction
3670 }
3671 tests := []struct {
3672 name string
3673 args args
3674 wantRes []Transaction
3675 wantErr assert.ErrorAssertionFunc
3676 }{
3677 {
3678 name: "when user does not have required permission",
3679 args: args{
3680 cc: &ClientConn{
3681 Account: &Account{
3682 Access: func() accessBitmap {
3683 var bits accessBitmap
3684 return bits
3685 }(),
3686 },
3687 Server: &Server{
3688 Accounts: map[string]*Account{},
3689 },
3690 },
3691 t: NewTransaction(
3692 TranGetNewsArtNameList, &[]byte{0, 1},
3693 ),
3694 },
3695 wantRes: []Transaction{
3696 {
3697 Flags: 0x00,
3698 IsReply: 0x01,
3699 Type: []byte{0, 0},
3700 ErrorCode: []byte{0, 0, 0, 1},
3701 Fields: []Field{
3702 NewField(FieldError, []byte("You are not allowed to read news.")),
3703 },
3704 },
3705 },
3706 wantErr: assert.NoError,
3707 },
3708 }
3709 for _, tt := range tests {
3710 t.Run(tt.name, func(t *testing.T) {
3711 gotRes, err := HandleGetNewsArtNameList(tt.args.cc, tt.args.t)
3712 if !tt.wantErr(t, err, fmt.Sprintf("HandleGetNewsArtNameList(%v, %v)", tt.args.cc, tt.args.t)) {
3713 return
3714 }
3715 tranAssertEqual(t, tt.wantRes, gotRes)
3716 })
3717 }
3718 }
3719
3720 func TestHandleNewNewsFldr(t *testing.T) {
3721 type args struct {
3722 cc *ClientConn
3723 t *Transaction
3724 }
3725 tests := []struct {
3726 name string
3727 args args
3728 wantRes []Transaction
3729 wantErr assert.ErrorAssertionFunc
3730 }{
3731 {
3732 name: "when user does not have required permission",
3733 args: args{
3734 cc: &ClientConn{
3735 Account: &Account{
3736 Access: func() accessBitmap {
3737 var bits accessBitmap
3738 return bits
3739 }(),
3740 },
3741 Server: &Server{
3742 Accounts: map[string]*Account{},
3743 },
3744 },
3745 t: NewTransaction(
3746 TranGetNewsArtNameList, &[]byte{0, 1},
3747 ),
3748 },
3749 wantRes: []Transaction{
3750 {
3751 Flags: 0x00,
3752 IsReply: 0x01,
3753 Type: []byte{0, 0},
3754 ErrorCode: []byte{0, 0, 0, 1},
3755 Fields: []Field{
3756 NewField(FieldError, []byte("You are not allowed to create news folders.")),
3757 },
3758 },
3759 },
3760 wantErr: assert.NoError,
3761 },
3762 {
3763 name: "with a valid request",
3764 args: args{
3765 cc: &ClientConn{
3766 Account: &Account{
3767 Access: func() accessBitmap {
3768 var bits accessBitmap
3769 bits.Set(accessNewsCreateFldr)
3770 return bits
3771 }(),
3772 },
3773 logger: NewTestLogger(),
3774 ID: &[]byte{0, 1},
3775 Server: &Server{
3776 ConfigDir: "/fakeConfigRoot",
3777 FS: func() *MockFileStore {
3778 mfs := &MockFileStore{}
3779 mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil)
3780 return mfs
3781 }(),
3782 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
3783 "test": {
3784 Type: [2]byte{0, 2},
3785 Count: nil,
3786 NameSize: 0,
3787 Name: "test",
3788 SubCats: make(map[string]NewsCategoryListData15),
3789 },
3790 }},
3791 },
3792 },
3793 t: NewTransaction(
3794 TranGetNewsArtNameList, &[]byte{0, 1},
3795 NewField(FieldFileName, []byte("testFolder")),
3796 NewField(FieldNewsPath,
3797 []byte{
3798 0, 1,
3799 0, 0,
3800 4,
3801 0x74, 0x65, 0x73, 0x74,
3802 },
3803 ),
3804 ),
3805 },
3806 wantRes: []Transaction{
3807 {
3808 clientID: &[]byte{0, 1},
3809 Flags: 0x00,
3810 IsReply: 0x01,
3811 Type: []byte{0, 0},
3812 ID: []byte{0, 0, 0, 0},
3813 ErrorCode: []byte{0, 0, 0, 0},
3814 Fields: []Field{},
3815 },
3816 },
3817 wantErr: assert.NoError,
3818 },
3819 //{
3820 // name: "when there is an error writing the threaded news file",
3821 // args: args{
3822 // cc: &ClientConn{
3823 // Account: &Account{
3824 // Access: func() accessBitmap {
3825 // var bits accessBitmap
3826 // bits.Set(accessNewsCreateFldr)
3827 // return bits
3828 // }(),
3829 // },
3830 // logger: NewTestLogger(),
3831 // ID: &[]byte{0, 1},
3832 // Server: &Server{
3833 // ConfigDir: "/fakeConfigRoot",
3834 // FS: func() *MockFileStore {
3835 // mfs := &MockFileStore{}
3836 // mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(os.ErrNotExist)
3837 // return mfs
3838 // }(),
3839 // ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
3840 // "test": {
3841 // Type: []byte{0, 2},
3842 // Count: nil,
3843 // NameSize: 0,
3844 // Name: "test",
3845 // SubCats: make(map[string]NewsCategoryListData15),
3846 // },
3847 // }},
3848 // },
3849 // },
3850 // t: NewTransaction(
3851 // TranGetNewsArtNameList, &[]byte{0, 1},
3852 // NewField(FieldFileName, []byte("testFolder")),
3853 // NewField(FieldNewsPath,
3854 // []byte{
3855 // 0, 1,
3856 // 0, 0,
3857 // 4,
3858 // 0x74, 0x65, 0x73, 0x74,
3859 // },
3860 // ),
3861 // ),
3862 // },
3863 // wantRes: []Transaction{
3864 // {
3865 // clientID: &[]byte{0, 1},
3866 // Flags: 0x00,
3867 // IsReply: 0x01,
3868 // Type: []byte{0, 0},
3869 // ErrorCode: []byte{0, 0, 0, 1},
3870 // Fields: []Field{
3871 // NewField(FieldError, []byte("Error creating news folder.")),
3872 // },
3873 // },
3874 // },
3875 // wantErr: assert.Error,
3876 // },
3877 }
3878 for _, tt := range tests {
3879 t.Run(tt.name, func(t *testing.T) {
3880 gotRes, err := HandleNewNewsFldr(tt.args.cc, tt.args.t)
3881 if !tt.wantErr(t, err, fmt.Sprintf("HandleNewNewsFldr(%v, %v)", tt.args.cc, tt.args.t)) {
3882 return
3883 }
3884 tranAssertEqual(t, tt.wantRes, gotRes)
3885 })
3886 }
3887 }
Friendship Quest remix of mobius, a hotline server in go #cli