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


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